diff --git a/.env.example b/.env.example
index 940c6bac..da57c210 100644
--- a/.env.example
+++ b/.env.example
@@ -1,65 +1,79 @@
- # Since the ".env" file is gitignored, you can use the ".env.example" file to
-# build a new ".env" file when you clone the repo. Keep this file up-to-date
-# when you add new variables to `.env`.
+# Server environment variables
+DATABASE_URL="postgresql://user:password@localhost:5432/pdr_ai"
+
+# Clerk Authentication
+NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY="pk_test_..."
+CLERK_SECRET_KEY="sk_test_..."
+
+# OpenAI API
+OPENAI_API_KEY="sk-..."
+
+# NextJS client environment variables
+NEXT_PUBLIC_UPLOADTHING_ENABLED="true"
+
+# Trend / web search (optional — leave keys unset if you do not use trend search)
+# SEARCH_PROVIDER default when unset is tavily-only (same as tavily).
+#   tavily     → requires TAVILY_API_KEY
+#   serper     → requires SERPER_API_KEY
+#   fallback   → Serper first, then Tavily if Serper returns no results; set both keys for full behavior
+#   parallel   → merge Serper + Tavily; set both keys for full behavior (Serper-only works with SERPER_API_KEY only)
+# If a required key is missing, the pipeline no-ops that provider; providerUsed may be "none" when no key backs the active path.
+TAVILY_API_KEY="tvly-..."
+SERPER_API_KEY="..."
+SEARCH_PROVIDER="tavily" # "tavily" | "serper" | "fallback" | "parallel"
+
+# Platform API Keys for Marketing Pipeline
+REDDIT_CLIENT_ID="your_reddit_client_id"
+REDDIT_CLIENT_SECRET="your_reddit_client_secret"
+REDDIT_USER_AGENT="your_reddit_user_agent"
+TWITTER_BEARER_TOKEN="your_twitter_bearer_token"
+LINKEDIN_ACCESS_TOKEN="your_linkedin_access_token"
+BLUESKY_HANDLE="your_bluesky_handle"
+BLUESKY_APP_PASSWORD="your_bluesky_app_password"
+
+# Document Processing (Optional)
+AZURE_DOC_INTELLIGENCE_ENDPOINT="https://..."
+AZURE_DOC_INTELLIGENCE_KEY="..."
+LANDING_AI_API_KEY="..."
 
-# This file will be committed to version control, so make sure not to have any
-# secrets in it. If you are cloning this repo, create a copy of this file named
-# ".env" and populate it with your secrets.
-
-# When adding additional environment variables, the schema in "/src/env.js"
-# should be updated accordingly.
-
-# Database 
-DATABASE_URL="" 
-
-# Docker Compose: password for PostgreSQL (used by db service)
-# POSTGRES_PASSWORD=password
-
-# Clerk Authentication (get from https://clerk.com/)
-
-NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=
-CLERK_SECRET_KEY=
+# Anthropic API (optional — enables Claude models, get from https://console.anthropic.com/)
+ANTHROPIC_API_KEY=
+ANTHROPIC_MODEL=
 
 # OpenAI API (get from https://platform.openai.com/)
 OPENAI_API_KEY=
 OPENAI_MODEL="gpt-5-mini"
 
-# Anthropic API (optional — enables Claude models, get from https://console.anthropic.com/)
-ANTHROPIC_API_KEY=
-
 # Google AI API (optional — enables Gemini models, get from https://aistudio.google.com/apikey)
 GOOGLE_AI_API_KEY=
+GOOGLE_MODEL=
 
 # Ollama (optional — enables local models via Ollama, see https://ollama.com/)
 OLLAMA_BASE_URL="http://localhost:11434"
 OLLAMA_MODEL="llama3.1:8b"
 
-# UploadThing (get from https://uploadthing.com/)
+# LangSmith Tracing (Optional)
+LANGCHAIN_TRACING_V2="false"
+LANGCHAIN_API_KEY="..."
+LANGCHAIN_PROJECT="pdr_ai_v2"
+
+# File Uploading (Optional)
 UPLOADTHING_SECRET="your_uploadthing_secret"
 UPLOADTHING_APP_ID="your_uploadthing_app_id"
+UPLOADTHING_TOKEN="..."
 
-# Datalab OCR API (optional - get from https://www.datalab.to/)
-# Required only if you want to enable OCR processing for scanned documents
-DATALAB_API_KEY="your_datalab_api_key"
-
-# Landing.AI OCR API (optional - get from https://www.landing.ai/)
-LANDING_AI_API_KEY="your_landing_ai_api_key"
-
-# Tavily API (optional - get from https://www.tavily.com/)
-TAVILY_API_KEY="your_tavily_api_key"
-
-# Azure Document Intelligence OCR API (optional - get from https://learn.microsoft.com/en-us/azure/applied-ai-services/document-intelligence/quickstarts/get-started-with-rest-api?pivots=programming-language-rest-api)
-AZURE_DOC_INTELLIGENCE_ENDPOINT="your_azure_doc_intelligence_endpoint"
-AZURE_DOC_INTELLIGENCE_KEY="your_azure_doc_intelligence_key"
+# Data APIs (Optional)
+DATALAB_API_KEY="..."
 
-# Inngest (required for background document processing - https://inngest.com/)
-INNGEST_EVENT_KEY="dev_placeholder"
+# Background Jobs
+JOB_RUNNER="inngest"
+INNGEST_EVENT_KEY="local"
 INNGEST_SIGNING_KEY="signkey-dev-xxxxx"
 
-# Sidecar (optional - get from https://github.com/pdr-ai/sidecar)
-SIDECAR_URL="your_sidecar_url"
+# Sidecar ML Compute (Optional)
+SIDECAR_URL="http://localhost:8080"
 
-# Neo4j (optional - get from https://neo4j.com/)
+# Neo4j (optional)
 NEO4J_URI="your_neo4j_uri"
 NEO4J_USERNAME="your_neo4j_username"
 NEO4J_PASSWORD="your_neo4j_password"
diff --git a/__tests__/api/trendSearch/search-provider.pbt.test.ts b/__tests__/api/trendSearch/search-provider.pbt.test.ts
new file mode 100644
index 00000000..e4fa0abb
--- /dev/null
+++ b/__tests__/api/trendSearch/search-provider.pbt.test.ts
@@ -0,0 +1,340 @@
+/**
+ * Property-based tests for search provider normalization and strategy behavior.
+ * Feature: Serper dual-channel search — Task 4.3
+ * Property 13: Serper adapter output conforms to RawSearchResult.
+ * Property 14: Fallback strategy invokes secondary when primary returns empty.
+ * Property 15: Parallel merge deduplicates by URL (Serper first, then Tavily).
+ * Property 16: Default (no env) matches Tavily-only behavior.
+ * Property 17: Serper-dependent strategies downgrade when key missing.
+ */
+
+const TAVILY_URL = "https://api.tavily.com/search";
+const SERPER_URL = "https://google.serper.dev/news";
+
+jest.mock("~/env", () => {
+    const server = {
+        TAVILY_API_KEY: "test-tavily-key",
+        SERPER_API_KEY: "test-serper-key",
+        SEARCH_PROVIDER: undefined as "tavily" | "serper" | "fallback" | "parallel" | undefined,
+    };
+    return { env: { server } };
+});
+
+import * as fc from "fast-check";
+import { env } from "~/env";
+import { callSerper } from "~/lib/tools/trend-search/providers/serper";
+import { executeSearch } from "~/lib/tools/trend-search/web-search";
+import type { PlannedQuery, RawSearchResult } from "~/lib/tools/trend-search/types";
+import type { ProviderStrategy } from "~/lib/tools/trend-search/providers/types";
+
+beforeEach(() => {
+    env.server.TAVILY_API_KEY = "test-tavily-key";
+    env.server.SERPER_API_KEY = "test-serper-key";
+    env.server.SEARCH_PROVIDER = undefined;
+});
+
+// ─── Arbitraries ─────────────────────────────────────────────────────────────
+
+const validCategories = ["fashion", "finance", "business", "tech"] as const;
+
+const categoryArb = fc.constantFrom(...validCategories);
+
+const plannedQueryArb: fc.Arbitrary<PlannedQuery> = fc.record({
+    searchQuery: fc.string({ minLength: 1, maxLength: 300 }),
+    category: categoryArb,
+    rationale: fc.string({ minLength: 1, maxLength: 200 }),
+});
+
+const subQueriesArb = fc.array(plannedQueryArb, { minLength: 1, maxLength: 5 });
+
+/** Serper news item shape (subset we use). */
+const serperNewsItemArb = fc.record({
+    link: fc.webUrl({ validSchemes: ["https"] }),
+    title: fc.option(fc.string({ maxLength: 200 }), { nil: undefined }),
+    snippet: fc.option(fc.string({ maxLength: 500 }), { nil: undefined }),
+    date: fc.option(fc.string(), { nil: undefined }),
+    position: fc.option(fc.nat({ max: 20 }), { nil: undefined }),
+});
+
+const serperNewsArrayArb = fc.array(serperNewsItemArb, { minLength: 0, maxLength: 15 });
+
+/** RawSearchResult arbitrary for merge tests. */
+const rawSearchResultArb = fc.record({
+    url: fc.webUrl({ validSchemes: ["https"] }),
+    title: fc.string({ minLength: 1, maxLength: 200 }),
+    content: fc.string({ maxLength: 500 }),
+    score: fc.double({ min: 0, max: 1 }),
+    publishedDate: fc.option(fc.string(), { nil: undefined }),
+});
+
+function normalizeUrl(url: string): string {
+    try {
+        return new URL(url).href;
+    } catch {
+        return url.trim();
+    }
+}
+
+function conformsToRawSearchResult(r: unknown): r is RawSearchResult {
+    if (r === null || typeof r !== "object") return false;
+    const o = r as Record<string, unknown>;
+    return (
+        typeof o.url === "string" &&
+        o.url.length > 0 &&
+        typeof o.title === "string" &&
+        typeof o.content === "string" &&
+        typeof o.score === "number" &&
+        (!("publishedDate" in o) || typeof o.publishedDate === "string" || o.publishedDate === undefined)
+    );
+}
+
+// ─── Property 13: Serper output conforms to RawSearchResult ───────────────────
+
+describe("Property 13: Serper-shaped responses normalize to RawSearchResult", () => {
+    it("for any random Serper news array, every output item conforms to RawSearchResult", async () => {
+        await fc.assert(
+            fc.asyncProperty(serperNewsArrayArb, async (news) => {
+                const fetchSpy = jest.spyOn(globalThis, "fetch").mockResolvedValue({
+                    ok: true,
+                    text: async () => "",
+                    json: async () => ({ news }),
+                } as Response);
+
+                const results = await callSerper("test query");
+
+                fetchSpy.mockRestore();
+
+                for (const item of results) {
+                    expect(conformsToRawSearchResult(item)).toBe(true);
+                    expect(item.url).toBeDefined();
+                    expect(typeof item.title).toBe("string");
+                    expect(typeof item.content).toBe("string");
+                    expect(typeof item.score).toBe("number");
+                }
+            }),
+            { numRuns: 80 }
+        );
+    });
+});
+
+// ─── Property 14: Fallback invokes secondary when primary returns empty ─────────
+
+describe("Property 14: Fallback strategy invokes secondary when primary returns empty", () => {
+    it("for random sub-query lists, when primary (Serper) returns empty, Tavily is invoked once per sub-query", async () => {
+        await fc.assert(
+            fc.asyncProperty(subQueriesArb, async (subQueries) => {
+                let serperCalls = 0;
+                let tavilyCalls = 0;
+                const fetchSpy = jest.spyOn(globalThis, "fetch").mockImplementation((input: RequestInfo | URL) => {
+                    const url = typeof input === "string" ? input : input instanceof URL ? input.href : (input as Request).url;
+                    if (url === SERPER_URL) {
+                        serperCalls++;
+                        return Promise.resolve({
+                            ok: true,
+                            text: async () => "",
+                            json: async () => ({ news: [] }),
+                        } as Response);
+                    }
+                    if (url === TAVILY_URL) {
+                        tavilyCalls++;
+                        return Promise.resolve({
+                            ok: true,
+                            text: async () => "",
+                            json: async () => ({
+                                results: [{ url: "https://tavily.com/1", title: "T", content: "C", score: 0.9 }],
+                            }),
+                        } as Response);
+                    }
+                    return Promise.reject(new Error(`Unexpected URL: ${url}`));
+                });
+
+                env.server.SEARCH_PROVIDER = "fallback";
+                env.server.SERPER_API_KEY = "test-serper-key";
+
+                await executeSearch(subQueries);
+
+                fetchSpy.mockRestore();
+
+                expect(serperCalls).toBe(subQueries.length);
+                expect(tavilyCalls).toBe(subQueries.length);
+            }),
+            { numRuns: 50 }
+        );
+    });
+});
+
+// ─── Property 15: Parallel dedup — Serper rows first, then Tavily (no cross-provider score compare) ──────────
+
+describe("Property 15: Parallel merge deduplicates by URL (Serper first)", () => {
+    it("for two random result sets with overlapping URLs, merged result has no duplicate URLs and Serper wins on URL tie", async () => {
+        await fc.assert(
+            fc.asyncProperty(
+                fc.array(rawSearchResultArb, { minLength: 0, maxLength: 5 }),
+                fc.array(rawSearchResultArb, { minLength: 0, maxLength: 5 }),
+                fc.string({ minLength: 1, maxLength: 100 }),
+                async (setA, setB, _query) => {
+                    // Tavily returns setA with original scores; Serper adapter recomputes score as 1 - position/totalResults
+                    const serperScores = setB.length > 0
+                        ? setB.map((_, i) => 1 - (i + 1) / setB.length)
+                        : [];
+                    const setBWithSerperScores = setB.map((r, i) => ({ ...r, score: serperScores[i] ?? 0 }));
+                    // Replicate executeSearch parallel merge: Serper first, then Tavily; first URL wins
+                    const byUrl = new Map<string, RawSearchResult>();
+                    for (const r of setBWithSerperScores) {
+                        const key = normalizeUrl(r.url);
+                        if (!key) continue;
+                        if (!byUrl.has(key)) byUrl.set(key, r);
+                    }
+                    for (const r of setA) {
+                        const key = normalizeUrl(r.url);
+                        if (!key) continue;
+                        if (!byUrl.has(key)) byUrl.set(key, r);
+                    }
+                    const pairKey = (r: RawSearchResult) => `${normalizeUrl(r.url)}::${Number(r.score).toFixed(10)}`;
+                    const expectedPairs = new Set([...byUrl.values()].map(pairKey));
+
+                    const fetchSpy = jest.spyOn(globalThis, "fetch").mockImplementation((input: RequestInfo | URL) => {
+                        const url = typeof input === "string" ? input : input instanceof URL ? input.href : (input as Request).url;
+                        if (url === TAVILY_URL) {
+                            return Promise.resolve({
+                                ok: true,
+                                text: async () => "",
+                                json: async () => ({ results: setA }),
+                            } as Response);
+                        }
+                        if (url === SERPER_URL) {
+                            const serperNews = setB.map((r, i) => ({
+                                link: r.url,
+                                title: r.title,
+                                snippet: r.content,
+                                position: i + 1,
+                            }));
+                            return Promise.resolve({
+                                ok: true,
+                                text: async () => "",
+                                json: async () => ({ news: serperNews }),
+                            } as Response);
+                        }
+                        return Promise.reject(new Error(`Unexpected URL: ${url}`));
+                    });
+
+                    env.server.SEARCH_PROVIDER = "parallel";
+                    env.server.SERPER_API_KEY = "test-serper-key";
+
+                    const { results } = await executeSearch(
+                        [{ searchQuery: "q", category: "tech", rationale: "r" }],
+                        "parallel"
+                    );
+
+                    fetchSpy.mockRestore();
+
+                    const resultUrls = results.map((r) => r.url);
+                    const uniqueUrls = new Set(resultUrls);
+                    expect(resultUrls.length).toBe(uniqueUrls.size);
+
+                    const actualPairs = new Set(results.map(pairKey));
+                    expect(actualPairs.size).toBe(expectedPairs.size);
+                    for (const p of actualPairs) {
+                        expect(expectedPairs.has(p)).toBe(true);
+                    }
+                }
+            ),
+            { numRuns: 60 }
+        );
+    });
+});
+
+// ─── Property 16: Default (no env) matches Tavily-only ──────────────────────────
+
+describe("Property 16: Default strategy matches Tavily-only behavior", () => {
+    it("when SEARCH_PROVIDER is unset, providerUsed is tavily and only Tavily is called", async () => {
+        await fc.assert(
+            fc.asyncProperty(subQueriesArb, async (subQueries) => {
+                let tavilyCalls = 0;
+                let serperCalls = 0;
+                const fetchSpy = jest.spyOn(globalThis, "fetch").mockImplementation((input: RequestInfo | URL) => {
+                    const url = typeof input === "string" ? input : input instanceof URL ? input.href : (input as Request).url;
+                    if (url === TAVILY_URL) {
+                        tavilyCalls++;
+                        return Promise.resolve({
+                            ok: true,
+                            text: async () => "",
+                            json: async () => ({
+                                results: [{ url: "https://tavily.com/1", title: "T", content: "C", score: 0.9 }],
+                            }),
+                        } as Response);
+                    }
+                    if (url === SERPER_URL) {
+                        serperCalls++;
+                        return Promise.resolve({
+                            ok: true,
+                            text: async () => "",
+                            json: async () => ({ news: [] }),
+                        } as Response);
+                    }
+                    return Promise.reject(new Error(`Unexpected URL: ${url}`));
+                });
+
+                env.server.SEARCH_PROVIDER = undefined;
+                env.server.SERPER_API_KEY = "test-serper-key";
+
+                const { providerUsed } = await executeSearch(subQueries);
+
+                fetchSpy.mockRestore();
+
+                expect(providerUsed).toBe("tavily");
+                expect(tavilyCalls).toBe(subQueries.length);
+                expect(serperCalls).toBe(0);
+            }),
+            { numRuns: 50 }
+        );
+    });
+});
+
+// ─── Property 17: Serper-dependent strategies downgrade when key missing ───────
+
+describe("Property 17: Missing Serper key downgrades Serper-dependent strategies to tavily", () => {
+    const serperDependentStrategies: ProviderStrategy[] = ["serper", "fallback", "parallel"];
+
+    it("for each Serper-dependent strategy, when SERPER_API_KEY is unset, providerUsed is tavily and no throw", async () => {
+        await fc.assert(
+            fc.asyncProperty(
+                fc.constantFrom(...serperDependentStrategies),
+                subQueriesArb,
+                async (strategy, subQueries) => {
+                    const fetchSpy = jest.spyOn(globalThis, "fetch").mockImplementation((input: RequestInfo | URL) => {
+                        const url = typeof input === "string" ? input : input instanceof URL ? input.href : (input as Request).url;
+                        if (url === TAVILY_URL) {
+                            return Promise.resolve({
+                                ok: true,
+                                text: async () => "",
+                                json: async () => ({
+                                    results: [{ url: "https://tavily.com/1", title: "T", content: "C", score: 0.9 }],
+                                }),
+                            } as Response);
+                        }
+                        if (url === SERPER_URL) {
+                            return Promise.resolve({
+                                ok: true,
+                                text: async () => "",
+                                json: async () => ({ news: [] }),
+                            } as Response);
+                        }
+                        return Promise.reject(new Error(`Unexpected URL: ${url}`));
+                    });
+
+                    env.server.SERPER_API_KEY = undefined as unknown as string;
+                    const warnSpy = jest.spyOn(console, "warn").mockImplementation();
+
+                    const { providerUsed } = await executeSearch(subQueries, strategy);
+
+                    warnSpy.mockRestore();
+                    fetchSpy.mockRestore();
+
+                    expect(providerUsed).toBe("tavily");
+                }
+            ),
+            { numRuns: 30 }
+        );
+    });
+});
diff --git a/__tests__/api/trendSearch/search-strategy.test.ts b/__tests__/api/trendSearch/search-strategy.test.ts
new file mode 100644
index 00000000..f3fdcae1
--- /dev/null
+++ b/__tests__/api/trendSearch/search-strategy.test.ts
@@ -0,0 +1,289 @@
+/**
+ * Unit tests for executeSearch strategy logic.
+ * Feature: Serper dual-channel search — Task 4.2
+ * Requirements: 3.1, 3.2, 3.3, 3.4, 3.5, 4.3, 6.1, 6.2
+ */
+
+const TAVILY_URL = "https://api.tavily.com/search";
+const SERPER_URL = "https://google.serper.dev/news";
+
+jest.mock("~/env", () => {
+    const server = {
+        TAVILY_API_KEY: "test-tavily-key",
+        SERPER_API_KEY: "test-serper-key",
+        SEARCH_PROVIDER: undefined as "tavily" | "serper" | "fallback" | "parallel" | undefined,
+    };
+    return { env: { server } };
+});
+
+import { env } from "~/env";
+import { executeSearch } from "~/lib/tools/trend-search/web-search";
+import type { PlannedQuery } from "~/lib/tools/trend-search/types";
+
+const subQueries: PlannedQuery[] = [
+    { searchQuery: "test query", category: "tech", rationale: "test" },
+];
+
+function tavilyResponse(results: { url: string; title?: string; content?: string; score?: number }[]) {
+    return {
+        ok: true,
+        text: async () => "",
+        json: async () => ({ results }),
+    } as Response;
+}
+
+function serperResponse(items: { link: string; title?: string; snippet?: string; score?: number }[]) {
+    return {
+        ok: true,
+        text: async () => "",
+        json: async () => ({
+            news: items.map((item) => ({
+                link: item.link,
+                title: item.title ?? "Untitled",
+                snippet: item.snippet ?? "",
+                position: 1,
+            })),
+        }),
+    } as Response;
+}
+
+function getFetchCallsByUrl(fetchSpy: jest.SpyInstance): { tavily: number; serper: number } {
+    const calls = fetchSpy.mock.calls as [string, unknown][];
+    let tavily = 0;
+    let serper = 0;
+    for (const [url] of calls) {
+        if (url === TAVILY_URL) tavily++;
+        if (url === SERPER_URL) serper++;
+    }
+    return { tavily, serper };
+}
+
+describe("executeSearch strategy logic", () => {
+    let fetchSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+        env.server.TAVILY_API_KEY = "test-tavily-key";
+        env.server.SERPER_API_KEY = "test-serper-key";
+        env.server.SEARCH_PROVIDER = undefined;
+        fetchSpy = jest.spyOn(globalThis, "fetch").mockImplementation((input: RequestInfo | URL) => {
+            const url = typeof input === "string" ? input : input instanceof URL ? input.href : (input as Request).url;
+            if (url === TAVILY_URL) {
+                return Promise.resolve(tavilyResponse([{ url: "https://tavily.com/1", title: "T", content: "C", score: 0.9 }]));
+            }
+            if (url === SERPER_URL) {
+                return Promise.resolve(serperResponse([{ link: "https://serper.com/1", title: "S", snippet: "Snippet" }]));
+            }
+            return Promise.reject(new Error(`Unexpected URL: ${url}`));
+        });
+    });
+
+    afterEach(() => {
+        fetchSpy.mockRestore();
+    });
+
+    describe("default strategy (no env) uses Tavily only", () => {
+        it("when SEARCH_PROVIDER is unset, only Tavily is called and providerUsed is tavily", async () => {
+            env.server.SEARCH_PROVIDER = undefined;
+            env.server.SERPER_API_KEY = "test-serper-key";
+
+            const { results, providerUsed } = await executeSearch(subQueries);
+
+            expect(providerUsed).toBe("tavily");
+            const { tavily, serper } = getFetchCallsByUrl(fetchSpy);
+            expect(tavily).toBe(1);
+            expect(serper).toBe(0);
+            expect(results).toHaveLength(1);
+            expect(results[0]!.url).toBe("https://tavily.com/1");
+        });
+    });
+
+    describe('"serper" strategy uses Serper only', () => {
+        it("when strategy is serper, only Serper is called and providerUsed is serper", async () => {
+            env.server.SEARCH_PROVIDER = "serper";
+
+            const { results, providerUsed } = await executeSearch(subQueries);
+
+            expect(providerUsed).toBe("serper");
+            const { tavily, serper } = getFetchCallsByUrl(fetchSpy);
+            expect(tavily).toBe(0);
+            expect(serper).toBe(1);
+            expect(results).toHaveLength(1);
+            expect(results[0]!.url).toBe("https://serper.com/1");
+        });
+    });
+
+    describe('"fallback" strategy tries Serper first, falls back to Tavily on total failure', () => {
+        it("when Serper returns no results for all sub-queries, Tavily is called and providerUsed is tavily", async () => {
+            env.server.SEARCH_PROVIDER = "fallback";
+            let callCount = 0;
+            fetchSpy.mockImplementation((input: RequestInfo | URL) => {
+                callCount++;
+                const url = typeof input === "string" ? input : input instanceof URL ? input.href : (input as Request).url;
+                if (url === SERPER_URL) {
+                    return Promise.resolve(serperResponse([])); // empty
+                }
+                if (url === TAVILY_URL) {
+                    return Promise.resolve(tavilyResponse([{ url: "https://tavily.com/fallback", title: "T", content: "C", score: 0.8 }]));
+                }
+                return Promise.reject(new Error(`Unexpected URL: ${url}`));
+            });
+
+            const { results, providerUsed } = await executeSearch(subQueries);
+
+            expect(providerUsed).toBe("tavily");
+            const { tavily, serper } = getFetchCallsByUrl(fetchSpy);
+            expect(serper).toBe(1);
+            expect(tavily).toBe(1);
+            expect(results).toHaveLength(1);
+            expect(results[0]!.url).toBe("https://tavily.com/fallback");
+        });
+    });
+
+    describe('"fallback" strategy does NOT fall back when Serper returns results', () => {
+        it("when Serper returns results, Tavily is not called and providerUsed is serper", async () => {
+            env.server.SEARCH_PROVIDER = "fallback";
+            fetchSpy.mockImplementation((input: RequestInfo | URL) => {
+                const url = typeof input === "string" ? input : input instanceof URL ? input.href : (input as Request).url;
+                if (url === SERPER_URL) {
+                    return Promise.resolve(serperResponse([{ link: "https://serper.com/ok", title: "S", snippet: "S" }]));
+                }
+                if (url === TAVILY_URL) {
+                    return Promise.resolve(tavilyResponse([{ url: "https://tavily.com/1", title: "T", content: "C", score: 0.9 }]));
+                }
+                return Promise.reject(new Error(`Unexpected URL: ${url}`));
+            });
+
+            const { results, providerUsed } = await executeSearch(subQueries);
+
+            expect(providerUsed).toBe("serper");
+            const { tavily, serper } = getFetchCallsByUrl(fetchSpy);
+            expect(serper).toBe(1);
+            expect(tavily).toBe(0);
+            expect(results).toHaveLength(1);
+            expect(results[0]!.url).toBe("https://serper.com/ok");
+        });
+    });
+
+    describe('"parallel" strategy calls both providers and merges results', () => {
+        it("when strategy is parallel, both Serper and Tavily are called and providerUsed is tavily+serper", async () => {
+            env.server.SEARCH_PROVIDER = "parallel";
+            fetchSpy.mockImplementation((input: RequestInfo | URL) => {
+                const url = typeof input === "string" ? input : input instanceof URL ? input.href : (input as Request).url;
+                if (url === SERPER_URL) {
+                    return Promise.resolve(serperResponse([{ link: "https://serper.com/1", title: "S", snippet: "S" }]));
+                }
+                if (url === TAVILY_URL) {
+                    return Promise.resolve(tavilyResponse([{ url: "https://tavily.com/1", title: "T", content: "C", score: 0.9 }]));
+                }
+                return Promise.reject(new Error(`Unexpected URL: ${url}`));
+            });
+
+            const { results, providerUsed } = await executeSearch(subQueries);
+
+            expect(providerUsed).toBe("tavily+serper");
+            const { tavily, serper } = getFetchCallsByUrl(fetchSpy);
+            expect(serper).toBe(1);
+            expect(tavily).toBe(1);
+            expect(results).toHaveLength(2);
+            const urls = results.map((r) => r.url).sort();
+            expect(urls).toEqual(["https://serper.com/1", "https://tavily.com/1"]);
+        });
+    });
+
+    describe('"parallel" strategy deduplicates by URL (first provider wins)', () => {
+        it("when both providers return the same URL, Serper row is kept — scores are not comparable across providers", async () => {
+            env.server.SEARCH_PROVIDER = "parallel";
+            const sameUrl = "https://example.com/same";
+            fetchSpy.mockImplementation((input: RequestInfo | URL) => {
+                const url = typeof input === "string" ? input : input instanceof URL ? input.href : (input as Request).url;
+                if (url === SERPER_URL) {
+                    return Promise.resolve(
+                        serperResponse([{ link: sameUrl, title: "From Serper", snippet: "S" }])
+                    );
+                }
+                if (url === TAVILY_URL) {
+                    return Promise.resolve(
+                        tavilyResponse([{ url: sameUrl, title: "From Tavily", content: "C", score: 0.95 }])
+                    );
+                }
+                return Promise.reject(new Error(`Unexpected URL: ${url}`));
+            });
+
+            const { results, providerUsed } = await executeSearch(subQueries);
+
+            expect(providerUsed).toBe("tavily+serper");
+            expect(results).toHaveLength(1);
+            expect(results[0]!.url).toBe(sameUrl);
+            // One Serper hit: rank 1 of 1 → score 0 (see serper adapter); Tavily is ignored for this URL.
+            expect(results[0]!.score).toBe(0);
+            expect(results[0]!.title).toBe("From Serper");
+        });
+    });
+
+    describe('missing Serper key with "serper" strategy downgrades to "tavily"', () => {
+        it("when SEARCH_PROVIDER is serper but SERPER_API_KEY is unset, only Tavily is called and providerUsed is tavily", async () => {
+            env.server.SEARCH_PROVIDER = "serper";
+            env.server.SERPER_API_KEY = undefined as unknown as string;
+            const warnSpy = jest.spyOn(console, "warn").mockImplementation();
+
+            const { results, providerUsed } = await executeSearch(subQueries);
+
+            expect(providerUsed).toBe("tavily");
+            const { tavily, serper } = getFetchCallsByUrl(fetchSpy);
+            expect(tavily).toBe(1);
+            expect(serper).toBe(0);
+            expect(results).toHaveLength(1);
+            expect(results[0]!.url).toBe("https://tavily.com/1");
+            expect(warnSpy).toHaveBeenCalledWith(
+                "[web-search] SERPER_API_KEY not set; downgrading strategy to tavily."
+            );
+            warnSpy.mockRestore();
+        });
+    });
+
+    describe("missing TAVILY_API_KEY on tavily path", () => {
+        it("returns empty results, providerUsed none, and does not call Tavily API", async () => {
+            env.server.SEARCH_PROVIDER = undefined;
+            env.server.TAVILY_API_KEY = undefined as unknown as string;
+            env.server.SERPER_API_KEY = "test-serper-key";
+            const warnSpy = jest.spyOn(console, "warn").mockImplementation();
+
+            const { results, providerUsed } = await executeSearch(subQueries);
+
+            expect(providerUsed).toBe("none");
+            expect(results).toHaveLength(0);
+            const { tavily, serper } = getFetchCallsByUrl(fetchSpy);
+            expect(tavily).toBe(0);
+            expect(serper).toBe(0);
+
+            warnSpy.mockRestore();
+        });
+    });
+
+    describe('"parallel" with Serper key but no Tavily key', () => {
+        it("uses providerUsed serper and only Serper fetch is made", async () => {
+            env.server.SEARCH_PROVIDER = "parallel";
+            env.server.SERPER_API_KEY = "test-serper-key";
+            env.server.TAVILY_API_KEY = undefined as unknown as string;
+            fetchSpy.mockImplementation((input: RequestInfo | URL) => {
+                const url = typeof input === "string" ? input : input instanceof URL ? input.href : (input as Request).url;
+                if (url === SERPER_URL) {
+                    return Promise.resolve(serperResponse([{ link: "https://serper.com/1", title: "S", snippet: "S" }]));
+                }
+                if (url === TAVILY_URL) {
+                    return Promise.resolve(tavilyResponse([{ url: "https://tavily.com/1", title: "T", content: "C", score: 0.9 }]));
+                }
+                return Promise.reject(new Error(`Unexpected URL: ${url}`));
+            });
+
+            const { results, providerUsed } = await executeSearch(subQueries);
+
+            expect(providerUsed).toBe("serper");
+            expect(results).toHaveLength(1);
+            expect(results[0]!.url).toBe("https://serper.com/1");
+            const { tavily, serper } = getFetchCallsByUrl(fetchSpy);
+            expect(serper).toBe(1);
+            expect(tavily).toBe(0);
+        });
+    });
+});
diff --git a/__tests__/api/trendSearch/serper-adapter.test.ts b/__tests__/api/trendSearch/serper-adapter.test.ts
new file mode 100644
index 00000000..c532ef10
--- /dev/null
+++ b/__tests__/api/trendSearch/serper-adapter.test.ts
@@ -0,0 +1,216 @@
+/**
+ * Unit tests for Serper adapter (callSerper).
+ * Feature: Serper dual-channel search — Task 4.1
+ */
+
+const mockFetch = jest.fn();
+
+jest.mock("~/env", () => ({
+  env: {
+    server: {
+      SERPER_API_KEY: "test-serper-key",
+    },
+  },
+}));
+
+import { env } from "~/env";
+import { callSerper } from "~/lib/tools/trend-search/providers/serper";
+
+const mockServer = env.server as { SERPER_API_KEY?: string | undefined };
+
+beforeEach(() => {
+  mockServer.SERPER_API_KEY = "test-serper-key";
+  mockFetch.mockReset();
+  jest.spyOn(globalThis, "fetch").mockImplementation(mockFetch);
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+const SERPER_NEWS_URL = "https://google.serper.dev/news";
+
+function makeOkResponse(body: { news?: unknown[] }) {
+  return {
+    ok: true,
+    text: async () => "",
+    json: async () => body,
+  } as Response;
+}
+
+function makeErrorResponse(status: number, statusText: string, body = "Error") {
+  return {
+    ok: false,
+    status,
+    statusText,
+    text: async () => body,
+    json: async () => {
+      throw new Error("not json");
+    },
+  } as unknown as Response;
+}
+
+describe("callSerper", () => {
+  describe("valid response normalizes correctly to RawSearchResult[]", () => {
+    it("maps link→url, title, snippet→content, score, publishedDate", async () => {
+      mockFetch.mockResolvedValue(
+        makeOkResponse({
+          news: [
+            {
+              title: "AI Trends 2026",
+              link: "https://example.com/1",
+              snippet: "Summary here",
+              date: "2 hours ago",
+              position: 1,
+            },
+          ],
+        }),
+      );
+
+      const results = await callSerper("AI trends");
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        SERPER_NEWS_URL,
+        expect.objectContaining({
+          method: "POST",
+          headers: {
+            "X-API-KEY": "test-serper-key",
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({ q: "AI trends", num: 10, gl: "us", hl: "en" }),
+        }),
+      );
+      expect(results).toHaveLength(1);
+      const r = results[0]!;
+      expect(r.url).toBe("https://example.com/1");
+      expect(r.title).toBe("AI Trends 2026");
+      expect(r.content).toBe("Summary here");
+      expect(r.score).toBeDefined();
+      expect(typeof r.score).toBe("number");
+      expect(r.publishedDate).toBe("2 hours ago");
+    });
+
+    it("uses Untitled and empty string when title/snippet missing", async () => {
+      mockFetch.mockResolvedValue(
+        makeOkResponse({
+          news: [{ link: "https://example.com/2" }],
+        }),
+      );
+
+      const results = await callSerper("query");
+
+      expect(results).toHaveLength(1);
+      expect(results[0]!.title).toBe("Untitled");
+      expect(results[0]!.content).toBe("");
+    });
+  });
+
+  describe("missing SERPER_API_KEY returns empty array", () => {
+    it("returns [] and does not call fetch when key is undefined", async () => {
+      const warnSpy = jest.spyOn(console, "warn").mockImplementation();
+      mockServer.SERPER_API_KEY = undefined;
+
+      const results = await callSerper("query");
+
+      expect(results).toEqual([]);
+      expect(mockFetch).not.toHaveBeenCalled();
+      warnSpy.mockRestore();
+    });
+  });
+
+  describe("non-2xx response throws error", () => {
+    it("throws with status and body text on 500", async () => {
+      mockFetch.mockResolvedValue(
+        makeErrorResponse(500, "Internal Server Error", "Server down"),
+      );
+
+      await expect(callSerper("query")).rejects.toThrow(
+        /Serper API error: 500 Internal Server Error.*Server down/,
+      );
+    });
+
+    it("throws on 401", async () => {
+      mockFetch.mockResolvedValue(
+        makeErrorResponse(401, "Unauthorized", "Invalid key"),
+      );
+
+      await expect(callSerper("query")).rejects.toThrow(/Serper API error: 401/);
+    });
+  });
+
+  describe("empty news array returns empty results", () => {
+    it("returns [] when news is empty array", async () => {
+      mockFetch.mockResolvedValue(makeOkResponse({ news: [] }));
+
+      const results = await callSerper("query");
+
+      expect(results).toEqual([]);
+    });
+
+    it("returns [] when news is missing", async () => {
+      mockFetch.mockResolvedValue(makeOkResponse({}));
+
+      const results = await callSerper("query");
+
+      expect(results).toEqual([]);
+    });
+  });
+
+  describe("positional score calculation is correct", () => {
+    it("first item has highest score, last has lowest (score = 1 - position/total)", async () => {
+      mockFetch.mockResolvedValue(
+        makeOkResponse({
+          news: [
+            { link: "https://a.com", position: 1 },
+            { link: "https://b.com", position: 2 },
+            { link: "https://c.com", position: 3 },
+          ],
+        }),
+      );
+
+      const results = await callSerper("query");
+
+      expect(results).toHaveLength(3);
+      const total = 3;
+      expect(results[0]!.score).toBeCloseTo(1 - 1 / total);
+      expect(results[1]!.score).toBeCloseTo(1 - 2 / total);
+      expect(results[2]!.score).toBeCloseTo(1 - 3 / total);
+      expect(results[0]!.score).toBeGreaterThan(results[1]!.score);
+      expect(results[1]!.score).toBeGreaterThan(results[2]!.score);
+    });
+
+    it("uses rank within items that have links only", async () => {
+      mockFetch.mockResolvedValue(
+        makeOkResponse({
+          news: [
+            { link: "https://a.com" },
+            { title: "no link — skipped" },
+            { link: "https://b.com" },
+          ],
+        }),
+      );
+
+      const results = await callSerper("query");
+
+      expect(results).toHaveLength(2);
+      expect(results[0]!.url).toBe("https://a.com");
+      expect(results[1]!.url).toBe("https://b.com");
+      expect(results[0]!.score).toBeCloseTo(1 - 1 / 2);
+      expect(results[1]!.score).toBeCloseTo(1 - 2 / 2);
+    });
+
+    it("uses index+1 when position is missing", async () => {
+      mockFetch.mockResolvedValue(
+        makeOkResponse({
+          news: [{ link: "https://a.com" }, { link: "https://b.com" }],
+        }),
+      );
+
+      const results = await callSerper("query");
+
+      expect(results).toHaveLength(2);
+      expect(results[0]!.score).toBeCloseTo(1 - 1 / 2);
+      expect(results[1]!.score).toBeCloseTo(1 - 2 / 2);
+    });
+  });
+});
diff --git a/__tests__/api/trendSearch/synthesizer.pbt.test.ts b/__tests__/api/trendSearch/synthesizer.pbt.test.ts
index 7ede35e7..185b7a78 100644
--- a/__tests__/api/trendSearch/synthesizer.pbt.test.ts
+++ b/__tests__/api/trendSearch/synthesizer.pbt.test.ts
@@ -30,11 +30,11 @@ const categoryArb = fc.constantFrom(...validCategories);
 
 const validQueryArb = fc
     .string({ minLength: 1, maxLength: 1000 })
-    .filter((s) => s.trim().length > 0);
+    .filter((s: string) => s.trim().length > 0);
 
 const validCompanyContextArb = fc
     .string({ minLength: 1, maxLength: 2000 })
-    .filter((s) => s.trim().length > 0);
+    .filter((s: string) => s.trim().length > 0);
 
 /** Single raw result (URL must be unique for traceability). */
 const rawResultArb = fc.record({
@@ -72,7 +72,12 @@ describe("Property 7: Synthesizer output structure", () => {
                 validQueryArb,
                 validCompanyContextArb,
                 fc.array(categoryArb, { minLength: 0, maxLength: 4 }),
-                async (rawResults, query, companyContext, categories) => {
+                async (
+                    rawResults: RawSearchResult[],
+                    query: string,
+                    companyContext: string,
+                    categories: SearchCategory[]
+                ) => {
                     const mockResults = buildMockResults(rawResults, 5);
                     mockInvoke.mockResolvedValue({ results: mockResults });
 
@@ -115,7 +120,12 @@ describe("Property 8: Source URL traceability", () => {
                 validQueryArb,
                 validCompanyContextArb,
                 fc.array(categoryArb, { minLength: 0, maxLength: 4 }),
-                async (rawResults, query, companyContext, categories) => {
+                async (
+                    rawResults: RawSearchResult[],
+                    query: string,
+                    companyContext: string,
+                    categories: SearchCategory[]
+                ) => {
                     const urlSet = new Set(rawResults.map((r) => r.url));
                     const mockResults = buildMockResults(rawResults, 5);
                     mockInvoke.mockResolvedValue({ results: mockResults });
diff --git a/__tests__/api/trendSearch/web-search.pbt.test.ts b/__tests__/api/trendSearch/web-search.pbt.test.ts
index 6347a2f3..41871d6a 100644
--- a/__tests__/api/trendSearch/web-search.pbt.test.ts
+++ b/__tests__/api/trendSearch/web-search.pbt.test.ts
@@ -112,11 +112,11 @@ describe("Unit: one sub-query returns 0 results, pipeline continues", () => {
             );
         });
 
-        const result = await executeSearch(subQueries);
+        const { results } = await executeSearch(subQueries);
 
         expect(fetchSpy).toHaveBeenCalledTimes(3);
-        expect(result.results).toHaveLength(2);
-        expect(result.results.map((r) => r.url)).toEqual(["https://b.com", "https://c.com"]);
+        expect(results).toHaveLength(2);
+        expect(results.map((r) => r.url)).toEqual(["https://b.com", "https://c.com"]);
     });
 });
 
@@ -151,14 +151,14 @@ describe("Unit: Tavily fails, retries 2 times then marks sub-query failed", () =
         const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
         const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
 
-        const result = await executeSearch(subQueries);
+        const { results } = await executeSearch(subQueries);
 
         consoleErrorSpy.mockRestore();
         consoleWarnSpy.mockRestore();
 
         // 1 + 2 retries for first sub-query, then 1 for second
         expect(fetchSpy).toHaveBeenCalledTimes(4);
-        expect(result.results).toHaveLength(1);
-        expect(result.results[0].url).toBe("https://ok.com");
+        expect(results).toHaveLength(1);
+        expect(results[0]!.url).toBe("https://ok.com");
     });
 });
diff --git a/docker-compose.yml b/docker-compose.yml
index 7b41ca40..aa831c4e 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -77,7 +77,9 @@ services:
       LANDING_AI_API_KEY: ${LANDING_AI_API_KEY:-}
       # Anthropic / Google (optional — enables Claude and Gemini models)
       ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY:-}
+      ANTHROPIC_MODEL: ${ANTHROPIC_MODEL:-}
       GOOGLE_AI_API_KEY: ${GOOGLE_AI_API_KEY:-}
+      GOOGLE_MODEL: ${GOOGLE_MODEL:-}
       # Ollama (optional — set OLLAMA_BASE_URL to an Ollama instance)
       OLLAMA_BASE_URL: ${OLLAMA_BASE_URL:-}
       OLLAMA_MODEL: ${OLLAMA_MODEL:-}
diff --git a/docs/deployment.md b/docs/deployment.md
index 92427abc..55b4a16f 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -65,6 +65,10 @@ Optional integrations:
 - LangSmith for tracing
 - Sidecar (deploy separately and set `SIDECAR_URL`)
 
+### Trend search (optional)
+
+Trend search calls external search APIs. Configure `TAVILY_API_KEY` and/or `SERPER_API_KEY` and set `SEARCH_PROVIDER` as documented in [`.env.example`](../.env.example) (`tavily`, `serper`, `fallback`, or `parallel`). If no API key backs the chosen path, the pipeline returns empty results and `providerUsed` may be `none`—this is expected when keys are omitted for local or OSS setups.
+
 ### Verifying Blob uploads on Vercel
 
 1. After deploy, sign in to the Employer portal and open `/employer/upload`.
@@ -98,7 +102,9 @@ Optional: Run the sidecar separately and point `SIDECAR_URL` to it.
 | `BLOB_READ_WRITE_TOKEN` | Yes (Vercel) | Required for Vercel Blob uploads |
 | `UPLOADTHING_TOKEN` | Optional | UploadThing legacy uploader |
 | `SIDECAR_URL` | Optional | Sidecar URL for reranking and Graph RAG |
-| `TAVILY_API_KEY` | Optional | Web search for analysis |
+| `TAVILY_API_KEY` | Optional | Tavily (trend search); required for `tavily` / `fallback` / `parallel` when using Tavily |
+| `SERPER_API_KEY` | Optional | Serper Google News (trend search); required for `serper` / `fallback` / `parallel` when using Serper |
+| `SEARCH_PROVIDER` | Optional | `tavily` (default), `serper`, `fallback`, or `parallel` — see `.env.example` |
 | `AZURE_DOC_INTELLIGENCE_*` | Optional | OCR for scanned PDFs |
 | `DATALAB_API_KEY` | Optional | Alternative OCR |
 | `LANDING_AI_API_KEY` | Optional | Fallback OCR |
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 61d83649..a0827d95 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -14442,7 +14442,7 @@ snapshots:
       isstream: 0.1.2
       jsonwebtoken: 9.0.3
       mime-types: 2.1.35
-      retry-axios: 2.6.0(axios@1.7.4)
+      retry-axios: 2.6.0(axios@1.7.4(debug@4.4.3))
       tough-cookie: 4.1.4
     transitivePeerDependencies:
       - supports-color
@@ -16762,7 +16762,7 @@ snapshots:
       path-parse: 1.0.7
       supports-preserve-symlinks-flag: 1.0.0
 
-  retry-axios@2.6.0(axios@1.7.4):
+  retry-axios@2.6.0(axios@1.7.4(debug@4.4.3)):
     dependencies:
       axios: 1.7.4(debug@4.4.3)
 
diff --git a/scripts/test-trend-search.ts b/scripts/test-trend-search.ts
index 791cd048..d72910b8 100644
--- a/scripts/test-trend-search.ts
+++ b/scripts/test-trend-search.ts
@@ -3,11 +3,17 @@
  * Calls the real OpenAI + Tavily APIs — no DB, no auth, no Inngest.
  *
  * Usage:
+ * 
+ * 1. Tavilly
  *   npx tsx scripts/test-trend-search.ts
  *
+ * 2. Serper
+ *   SEARCH_PROVIDER="serper" npx tsx scripts/test-trend-search.ts
+ *
  * Required env vars (reads from .env automatically via dotenv):
  *   OPENAI_API_KEY
- *   TAVILY_API_KEY
+ *   TAVILY_API_KEY (if using Tavily)
+ *   SERPER_API_KEY (if using Serper)
  * 
  *
  *   ┌─────────────────────────────────────────────────────────────────────────────┐
@@ -15,12 +21,13 @@
  *   │                                                                             │
  *   │  Required env vars:                                                         │
  *   │   - OPENAI_API_KEY                                                          │
- *   │   - TAVILY_API_KEY                                                          │
+ *   │   - TAVILY_API_KEY (if using Tavily)                                        │
+ *   │   - SERPER_API_KEY (if using Serper)                                        │
  *   │                                                                             │
  *   │  Sample output:                                                             │
  *   └─────────────────────────────────────────────────────────────────────────────┘
  *
-─── Input ───
+─── Input ─── (tavily)
 {
   "query": "latest AI trends in retail marketing",
   "companyContext": "We are a mid-size fashion retailer focused on Gen Z customers in the US market.",
@@ -73,6 +80,61 @@ Running pipeline (plan → search → synthesize)…
     "createdAt": "2026-02-23T08:41:22.609Z"
   }
 }
+
+─── Input ─── (serper)
+{
+  "query": "latest AI trends in retail marketing",
+  "companyContext": "We are a mid-size fashion retailer focused on Gen Z customers in the US market.",
+  "categories": [
+    "fashion",
+    "tech"
+  ]
+}
+
+Running pipeline (plan → search → synthesize)…
+
+  ⏳ stage: searching
+[trend-search] Search provider used: serper
+  ⏳ stage: synthesizing
+─── Output ───
+{
+  "results": [
+    {
+      "sourceUrl": "https://www.businessoffashion.com/articles/marketing-pr/fashions-new-ai-marketing-toolkit/",
+      "summary": "Fashion brands are leveraging AI tools to enhance marketing campaigns.",
+      "description": "This article discusses how various fashion brands are utilizing AI to create faster, cheaper, and more personalized marketing campaigns. Given your focus on Gen Z customers, understanding these AI marketing strategies can help your mid-size fashion retail company effectively engage with this demographic, which values personalization and innovative marketing approaches."
+    },
+    {
+      "sourceUrl": "https://www.mckinsey.com/industries/retail/our-insights/merchants-unleashed-how-agentic-ai-transforms-retail-merchandising",
+      "summary": "AI is transforming retail merchandising, allowing for more efficient operations.",
+      "description": "This McKinsey article highlights how AI is reshaping retail merchandising, enabling retailers to optimize their operations and better meet consumer demands. As a fashion retailer targeting Gen Z, adopting AI-driven merchandising strategies can enhance your inventory management and customer engagement, aligning with the preferences of this tech-savvy generation."
+    },
+    {
+      "sourceUrl": "https://www.retailtouchpoints.com/executive-viewpoints/how-ai-can-handle-the-3-biggest-gen-z-retail-trends-that-shaped-the-2025-holiday-season/156558/",
+      "summary": "AI can address key retail trends influencing Gen Z shopping behaviors.",
+      "description": "This piece explores how AI can help retailers adapt to the evolving trends that shape Gen Z's shopping habits. It provides insights into the values and preferences of Gen Z consumers, which is crucial for your company as you aim to connect with this audience through effective marketing and product offerings."
+    },
+    {
+      "sourceUrl": "https://www.mckinsey.com/industries/consumer-packaged-goods/our-insights/the-state-of-the-us-consumer",
+      "summary": "AI is influencing US consumer spending trends, particularly among younger demographics.",
+      "description": "This report from McKinsey discusses the impact of AI on consumer spending, particularly highlighting how younger consumers, including Gen Z, are embracing AI-supported shopping experiences. Understanding these trends can help your fashion retail business tailor its marketing strategies to better resonate with Gen Z customers."
+    },
+    {
+      "sourceUrl": "https://www.deloitte.com/us/en/Industries/consumer/articles/future-of-fashion-omnichannel-strategies.html",
+      "summary": "Digital transformation and omnichannel strategies are crucial for future fashion retail.",
+      "description": "This article outlines how digital transformation and omnichannel strategies are shaping the future of fashion retail. For a mid-size fashion retailer focused on Gen Z, leveraging these strategies can enhance customer experiences and improve engagement across various platforms, aligning with the expectations of today's consumers."
+    }
+  ],
+  "metadata": {
+    "query": "latest AI trends in retail marketing",
+    "companyContext": "We are a mid-size fashion retailer focused on Gen Z customers in the US market.",
+    "categories": [
+      "fashion",
+      "tech"
+    ],
+    "createdAt": "2026-03-08T21:31:39.644Z"
+  }
+}
  */
 
 import dotenv from "dotenv";
diff --git a/src/app/api/agents/documentQ&A/services/models.ts b/src/app/api/agents/documentQ&A/services/models.ts
index 40d46316..ffe50b37 100644
--- a/src/app/api/agents/documentQ&A/services/models.ts
+++ b/src/app/api/agents/documentQ&A/services/models.ts
@@ -106,4 +106,3 @@ export function getEmbeddings(): OpenAIEmbeddings {
         openAIApiKey: process.env.OPENAI_API_KEY,
     });
 }
-
diff --git a/src/app/api/company/metadata/extract/route.ts b/src/app/api/company/metadata/extract/route.ts
index f0823e99..887949f6 100644
--- a/src/app/api/company/metadata/extract/route.ts
+++ b/src/app/api/company/metadata/extract/route.ts
@@ -1,18 +1,16 @@
 /**
- * Demo endpoint — Company Metadata Extraction
+ * POST /api/company/metadata/extract
  *
- * Processes ALL documents for the logged-in user's company, extracts
- * metadata from each, and merges them into a single canonical JSON.
- * No DB writes — returns the result directly.
+ * Extracts metadata from the logged-in user's company documents and merges
+ * them into a single canonical JSON.
+ *
+ * By default, only processes documents uploaded AFTER the last extraction
+ * (incremental mode). Use `{ "force": true }` to re-process all documents.
  *
  * Usage:
  *   POST /api/company/metadata/extract
- *   (no body required — uses the authenticated user's company)
- *
+ *   POST /api/company/metadata/extract   body: { "force": true }
  *   POST /api/company/metadata/extract   body: { "debug": true }
- *   (returns per-document diagnostics instead of running extraction)
- *
- * Returns the full CompanyMetadataJSON + aggregated diff.
  */
 
 import { NextResponse } from "next/server";
@@ -21,7 +19,7 @@ import { eq, sql } from "drizzle-orm";
 
 import { db } from "~/server/db";
 import { users, document as documentTable, documentContextChunks } from "~/server/db/schema";
-import { companyMetadata } from "~/server/db/schema/company-metadata";
+import { companyMetadata, companyMetadataHistory } from "~/server/db/schema/company-metadata";
 import { extractCompanyFacts } from "~/lib/tools/company-metadata/extractor";
 import { mergeCompanyMetadata } from "~/lib/tools/company-metadata/merger";
 import { createEmptyMetadata } from "~/lib/tools/company-metadata/types";
@@ -29,7 +27,6 @@ import type { CompanyMetadataJSON, MetadataDiff } from "~/lib/tools/company-meta
 
 export async function POST(request: Request) {
     try {
-        // Auth
         const { userId } = await auth();
         if (!userId) {
             return NextResponse.json(
@@ -52,118 +49,181 @@ export async function POST(request: Request) {
 
         const companyId = String(userInfo.companyId);
 
-        // Check for debug mode
+        // Parse optional body flags
         let debug = false;
+        let force = false;
         try {
-            const body = (await request.json()) as { debug?: boolean };
+            const body = (await request.json()) as { debug?: boolean; force?: boolean };
             debug = body.debug === true;
+            force = body.force === true;
         } catch {
-            // No body or invalid JSON — that's fine
+            // No body or invalid JSON — that's fine, defaults apply
         }
 
-        // Find all documents for this company
-        const docs = await db
-            .select({ id: documentTable.id, title: documentTable.title })
-            .from(documentTable)
-            .where(eq(documentTable.companyId, userInfo.companyId));
+        // Load existing metadata row (for incremental extraction)
+        const [existingRow] = await db
+            .select({
+                metadata: companyMetadata.metadata,
+                lastExtractionDocumentId: companyMetadata.lastExtractionDocumentId,
+            })
+            .from(companyMetadata)
+            .where(eq(companyMetadata.companyId, userInfo.companyId));
+
+        // Build document query — incremental by default, full if force=true or no prior extraction
+        const lastDocId = existingRow?.lastExtractionDocumentId;
+        const isIncremental = !force && lastDocId != null;
+
+        const docs = isIncremental
+            ? await db
+                  .select({ id: documentTable.id, title: documentTable.title })
+                  .from(documentTable)
+                  .where(
+                      sql`${documentTable.companyId} = ${userInfo.companyId} AND ${documentTable.id} > ${lastDocId}`,
+                  )
+            : await db
+                  .select({ id: documentTable.id, title: documentTable.title })
+                  .from(documentTable)
+                  .where(eq(documentTable.companyId, userInfo.companyId));
 
         if (docs.length === 0) {
             return NextResponse.json({
-                message: "No documents found for this company",
-                metadata: null,
+                message: isIncremental
+                    ? "No new documents since last extraction"
+                    : "No documents found for this company",
+                metadata: isIncremental ? existingRow?.metadata ?? null : null,
                 documentsProcessed: 0,
+                incremental: isIncremental,
             });
         }
 
-        // Debug mode: return per-document chunk counts without running extraction
-        if (debug) {
-            const diagnostics = [];
-            for (const doc of docs) {
-                const [row] = await db
-                    .select({ count: sql<number>`count(*)` })
-                    .from(documentContextChunks)
-                    .where(eq(documentContextChunks.documentId, BigInt(doc.id)));
-                diagnostics.push({
-                    documentId: doc.id,
-                    title: doc.title,
-                    chunkCount: Number(row?.count ?? 0),
-                });
-            }
-            return NextResponse.json({
-                companyId,
-                totalDocuments: docs.length,
-                documents: diagnostics,
-                documentsWithChunks: diagnostics.filter((d) => d.chunkCount > 0).length,
-            });
-        }
+        // For incremental: merge into existing. For full: start fresh (force) or merge into existing.
+        const baseMetadata = force ? null : existingRow?.metadata ?? null;
 
-        // Process each document sequentially, merging into canonical metadata
-        let metadata: CompanyMetadataJSON = createEmptyMetadata(companyId);
-        const allDiffs: MetadataDiff = { added: [], updated: [], deprecated: [] };
-        let documentsWithFacts = 0;
+        return processDocuments(docs, companyId, userInfo.companyId, baseMetadata, debug, isIncremental, userId);
+    } catch (error) {
+        console.error("[company-metadata] POST /extract error:", error);
+        return NextResponse.json(
+            { error: "Internal server error" },
+            { status: 500 },
+        );
+    }
+}
 
+async function processDocuments(
+    docs: Array<{ id: number; title: string }>,
+    companyId: string,
+    companyIdBigint: bigint,
+    existingMetadata: CompanyMetadataJSON | null,
+    debug: boolean,
+    incremental: boolean,
+    userId: string,
+) {
+    // Debug mode: return per-document chunk counts without running extraction
+    if (debug) {
+        const diagnostics = [];
         for (const doc of docs) {
-            const extracted = await extractCompanyFacts({
+            const [row] = await db
+                .select({ count: sql<number>`count(*)` })
+                .from(documentContextChunks)
+                .where(eq(documentContextChunks.documentId, BigInt(doc.id)));
+            diagnostics.push({
                 documentId: doc.id,
-                companyId,
+                title: doc.title,
+                chunkCount: Number(row?.count ?? 0),
             });
+        }
+        return NextResponse.json({
+            companyId,
+            incremental,
+            totalDocuments: docs.length,
+            documents: diagnostics,
+            documentsWithChunks: diagnostics.filter((d) => d.chunkCount > 0).length,
+        });
+    }
 
-            if (!extracted) continue;
+    // Start from existing metadata (incremental) or empty (full re-extract)
+    let metadata: CompanyMetadataJSON = existingMetadata ?? createEmptyMetadata(companyId);
+    const allDiffs: MetadataDiff = { added: [], updated: [], deprecated: [] };
+    let documentsWithFacts = 0;
+    let lastDocId = 0;
 
-            const { updatedMetadata, diff } = mergeCompanyMetadata(
-                metadata,
-                extracted,
-            );
+    for (const doc of docs) {
+        const extracted = await extractCompanyFacts({
+            documentId: doc.id,
+            companyId,
+        });
 
-            metadata = updatedMetadata;
-            allDiffs.added.push(...diff.added);
-            allDiffs.updated.push(...diff.updated);
-            allDiffs.deprecated.push(...diff.deprecated);
-            documentsWithFacts++;
-        }
+        if (!extracted) continue;
 
-        if (documentsWithFacts === 0) {
-            return NextResponse.json({
-                message: "No extractable company facts found in any document",
-                metadata: null,
-                documentsProcessed: docs.length,
-            });
-        }
+        const { updatedMetadata, diff } = mergeCompanyMetadata(
+            metadata,
+            extracted,
+        );
 
-        // Save to database
-        await db
-            .insert(companyMetadata)
-            .values({
-                companyId: userInfo.companyId,
-                metadata: metadata,
-            })
-            .onConflictDoUpdate({
-                target: companyMetadata.companyId,
-                set: {
-                    metadata: metadata,
-                },
-            });
+        metadata = updatedMetadata;
+        allDiffs.added.push(...diff.added);
+        allDiffs.updated.push(...diff.updated);
+        allDiffs.deprecated.push(...diff.deprecated);
+        documentsWithFacts++;
+        lastDocId = Math.max(lastDocId, doc.id);
+    }
 
+    if (documentsWithFacts === 0 && !existingMetadata) {
         return NextResponse.json({
-            metadata,
+            message: "No extractable company facts found in any document",
+            metadata: null,
             documentsProcessed: docs.length,
-            documentsWithFacts,
-            diff: {
-                added: allDiffs.added,
-                updated: allDiffs.updated,
-                deprecated: allDiffs.deprecated,
-                summary: {
-                    added: allDiffs.added.length,
-                    updated: allDiffs.updated.length,
-                    deprecated: allDiffs.deprecated.length,
-                },
+            incremental,
+        });
+    }
+
+    // Update provenance
+    metadata.provenance.total_documents_processed =
+        (existingMetadata?.provenance.total_documents_processed ?? 0) +
+        (incremental ? documentsWithFacts : documentsWithFacts);
+
+    // Save to database with lastExtractionDocumentId tracking
+    await db
+        .insert(companyMetadata)
+        .values({
+            companyId: companyIdBigint,
+            metadata: metadata,
+            ...(lastDocId > 0 && { lastExtractionDocumentId: BigInt(lastDocId) }),
+        })
+        .onConflictDoUpdate({
+            target: companyMetadata.companyId,
+            set: {
+                metadata: metadata,
+                ...(lastDocId > 0 && { lastExtractionDocumentId: BigInt(lastDocId) }),
             },
         });
-    } catch (error) {
-        console.error("[company-metadata] POST /extract error:", error);
-        return NextResponse.json(
-            { error: "Internal server error" },
-            { status: 500 },
-        );
+
+    // Write audit history entry for this extraction
+    const hasChanges = allDiffs.added.length > 0 || allDiffs.updated.length > 0 || allDiffs.deprecated.length > 0;
+    if (hasChanges) {
+        await db.insert(companyMetadataHistory).values({
+            companyId: companyIdBigint,
+            documentId: lastDocId > 0 ? BigInt(lastDocId) : null,
+            changeType: "extraction",
+            diff: allDiffs,
+            changedBy: userId,
+        });
     }
+
+    return NextResponse.json({
+        metadata,
+        documentsProcessed: docs.length,
+        documentsWithFacts,
+        incremental,
+        diff: {
+            added: allDiffs.added,
+            updated: allDiffs.updated,
+            deprecated: allDiffs.deprecated,
+            summary: {
+                added: allDiffs.added.length,
+                updated: allDiffs.updated.length,
+                deprecated: allDiffs.deprecated.length,
+            },
+        },
+    });
 }
diff --git a/src/app/api/company/metadata/history/route.ts b/src/app/api/company/metadata/history/route.ts
new file mode 100644
index 00000000..df108c88
--- /dev/null
+++ b/src/app/api/company/metadata/history/route.ts
@@ -0,0 +1,56 @@
+/**
+ * GET /api/company/metadata/history
+ *
+ * Returns the audit history for the logged-in user's company metadata.
+ * Sorted newest-first, limited to 100 entries.
+ */
+
+import { NextResponse } from "next/server";
+import { auth } from "@clerk/nextjs/server";
+import { eq, desc } from "drizzle-orm";
+
+import { db } from "~/server/db";
+import { users } from "~/server/db/schema";
+import { companyMetadataHistory } from "~/server/db/schema/company-metadata";
+
+export async function GET() {
+    try {
+        const { userId } = await auth();
+        if (!userId) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const [userInfo] = await db
+            .select({ companyId: users.companyId })
+            .from(users)
+            .where(eq(users.userId, userId));
+
+        if (!userInfo) {
+            return NextResponse.json({ error: "User not found" }, { status: 400 });
+        }
+
+        const history = await db
+            .select({
+                id: companyMetadataHistory.id,
+                changeType: companyMetadataHistory.changeType,
+                diff: companyMetadataHistory.diff,
+                changedBy: companyMetadataHistory.changedBy,
+                documentId: companyMetadataHistory.documentId,
+                createdAt: companyMetadataHistory.createdAt,
+            })
+            .from(companyMetadataHistory)
+            .where(eq(companyMetadataHistory.companyId, userInfo.companyId))
+            .orderBy(desc(companyMetadataHistory.createdAt))
+            .limit(100);
+
+        const serializable = history.map((h) => ({
+            ...h,
+            documentId: h.documentId != null ? String(h.documentId) : null,
+        }));
+
+        return NextResponse.json({ history: serializable });
+    } catch (error) {
+        console.error("[company-metadata/history] GET error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}
diff --git a/src/app/api/company/metadata/route.ts b/src/app/api/company/metadata/route.ts
index e27fb685..4ad228ab 100644
--- a/src/app/api/company/metadata/route.ts
+++ b/src/app/api/company/metadata/route.ts
@@ -7,10 +7,11 @@
 import { NextResponse } from "next/server";
 import { auth } from "@clerk/nextjs/server";
 import { eq } from "drizzle-orm";
+import { z } from "zod";
 
 import { db } from "~/server/db";
 import { users } from "~/server/db/schema";
-import { companyMetadata } from "~/server/db/schema/company-metadata";
+import { companyMetadata, companyMetadataHistory } from "~/server/db/schema/company-metadata";
 
 export async function GET() {
     try {
@@ -65,3 +66,133 @@ export async function GET() {
         );
     }
 }
+
+const PatchSchema = z.object({
+    path: z.string().min(1),
+    value: z.string(),
+});
+
+function buildManualFact(value: string | number, existing?: { visibility?: string; usage?: string }) {
+    const now = new Date().toISOString();
+    return {
+        value,
+        visibility: (existing?.visibility as "public" | "internal" | "confidential") ?? ("public" as const),
+        usage: (existing?.usage as "outreach_ok" | "internal_only" | "do_not_use") ?? ("outreach_ok" as const),
+        confidence: 1.0,
+        priority: "manual_override" as const,
+        status: "active" as const,
+        last_updated: now,
+        sources: [{ doc_id: 0, doc_name: "Manual edit", extracted_at: now }],
+    };
+}
+
+export async function PATCH(request: Request) {
+    try {
+        const { userId } = await auth();
+        if (!userId) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const body = await request.json() as unknown;
+        const parsed = PatchSchema.safeParse(body);
+        if (!parsed.success) {
+            return NextResponse.json({ error: "Invalid request body" }, { status: 400 });
+        }
+        const { path, value } = parsed.data;
+
+        const [userInfo] = await db
+            .select({ companyId: users.companyId })
+            .from(users)
+            .where(eq(users.userId, userId));
+
+        if (!userInfo) {
+            return NextResponse.json({ error: "User not found" }, { status: 400 });
+        }
+
+        const [existing] = await db
+            .select({ metadata: companyMetadata.metadata })
+            .from(companyMetadata)
+            .where(eq(companyMetadata.companyId, userInfo.companyId));
+
+        if (!existing) {
+            return NextResponse.json(
+                { error: "No metadata found. Run extraction first." },
+                { status: 404 },
+            );
+        }
+
+        const updatedMetadata = structuredClone(existing.metadata);
+        const now = new Date().toISOString();
+        const segments = path.split(".");
+        let oldFact: unknown = undefined;
+        let updatedFact: unknown = undefined;
+
+        if (segments[0] === "company" && segments[1]) {
+            const field = segments[1];
+            const existingFact = updatedMetadata.company[field];
+            oldFact = existingFact;
+            updatedFact = buildManualFact(
+                field === "founded_year" ? Number(value) : value,
+                existingFact,
+            );
+            updatedMetadata.company[field] = updatedFact;
+        } else if (segments[0] === "people" && segments[1] && segments[2]) {
+            const idx = Number(segments[1]);
+            const field = segments[2];
+            if (isNaN(idx) || idx < 0 || idx >= updatedMetadata.people.length) {
+                return NextResponse.json({ error: "Invalid people index" }, { status: 400 });
+            }
+            const person = updatedMetadata.people[idx]!;
+            oldFact = person[field];
+            updatedFact = buildManualFact(value, person[field]);
+            person[field] = updatedFact;
+        } else if (segments[0] === "services" && segments[1] && segments[2]) {
+            const idx = Number(segments[1]);
+            const field = segments[2];
+            if (isNaN(idx) || idx < 0 || idx >= updatedMetadata.services.length) {
+                return NextResponse.json({ error: "Invalid services index" }, { status: 400 });
+            }
+            const service = updatedMetadata.services[idx]!;
+            oldFact = service[field];
+            updatedFact = buildManualFact(value, service[field]);
+            service[field] = updatedFact;
+        } else if (segments[0] === "markets" && segments[1] && segments[2] != null) {
+            const subfield = segments[1] as "primary" | "verticals" | "geographies";
+            const idx = Number(segments[2]);
+            const arr = updatedMetadata.markets[subfield];
+            if (!arr || isNaN(idx) || idx < 0 || idx >= arr.length) {
+                return NextResponse.json({ error: "Invalid markets index" }, { status: 400 });
+            }
+            oldFact = arr[idx];
+            updatedFact = buildManualFact(value, arr[idx]);
+            arr[idx] = updatedFact;
+        } else {
+            return NextResponse.json({ error: `Unsupported path: ${path}` }, { status: 400 });
+        }
+
+        updatedMetadata.updated_at = now;
+
+        const diff = {
+            added: oldFact ? [] : [{ path, new: updatedFact }],
+            updated: oldFact ? [{ path, old: oldFact, new: updatedFact }] : [],
+            deprecated: [],
+        };
+
+        await db
+            .update(companyMetadata)
+            .set({ metadata: updatedMetadata })
+            .where(eq(companyMetadata.companyId, userInfo.companyId));
+
+        await db.insert(companyMetadataHistory).values({
+            companyId: userInfo.companyId,
+            changeType: "manual_override",
+            diff,
+            changedBy: userId,
+        });
+
+        return NextResponse.json({ success: true, path, fact: updatedFact });
+    } catch (error) {
+        console.error("[company-metadata] PATCH error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}
diff --git a/src/app/api/marketing-pipeline/route.ts b/src/app/api/marketing-pipeline/route.ts
index 94a1cc0f..4f1e2dab 100644
--- a/src/app/api/marketing-pipeline/route.ts
+++ b/src/app/api/marketing-pipeline/route.ts
@@ -52,9 +52,13 @@ export async function POST(request: Request) {
             );
         }
 
+        const url = new URL(request.url);
+        const debug = url.searchParams.get("debug") === "true";
+
         const result = await runMarketingPipeline({
             companyId,
             input: validation.data,
+            debug,
         });
 
         return NextResponse.json(
diff --git a/src/app/employer/documents/components/CompanyMetadataPanel.tsx b/src/app/employer/documents/components/CompanyMetadataPanel.tsx
index 2fd6d91a..52a704a6 100644
--- a/src/app/employer/documents/components/CompanyMetadataPanel.tsx
+++ b/src/app/employer/documents/components/CompanyMetadataPanel.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import React, { useEffect, useState, useCallback } from "react";
+import React, { useEffect, useState, useCallback, useRef } from "react";
 import Link from "next/link";
 import {
   Building2,
@@ -8,9 +8,12 @@ import {
   Briefcase,
   RefreshCw,
   AlertCircle,
+  AlertTriangle,
   FileText,
+  Scale,
   Sparkles,
   Pencil,
+  Download,
 } from "lucide-react";
 import { Button } from "~/app/employer/documents/components/ui/button";
 import { Card, CardHeader, CardTitle, CardContent } from "~/app/employer/documents/components/ui/card";
@@ -20,7 +23,9 @@ import { PeopleSection } from "~/app/employer/metadata/components/PeopleSection"
 import { ServicesSection } from "~/app/employer/metadata/components/ServicesSection";
 import { MarketsSection } from "~/app/employer/metadata/components/MarketsSection";
 import { ProvenanceCard } from "~/app/employer/metadata/components/ProvenanceCard";
-import type { CompanyMetadataJSON } from "~/lib/tools/company-metadata/types";
+import { MetadataHistorySection } from "~/app/employer/metadata/components/MetadataHistorySection";
+import { LegalSection } from "~/app/employer/metadata/components/LegalSection";
+import type { CompanyMetadataJSON, CompanyInfo, PersonEntry } from "~/lib/tools/company-metadata/types";
 
 interface CompanyProfile {
   name: string;
@@ -42,7 +47,7 @@ interface StatsCardProps {
   title: string;
   value: number | string;
   icon: React.ComponentType<{ className?: string }>;
-  color: "purple" | "blue" | "green" | "amber";
+  color: "purple" | "blue" | "green" | "amber" | "rose";
 }
 
 const colorMap = {
@@ -50,6 +55,7 @@ const colorMap = {
   blue: { border: "border-l-blue-500", text: "text-blue-500" },
   green: { border: "border-l-green-500", text: "text-green-500" },
   amber: { border: "border-l-amber-500", text: "text-amber-500" },
+  rose: { border: "border-l-rose-500", text: "text-rose-500" },
 };
 
 function MetadataStatsCard({ title, value, icon: Icon, color }: StatsCardProps) {
@@ -78,6 +84,8 @@ export function CompanyMetadataPanel() {
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
   const [extracting, setExtracting] = useState(false);
+  const [isEditMode, setIsEditMode] = useState(false);
+  const previousDataRef = useRef<MetadataResponse | null>(null);
 
   const fetchMetadata = useCallback(async () => {
     setLoading(true);
@@ -102,12 +110,95 @@ export function CompanyMetadataPanel() {
     }
   }, []);
 
-  const runExtraction = useCallback(async () => {
+  const handleFieldSave = useCallback(async (path: string, value: string) => {
+    previousDataRef.current = data;
+    const now = new Date().toISOString();
+    const manualSource = { doc_id: 0, doc_name: "Manual edit", extracted_at: now };
+
+    // Optimistic update
+    setData((prev) => {
+      if (!prev?.metadata) return prev;
+      const m = structuredClone(prev.metadata);
+      const segments = path.split(".");
+
+      const buildFact = (val: string | number, existing?: { visibility?: string; usage?: string }) => ({
+        value: val,
+        visibility: existing?.visibility ?? "public",
+        usage: existing?.usage ?? "outreach_ok",
+        confidence: 1.0,
+        priority: "manual_override" as const,
+        status: "active" as const,
+        last_updated: now,
+        sources: [manualSource],
+      });
+
+      if (segments[0] === "company" && segments[1]) {
+        const field = segments[1];
+        const existing = m.company[field];
+        (m.company as Record<string, unknown>)[field] = buildFact(field === "founded_year" ? Number(value) : value, existing);
+      } else if (segments[0] === "people" && segments[1] && segments[2]) {
+        const idx = Number(segments[1]);
+        const field = segments[2];
+        const person = m.people[idx];
+        if (person) {
+          (person as Record<string, unknown>)[field] = buildFact(value, person[field]);
+        }
+      } else if (segments[0] === "services" && segments[1] && segments[2]) {
+        const idx = Number(segments[1]);
+        const field = segments[2];
+        const service = m.services[idx];
+        if (service) {
+          (service as Record<string, unknown>)[field] = buildFact(value, service[field]);
+        }
+      } else if (segments[0] === "markets" && segments[1] && segments[2] != null) {
+        const sub = segments[1] as "primary" | "verticals" | "geographies";
+        const idx = Number(segments[2]);
+        const arr = m.markets[sub];
+        if (arr?.[idx]) {
+          arr[idx] = buildFact(value, arr[idx]) as typeof arr[number];
+        }
+      }
+      m.updated_at = now;
+      return { ...prev, metadata: m };
+    });
+    try {
+      const res = await fetch("/api/company/metadata", {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ path, value }),
+      });
+      if (!res.ok) throw new Error("Save failed");
+      await fetchMetadata();
+    } catch (err) {
+      if (previousDataRef.current !== null) {
+        setData(previousDataRef.current);
+      }
+      throw err;
+    }
+  }, [data, fetchMetadata]);
+
+  const handleExportJson = useCallback(() => {
+    if (!data?.metadata) return;
+    const json = JSON.stringify(data.metadata, null, 2);
+    const blob = new Blob([json], { type: "application/json" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `company-metadata-${new Date().toISOString().split("T")[0]}.json`;
+    a.click();
+    URL.revokeObjectURL(url);
+  }, [data]);
+
+  const runExtraction = useCallback(async (force = false) => {
     setExtracting(true);
     setError(null);
     try {
-      const response = await fetch("/api/company/metadata/extract", { method: "POST" });
-      const result = (await response.json()) as { error?: string };
+      const response = await fetch("/api/company/metadata/extract", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ force }),
+      });
+      const result = (await response.json()) as { error?: string; message?: string };
       if (result.error) throw new Error(result.error);
       await fetchMetadata();
     } catch (err) {
@@ -183,13 +274,44 @@ export function CompanyMetadataPanel() {
           </div>
           <div className="flex gap-3">
             <Button
-              onClick={() => void runExtraction()}
+              onClick={handleExportJson}
+              disabled={!data?.metadata}
+              variant="outline"
+              className="rounded-xl h-9 px-4 gap-2 font-bold"
+            >
+              <Download className="w-4 h-4" />
+              Export JSON
+            </Button>
+            <Button
+              onClick={() => void runExtraction(false)}
               disabled={extracting}
               variant="outline"
               className="rounded-xl h-9 px-4 gap-2 font-bold"
+              title="Process only new documents since last extraction"
             >
               <Sparkles className={cn("w-4 h-4", extracting && "animate-pulse")} />
-              {extracting ? "Extracting..." : "Re-extract"}
+              {extracting ? "Extracting..." : "Extract New"}
+            </Button>
+            <Button
+              onClick={() => void runExtraction(true)}
+              disabled={extracting}
+              variant="outline"
+              className="rounded-xl h-9 px-4 gap-2 font-bold text-amber-600 hover:text-amber-700 border-amber-200 hover:border-amber-300"
+              title="Re-process all documents from scratch"
+            >
+              <RefreshCw className={cn("w-4 h-4", extracting && "animate-spin")} />
+              Full Re-extract
+            </Button>
+            <Button
+              onClick={() => setIsEditMode((prev) => !prev)}
+              variant={isEditMode ? "default" : "outline"}
+              className={cn(
+                "rounded-xl h-9 px-4 gap-2 font-bold",
+                isEditMode && "bg-purple-600 hover:bg-purple-700 text-white shadow-lg shadow-purple-500/20",
+              )}
+            >
+              <Pencil className="w-4 h-4" />
+              {isEditMode ? "Done" : "Edit"}
             </Button>
             <Button
               onClick={() => void fetchMetadata()}
@@ -301,7 +423,7 @@ export function CompanyMetadataPanel() {
           </Card>
         ) : (
           <>
-            <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4">
+            <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-5 gap-4">
               <MetadataStatsCard
                 title="Company Fields"
                 value={Object.keys(metadata.company).filter((k) => metadata.company[k]).length}
@@ -315,6 +437,12 @@ export function CompanyMetadataPanel() {
                 icon={Briefcase}
                 color="green"
               />
+              <MetadataStatsCard
+                title="Legal"
+                value={(metadata.legal ?? []).length}
+                icon={Scale}
+                color="rose"
+              />
               <MetadataStatsCard
                 title="Documents Processed"
                 value={metadata.provenance.total_documents_processed}
@@ -323,21 +451,91 @@ export function CompanyMetadataPanel() {
               />
             </div>
 
-            <CompanyInfoCard company={metadata.company} />
+            <MissingMetadataAlert company={metadata.company} people={metadata.people} />
+
+            <CompanyInfoCard
+              company={metadata.company}
+              isEditMode={isEditMode}
+              onFieldSave={handleFieldSave}
+            />
 
-            {metadata.people.length > 0 && <PeopleSection people={metadata.people} />}
+            {metadata.people.length > 0 && (
+              <PeopleSection people={metadata.people} isEditMode={isEditMode} onFieldSave={handleFieldSave} />
+            )}
 
-            {metadata.services.length > 0 && <ServicesSection services={metadata.services} />}
+            {metadata.services.length > 0 && (
+              <ServicesSection services={metadata.services} isEditMode={isEditMode} onFieldSave={handleFieldSave} />
+            )}
 
             {(metadata.markets.primary?.length ?? 0) > 0 ||
             (metadata.markets.geographies?.length ?? 0) > 0 ? (
-              <MarketsSection markets={metadata.markets} />
+              <MarketsSection markets={metadata.markets} isEditMode={isEditMode} onFieldSave={handleFieldSave} />
             ) : null}
 
+            {(metadata.legal ?? []).length > 0 && (
+              <LegalSection legal={metadata.legal ?? []} />
+            )}
+
             <ProvenanceCard provenance={metadata.provenance} updatedAt={data?.updatedAt} />
+
+            <MetadataHistorySection />
           </>
         )}
       </div>
     </div>
   );
 }
+
+/* Missing Metadata Alert */
+const EXPECTED_FIELDS: Array<{ key: keyof CompanyInfo; label: string }> = [
+  { key: "name", label: "Company Name" },
+  { key: "industry", label: "Industry" },
+  { key: "headquarters", label: "Headquarters" },
+  { key: "founded_year", label: "Founded Year" },
+  { key: "description", label: "Description" },
+  { key: "website", label: "Website" },
+  { key: "size", label: "Company Size" },
+];
+
+function MissingMetadataAlert({ company, people }: { company: CompanyInfo; people: PersonEntry[] }) {
+  const missingFields = EXPECTED_FIELDS.filter((f) => {
+    const field = company[f.key];
+    if (!field) return true;
+    const val = (field as { value?: unknown }).value;
+    return val === undefined || val === null || val === "";
+  });
+  const peopleWithoutRoles = people.filter((p) => !p.role);
+
+  if (missingFields.length === 0 && peopleWithoutRoles.length === 0) return null;
+
+  return (
+    <Card className="p-4 border-amber-300 dark:border-amber-700 bg-amber-50 dark:bg-amber-950/30 shadow-sm">
+      <div className="flex items-start gap-3">
+        <div className="p-2 bg-amber-100 dark:bg-amber-900/40 rounded-lg shrink-0">
+          <AlertTriangle className="w-5 h-5 text-amber-600 dark:text-amber-400" />
+        </div>
+        <div className="flex-1 min-w-0">
+          <h4 className="text-sm font-bold text-amber-800 dark:text-amber-300">
+            Incomplete Metadata
+          </h4>
+          {missingFields.length > 0 && (
+            <p className="text-sm text-amber-700 dark:text-amber-400 mt-1">
+              Missing company fields:{" "}
+              <span className="font-semibold">
+                {missingFields.map((f) => f.label).join(", ")}
+              </span>
+            </p>
+          )}
+          {peopleWithoutRoles.length > 0 && (
+            <p className="text-sm text-amber-700 dark:text-amber-400 mt-1">
+              {peopleWithoutRoles.length} {peopleWithoutRoles.length === 1 ? "person" : "people"} missing role information
+            </p>
+          )}
+          <p className="text-xs text-amber-600 dark:text-amber-500 mt-2">
+            Upload more documents or manually edit fields to fill in missing information.
+          </p>
+        </div>
+      </div>
+    </Card>
+  );
+}
diff --git a/src/app/employer/metadata/components/CompanyInfoCard.tsx b/src/app/employer/metadata/components/CompanyInfoCard.tsx
index 1ba61bec..bf5bdcb6 100644
--- a/src/app/employer/metadata/components/CompanyInfoCard.tsx
+++ b/src/app/employer/metadata/components/CompanyInfoCard.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import React from "react";
+import React, { useState, useEffect } from "react";
 import {
     Building2,
     Globe,
@@ -13,12 +13,15 @@ import {
 import { Card, CardHeader, CardTitle, CardContent } from "~/app/employer/documents/components/ui/card";
 import { ConfidenceBadge } from "./ConfidenceBadge";
 import { VisibilityBadge } from "./VisibilityBadge";
+import { PriorityBadge } from "./PriorityBadge";
 import type { CompanyInfo, MetadataFact } from "~/lib/tools/company-metadata/types";
 
 type AnyMetadataFact = MetadataFact<string> | MetadataFact<number> | MetadataFact<unknown>;
 
 interface CompanyInfoCardProps {
     company: CompanyInfo;
+    isEditMode?: boolean;
+    onFieldSave?: (field: string, value: string) => Promise<void>;
 }
 
 interface FieldDisplayProps {
@@ -26,12 +29,97 @@ interface FieldDisplayProps {
     fact: AnyMetadataFact | undefined;
     icon: React.ComponentType<{ className?: string }>;
     isLink?: boolean;
+    fieldKey: string;
+    isEditMode?: boolean;
+    onFieldSave?: (field: string, value: string) => Promise<void>;
 }
 
-function FieldDisplay({ label, fact, icon: Icon, isLink }: FieldDisplayProps) {
-    if (!fact) return null;
+/** Inline editor strip: input + Save/Reset buttons. Used inside both FieldDisplay and the description section. */
+function InlineEditor({
+    fieldKey,
+    initialValue,
+    multiline,
+    onFieldSave,
+    onReset,
+}: {
+    fieldKey: string;
+    initialValue: string;
+    multiline?: boolean;
+    onFieldSave: (field: string, value: string) => Promise<void>;
+    onReset: () => void;
+}) {
+    const [value, setValue] = useState(initialValue);
+    const [saving, setSaving] = useState(false);
+    const [localError, setLocalError] = useState<string | null>(null);
 
-    const value = String(fact.value);
+    // Keep value in sync if parent resets (isEditMode toggled off → on)
+    useEffect(() => {
+        setValue(initialValue);
+        setLocalError(null);
+    }, [initialValue]);
+
+    const handleSave = async () => {
+        if (value.trim() === initialValue) return;
+        setSaving(true);
+        setLocalError(null);
+        try {
+            await onFieldSave(fieldKey, value.trim());
+        } catch {
+            setLocalError("Failed to save. Try again.");
+        } finally {
+            setSaving(false);
+        }
+    };
+
+    return (
+        <div className="space-y-2">
+            {multiline ? (
+                <textarea
+                    className="w-full px-2 py-1 text-sm border border-border rounded bg-background text-foreground focus:outline-none focus:ring-2 focus:ring-purple-500 resize-none"
+                    rows={3}
+                    value={value}
+                    onChange={(e) => setValue(e.target.value)}
+                    disabled={saving}
+                />
+            ) : (
+                <input
+                    className="w-full px-2 py-1 text-sm border border-border rounded bg-background text-foreground focus:outline-none focus:ring-2 focus:ring-purple-500"
+                    value={value}
+                    onChange={(e) => setValue(e.target.value)}
+                    disabled={saving}
+                />
+            )}
+            {localError && <p className="text-xs text-destructive">{localError}</p>}
+            <div className="flex gap-2">
+                <button
+                    onClick={() => void handleSave()}
+                    disabled={saving || value.trim() === initialValue}
+                    className="px-2 py-1 text-xs font-semibold bg-purple-600 text-white rounded hover:bg-purple-700 disabled:opacity-50 transition-colors"
+                >
+                    {saving ? "Saving..." : "Save"}
+                </button>
+                <button
+                    onClick={() => { setValue(initialValue); setLocalError(null); onReset(); }}
+                    disabled={saving}
+                    className="px-2 py-1 text-xs font-semibold border border-border rounded hover:bg-muted transition-colors"
+                >
+                    Reset
+                </button>
+            </div>
+        </div>
+    );
+}
+
+function FieldDisplay({ label, fact, icon: Icon, isLink, fieldKey, isEditMode, onFieldSave }: FieldDisplayProps) {
+    const [editKey, setEditKey] = useState(0); // bump to reset InlineEditor
+    const currentValue = fact ? String(fact.value) : "";
+
+    // When edit mode is toggled off, bump key so InlineEditor resets on next open
+    useEffect(() => {
+        if (!isEditMode) setEditKey((k) => k + 1);
+    }, [isEditMode]);
+
+    if (!fact && !isEditMode) return null;
 
     return (
         <div className="flex items-start gap-3 p-4 rounded-lg bg-muted/50 hover:bg-muted transition-colors">
@@ -39,38 +127,63 @@ function FieldDisplay({ label, fact, icon: Icon, isLink }: FieldDisplayProps) {
                 <Icon className="w-4 h-4 text-purple-600 dark:text-purple-400" />
             </div>
             <div className="flex-1 min-w-0">
-                <div className="flex items-center gap-2 mb-1">
+                <div className="flex items-center gap-2 mb-1 flex-wrap">
                     <span className="text-xs font-semibold text-muted-foreground uppercase tracking-wide">
                         {label}
                     </span>
-                    <VisibilityBadge visibility={fact.visibility} />
-                    <ConfidenceBadge confidence={fact.confidence} />
+                    {fact && <VisibilityBadge visibility={fact.visibility} />}
+                    {fact && <ConfidenceBadge confidence={fact.confidence} />}
+                    {fact && <PriorityBadge priority={fact.priority} />}
                 </div>
-                {isLink && value.startsWith("http") ? (
-                    <a
-                        href={value}
-                        target="_blank"
-                        rel="noopener noreferrer"
-                        className="text-foreground font-medium hover:text-purple-600 transition-colors flex items-center gap-1 group"
-                    >
-                        <span className="truncate">{value}</span>
-                        <ExternalLink className="w-3 h-3 opacity-0 group-hover:opacity-100 transition-opacity shrink-0" />
-                    </a>
-                ) : (
-                    <p className="text-foreground font-medium">{value}</p>
-                )}
-                {fact.sources.length > 0 && (
-                    <p className="text-xs text-muted-foreground mt-1">
-                        Source: {fact.sources[0]?.doc_name ?? "Unknown"}
-                        {fact.sources.length > 1 && ` +${fact.sources.length - 1} more`}
-                    </p>
-                )}
+                {isEditMode && onFieldSave ? (
+                    <InlineEditor
+                        key={editKey}
+                        fieldKey={fieldKey}
+                        initialValue={currentValue}
+                        onFieldSave={onFieldSave}
+                        onReset={() => undefined}
+                    />
+                ) : fact ? (
+                    <>
+                        {isLink && currentValue.startsWith("http") ? (
+                            <a
+                                href={currentValue}
+                                target="_blank"
+                                rel="noopener noreferrer"
+                                className="text-foreground font-medium hover:text-purple-600 transition-colors flex items-center gap-1 group"
+                            >
+                                <span className="truncate">{currentValue}</span>
+                                <ExternalLink className="w-3 h-3 opacity-0 group-hover:opacity-100 transition-opacity shrink-0" />
+                            </a>
+                        ) : (
+                            <p className="text-foreground font-medium">{currentValue}</p>
+                        )}
+                        {fact.priority === "manual_override" ? (
+                            <p className="text-xs text-violet-600 dark:text-violet-400 font-semibold mt-1">
+                                Manual edit
+                            </p>
+                        ) : (fact.sources?.length ?? 0) > 0 ? (
+                            <p className="text-xs text-muted-foreground mt-1">
+                                Source: {fact.sources[0]?.doc_name ?? "Unknown"}
+                                {fact.sources.length > 1 && ` +${fact.sources.length - 1} more`}
+                            </p>
+                        ) : null}
+                    </>
+                ) : null}
             </div>
         </div>
     );
 }
 
-export function CompanyInfoCard({ company }: CompanyInfoCardProps) {
+export function CompanyInfoCard({ company, isEditMode, onFieldSave }: CompanyInfoCardProps) {
+    const [descEditKey, setDescEditKey] = useState(0);
+
+    useEffect(() => {
+        if (!isEditMode) setDescEditKey((k) => k + 1);
+    }, [isEditMode]);
+
+    const descValue = company.description ? String(company.description.value) : "";
+
     return (
         <Card className="border-none shadow-sm">
             <CardHeader className="border-b border-border pb-4">
@@ -92,47 +205,83 @@ export function CompanyInfoCard({ company }: CompanyInfoCardProps) {
                         label="Company Name"
                         fact={company.name}
                         icon={Building2}
+                        fieldKey="company.name"
+                        isEditMode={isEditMode}
+                        onFieldSave={onFieldSave}
                     />
                     <FieldDisplay
                         label="Industry"
                         fact={company.industry}
                         icon={Briefcase}
+                        fieldKey="company.industry"
+                        isEditMode={isEditMode}
+                        onFieldSave={onFieldSave}
                     />
                     <FieldDisplay
                         label="Headquarters"
                         fact={company.headquarters}
                         icon={MapPin}
+                        fieldKey="company.headquarters"
+                        isEditMode={isEditMode}
+                        onFieldSave={onFieldSave}
                     />
                     <FieldDisplay
                         label="Founded"
                         fact={company.founded_year}
                         icon={Calendar}
+                        fieldKey="company.founded_year"
+                        isEditMode={isEditMode}
+                        onFieldSave={onFieldSave}
                     />
                     <FieldDisplay
                         label="Company Size"
                         fact={company.size}
                         icon={Users}
+                        fieldKey="company.size"
+                        isEditMode={isEditMode}
+                        onFieldSave={onFieldSave}
                     />
                     <FieldDisplay
                         label="Website"
                         fact={company.website}
                         icon={Globe}
                         isLink
+                        fieldKey="company.website"
+                        isEditMode={isEditMode}
+                        onFieldSave={onFieldSave}
                     />
                 </div>
 
-                {company.description && (
+                {(company.description ?? isEditMode) && (
                     <div className="mt-6 p-4 rounded-lg bg-muted/50">
-                        <div className="flex items-center gap-2 mb-2">
+                        <div className="flex items-center gap-2 mb-2 flex-wrap">
                             <span className="text-xs font-semibold text-muted-foreground uppercase tracking-wide">
                                 Description
                             </span>
-                            <VisibilityBadge visibility={company.description.visibility} />
-                            <ConfidenceBadge confidence={company.description.confidence} />
+                            {company.description && (
+                                <>
+                                    <VisibilityBadge visibility={company.description.visibility} />
+                                    <ConfidenceBadge confidence={company.description.confidence} />
+                                    <PriorityBadge priority={company.description.priority} />
+                                </>
+                            )}
                         </div>
-                        <p className="text-foreground leading-relaxed">
-                            {String(company.description.value)}
-                        </p>
+                        {isEditMode && onFieldSave ? (
+                            <InlineEditor
+                                key={descEditKey}
+                                fieldKey="company.description"
+                                initialValue={descValue}
+                                multiline
+                                onFieldSave={onFieldSave}
+                                onReset={() => undefined}
+                            />
+                        ) : (
+                            company.description && (
+                                <p className="text-foreground leading-relaxed">
+                                    {descValue}
+                                </p>
+                            )
+                        )}
                     </div>
                 )}
             </CardContent>
diff --git a/src/app/employer/metadata/components/InlineEditor.tsx b/src/app/employer/metadata/components/InlineEditor.tsx
new file mode 100644
index 00000000..73053c48
--- /dev/null
+++ b/src/app/employer/metadata/components/InlineEditor.tsx
@@ -0,0 +1,72 @@
+"use client";
+
+import React, { useState, useEffect } from "react";
+
+interface InlineEditorProps {
+    path: string;
+    initialValue: string;
+    multiline?: boolean;
+    onSave: (path: string, value: string) => Promise<void>;
+}
+
+export function InlineEditor({ path, initialValue, multiline, onSave }: InlineEditorProps) {
+    const [value, setValue] = useState(initialValue);
+    const [saving, setSaving] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    useEffect(() => {
+        setValue(initialValue);
+        setError(null);
+    }, [initialValue]);
+
+    const handleSave = async () => {
+        if (value.trim() === initialValue) return;
+        setSaving(true);
+        setError(null);
+        try {
+            await onSave(path, value.trim());
+        } catch {
+            setError("Failed to save.");
+        } finally {
+            setSaving(false);
+        }
+    };
+
+    return (
+        <div className="space-y-1.5">
+            {multiline ? (
+                <textarea
+                    className="w-full px-2 py-1 text-sm border border-border rounded bg-background text-foreground focus:outline-none focus:ring-2 focus:ring-purple-500 resize-none"
+                    rows={3}
+                    value={value}
+                    onChange={(e) => setValue(e.target.value)}
+                    disabled={saving}
+                />
+            ) : (
+                <input
+                    className="w-full px-2 py-1 text-sm border border-border rounded bg-background text-foreground focus:outline-none focus:ring-2 focus:ring-purple-500"
+                    value={value}
+                    onChange={(e) => setValue(e.target.value)}
+                    disabled={saving}
+                />
+            )}
+            {error && <p className="text-xs text-destructive">{error}</p>}
+            <div className="flex gap-2">
+                <button
+                    onClick={() => void handleSave()}
+                    disabled={saving || value.trim() === initialValue}
+                    className="px-2 py-1 text-xs font-semibold bg-purple-600 text-white rounded hover:bg-purple-700 disabled:opacity-50 transition-colors"
+                >
+                    {saving ? "Saving..." : "Save"}
+                </button>
+                <button
+                    onClick={() => { setValue(initialValue); setError(null); }}
+                    disabled={saving}
+                    className="px-2 py-1 text-xs font-semibold border border-border rounded hover:bg-muted transition-colors"
+                >
+                    Reset
+                </button>
+            </div>
+        </div>
+    );
+}
diff --git a/src/app/employer/metadata/components/LegalSection.tsx b/src/app/employer/metadata/components/LegalSection.tsx
new file mode 100644
index 00000000..26396c44
--- /dev/null
+++ b/src/app/employer/metadata/components/LegalSection.tsx
@@ -0,0 +1,111 @@
+"use client";
+
+import React from "react";
+import { Scale, Calendar, Users as UsersIcon } from "lucide-react";
+import { Card, CardHeader, CardTitle, CardContent } from "~/app/employer/documents/components/ui/card";
+import { ConfidenceBadge } from "./ConfidenceBadge";
+import { VisibilityBadge } from "./VisibilityBadge";
+import { PriorityBadge } from "./PriorityBadge";
+import type { LegalEntry } from "~/lib/tools/company-metadata/types";
+
+interface LegalSectionProps {
+    legal: LegalEntry[];
+}
+
+export function LegalSection({ legal }: LegalSectionProps) {
+    return (
+        <Card className="border-none shadow-sm">
+            <CardHeader className="border-b border-border pb-4">
+                <div className="flex items-center gap-3">
+                    <div className="p-2 bg-rose-600 rounded-lg">
+                        <Scale className="w-5 h-5 text-white" />
+                    </div>
+                    <div>
+                        <CardTitle className="text-lg font-bold">Legal Documents</CardTitle>
+                        <p className="text-sm text-muted-foreground">
+                            {legal.length} {legal.length === 1 ? "document" : "documents"} identified
+                        </p>
+                    </div>
+                </div>
+            </CardHeader>
+            <CardContent className="pt-6">
+                <div className="space-y-4">
+                    {legal.map((entry, index) => (
+                        <LegalCard key={index} entry={entry} />
+                    ))}
+                </div>
+            </CardContent>
+        </Card>
+    );
+}
+
+function LegalCard({ entry }: { entry: LegalEntry }) {
+    const typeValue = entry.type ? String(entry.type.value) : null;
+    const statusValue = entry.status ? String(entry.status.value).toLowerCase() : null;
+
+    const statusColor = statusValue === "active"
+        ? "text-green-600 bg-green-100 dark:bg-green-900/30"
+        : statusValue === "expired"
+            ? "text-red-600 bg-red-100 dark:bg-red-900/30"
+            : "text-amber-600 bg-amber-100 dark:bg-amber-900/30";
+
+    return (
+        <div className="p-4 rounded-lg bg-muted/50 hover:bg-muted transition-colors">
+            <div className="flex-1 min-w-0">
+                <div className="flex items-center gap-2 flex-wrap mb-2">
+                    <h4 className="font-semibold text-foreground">
+                        {String(entry.name.value)}
+                    </h4>
+                    {typeValue && (
+                        <span className="px-2 py-0.5 rounded-full text-[10px] font-semibold bg-rose-100 text-rose-700 dark:bg-rose-900/30 dark:text-rose-400">
+                            {typeValue.replace(/_/g, " ")}
+                        </span>
+                    )}
+                    {statusValue && (
+                        <span className={`px-2 py-0.5 rounded-full text-[10px] font-semibold ${statusColor}`}>
+                            {statusValue.charAt(0).toUpperCase() + statusValue.slice(1)}
+                        </span>
+                    )}
+                    <VisibilityBadge visibility={entry.name.visibility} />
+                    <PriorityBadge priority={entry.name.priority} />
+                </div>
+
+                {entry.summary && (
+                    <p className="text-sm text-muted-foreground leading-relaxed mb-2">
+                        {String(entry.summary.value)}
+                    </p>
+                )}
+
+                <div className="flex flex-wrap gap-4 text-xs text-muted-foreground">
+                    {entry.effective_date && (
+                        <span className="flex items-center gap-1">
+                            <Calendar className="w-3 h-3" />
+                            Effective: {String(entry.effective_date.value)}
+                        </span>
+                    )}
+                    {entry.expiry_date && (
+                        <span className="flex items-center gap-1">
+                            <Calendar className="w-3 h-3" />
+                            Expires: {String(entry.expiry_date.value)}
+                        </span>
+                    )}
+                    {entry.parties && (
+                        <span className="flex items-center gap-1">
+                            <UsersIcon className="w-3 h-3" />
+                            {String(entry.parties.value)}
+                        </span>
+                    )}
+                </div>
+
+                <div className="flex items-center gap-2 mt-3">
+                    <ConfidenceBadge confidence={entry.name.confidence} />
+                    {entry.name.sources.length > 0 && (
+                        <span className="text-[10px] text-muted-foreground">
+                            from {entry.name.sources[0]?.doc_name ?? "document"}
+                        </span>
+                    )}
+                </div>
+            </div>
+        </div>
+    );
+}
diff --git a/src/app/employer/metadata/components/MarketsSection.tsx b/src/app/employer/metadata/components/MarketsSection.tsx
index c2dc372a..be761b19 100644
--- a/src/app/employer/metadata/components/MarketsSection.tsx
+++ b/src/app/employer/metadata/components/MarketsSection.tsx
@@ -1,17 +1,20 @@
 "use client";
 
-import React from "react";
+import React, { useState, useEffect } from "react";
 import { Globe, Target, MapPin } from "lucide-react";
 import { Card, CardHeader, CardTitle, CardContent } from "~/app/employer/documents/components/ui/card";
 import { ConfidenceBadge } from "./ConfidenceBadge";
 import { VisibilityBadge } from "./VisibilityBadge";
+import { PriorityBadge } from "./PriorityBadge";
 import type { MarketsInfo, MetadataFact } from "~/lib/tools/company-metadata/types";
 
 interface MarketsSectionProps {
     markets: MarketsInfo;
+    isEditMode?: boolean;
+    onFieldSave?: (path: string, value: string) => Promise<void>;
 }
 
-export function MarketsSection({ markets }: MarketsSectionProps) {
+export function MarketsSection({ markets, isEditMode, onFieldSave }: MarketsSectionProps) {
     const hasPrimary = markets.primary && markets.primary.length > 0;
     const hasVerticals = markets.verticals && markets.verticals.length > 0;
     const hasGeographies = markets.geographies && markets.geographies.length > 0;
@@ -36,25 +39,34 @@ export function MarketsSection({ markets }: MarketsSectionProps) {
                     {hasPrimary && (
                         <MarketGroup
                             title="Primary Markets"
+                            subfield="primary"
                             icon={Target}
                             items={markets.primary!}
                             color="purple"
+                            isEditMode={isEditMode}
+                            onFieldSave={onFieldSave}
                         />
                     )}
                     {hasVerticals && (
                         <MarketGroup
                             title="Verticals"
+                            subfield="verticals"
                             icon={Target}
                             items={markets.verticals!}
                             color="blue"
+                            isEditMode={isEditMode}
+                            onFieldSave={onFieldSave}
                         />
                     )}
                     {hasGeographies && (
                         <MarketGroup
                             title="Geographies"
+                            subfield="geographies"
                             icon={MapPin}
                             items={markets.geographies!}
                             color="green"
+                            isEditMode={isEditMode}
+                            onFieldSave={onFieldSave}
                         />
                     )}
                 </div>
@@ -65,9 +77,12 @@ export function MarketsSection({ markets }: MarketsSectionProps) {
 
 interface MarketGroupProps {
     title: string;
+    subfield: string;
     icon: React.ComponentType<{ className?: string }>;
     items: MetadataFact[];
     color: "purple" | "blue" | "green";
+    isEditMode?: boolean;
+    onFieldSave?: (path: string, value: string) => Promise<void>;
 }
 
 const colorClasses = {
@@ -76,36 +91,124 @@ const colorClasses = {
     green: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400",
 };
 
-function MarketGroup({ title, icon: Icon, items, color }: MarketGroupProps) {
+const ringColors = {
+    purple: "focus:ring-purple-500",
+    blue: "focus:ring-blue-500",
+    green: "focus:ring-green-500",
+};
+
+const btnColors = {
+    purple: "bg-purple-600 hover:bg-purple-700",
+    blue: "bg-blue-600 hover:bg-blue-700",
+    green: "bg-green-600 hover:bg-green-700",
+};
+
+function MarketItemEditor({
+    path,
+    initialValue,
+    color,
+    onSave,
+}: {
+    path: string;
+    initialValue: string;
+    color: "purple" | "blue" | "green";
+    onSave: (path: string, value: string) => Promise<void>;
+}) {
+    const [value, setValue] = useState(initialValue);
+    const [saving, setSaving] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    useEffect(() => {
+        setValue(initialValue);
+        setError(null);
+    }, [initialValue]);
+
+    const handleSave = async () => {
+        if (value.trim() === initialValue) return;
+        setSaving(true);
+        setError(null);
+        try {
+            await onSave(path, value.trim());
+        } catch {
+            setError("Failed to save.");
+        } finally {
+            setSaving(false);
+        }
+    };
+
+    return (
+        <div className="flex items-center gap-2">
+            <input
+                className={`flex-1 px-2 py-1 text-sm border border-border rounded bg-background text-foreground focus:outline-none focus:ring-2 ${ringColors[color]}`}
+                value={value}
+                onChange={(e) => setValue(e.target.value)}
+                disabled={saving}
+            />
+            <button
+                onClick={() => void handleSave()}
+                disabled={saving || value.trim() === initialValue}
+                className={`px-2 py-1 text-xs font-semibold text-white rounded disabled:opacity-50 transition-colors ${btnColors[color]}`}
+            >
+                {saving ? "..." : "Save"}
+            </button>
+            {error && <span className="text-xs text-destructive">{error}</span>}
+        </div>
+    );
+}
+
+function MarketGroup({ title, subfield, icon: Icon, items, color, isEditMode, onFieldSave }: MarketGroupProps) {
     return (
         <div>
             <div className="flex items-center gap-2 mb-3">
                 <Icon className={`w-4 h-4 ${color === "purple" ? "text-purple-600" : color === "blue" ? "text-blue-600" : "text-green-600"}`} />
                 <h4 className="text-sm font-semibold text-foreground">{title}</h4>
             </div>
-            <div className="flex flex-wrap gap-2">
-                {items.map((item, index) => (
-                    <div
-                        key={index}
-                        className={`group relative px-3 py-1.5 rounded-lg text-sm font-medium ${colorClasses[color]} cursor-default`}
-                    >
-                        {String(item.value)}
+            {isEditMode && onFieldSave ? (
+                <div className="space-y-2">
+                    {items.map((item, index) => (
+                        <div key={index}>
+                            <div className="flex items-center gap-1 mb-1">
+                                <PriorityBadge priority={item.priority} />
+                            </div>
+                            <MarketItemEditor
+                                path={`markets.${subfield}.${index}`}
+                                initialValue={String(item.value)}
+                                color={color}
+                                onSave={onFieldSave}
+                            />
+                        </div>
+                    ))}
+                </div>
+            ) : (
+                <div className="flex flex-wrap gap-2">
+                    {items.map((item, index) => (
+                        <div
+                            key={index}
+                            className={`group relative px-3 py-1.5 rounded-lg text-sm font-medium ${colorClasses[color]} cursor-default`}
+                        >
+                            {String(item.value)}
 
-                        {/* Hover tooltip */}
-                        <div className="absolute bottom-full left-1/2 -translate-x-1/2 mb-2 px-3 py-2 bg-popover border border-border rounded-lg shadow-lg opacity-0 group-hover:opacity-100 transition-opacity pointer-events-none z-10 min-w-[150px]">
-                            <div className="flex items-center gap-2 mb-1">
-                                <VisibilityBadge visibility={item.visibility} />
-                                <ConfidenceBadge confidence={item.confidence} />
+                            {/* Hover tooltip */}
+                            <div className="absolute bottom-full left-1/2 -translate-x-1/2 mb-2 px-3 py-2 bg-popover border border-border rounded-lg shadow-lg opacity-0 group-hover:opacity-100 transition-opacity pointer-events-none z-10 min-w-[150px]">
+                                <div className="flex items-center gap-2 mb-1">
+                                    <VisibilityBadge visibility={item.visibility} />
+                                    <ConfidenceBadge confidence={item.confidence} />
+                                    <PriorityBadge priority={item.priority} />
+                                </div>
+                                {item.priority === "manual_override" ? (
+                                    <p className="text-[10px] text-violet-600 dark:text-violet-400 font-semibold">
+                                        Manual edit
+                                    </p>
+                                ) : item.sources.length > 0 ? (
+                                    <p className="text-[10px] text-muted-foreground">
+                                        Source: {item.sources[0]?.doc_name ?? "Unknown"}
+                                    </p>
+                                ) : null}
                             </div>
-                            {item.sources.length > 0 && (
-                                <p className="text-[10px] text-muted-foreground">
-                                    Source: {item.sources[0]?.doc_name ?? "Unknown"}
-                                </p>
-                            )}
                         </div>
-                    </div>
-                ))}
-            </div>
+                    ))}
+                </div>
+            )}
         </div>
     );
 }
diff --git a/src/app/employer/metadata/components/MetadataHistorySection.tsx b/src/app/employer/metadata/components/MetadataHistorySection.tsx
new file mode 100644
index 00000000..237bdc24
--- /dev/null
+++ b/src/app/employer/metadata/components/MetadataHistorySection.tsx
@@ -0,0 +1,237 @@
+"use client";
+
+import React, { useState, useEffect, useCallback } from "react";
+import { History, ChevronDown, ChevronUp, RefreshCw } from "lucide-react";
+import { Card, CardHeader, CardTitle, CardContent } from "~/app/employer/documents/components/ui/card";
+import { cn } from "~/lib/utils";
+import type { MetadataDiff, ChangeType } from "~/lib/tools/company-metadata/types";
+
+interface HistoryEntry {
+    id: number;
+    changeType: ChangeType;
+    diff: MetadataDiff;
+    changedBy: string;
+    documentId: bigint | null;
+    createdAt: string;
+}
+
+interface HistoryResponse {
+    history: HistoryEntry[];
+    error?: string;
+}
+
+const changeTypeConfig: Record<ChangeType, { label: string; className: string }> = {
+    extraction: {
+        label: "AI Extraction",
+        className: "bg-blue-100 text-blue-700 dark:bg-blue-900/30 dark:text-blue-400",
+    },
+    merge: {
+        label: "Merge",
+        className: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400",
+    },
+    manual_override: {
+        label: "Manual Edit",
+        className: "bg-violet-100 text-violet-700 dark:bg-violet-900/30 dark:text-violet-400",
+    },
+    deprecation: {
+        label: "Deprecation",
+        className: "bg-amber-100 text-amber-700 dark:bg-amber-900/30 dark:text-amber-400",
+    },
+};
+
+function DiffSummary({ diff, expanded }: { diff: MetadataDiff; expanded: boolean }) {
+    const totalChanges = diff.added.length + diff.updated.length + diff.deprecated.length;
+    if (totalChanges === 0) {
+        return <p className="text-xs text-muted-foreground">No field changes recorded.</p>;
+    }
+
+    return (
+        <div className="space-y-1">
+            {/* Summary chips */}
+            <div className="flex gap-2 flex-wrap">
+                {diff.added.length > 0 && (
+                    <span className="text-[10px] font-semibold px-1.5 py-0.5 rounded bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400">
+                        +{diff.added.length} added
+                    </span>
+                )}
+                {diff.updated.length > 0 && (
+                    <span className="text-[10px] font-semibold px-1.5 py-0.5 rounded bg-blue-100 text-blue-700 dark:bg-blue-900/30 dark:text-blue-400">
+                        ~{diff.updated.length} updated
+                    </span>
+                )}
+                {diff.deprecated.length > 0 && (
+                    <span className="text-[10px] font-semibold px-1.5 py-0.5 rounded bg-amber-100 text-amber-700 dark:bg-amber-900/30 dark:text-amber-400">
+                        -{diff.deprecated.length} deprecated
+                    </span>
+                )}
+            </div>
+
+            {/* Expanded field paths */}
+            {expanded && (
+                <div className="mt-2 space-y-1 border-l-2 border-border pl-3">
+                    {diff.added.map((entry, i) => (
+                        <div key={i} className="text-xs text-green-700 dark:text-green-400 font-mono">
+                            + {entry.path}
+                            {entry.new && (
+                                <span className="text-muted-foreground ml-2">
+                                    → {String((entry.new as { value?: unknown }).value ?? "").slice(0, 60)}
+                                </span>
+                            )}
+                        </div>
+                    ))}
+                    {diff.updated.map((entry, i) => (
+                        <div key={i} className="text-xs text-blue-700 dark:text-blue-400 font-mono">
+                            ~ {entry.path}
+                            {entry.old && entry.new && (
+                                <span className="text-muted-foreground ml-2">
+                                    {String((entry.old as { value?: unknown }).value ?? "").slice(0, 30)}
+                                    {" → "}
+                                    {String((entry.new as { value?: unknown }).value ?? "").slice(0, 30)}
+                                </span>
+                            )}
+                        </div>
+                    ))}
+                    {diff.deprecated.map((entry, i) => (
+                        <div key={i} className="text-xs text-amber-700 dark:text-amber-400 font-mono">
+                            - {entry.path}
+                        </div>
+                    ))}
+                </div>
+            )}
+        </div>
+    );
+}
+
+function HistoryEntryRow({ entry }: { entry: HistoryEntry }) {
+    const [expanded, setExpanded] = useState(false);
+    const config = changeTypeConfig[entry.changeType];
+    const totalChanges = entry.diff.added.length + entry.diff.updated.length + entry.diff.deprecated.length;
+    const date = new Date(entry.createdAt);
+    const dateStr = date.toLocaleDateString(undefined, { month: "short", day: "numeric", year: "numeric" });
+    const timeStr = date.toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit" });
+
+    return (
+        <div className="relative pl-6">
+            {/* Timeline dot */}
+            <div className="absolute left-0 top-1.5 w-3 h-3 rounded-full border-2 border-border bg-background" />
+
+            <div className="pb-4">
+                <div className="flex items-start justify-between gap-2">
+                    <div className="flex items-center gap-2 flex-wrap">
+                        <span className={cn("text-[10px] font-semibold px-1.5 py-0.5 rounded", config.className)}>
+                            {config.label}
+                        </span>
+                        <span className="text-xs text-muted-foreground">
+                            {dateStr} at {timeStr}
+                        </span>
+                    </div>
+                    {totalChanges > 0 && (
+                        <button
+                            onClick={() => setExpanded((v) => !v)}
+                            className="flex items-center gap-1 text-xs text-muted-foreground hover:text-foreground transition-colors shrink-0"
+                        >
+                            {expanded ? <ChevronUp className="w-3 h-3" /> : <ChevronDown className="w-3 h-3" />}
+                            {expanded ? "Hide" : "Details"}
+                        </button>
+                    )}
+                </div>
+
+                <div className="mt-1.5">
+                    <DiffSummary diff={entry.diff} expanded={expanded} />
+                </div>
+            </div>
+        </div>
+    );
+}
+
+export function MetadataHistorySection() {
+    const [history, setHistory] = useState<HistoryEntry[]>([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState<string | null>(null);
+    const [showAll, setShowAll] = useState(false);
+
+    const INITIAL_SHOW = 10;
+
+    const fetchHistory = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const res = await fetch("/api/company/metadata/history");
+            const data = (await res.json()) as HistoryResponse;
+            if (data.error) throw new Error(data.error);
+            setHistory(data.history);
+        } catch (err) {
+            setError(err instanceof Error ? err.message : "Failed to load history");
+        } finally {
+            setLoading(false);
+        }
+    }, []);
+
+    useEffect(() => {
+        void fetchHistory();
+    }, [fetchHistory]);
+
+    const displayed = showAll ? history : history.slice(0, INITIAL_SHOW);
+
+    return (
+        <Card className="border-none shadow-sm">
+            <CardHeader className="border-b border-border pb-4">
+                <div className="flex items-center justify-between">
+                    <div className="flex items-center gap-3">
+                        <div className="p-2 bg-slate-600 rounded-lg">
+                            <History className="w-5 h-5 text-white" />
+                        </div>
+                        <div>
+                            <CardTitle className="text-lg font-bold">Change History</CardTitle>
+                            <p className="text-sm text-muted-foreground">
+                                Audit log of all metadata updates
+                            </p>
+                        </div>
+                    </div>
+                    <button
+                        onClick={() => void fetchHistory()}
+                        disabled={loading}
+                        className="p-1.5 rounded hover:bg-muted transition-colors text-muted-foreground hover:text-foreground"
+                        title="Refresh history"
+                    >
+                        <RefreshCw className={cn("w-4 h-4", loading && "animate-spin")} />
+                    </button>
+                </div>
+            </CardHeader>
+            <CardContent className="pt-6">
+                {loading ? (
+                    <div className="flex items-center gap-2 text-sm text-muted-foreground py-4">
+                        <RefreshCw className="w-4 h-4 animate-spin" />
+                        Loading history...
+                    </div>
+                ) : error ? (
+                    <p className="text-sm text-destructive py-4">{error}</p>
+                ) : history.length === 0 ? (
+                    <p className="text-sm text-muted-foreground py-4">No history yet. Changes will appear here after extractions or manual edits.</p>
+                ) : (
+                    <>
+                        {/* Timeline */}
+                        <div className="relative border-l-2 border-border ml-1.5">
+                            {displayed.map((entry) => (
+                                <HistoryEntryRow key={entry.id} entry={entry} />
+                            ))}
+                        </div>
+
+                        {history.length > INITIAL_SHOW && (
+                            <button
+                                onClick={() => setShowAll((v) => !v)}
+                                className="mt-3 text-xs font-semibold text-muted-foreground hover:text-foreground transition-colors flex items-center gap-1"
+                            >
+                                {showAll ? (
+                                    <><ChevronUp className="w-3 h-3" /> Show less</>
+                                ) : (
+                                    <><ChevronDown className="w-3 h-3" /> Show {history.length - INITIAL_SHOW} more</>
+                                )}
+                            </button>
+                        )}
+                    </>
+                )}
+            </CardContent>
+        </Card>
+    );
+}
diff --git a/src/app/employer/metadata/components/PeopleSection.tsx b/src/app/employer/metadata/components/PeopleSection.tsx
index 44818619..eb5487d4 100644
--- a/src/app/employer/metadata/components/PeopleSection.tsx
+++ b/src/app/employer/metadata/components/PeopleSection.tsx
@@ -1,17 +1,20 @@
 "use client";
 
-import React from "react";
+import React, { useState, useEffect } from "react";
 import { Users, Mail, Phone, Building } from "lucide-react";
 import { Card, CardHeader, CardTitle, CardContent } from "~/app/employer/documents/components/ui/card";
 import { ConfidenceBadge } from "./ConfidenceBadge";
 import { VisibilityBadge } from "./VisibilityBadge";
-import type { PersonEntry } from "~/lib/tools/company-metadata/types";
+import { PriorityBadge } from "./PriorityBadge";
+import type { PersonEntry, MetadataFact } from "~/lib/tools/company-metadata/types";
 
 interface PeopleSectionProps {
     people: PersonEntry[];
+    isEditMode?: boolean;
+    onFieldSave?: (path: string, value: string) => Promise<void>;
 }
 
-export function PeopleSection({ people }: PeopleSectionProps) {
+export function PeopleSection({ people, isEditMode, onFieldSave }: PeopleSectionProps) {
     return (
         <Card className="border-none shadow-sm">
             <CardHeader className="border-b border-border pb-4">
@@ -30,7 +33,13 @@ export function PeopleSection({ people }: PeopleSectionProps) {
             <CardContent className="pt-6">
                 <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
                     {people.map((person, index) => (
-                        <PersonCard key={index} person={person} />
+                        <PersonCard
+                            key={index}
+                            person={person}
+                            index={index}
+                            isEditMode={isEditMode}
+                            onFieldSave={onFieldSave}
+                        />
                     ))}
                 </div>
             </CardContent>
@@ -38,7 +47,90 @@ export function PeopleSection({ people }: PeopleSectionProps) {
     );
 }
 
-function PersonCard({ person }: { person: PersonEntry }) {
+function PersonFieldEditor({
+    path,
+    initialValue,
+    onSave,
+}: {
+    path: string;
+    initialValue: string;
+    onSave: (path: string, value: string) => Promise<void>;
+}) {
+    const [value, setValue] = useState(initialValue);
+    const [saving, setSaving] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    useEffect(() => {
+        setValue(initialValue);
+        setError(null);
+    }, [initialValue]);
+
+    const handleSave = async () => {
+        if (value.trim() === initialValue) return;
+        setSaving(true);
+        setError(null);
+        try {
+            await onSave(path, value.trim());
+        } catch {
+            setError("Failed to save.");
+        } finally {
+            setSaving(false);
+        }
+    };
+
+    return (
+        <div className="space-y-1 mt-1">
+            <input
+                className="w-full px-2 py-1 text-sm border border-border rounded bg-background text-foreground focus:outline-none focus:ring-2 focus:ring-blue-500"
+                value={value}
+                onChange={(e) => setValue(e.target.value)}
+                disabled={saving}
+            />
+            {error && <p className="text-xs text-destructive">{error}</p>}
+            <div className="flex gap-2">
+                <button
+                    onClick={() => void handleSave()}
+                    disabled={saving || value.trim() === initialValue}
+                    className="px-2 py-0.5 text-xs font-semibold bg-blue-600 text-white rounded hover:bg-blue-700 disabled:opacity-50 transition-colors"
+                >
+                    {saving ? "Saving..." : "Save"}
+                </button>
+                <button
+                    onClick={() => { setValue(initialValue); setError(null); }}
+                    disabled={saving}
+                    className="px-2 py-0.5 text-xs font-semibold border border-border rounded hover:bg-muted transition-colors"
+                >
+                    Reset
+                </button>
+            </div>
+        </div>
+    );
+}
+
+/** Check all fields on a person for the best source to display */
+function getPersonSource(person: PersonEntry): { docName: string; hasManualEdit: boolean } {
+    const allFacts: (MetadataFact<unknown> | undefined)[] = [
+        person.name, person.role, person.email, person.phone, person.department,
+    ];
+    const hasManualEdit = allFacts.some((f) => f?.priority === "manual_override");
+    if (hasManualEdit) {
+        return { docName: "Manual edit", hasManualEdit: true };
+    }
+    const firstSource = person.name.sources[0]?.doc_name ?? "document";
+    return { docName: firstSource, hasManualEdit: false };
+}
+
+function PersonCard({
+    person,
+    index,
+    isEditMode,
+    onFieldSave,
+}: {
+    person: PersonEntry;
+    index: number;
+    isEditMode?: boolean;
+    onFieldSave?: (path: string, value: string) => Promise<void>;
+}) {
     const name = String(person.name.value);
     const initials = name
         .split(" ")
@@ -47,6 +139,46 @@ function PersonCard({ person }: { person: PersonEntry }) {
         .toUpperCase()
         .slice(0, 2);
 
+    if (isEditMode && onFieldSave) {
+        const editableFields = [
+            { label: "Name", key: "name", value: name },
+            { label: "Role", key: "role", value: person.role ? String(person.role.value) : "" },
+            { label: "Department", key: "department", value: person.department ? String(person.department.value) : "" },
+            { label: "Email", key: "email", value: person.email ? String(person.email.value) : "" },
+            { label: "Phone", key: "phone", value: person.phone ? String(person.phone.value) : "" },
+        ];
+
+        return (
+            <div className="p-4 rounded-lg border border-blue-200 dark:border-blue-800 bg-muted/50 space-y-3">
+                <div className="flex items-center gap-3">
+                    <div className="w-10 h-10 rounded-full bg-blue-600 flex items-center justify-center text-white font-bold text-xs shrink-0">
+                        {initials}
+                    </div>
+                    <div className="flex items-center gap-2 flex-wrap">
+                        <span className="font-semibold text-foreground">{name}</span>
+                        <PriorityBadge priority={person.name.priority} />
+                    </div>
+                </div>
+                <div className="space-y-2.5">
+                    {editableFields.map(({ label, key, value: val }) => (
+                        <div key={key}>
+                            <span className="text-[10px] font-semibold text-muted-foreground uppercase tracking-wide">
+                                {label}
+                            </span>
+                            <PersonFieldEditor
+                                path={`people.${index}.${key}`}
+                                initialValue={val}
+                                onSave={onFieldSave}
+                            />
+                        </div>
+                    ))}
+                </div>
+            </div>
+        );
+    }
+
+    const { docName, hasManualEdit } = getPersonSource(person);
+
     return (
         <div className="p-4 rounded-lg bg-muted/50 hover:bg-muted transition-colors">
             <div className="flex items-start gap-3">
@@ -57,17 +189,21 @@ function PersonCard({ person }: { person: PersonEntry }) {
                     <div className="flex items-center gap-2 flex-wrap">
                         <h4 className="font-semibold text-foreground truncate">{name}</h4>
                         <VisibilityBadge visibility={person.name.visibility} />
+                        <PriorityBadge priority={person.name.priority} />
                     </div>
 
                     {person.role && (
-                        <p className="text-sm text-muted-foreground mt-0.5 flex items-center gap-1">
-                            <Building className="w-3 h-3" />
-                            <span className="truncate">{String(person.role.value)}</span>
-                        </p>
+                        <div className="flex items-center gap-1.5 mt-1">
+                            <Building className="w-3.5 h-3.5 text-muted-foreground shrink-0" />
+                            <span className="text-sm text-muted-foreground truncate">{String(person.role.value)}</span>
+                            {person.role.priority === "manual_override" && (
+                                <PriorityBadge priority={person.role.priority} />
+                            )}
+                        </div>
                     )}
 
                     {person.department && (
-                        <p className="text-xs text-muted-foreground mt-1">
+                        <p className="text-xs text-muted-foreground mt-1 ml-5">
                             {String(person.department.value)}
                         </p>
                     )}
@@ -78,8 +214,8 @@ function PersonCard({ person }: { person: PersonEntry }) {
                                 href={`mailto:${String(person.email.value)}`}
                                 className="text-xs text-blue-600 hover:text-blue-700 dark:text-blue-400 flex items-center gap-1"
                             >
-                                <Mail className="w-3 h-3" />
-                                <span className="truncate max-w-[120px]">
+                                <Mail className="w-3 h-3 shrink-0" />
+                                <span className="truncate max-w-[140px]">
                                     {String(person.email.value)}
                                 </span>
                             </a>
@@ -90,7 +226,7 @@ function PersonCard({ person }: { person: PersonEntry }) {
                                 href={`tel:${String(person.phone.value)}`}
                                 className="text-xs text-blue-600 hover:text-blue-700 dark:text-blue-400 flex items-center gap-1"
                             >
-                                <Phone className="w-3 h-3" />
+                                <Phone className="w-3 h-3 shrink-0" />
                                 <span>{String(person.phone.value)}</span>
                             </a>
                         )}
@@ -98,11 +234,9 @@ function PersonCard({ person }: { person: PersonEntry }) {
 
                     <div className="flex items-center gap-2 mt-2">
                         <ConfidenceBadge confidence={person.name.confidence} />
-                        {person.name.sources.length > 0 && (
-                            <span className="text-[10px] text-muted-foreground">
-                                from {person.name.sources[0]?.doc_name ?? "document"}
-                            </span>
-                        )}
+                        <span className={`text-[10px] ${hasManualEdit ? "text-violet-600 dark:text-violet-400 font-semibold" : "text-muted-foreground"}`}>
+                            {hasManualEdit ? "Manual edit" : `from ${docName}`}
+                        </span>
                     </div>
                 </div>
             </div>
diff --git a/src/app/employer/metadata/components/PriorityBadge.tsx b/src/app/employer/metadata/components/PriorityBadge.tsx
new file mode 100644
index 00000000..21c20a99
--- /dev/null
+++ b/src/app/employer/metadata/components/PriorityBadge.tsx
@@ -0,0 +1,20 @@
+"use client";
+
+import React from "react";
+import { Pin } from "lucide-react";
+import type { Priority } from "~/lib/tools/company-metadata/types";
+
+interface PriorityBadgeProps {
+    priority: Priority;
+}
+
+export function PriorityBadge({ priority }: PriorityBadgeProps) {
+    if (priority !== "manual_override") return null;
+
+    return (
+        <span className="inline-flex items-center gap-1 px-1.5 py-0.5 rounded text-[10px] font-semibold bg-violet-100 text-violet-700 dark:bg-violet-900/30 dark:text-violet-400">
+            <Pin className="w-3 h-3" />
+            Manual
+        </span>
+    );
+}
diff --git a/src/app/employer/metadata/components/ServicesSection.tsx b/src/app/employer/metadata/components/ServicesSection.tsx
index 81db6c72..bbff0e0f 100644
--- a/src/app/employer/metadata/components/ServicesSection.tsx
+++ b/src/app/employer/metadata/components/ServicesSection.tsx
@@ -1,17 +1,20 @@
 "use client";
 
-import React from "react";
+import React, { useState, useEffect } from "react";
 import { Briefcase, CheckCircle, Clock, XCircle } from "lucide-react";
 import { Card, CardHeader, CardTitle, CardContent } from "~/app/employer/documents/components/ui/card";
 import { ConfidenceBadge } from "./ConfidenceBadge";
 import { VisibilityBadge } from "./VisibilityBadge";
-import type { ServiceEntry } from "~/lib/tools/company-metadata/types";
+import { PriorityBadge } from "./PriorityBadge";
+import type { ServiceEntry, MetadataFact } from "~/lib/tools/company-metadata/types";
 
 interface ServicesSectionProps {
     services: ServiceEntry[];
+    isEditMode?: boolean;
+    onFieldSave?: (path: string, value: string) => Promise<void>;
 }
 
-export function ServicesSection({ services }: ServicesSectionProps) {
+export function ServicesSection({ services, isEditMode, onFieldSave }: ServicesSectionProps) {
     return (
         <Card className="border-none shadow-sm">
             <CardHeader className="border-b border-border pb-4">
@@ -30,7 +33,13 @@ export function ServicesSection({ services }: ServicesSectionProps) {
             <CardContent className="pt-6">
                 <div className="space-y-4">
                     {services.map((service, index) => (
-                        <ServiceCard key={index} service={service} />
+                        <ServiceCard
+                            key={index}
+                            service={service}
+                            index={index}
+                            isEditMode={isEditMode}
+                            onFieldSave={onFieldSave}
+                        />
                     ))}
                 </div>
             </CardContent>
@@ -38,7 +47,102 @@ export function ServicesSection({ services }: ServicesSectionProps) {
     );
 }
 
-function ServiceCard({ service }: { service: ServiceEntry }) {
+function ServiceFieldEditor({
+    path,
+    initialValue,
+    multiline,
+    onSave,
+}: {
+    path: string;
+    initialValue: string;
+    multiline?: boolean;
+    onSave: (path: string, value: string) => Promise<void>;
+}) {
+    const [value, setValue] = useState(initialValue);
+    const [saving, setSaving] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    useEffect(() => {
+        setValue(initialValue);
+        setError(null);
+    }, [initialValue]);
+
+    const handleSave = async () => {
+        if (value.trim() === initialValue) return;
+        setSaving(true);
+        setError(null);
+        try {
+            await onSave(path, value.trim());
+        } catch {
+            setError("Failed to save.");
+        } finally {
+            setSaving(false);
+        }
+    };
+
+    return (
+        <div className="space-y-1">
+            {multiline ? (
+                <textarea
+                    className="w-full px-2 py-1 text-sm border border-border rounded bg-background text-foreground focus:outline-none focus:ring-2 focus:ring-green-500 resize-none"
+                    rows={2}
+                    value={value}
+                    onChange={(e) => setValue(e.target.value)}
+                    disabled={saving}
+                />
+            ) : (
+                <input
+                    className="w-full px-2 py-1 text-sm border border-border rounded bg-background text-foreground focus:outline-none focus:ring-2 focus:ring-green-500"
+                    value={value}
+                    onChange={(e) => setValue(e.target.value)}
+                    disabled={saving}
+                />
+            )}
+            {error && <p className="text-xs text-destructive">{error}</p>}
+            <div className="flex gap-2">
+                <button
+                    onClick={() => void handleSave()}
+                    disabled={saving || value.trim() === initialValue}
+                    className="px-2 py-0.5 text-xs font-semibold bg-green-600 text-white rounded hover:bg-green-700 disabled:opacity-50 transition-colors"
+                >
+                    {saving ? "Saving..." : "Save"}
+                </button>
+                <button
+                    onClick={() => { setValue(initialValue); setError(null); }}
+                    disabled={saving}
+                    className="px-2 py-0.5 text-xs font-semibold border border-border rounded hover:bg-muted transition-colors"
+                >
+                    Reset
+                </button>
+            </div>
+        </div>
+    );
+}
+
+/** Check all fields on a service for the best source to display */
+function getServiceSource(service: ServiceEntry): { docName: string; hasManualEdit: boolean } {
+    const allFacts: (MetadataFact<unknown> | undefined)[] = [
+        service.name, service.description, service.status,
+    ];
+    const hasManualEdit = allFacts.some((f) => f?.priority === "manual_override");
+    if (hasManualEdit) {
+        return { docName: "Manual edit", hasManualEdit: true };
+    }
+    const firstSource = service.name.sources[0]?.doc_name ?? "document";
+    return { docName: firstSource, hasManualEdit: false };
+}
+
+function ServiceCard({
+    service,
+    index,
+    isEditMode,
+    onFieldSave,
+}: {
+    service: ServiceEntry;
+    index: number;
+    isEditMode?: boolean;
+    onFieldSave?: (path: string, value: string) => Promise<void>;
+}) {
     const status = service.status ? String(service.status.value).toLowerCase() : "active";
 
     const StatusIcon = status === "active"
@@ -53,6 +157,45 @@ function ServiceCard({ service }: { service: ServiceEntry }) {
             ? "text-red-600 bg-red-100 dark:bg-red-900/30"
             : "text-amber-600 bg-amber-100 dark:bg-amber-900/30";
 
+    if (isEditMode && onFieldSave) {
+        return (
+            <div className="p-4 rounded-lg bg-muted/50 space-y-3">
+                <div className="flex items-center gap-2 flex-wrap mb-1">
+                    <span className={`inline-flex items-center gap-1 px-2 py-0.5 rounded-full text-[10px] font-semibold ${statusColor}`}>
+                        <StatusIcon className="w-3 h-3" />
+                        {status.charAt(0).toUpperCase() + status.slice(1)}
+                    </span>
+                    <PriorityBadge priority={service.name.priority} />
+                </div>
+                <div>
+                    <span className="text-xs font-semibold text-muted-foreground uppercase tracking-wide">Name</span>
+                    <ServiceFieldEditor
+                        path={`services.${index}.name`}
+                        initialValue={String(service.name.value)}
+                        onSave={onFieldSave}
+                    />
+                </div>
+                <div>
+                    <span className="text-xs font-semibold text-muted-foreground uppercase tracking-wide">Description</span>
+                    <ServiceFieldEditor
+                        path={`services.${index}.description`}
+                        initialValue={service.description ? String(service.description.value) : ""}
+                        multiline
+                        onSave={onFieldSave}
+                    />
+                </div>
+                <div>
+                    <span className="text-xs font-semibold text-muted-foreground uppercase tracking-wide">Status</span>
+                    <ServiceFieldEditor
+                        path={`services.${index}.status`}
+                        initialValue={service.status ? String(service.status.value) : "active"}
+                        onSave={onFieldSave}
+                    />
+                </div>
+            </div>
+        );
+    }
+
     return (
         <div className="p-4 rounded-lg bg-muted/50 hover:bg-muted transition-colors">
             <div className="flex items-start justify-between gap-4">
@@ -66,6 +209,7 @@ function ServiceCard({ service }: { service: ServiceEntry }) {
                             {status.charAt(0).toUpperCase() + status.slice(1)}
                         </span>
                         <VisibilityBadge visibility={service.name.visibility} />
+                        <PriorityBadge priority={service.name.priority} />
                     </div>
 
                     {service.description && (
@@ -76,11 +220,18 @@ function ServiceCard({ service }: { service: ServiceEntry }) {
 
                     <div className="flex items-center gap-2 mt-3">
                         <ConfidenceBadge confidence={service.name.confidence} />
-                        {service.name.sources.length > 0 && (
-                            <span className="text-[10px] text-muted-foreground">
-                                from {service.name.sources[0]?.doc_name ?? "document"}
-                            </span>
-                        )}
+                        {(() => {
+                            const { docName, hasManualEdit } = getServiceSource(service);
+                            return hasManualEdit ? (
+                                <span className="text-[10px] text-violet-600 dark:text-violet-400 font-semibold">
+                                    Manual edit
+                                </span>
+                            ) : (
+                                <span className="text-[10px] text-muted-foreground">
+                                    from {docName}
+                                </span>
+                            );
+                        })()}
                     </div>
                 </div>
             </div>
diff --git a/src/app/employer/metadata/page.tsx b/src/app/employer/metadata/page.tsx
index 1dbc9965..38cbb59d 100644
--- a/src/app/employer/metadata/page.tsx
+++ b/src/app/employer/metadata/page.tsx
@@ -7,7 +7,9 @@ import {
     Briefcase,
     RefreshCw,
     AlertCircle,
+    AlertTriangle,
     FileText,
+    Scale,
     Sparkles,
 } from "lucide-react";
 import { Button } from "~/app/employer/documents/components/ui/button";
@@ -19,6 +21,7 @@ import { PeopleSection } from "./components/PeopleSection";
 import { ServicesSection } from "./components/ServicesSection";
 import { MarketsSection } from "./components/MarketsSection";
 import { ProvenanceCard } from "./components/ProvenanceCard";
+import { LegalSection } from "./components/LegalSection";
 import type { CompanyMetadataJSON } from "~/lib/tools/company-metadata/types";
 
 interface MetadataResponse {
@@ -205,7 +208,7 @@ export default function MetadataPage() {
                     ) : (
                         <>
                             {/* Summary Stats */}
-                            <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4">
+                            <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-5 gap-4">
                                 <StatsCard
                                     title="Company Fields"
                                     value={Object.keys(metadata.company).filter(k => metadata.company[k]).length}
@@ -225,13 +228,22 @@ export default function MetadataPage() {
                                     color="green"
                                 />
                                 <StatsCard
-                                    title="Documents Processed"
+                                    title="Legal"
+                                    value={(metadata.legal ?? []).length}
+                                    icon={Scale}
+                                    color="rose"
+                                />
+                                <StatsCard
+                                    title="Docs Processed"
                                     value={metadata.provenance.total_documents_processed}
                                     icon={FileText}
                                     color="amber"
                                 />
                             </div>
 
+                            {/* Missing Info Alert */}
+                            <MissingInfoAlert company={metadata.company} people={metadata.people} />
+
                             {/* Company Info */}
                             <CompanyInfoCard company={metadata.company} />
 
@@ -251,6 +263,11 @@ export default function MetadataPage() {
                                 <MarketsSection markets={metadata.markets} />
                             ) : null}
 
+                            {/* Legal Section */}
+                            {(metadata.legal ?? []).length > 0 && (
+                                <LegalSection legal={metadata.legal ?? []} />
+                            )}
+
                             {/* Provenance */}
                             <ProvenanceCard
                                 provenance={metadata.provenance}
@@ -264,12 +281,68 @@ export default function MetadataPage() {
     );
 }
 
+/* Missing Info Alert */
+import type { CompanyInfo, PersonEntry } from "~/lib/tools/company-metadata/types";
+
+const EXPECTED_COMPANY_FIELDS: Array<{ key: keyof CompanyInfo; label: string }> = [
+    { key: "name", label: "Company Name" },
+    { key: "industry", label: "Industry" },
+    { key: "headquarters", label: "Headquarters" },
+    { key: "founded_year", label: "Founded Year" },
+    { key: "description", label: "Description" },
+    { key: "website", label: "Website" },
+    { key: "size", label: "Company Size" },
+];
+
+function MissingInfoAlert({ company, people }: { company: CompanyInfo; people: PersonEntry[] }) {
+    const missingFields = EXPECTED_COMPANY_FIELDS.filter((f) => {
+        const field = company[f.key];
+        if (!field) return true;
+        const val = (field as { value?: unknown }).value;
+        return val === undefined || val === null || val === "";
+    });
+    const peopleWithoutRoles = people.filter((p) => !p.role);
+
+    if (missingFields.length === 0 && peopleWithoutRoles.length === 0) return null;
+
+    return (
+        <Card className="p-4 border-amber-300 dark:border-amber-700 bg-amber-50 dark:bg-amber-950/30 shadow-sm">
+            <div className="flex items-start gap-3">
+                <div className="p-2 bg-amber-100 dark:bg-amber-900/40 rounded-lg shrink-0">
+                    <AlertTriangle className="w-5 h-5 text-amber-600 dark:text-amber-400" />
+                </div>
+                <div className="flex-1 min-w-0">
+                    <h4 className="text-sm font-bold text-amber-800 dark:text-amber-300">
+                        Incomplete Metadata
+                    </h4>
+                    {missingFields.length > 0 && (
+                        <p className="text-sm text-amber-700 dark:text-amber-400 mt-1">
+                            Missing company fields:{" "}
+                            <span className="font-semibold">
+                                {missingFields.map((f) => f.label).join(", ")}
+                            </span>
+                        </p>
+                    )}
+                    {peopleWithoutRoles.length > 0 && (
+                        <p className="text-sm text-amber-700 dark:text-amber-400 mt-1">
+                            {peopleWithoutRoles.length} {peopleWithoutRoles.length === 1 ? "person" : "people"} missing role information
+                        </p>
+                    )}
+                    <p className="text-xs text-amber-600 dark:text-amber-500 mt-2">
+                        Upload more documents or manually edit fields to fill in missing information.
+                    </p>
+                </div>
+            </div>
+        </Card>
+    );
+}
+
 /* Local StatsCard component */
 interface StatsCardProps {
     title: string;
     value: number | string;
     icon: React.ComponentType<{ className?: string }>;
-    color: "purple" | "blue" | "green" | "amber";
+    color: "purple" | "blue" | "green" | "amber" | "rose";
 }
 
 const colorMap = {
@@ -277,6 +350,7 @@ const colorMap = {
     blue: { border: "border-l-blue-500", text: "text-blue-500" },
     green: { border: "border-l-green-500", text: "text-green-500" },
     amber: { border: "border-l-amber-500", text: "text-amber-500" },
+    rose: { border: "border-l-rose-500", text: "text-rose-500" },
 };
 
 function StatsCard({ title, value, icon: Icon, color }: StatsCardProps) {
diff --git a/src/app/employer/tools/marketing-pipeline/page.tsx b/src/app/employer/tools/marketing-pipeline/page.tsx
index b7b39085..2478edba 100644
--- a/src/app/employer/tools/marketing-pipeline/page.tsx
+++ b/src/app/employer/tools/marketing-pipeline/page.tsx
@@ -1,9 +1,9 @@
 "use client";
 
-import { useMemo, useState } from "react";
+import { Suspense, useMemo, useState } from "react";
 import Image from "next/image";
-import { useRouter } from "next/navigation";
-import { ArrowLeft, Brain, Loader2, MessageSquareText, Megaphone, Sparkles } from "lucide-react";
+import { useRouter, useSearchParams } from "next/navigation";
+import { ArrowLeft, Brain, ChevronDown, ChevronRight, Loader2, MessageSquareText, Megaphone, Sparkles } from "lucide-react";
 import ProfileDropdown from "~/app/employer/_components/ProfileDropdown";
 import { ThemeToggle } from "~/app/_components/ThemeToggle";
 import homeStyles from "~/styles/Employer/Home.module.css";
@@ -11,6 +11,18 @@ import styles from "~/styles/Employer/MarketingPipeline.module.css";
 
 type Platform = "x" | "linkedin" | "reddit" | "bluesky";
 
+interface DNADebugInfo {
+    source: "metadata" | "rag";
+    contextUsed: string;
+    dna: {
+        coreMission: string;
+        keyDifferentiators: string[];
+        provenResults: string[];
+        humanStory: string;
+        technicalEdge: string;
+    };
+}
+
 interface PipelineResponse {
     success: boolean;
     message?: string;
@@ -24,6 +36,7 @@ interface PipelineResponse {
             snippet: string;
             source: Platform;
         }>;
+        dnaDebug?: DNADebugInfo;
     };
 }
 
@@ -49,12 +62,23 @@ function usePlatformLogoClassNames() {
 }
 
 export default function MarketingPipelinePage() {
+    return (
+        <Suspense>
+            <MarketingPipelineContent />
+        </Suspense>
+    );
+}
+
+function MarketingPipelineContent() {
     const router = useRouter();
+    const searchParams = useSearchParams();
+    const isDebug = searchParams.get("debug") === "true";
     const [platform, setPlatform] = useState<Platform | null>(null);
     const [prompt, setPrompt] = useState("");
     const [loading, setLoading] = useState(false);
     const [error, setError] = useState<string | null>(null);
     const [result, setResult] = useState<PipelineResponse["data"] | null>(null);
+    const [debugOpen, setDebugOpen] = useState(false);
 
     const logoClassNames = usePlatformLogoClassNames();
     const selectedPlatform = PLATFORM_OPTIONS.find((option) => option.id === platform) ?? null;
@@ -76,7 +100,8 @@ export default function MarketingPipelinePage() {
 
         setLoading(true);
         try {
-            const response = await fetch("/api/marketing-pipeline", {
+            const apiUrl = isDebug ? "/api/marketing-pipeline?debug=true" : "/api/marketing-pipeline";
+            const response = await fetch(apiUrl, {
                 method: "POST",
                 headers: {
                     "Content-Type": "application/json",
@@ -300,6 +325,79 @@ image/video: ${result["image/video"]}`}
                                                 </div>
                                             </>
                                         )}
+
+                                        {isDebug && result.dnaDebug && (
+                                            <div style={{ marginTop: "1rem", borderTop: "1px solid var(--border-color, #e5e7eb)", paddingTop: "0.75rem" }}>
+                                                <button
+                                                    type="button"
+                                                    onClick={() => setDebugOpen((prev) => !prev)}
+                                                    style={{
+                                                        display: "flex",
+                                                        alignItems: "center",
+                                                        gap: "0.375rem",
+                                                        background: "none",
+                                                        border: "none",
+                                                        cursor: "pointer",
+                                                        padding: 0,
+                                                        fontSize: "0.75rem",
+                                                        fontWeight: 600,
+                                                        color: "var(--text-muted, #6b7280)",
+                                                    }}
+                                                >
+                                                    {debugOpen ? <ChevronDown size={14} /> : <ChevronRight size={14} />}
+                                                    Debug: DNA Source
+                                                    <span style={{
+                                                        marginLeft: "0.5rem",
+                                                        padding: "0.125rem 0.5rem",
+                                                        borderRadius: "9999px",
+                                                        fontSize: "0.625rem",
+                                                        fontWeight: 700,
+                                                        textTransform: "uppercase",
+                                                        letterSpacing: "0.05em",
+                                                        background: result.dnaDebug.source === "metadata" ? "#dcfce7" : "#fef3c7",
+                                                        color: result.dnaDebug.source === "metadata" ? "#166534" : "#92400e",
+                                                    }}>
+                                                        {result.dnaDebug.source}
+                                                    </span>
+                                                </button>
+
+                                                {debugOpen && (
+                                                    <div style={{ marginTop: "0.5rem", fontSize: "0.75rem" }}>
+                                                        <div style={{ fontWeight: 600, marginBottom: "0.25rem", color: "var(--text-muted, #6b7280)" }}>
+                                                            CompanyDNA
+                                                        </div>
+                                                        <pre style={{
+                                                            background: "var(--bg-secondary, #f9fafb)",
+                                                            padding: "0.5rem",
+                                                            borderRadius: "0.375rem",
+                                                            overflow: "auto",
+                                                            maxHeight: "12rem",
+                                                            fontSize: "0.6875rem",
+                                                            lineHeight: 1.5,
+                                                        }}>
+                                                            {JSON.stringify(result.dnaDebug.dna, null, 2)}
+                                                        </pre>
+
+                                                        <div style={{ fontWeight: 600, marginTop: "0.5rem", marginBottom: "0.25rem", color: "var(--text-muted, #6b7280)" }}>
+                                                            Raw context sent to LLM
+                                                        </div>
+                                                        <pre style={{
+                                                            background: "var(--bg-secondary, #f9fafb)",
+                                                            padding: "0.5rem",
+                                                            borderRadius: "0.375rem",
+                                                            overflow: "auto",
+                                                            maxHeight: "16rem",
+                                                            fontSize: "0.6875rem",
+                                                            lineHeight: 1.5,
+                                                            whiteSpace: "pre-wrap",
+                                                            wordBreak: "break-word",
+                                                        }}>
+                                                            {result.dnaDebug.contextUsed}
+                                                        </pre>
+                                                    </div>
+                                                )}
+                                            </div>
+                                        )}
                                     </div>
                                 )}
                             </div>
diff --git a/src/env.ts b/src/env.ts
index 020743f9..8d7fa39f 100644
--- a/src/env.ts
+++ b/src/env.ts
@@ -10,11 +10,14 @@ const optionalString = () =>
   z.preprocess(normalize, z.string().min(1).optional());
 
 const serverSchema = z.object({
-  DATABASE_URL: z.preprocess(normalize, z.string().url()),
+  // Non-empty string only — avoid z.string().url(): many valid Prisma/Postgres URLs fail strict URL parsing (password encoding, sslmode params, etc.).
+  DATABASE_URL: requiredString(),
   OPENAI_API_KEY: requiredString(),
   OPENAI_MODEL: optionalString(),
   ANTHROPIC_API_KEY: optionalString(),
+  ANTHROPIC_MODEL: optionalString(),
   GOOGLE_AI_API_KEY: optionalString(),
+  GOOGLE_MODEL: optionalString(),
   OLLAMA_BASE_URL: optionalString(),
   OLLAMA_MODEL: optionalString(),
   CLERK_SECRET_KEY: requiredString(),
@@ -98,7 +101,9 @@ function parseServerEnv() {
     OPENAI_API_KEY: process.env.OPENAI_API_KEY,
     OPENAI_MODEL: process.env.OPENAI_MODEL,
     ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+    ANTHROPIC_MODEL: process.env.ANTHROPIC_MODEL,
     GOOGLE_AI_API_KEY: process.env.GOOGLE_AI_API_KEY,
+    GOOGLE_MODEL: process.env.GOOGLE_MODEL,
     OLLAMA_BASE_URL: process.env.OLLAMA_BASE_URL,
     OLLAMA_MODEL: process.env.OLLAMA_MODEL,
     CLERK_SECRET_KEY: process.env.CLERK_SECRET_KEY,
@@ -107,12 +112,7 @@ function parseServerEnv() {
     DATALAB_API_KEY: process.env.DATALAB_API_KEY,
     TAVILY_API_KEY: process.env.TAVILY_API_KEY,
     SERPER_API_KEY: process.env.SERPER_API_KEY,
-    SEARCH_PROVIDER: process.env.SEARCH_PROVIDER as
-      | "tavily"
-      | "serper"
-      | "fallback"
-      | "parallel"
-      | undefined,
+    SEARCH_PROVIDER: process.env.SEARCH_PROVIDER as "tavily" | "serper" | "fallback" | "parallel" | undefined,
     REDDIT_CLIENT_ID: process.env.REDDIT_CLIENT_ID,
     REDDIT_CLIENT_SECRET: process.env.REDDIT_CLIENT_SECRET,
     REDDIT_USER_AGENT: process.env.REDDIT_USER_AGENT,
diff --git a/src/lib/ai/chat-model-factory.ts b/src/lib/ai/chat-model-factory.ts
index 3a10fbed..12f0a287 100644
--- a/src/lib/ai/chat-model-factory.ts
+++ b/src/lib/ai/chat-model-factory.ts
@@ -10,18 +10,25 @@ import {
   type AIModelType,
   type LLMProvider,
 } from "~/app/api/agents/documentQ&A/services/types";
+import { env } from "~/env";
 
 const REASONING_MODELS: ReadonlySet<string> = new Set([
   "gpt-5-mini",
   "gpt-5-nano",
 ]);
 
-const PROVIDER_ENV_MODEL_KEY: Record<LLMProvider, string> = {
-  openai: "OPENAI_MODEL",
-  anthropic: "ANTHROPIC_MODEL",
-  google: "GOOGLE_MODEL",
-  ollama: "OLLAMA_MODEL",
-};
+function getServerModelOverride(provider: LLMProvider): string | undefined {
+  switch (provider) {
+    case "openai":
+      return env.server.OPENAI_MODEL;
+    case "anthropic":
+      return env.server.ANTHROPIC_MODEL;
+    case "google":
+      return env.server.GOOGLE_MODEL;
+    case "ollama":
+      return env.server.OLLAMA_MODEL;
+  }
+}
 
 function coerceModel(
   provider: LLMProvider,
@@ -31,10 +38,7 @@ function coerceModel(
     return requested;
   }
 
-  const envValue = process.env[PROVIDER_ENV_MODEL_KEY[provider]] as
-    | AIModelType
-    | undefined;
-
+  const envValue = getServerModelOverride(provider);
   if (envValue && isModelAllowedForProvider(provider, envValue)) {
     return envValue;
   }
@@ -46,17 +50,15 @@ export function getProviderDefaultModel(provider: LLMProvider): AIModelType {
   return coerceModel(provider);
 }
 
-export function getProviderBaseUrl(provider: LLMProvider): string {
-  if (provider === "ollama") {
-    const url = process.env.OLLAMA_BASE_URL;
-    if (!url) {
-      throw new Error(
-        "OLLAMA_BASE_URL is not set. Add it to your .env file (e.g. OLLAMA_BASE_URL=\"http://localhost:11434\").",
-      );
-    }
-    return url;
+/** Base URL for the local Ollama HTTP API (used by ChatOllama only). */
+export function getOllamaBaseUrl(): string {
+  const url = process.env.OLLAMA_BASE_URL;
+  if (!url) {
+    throw new Error(
+      "OLLAMA_BASE_URL is not set. Add it to your .env file (e.g. OLLAMA_BASE_URL=\"http://localhost:11434\").",
+    );
   }
-  return "https://api.openai.com/v1";
+  return url;
 }
 
 export function getChatModelForProvider(opts: {
@@ -70,14 +72,14 @@ export function getChatModelForProvider(opts: {
 
   if (!(ProviderModelMap[provider] as readonly string[]).includes(modelName)) {
     throw new Error(
-      `Model \"${modelName}\" is not supported for provider \"${provider}\"`,
+      `Model \"${String(modelName)}\" is not supported for provider \"${String(provider)}\"`,
     );
   }
 
   switch (provider) {
     case "ollama":
       return new ChatOllama({
-        baseUrl: getProviderBaseUrl("ollama"),
+        baseUrl: getOllamaBaseUrl(),
         model: modelName,
         temperature: temperature ?? 0.7,
       });
@@ -136,9 +138,7 @@ export function describeProviderError(
     ) {
       return {
         status: 502,
-        message: `Unable to reach Ollama at ${getProviderBaseUrl(
-          "ollama",
-        )}. Please ensure the Ollama server is running.`,
+        message: `Unable to reach Ollama at ${process.env.OLLAMA_BASE_URL ?? "(OLLAMA_BASE_URL not set)"}. Please ensure the Ollama server is running.`,
       };
     }
     if (
@@ -176,7 +176,7 @@ export function assertProviderModelSupport(
 ) {
   if (!isModelAllowedForProvider(provider, model)) {
     throw new Error(
-      `Model \"${model}\" is not supported for provider \"${provider}\"`,
+      `Model \"${String(model)}\" is not supported for provider \"${String(provider)}\"`,
     );
   }
 }
diff --git a/src/lib/models.ts b/src/lib/models.ts
new file mode 100644
index 00000000..95e631f4
--- /dev/null
+++ b/src/lib/models.ts
@@ -0,0 +1,124 @@
+/**
+ * Shared chat model factory for use across the app (document Q&A, marketing pipeline, etc.).
+ * Swap models in one place; all callers use LangChain BaseChatModel.
+ */
+import { ChatOpenAI, OpenAIEmbeddings } from "@langchain/openai";
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
+import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
+
+export type AIModelType =
+  | "gpt-4o"
+  | "gpt-5.2"
+  | "gpt-5.1"
+  | "gpt-5-nano"
+  | "gpt-5-mini"
+  | "claude-sonnet-4"
+  | "claude-opus-4.5"
+  | "gemini-2.5-flash"
+  | "gemini-3-flash"
+  | "gemini-3-pro";
+
+/**
+ * Get a chat model instance based on the model type.
+ * Supports OpenAI, Anthropic, and Google Gemini.
+ */
+export function getChatModel(modelType: AIModelType): BaseChatModel {
+  switch (modelType) {
+    case "gpt-4o":
+      return new ChatOpenAI({
+        openAIApiKey: process.env.OPENAI_API_KEY,
+        modelName: "gpt-4o",
+        temperature: 0.7,
+        timeout: 600000,
+      });
+
+    case "gpt-5.2":
+      return new ChatOpenAI({
+        openAIApiKey: process.env.OPENAI_API_KEY,
+        modelName: "gpt-5.2",
+        temperature: 0.7,
+        timeout: 600000,
+      });
+
+    case "gpt-5.1":
+      return new ChatOpenAI({
+        openAIApiKey: process.env.OPENAI_API_KEY,
+        modelName: "gpt-5.1",
+        temperature: 0.7,
+        timeout: 600000,
+      });
+
+    case "gpt-5-nano":
+      return new ChatOpenAI({
+        openAIApiKey: process.env.OPENAI_API_KEY,
+        modelName: "gpt-5-nano-2025-08-07",
+        timeout: 300000,
+      });
+
+    case "gpt-5-mini":
+      return new ChatOpenAI({
+        openAIApiKey: process.env.OPENAI_API_KEY,
+        modelName: "gpt-5-mini-2025-08-07",
+        temperature: 0.3,
+        timeout: 600000,
+      });
+
+    case "claude-sonnet-4":
+      return new ChatAnthropic({
+        anthropicApiKey: process.env.ANTHROPIC_API_KEY,
+        modelName: "claude-sonnet-4-20250514",
+        temperature: 0.7,
+      });
+
+    case "claude-opus-4.5":
+      return new ChatAnthropic({
+        anthropicApiKey: process.env.ANTHROPIC_API_KEY,
+        modelName: "claude-opus-4.5",
+        temperature: 0.7,
+      });
+
+    case "gemini-2.5-flash":
+      return new ChatGoogleGenerativeAI({
+        apiKey: process.env.GOOGLE_AI_API_KEY,
+        model: "gemini-2.5-flash",
+        temperature: 0.7,
+      });
+
+    case "gemini-3-flash":
+      return new ChatGoogleGenerativeAI({
+        apiKey: process.env.GOOGLE_AI_API_KEY,
+        model: "gemini-3-flash-preview",
+        temperature: 0.7,
+      });
+
+    case "gemini-3-pro":
+      return new ChatGoogleGenerativeAI({
+        apiKey: process.env.GOOGLE_AI_API_KEY,
+        model: "gemini-3-pro-preview",
+        temperature: 0.7,
+      });
+
+    default:
+      return new ChatOpenAI({
+        openAIApiKey: process.env.OPENAI_API_KEY,
+        modelName: "gpt-4o",
+        temperature: 0.7,
+        timeout: 600000,
+      });
+  }
+}
+
+export function getEmbeddings(): OpenAIEmbeddings {
+  return new OpenAIEmbeddings({
+    model: "text-embedding-ada-002",
+    openAIApiKey: process.env.OPENAI_API_KEY,
+  });
+}
+
+/** Marketing pipeline model config: one place to swap models per stage. */
+export const MARKETING_MODELS = {
+  dnaExtraction: "gpt-4o" as AIModelType,
+  competitorAnalysis: "gpt-4o" as AIModelType,
+  contentGeneration: "gpt-4o" as AIModelType,
+} as const;
diff --git a/src/lib/ocr/processor.ts b/src/lib/ocr/processor.ts
index 42979a69..ab4ee54c 100644
--- a/src/lib/ocr/processor.ts
+++ b/src/lib/ocr/processor.ts
@@ -450,23 +450,28 @@ export async function storeBatch(
 
   return withDbRetry(async () => {
     return db.transaction(async (tx) => {
-      const parentValues = vectorizedChunks.map((chunk) => ({
-        documentId: BigInt(documentId),
-        structureId: BigInt(rootStructureId),
-        content: chunk.content,
-        tokenCount: Math.ceil(chunk.content.length / 4),
-        charCount: chunk.content.length,
-        embedding:
-          chunk.vector && chunk.vector.length > 0
-            ? sql`${JSON.stringify(chunk.vector)}::vector(1536)`
-            : null,
-        pageNumber: chunk.metadata.pageNumber,
-        semanticType: chunk.metadata.isTable ? ("tabular" as const) : ("narrative" as const),
-        contentHash: crypto
-          .createHash("sha256")
-          .update(chunk.content)
-          .digest("hex"),
-      }));
+      const parentValues = vectorizedChunks.map((chunk) => {
+        const semanticType: "tabular" | "narrative" = chunk.metadata.isTable
+          ? "tabular"
+          : "narrative";
+        return {
+          documentId: BigInt(documentId),
+          structureId: BigInt(rootStructureId),
+          content: chunk.content,
+          tokenCount: Math.ceil(chunk.content.length / 4),
+          charCount: chunk.content.length,
+          embedding:
+            chunk.vector && chunk.vector.length > 0
+              ? sql`${JSON.stringify(chunk.vector)}::vector(1536)`
+              : null,
+          pageNumber: chunk.metadata.pageNumber,
+          semanticType,
+          contentHash: crypto
+            .createHash("sha256")
+            .update(chunk.content)
+            .digest("hex"),
+        };
+      });
 
       const parentRows = await tx
         .insert(documentContextChunks)
diff --git a/src/lib/tools/company-metadata/extractor.ts b/src/lib/tools/company-metadata/extractor.ts
index 65789afe..ac5cba1b 100644
--- a/src/lib/tools/company-metadata/extractor.ts
+++ b/src/lib/tools/company-metadata/extractor.ts
@@ -38,6 +38,7 @@ import type {
     ServiceEntry,
     ProjectEntry,
     SubprojectEntry,
+    LegalEntry,
     MarketsInfo,
 } from "./types";
 
@@ -60,6 +61,54 @@ const EXTRACTION_MODEL = "gpt-5-nano";
  */
 const MULTI_MENTION_BOOST = 0.05;
 
+// ============================================================================
+// Boilerplate detection heuristics
+// ============================================================================
+
+/** Minimum character count for a chunk to be worth sending to LLM. */
+const MIN_CHUNK_CHARS = 40;
+
+/** Patterns that indicate boilerplate content (case-insensitive). */
+const BOILERPLATE_PATTERNS = [
+    /^table of contents$/i,
+    /^\s*contents\s*$/i,
+    /^page\s+\d+\s*(of\s+\d+)?$/i,
+    /^©\s*\d{4}/,
+    /copyright\s+©?\s*\d{4}/i,
+    /all rights reserved/i,
+    /confidential\s+and\s+proprietary/i,
+    /^\s*disclaimer\s*$/i,
+    /this document is confidential/i,
+    /do not distribute/i,
+    /^\s*\d+\s*$/,                            // just a page number
+    /^(\.{2,}\s*\d+\s*\n?)+$/,               // TOC dotted lines: "Section...12"
+];
+
+/**
+ * Returns true if a chunk is likely boilerplate that won't contain
+ * useful company metadata. Uses content length and pattern matching.
+ */
+function isBoilerplate(content: string): boolean {
+    const trimmed = content.trim();
+
+    // Too short to contain meaningful facts
+    if (trimmed.length < MIN_CHUNK_CHARS) return true;
+
+    // Check against boilerplate patterns
+    for (const pattern of BOILERPLATE_PATTERNS) {
+        if (pattern.test(trimmed)) return true;
+    }
+
+    // TOC heuristic: many lines that end with page numbers (e.g., "Introduction ... 3")
+    const lines = trimmed.split("\n").filter((l) => l.trim().length > 0);
+    if (lines.length >= 3) {
+        const tocLines = lines.filter((l) => /\.{2,}\s*\d+\s*$/.test(l) || /\s{3,}\d+\s*$/.test(l));
+        if (tocLines.length / lines.length > 0.6) return true;
+    }
+
+    return false;
+}
+
 // ============================================================================
 // Zod schema for structured output (same schema, used per-batch)
 // ============================================================================
@@ -98,6 +147,16 @@ const ProjectSchema = z.object({
     subprojects: z.array(SubprojectSchema).nullable(),
 });
 
+const LegalSchema = z.object({
+    name: MetadataFactSchema,
+    type: MetadataFactSchema.nullable(),
+    summary: MetadataFactSchema.nullable(),
+    effective_date: MetadataFactSchema.nullable(),
+    expiry_date: MetadataFactSchema.nullable(),
+    parties: MetadataFactSchema.nullable(),
+    status: MetadataFactSchema.nullable(),
+});
+
 const ExtractionOutputSchema = z.object({
     company: z
         .object({
@@ -128,6 +187,9 @@ const ExtractionOutputSchema = z.object({
             }),
         )
         .describe("Company policies, certifications, or compliance facts"),
+    legal: z
+        .array(LegalSchema)
+        .describe("Legal documents, contracts, NDAs, terms of service, privacy policies, or regulatory references"),
 });
 
 type ExtractionOutput = z.infer<typeof ExtractionOutputSchema>;
@@ -170,6 +232,7 @@ export async function extractCompanyFacts(
         .select({
             content: documentContextChunks.content,
             pageNumber: documentContextChunks.pageNumber,
+            semanticType: documentContextChunks.semanticType,
         })
         .from(documentContextChunks)
         .where(eq(documentContextChunks.documentId, BigInt(documentId)));
@@ -185,14 +248,34 @@ export async function extractCompanyFacts(
         (a, b) => (a.pageNumber ?? 0) - (b.pageNumber ?? 0),
     );
 
+    // 2b. Filter out low-value chunks to reduce LLM tokens
+    const filteredChunks = sortedChunks.filter((c) => {
+        // Skip chunks tagged as reference (TOCs, disclaimers)
+        if (c.semanticType === "reference") {
+            return false;
+        }
+        // Skip chunks that are mostly boilerplate based on content heuristics
+        if (isBoilerplate(c.content)) {
+            return false;
+        }
+        return true;
+    });
+
+    if (filteredChunks.length === 0) {
+        console.warn(
+            `[CompanyMetadataExtractor] All ${chunks.length} chunks filtered as boilerplate for document ${documentId}`,
+        );
+        return null;
+    }
+
     // 3. Split into batches
     const batches = splitIntoBatches(
-        sortedChunks.map((c) => c.content),
+        filteredChunks.map((c) => c.content),
         CHUNKS_PER_BATCH,
     );
 
     console.log(
-        `[CompanyMetadataExtractor] Document ${documentId}: ${chunks.length} chunks → ${batches.length} batches`,
+        `[CompanyMetadataExtractor] Document ${documentId}: ${chunks.length} chunks → ${filteredChunks.length} after filtering → ${batches.length} batches`,
     );
 
     // 4. Extract from each batch in parallel (capped concurrency)
@@ -401,6 +484,14 @@ function aggregateResults(
         }
     }
 
+    // ---- Legal: merge by normalised name ----
+    const legal = mergeNamedEntries(
+        batchResults.flatMap((r) => r.legal),
+        extractedAt,
+        source,
+        hydrateLegalEntry,
+    );
+
     // ---- Assemble ----
     return {
         document_id: documentId,
@@ -413,6 +504,7 @@ function aggregateResults(
             ...(Object.keys(markets).length > 0 && { markets }),
             ...(projects.length > 0 && { projects }),
             ...(Object.keys(policies).length > 0 && { policies }),
+            ...(legal.length > 0 && { legal }),
         },
     };
 }
@@ -522,6 +614,7 @@ type RawPerson = z.infer<typeof PersonSchema>;
 type RawService = z.infer<typeof ServiceSchema>;
 type RawProject = z.infer<typeof ProjectSchema>;
 type RawSubproject = z.infer<typeof SubprojectSchema>;
+type RawLegal = z.infer<typeof LegalSchema>;
 
 function hydratePersonEntry(
     group: RawPerson[],
@@ -637,3 +730,29 @@ function hydrateSubprojectEntry(
 
     return entry;
 }
+
+function hydrateLegalEntry(
+    group: RawLegal[],
+    extractedAt: string,
+    source: MetadataSource,
+): LegalEntry {
+    const count = group.length;
+    const bestName = pickHighestConfidence(group.map((g) => g.name));
+
+    const entry: LegalEntry = {
+        name: hydrate(bestName, boostConfidence(bestName.confidence, count), extractedAt, source),
+    };
+
+    const optionalFields = ["type", "summary", "effective_date", "expiry_date", "parties", "status"] as const;
+    for (const field of optionalFields) {
+        const candidates = group
+            .map((g) => g[field])
+            .filter((f): f is RawFact => f != null);
+        if (candidates.length > 0) {
+            const best = pickHighestConfidence(candidates);
+            entry[field] = hydrate(best, boostConfidence(best.confidence, candidates.length), extractedAt, source);
+        }
+    }
+
+    return entry;
+}
diff --git a/src/lib/tools/company-metadata/merger.ts b/src/lib/tools/company-metadata/merger.ts
index e4109195..e3cfb805 100644
--- a/src/lib/tools/company-metadata/merger.ts
+++ b/src/lib/tools/company-metadata/merger.ts
@@ -27,6 +27,7 @@ import type {
     ServiceEntry,
     ProjectEntry,
     SubprojectEntry,
+    LegalEntry,
     MarketsInfo,
 } from "./types";
 
@@ -99,6 +100,16 @@ export function mergeCompanyMetadata(
         );
     }
 
+    // ---- Legal ----
+    if (extracted.facts.legal) {
+        merged.legal = mergeNamedArray(
+            merged.legal ?? [],
+            extracted.facts.legal,
+            "legal",
+            diff,
+        );
+    }
+
     // ---- Markets ----
     if (extracted.facts.markets) {
         merged.markets = mergeMarkets(merged.markets, extracted.facts.markets, diff);
@@ -221,7 +232,7 @@ function normaliseName(fact: MetadataFact<unknown>): string {
     return String(fact.value).toLowerCase().trim().replace(/\s+/g, " ");
 }
 
-type NamedEntry = PersonEntry | ServiceEntry | ProjectEntry | SubprojectEntry;
+type NamedEntry = PersonEntry | ServiceEntry | ProjectEntry | SubprojectEntry | LegalEntry;
 
 /**
  * Merge an array of named entries. Entries are matched by normalised name.
diff --git a/src/lib/tools/company-metadata/prompts.ts b/src/lib/tools/company-metadata/prompts.ts
index 8fd4a65c..a7a7d3d0 100644
--- a/src/lib/tools/company-metadata/prompts.ts
+++ b/src/lib/tools/company-metadata/prompts.ts
@@ -24,6 +24,7 @@ RULES:
 - For usage, default to "outreach_ok_with_approval" unless the content is clearly promotional/public (then "outreach_ok") or clearly internal/sensitive (then "no_outreach").
 - If you find people's personal emails or phone numbers, set visibility to "private" and usage to "no_outreach".
 - For projects, preserve any hierarchy you find (project → subproject).
+- For legal content (contracts, NDAs, terms of service, privacy policies, regulatory references), extract the document title as "name", the type (contract, NDA, terms_of_service, privacy_policy, regulation), a brief summary, effective/expiry dates if stated, involved parties, and status (active, expired, pending).
 - If the section does not contain any relevant company metadata, return empty arrays/objects. Do NOT fabricate data.`;
 
 // ============================================================================
diff --git a/src/lib/tools/company-metadata/types.ts b/src/lib/tools/company-metadata/types.ts
index 523e9861..f09786b1 100644
--- a/src/lib/tools/company-metadata/types.ts
+++ b/src/lib/tools/company-metadata/types.ts
@@ -108,6 +108,7 @@ export interface CompanyMetadataJSON {
     markets: MarketsInfo;
     projects: ProjectEntry[];
     policies: Record<string, MetadataFact>;
+    legal: LegalEntry[];
 
     provenance: ProvenanceInfo;
     derived_views?: Record<string, string>;
@@ -162,6 +163,17 @@ export interface SubprojectEntry {
     status?: MetadataFact;
 }
 
+export interface LegalEntry {
+    name: MetadataFact; // title of the legal document/clause
+    type?: MetadataFact; // e.g. "contract", "NDA", "terms_of_service", "privacy_policy", "regulation"
+    summary?: MetadataFact;
+    effective_date?: MetadataFact;
+    expiry_date?: MetadataFact;
+    parties?: MetadataFact; // comma-separated or descriptive
+    status?: MetadataFact; // e.g. "active", "expired", "pending"
+    [key: string]: MetadataFact<unknown> | undefined;
+}
+
 export interface ProvenanceInfo {
     total_documents_processed: number;
     last_document_processed?: {
@@ -235,6 +247,7 @@ export function createEmptyMetadata(companyId: string): CompanyMetadataJSON {
         markets: {},
         projects: [],
         policies: {},
+        legal: [],
         provenance: {
             total_documents_processed: 0,
             extraction_model: "",
diff --git a/src/lib/tools/marketing-pipeline/competitor.ts b/src/lib/tools/marketing-pipeline/competitor.ts
new file mode 100644
index 00000000..7a9d2571
--- /dev/null
+++ b/src/lib/tools/marketing-pipeline/competitor.ts
@@ -0,0 +1,88 @@
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+import { executeSearch } from "~/lib/tools/trend-search/web-search";
+import type { PlannedQuery } from "~/lib/tools/trend-search/types";
+import { getChatModel, MARKETING_MODELS } from "~/lib/models";
+import type { CompetitorAnalysis } from "~/lib/tools/marketing-pipeline/types";
+import { CompetitorAnalysisSchema } from "~/lib/tools/marketing-pipeline/types";
+
+/**
+ * Build search queries to find competitor messaging and positioning.
+ */
+function buildCompetitorQueries(companyName: string, categories: string[]): PlannedQuery[] {
+  const categoryStr = categories.length > 0 ? categories.join(" ") : "industry";
+  return [
+    {
+      searchQuery: `${companyName} competitors ${categoryStr} positioning`,
+      category: "business",
+      rationale: "Find direct competitors and their positioning",
+    },
+    {
+      searchQuery: `${categoryStr} market leaders alternative solutions 2025`,
+      category: "business",
+      rationale: "Find alternatives and market leaders",
+    },
+    {
+      searchQuery: `${companyName} vs competitors comparison`,
+      category: "business",
+      rationale: "Find comparison content and differentiators",
+    },
+  ];
+}
+
+/**
+ * Use web search + LLM to synthesize a competitor landscape for the company.
+ */
+export async function analyzeCompetitors(args: {
+  companyName: string;
+  categories: string[];
+  companyContext?: string;
+}): Promise<CompetitorAnalysis> {
+  const { companyName, categories, companyContext = "" } = args;
+
+  const plannedQueries = buildCompetitorQueries(companyName, categories);
+
+  let rawContext = companyContext;
+  try {
+    const { results } = await executeSearch(plannedQueries);
+    if (results.length > 0) {
+      rawContext +=
+        "\n\nWeb search results (competitors / market):\n" +
+        results
+          .slice(0, 12)
+          .map(
+            (r, i) =>
+              `${i + 1}. [${r.title}] ${r.content.slice(0, 200)}... (${r.url})`,
+          )
+          .join("\n\n");
+    }
+  } catch (error) {
+    console.warn("[marketing-pipeline] competitor web search failed:", error);
+  }
+
+  if (!rawContext.trim()) {
+    rawContext = `Company: ${companyName}. Categories: ${categories.join(", ") || "Unknown"}. No search results.`;
+  }
+
+  const systemPrompt = `You are a competitive intelligence analyst. Given company name, categories, and optional web search results about competitors and the market, produce a structured CompetitorAnalysis.
+
+Rules:
+- Use ONLY information from the provided context and search results. Do not invent competitor names or quotes.
+- If few or no results: return empty or short placeholder arrays and "Not enough data" style strings where needed.
+- competitors: array of { name, positioning (1 sentence), weaknesses (1-3 short items) } for up to 5 competitors.
+- ourAdvantages: 2-5 short phrases where our company clearly wins (infer from context or leave minimal).
+- marketGaps: 2-4 opportunities competitors miss.
+- messagingAntiPatterns: 2-4 clichés or messages competitors use that we should avoid.
+
+Return valid JSON matching the schema.`;
+
+  const chat = getChatModel(MARKETING_MODELS.competitorAnalysis);
+  const model = chat.withStructuredOutput(CompetitorAnalysisSchema, {
+    name: "competitor_analysis",
+  });
+  const response = await model.invoke([
+    new SystemMessage(systemPrompt),
+    new HumanMessage(rawContext),
+  ]);
+
+  return CompetitorAnalysisSchema.parse(response);
+}
diff --git a/src/lib/tools/marketing-pipeline/context.ts b/src/lib/tools/marketing-pipeline/context.ts
index 153ca61e..a6ba6d14 100644
--- a/src/lib/tools/marketing-pipeline/context.ts
+++ b/src/lib/tools/marketing-pipeline/context.ts
@@ -1,12 +1,27 @@
 import { eq } from "drizzle-orm";
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
 import { db } from "~/server/db";
-import { category, company } from "~/server/db/schema";
+import { category, company, companyMetadata } from "~/server/db/schema";
 import {
     companyEnsembleSearch,
     createOpenAIEmbeddings,
     type CompanySearchOptions,
     type SearchResult,
 } from "~/lib/tools/rag";
+import { getChatModel, MARKETING_MODELS } from "~/lib/models";
+import type { CompanyDNA, DNADebugInfo } from "~/lib/tools/marketing-pipeline/types";
+import { CompanyDNASchema } from "~/lib/tools/marketing-pipeline/types";
+import type { CompanyMetadataJSON, MetadataFact } from "~/lib/tools/company-metadata/types";
+
+const DIFFERENTIATOR_QUERY_PARTS = [
+    "unique strengths",
+    "competitive advantages",
+    "awards",
+    "metrics",
+    "customer outcomes",
+    "open source",
+    "differentiator",
+];
 
 export async function buildCompanyKnowledgeContext(args: {
     companyId: number;
@@ -54,3 +69,236 @@ export async function buildCompanyKnowledgeContext(args: {
     return contextParts.join("\n");
 }
 
+/**
+ * Extract CompanyDNA using stored metadata when available, falling back to RAG.
+ *
+ * Priority: company_metadata table → dual RAG queries → minimal fallback.
+ */
+export interface ExtractCompanyDNAResult {
+    dna: CompanyDNA;
+    debug: DNADebugInfo;
+}
+
+export async function extractCompanyDNA(args: {
+    companyId: number;
+    prompt: string;
+}): Promise<ExtractCompanyDNAResult> {
+    const { companyId, prompt } = args;
+
+    // Try metadata-first approach
+    const metadataContext = await buildMetadataContext(companyId);
+    if (metadataContext) {
+        console.log("[marketing-pipeline] extractCompanyDNA: using METADATA for company %d", companyId);
+        const dna = await synthesizeDNA(metadataContext, prompt);
+        return { dna, debug: { source: "metadata", contextUsed: metadataContext, dna } };
+    }
+
+    // Fallback: dual RAG extraction for companies without metadata
+    console.log("[marketing-pipeline] extractCompanyDNA: using RAG FALLBACK for company %d (no metadata found)", companyId);
+    const ragContext = await buildRAGContext(companyId, prompt);
+    const dna = await synthesizeDNA(ragContext, prompt);
+    return { dna, debug: { source: "rag", contextUsed: ragContext, dna } };
+}
+
+// ============================================================================
+// Metadata-based context (preferred path)
+// ============================================================================
+
+const MIN_CONFIDENCE = 0.5;
+
+/** Read active fact value if confidence meets threshold. */
+function readFact<T>(fact: MetadataFact<T> | undefined): T | undefined {
+    if (!fact) return undefined;
+    if (fact.status !== "active") return undefined;
+    if (fact.confidence < MIN_CONFIDENCE) return undefined;
+    return fact.value;
+}
+
+/**
+ * Build a structured text block from the company_metadata JSONB for LLM synthesis.
+ * Returns null if no metadata row exists.
+ */
+async function buildMetadataContext(companyId: number): Promise<string | null> {
+    const [row] = await db
+        .select({ metadata: companyMetadata.metadata })
+        .from(companyMetadata)
+        .where(eq(companyMetadata.companyId, BigInt(companyId)))
+        .limit(1);
+
+    if (!row?.metadata) return null;
+
+    const md = row.metadata as CompanyMetadataJSON;
+    const parts: string[] = [];
+
+    // Company info
+    const name = readFact(md.company.name);
+    const description = readFact(md.company.description);
+    const industry = readFact(md.company.industry);
+    const size = readFact(md.company.size);
+    const founded = readFact(md.company.founded_year as MetadataFact<number> | undefined);
+    const hq = readFact(md.company.headquarters);
+
+    parts.push("=== Company ===");
+    if (name) parts.push(`Name: ${name}`);
+    if (description) parts.push(`Description: ${description}`);
+    if (industry) parts.push(`Industry: ${industry}`);
+    if (size) parts.push(`Size: ${size}`);
+    if (founded) parts.push(`Founded: ${founded}`);
+    if (hq) parts.push(`Headquarters: ${hq}`);
+
+    // Services → differentiators and technical edge
+    if (md.services.length > 0) {
+        const serviceLines = md.services
+            .map((s): string | null => {
+                const sName = readFact(s.name);
+                const sDesc = readFact(s.description);
+                if (!sName) return null;
+                return sDesc ? `- ${sName}: ${sDesc}` : `- ${sName}`;
+            })
+            .filter((v): v is string => v != null);
+        if (serviceLines.length > 0) {
+            parts.push("", "=== Services & Products ===", ...serviceLines);
+        }
+    }
+
+    // Projects → proven results
+    if (md.projects.length > 0) {
+        const projectLines = md.projects
+            .map((p): string | null => {
+                const pName = readFact(p.name);
+                const pDesc = readFact(p.description);
+                const pStatus = readFact(p.status);
+                if (!pName) return null;
+                const detail = [pDesc, pStatus].filter(Boolean).join(" | ");
+                return detail ? `- ${pName}: ${detail}` : `- ${pName}`;
+            })
+            .filter((v): v is string => v != null);
+        if (projectLines.length > 0) {
+            parts.push("", "=== Projects & Outcomes ===", ...projectLines);
+        }
+    }
+
+    // People → human story
+    if (md.people.length > 0) {
+        const personLines = md.people
+            .slice(0, 8)
+            .map((p): string | null => {
+                const pName = readFact(p.name);
+                const pRole = readFact(p.role);
+                if (!pName) return null;
+                return pRole ? `- ${pName} (${pRole})` : `- ${pName}`;
+            })
+            .filter((v): v is string => v != null);
+        if (personLines.length > 0) {
+            parts.push("", "=== Key People ===", ...personLines);
+        }
+    }
+
+    // Markets → differentiators
+    const marketParts: string[] = [];
+    if (md.markets.primary?.length) {
+        const vals = md.markets.primary.map((f) => readFact(f)).filter((v): v is string => v != null);
+        if (vals.length) marketParts.push(`Primary markets: ${vals.join(", ")}`);
+    }
+    if (md.markets.verticals?.length) {
+        const vals = md.markets.verticals.map((f) => readFact(f)).filter((v): v is string => v != null);
+        if (vals.length) marketParts.push(`Verticals: ${vals.join(", ")}`);
+    }
+    if (md.markets.geographies?.length) {
+        const vals = md.markets.geographies.map((f) => readFact(f)).filter((v): v is string => v != null);
+        if (vals.length) marketParts.push(`Geographies: ${vals.join(", ")}`);
+    }
+    if (marketParts.length > 0) {
+        parts.push("", "=== Markets ===", ...marketParts);
+    }
+
+    // Policies → differentiators (certifications, compliance)
+    const policyEntries = Object.entries(md.policies);
+    if (policyEntries.length > 0) {
+        const policyLines = policyEntries
+            .map(([key, fact]): string | null => {
+                const val = readFact(fact);
+                return val ? `- ${key}: ${val}` : null;
+            })
+            .filter((v): v is string => v != null);
+        if (policyLines.length > 0) {
+            parts.push("", "=== Policies & Certifications ===", ...policyLines);
+        }
+    }
+
+    return parts.join("\n");
+}
+
+// ============================================================================
+// RAG-based context (fallback)
+// ============================================================================
+
+async function buildRAGContext(companyId: number, prompt: string): Promise<string> {
+    const [companyRow, categoryRows] = await Promise.all([
+        db.select().from(company).where(eq(company.id, companyId)).limit(1),
+        db.select().from(category).where(eq(category.companyId, BigInt(companyId))).limit(8),
+    ]);
+
+    const companyInfo = companyRow[0];
+    const categoryNames = categoryRows.map((r) => r.name).filter(Boolean);
+    const baseMeta = `Company: ${companyInfo?.name ?? "Unknown"}. Categories: ${categoryNames.join(", ") || "None"}.`;
+
+    const embeddings = createOpenAIEmbeddings();
+    const options: CompanySearchOptions = { companyId, topK: 4, weights: [0.4, 0.6] };
+
+    let generalSnippets: string[] = [];
+    let differentiatorSnippets: string[] = [];
+
+    try {
+        const [generalResults, diffResults] = await Promise.all([
+            companyEnsembleSearch(prompt, options, embeddings),
+            companyEnsembleSearch(
+                `${baseMeta} ${DIFFERENTIATOR_QUERY_PARTS.join(" ")}`,
+                { ...options, topK: 4 },
+                embeddings,
+            ),
+        ]);
+
+        generalSnippets = generalResults
+            .slice(0, 4)
+            .map((r) => r.pageContent.trim().replace(/\s+/g, " ").slice(0, 320))
+            .filter(Boolean);
+        differentiatorSnippets = diffResults
+            .slice(0, 4)
+            .map((r) => r.pageContent.trim().replace(/\s+/g, " ").slice(0, 320))
+            .filter(Boolean);
+    } catch (error) {
+        console.warn("[marketing-pipeline] extractCompanyDNA RAG failed:", error);
+    }
+
+    const combinedSnippets = [...new Set([...generalSnippets, ...differentiatorSnippets])];
+    return combinedSnippets.length > 0
+        ? combinedSnippets.map((s, i) => `${i + 1}. ${s}`).join("\n\n")
+        : `Company Name: ${companyInfo?.name ?? "Unknown Company"}. No KB snippets available.`;
+}
+
+// ============================================================================
+// Shared LLM synthesis
+// ============================================================================
+
+const DNA_SYSTEM_PROMPT = `You are a strategist. Given company information, distill it into a structured CompanyDNA.
+Rules:
+- Use ONLY information present in the input. Do not invent.
+- If something is missing, use a short placeholder like "Not specified" or an empty array.
+- coreMission: one sentence on what the company does and for whom.
+- keyDifferentiators: 2-5 short phrases (e.g. "open source", "no vendor lock-in").
+- provenResults: metrics, outcomes, awards, case results mentioned.
+- humanStory: founding story, team ethos, or values if present; otherwise "Not specified".
+- technicalEdge: one simple sentence on how it works or why it's better; keep it non-technical.
+Return valid JSON matching the schema.`;
+
+async function synthesizeDNA(context: string, userPrompt: string): Promise<CompanyDNA> {
+    const chat = getChatModel(MARKETING_MODELS.dnaExtraction);
+    const model = chat.withStructuredOutput(CompanyDNASchema, { name: "company_dna" });
+    const response = await model.invoke([
+        new SystemMessage(DNA_SYSTEM_PROMPT),
+        new HumanMessage(`Company information:\n\n${context}\n\nUser focus: ${userPrompt}`),
+    ]);
+    return CompanyDNASchema.parse(response);
+}
+
diff --git a/src/lib/tools/marketing-pipeline/generator.ts b/src/lib/tools/marketing-pipeline/generator.ts
index 92cc4f53..d0036d03 100644
--- a/src/lib/tools/marketing-pipeline/generator.ts
+++ b/src/lib/tools/marketing-pipeline/generator.ts
@@ -1,9 +1,13 @@
-import { ChatOpenAI } from "@langchain/openai";
 import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import type { MarketingPlatform, MarketingResearchResult } from "~/lib/tools/marketing-pipeline/types";
+import { getChatModel, MARKETING_MODELS } from "~/lib/models";
+import type {
+  MarketingPlatform,
+  MarketingResearchResult,
+  MessagingStrategy,
+} from "~/lib/tools/marketing-pipeline/types";
 import { MarketingPipelineOutputSchema } from "~/lib/tools/marketing-pipeline/types";
 
-const SYSTEM_PROMPT = `You are a sharp B2B copywriter who writes like an operator sharing hard-won lessons—not a brand broadcasting announcements.
+const SYSTEM_PROMPT_BASE = `You are a sharp B2B copywriter who writes like an operator sharing hard-won lessons—not a brand broadcasting announcements.
 
 Voice & craft:
 - Write as a knowledgeable peer, not a marketing department. First person ("we", "our team") is fine.
@@ -26,6 +30,13 @@ Media selection:
 Output:
 - Return JSON matching the schema exactly. No extra keys.`;
 
+const STRATEGY_RULES = `
+When a Messaging Strategy is provided:
+- Lead with the recommended angle and human hook when it fits the platform; balance human story with technical depth.
+- Back claims with the key proof points given; do not add proof not in company context.
+- Do NOT use any phrase or theme in the strategy's avoid list.
+- Keep the post aligned with the positioning angle while staying platform-native.`;
+
 function platformTemplate(platform: MarketingPlatform): string {
 switch (platform) {
     case "x":
@@ -165,34 +176,50 @@ We rebuilt our pipeline around that idea. Early results are promising.
 """`,
 };
 
+function formatStrategyBlock(strategy: MessagingStrategy): string {
+  return [
+    `Positioning angle: ${strategy.angle}`,
+    `Key proof: ${strategy.keyProof.join("; ")}`,
+    `Human hook: ${strategy.humanHook}`,
+    `Avoid: ${strategy.avoidList.join("; ")}`,
+  ].join("\n");
+}
+
 function buildPrompt(args: {
     platform: MarketingPlatform;
     prompt: string;
     companyContext: string;
     research: MarketingResearchResult[];
+    strategy?: MessagingStrategy;
 }): string {
-    return `Selected platform: ${args.platform}
-User prompt: ${args.prompt}
-
-Company context (source of truth — all product claims must come from here):
-${args.companyContext}
-
-Trend references (use as narrative hooks or framing, never quote or attribute):
-${formatTrendReferences(args.research)}
-
-${platformTemplate(args.platform)}
-
-${PLATFORM_EXAMPLES[args.platform] ?? ""}
-
-Task:
-Write ONE post for the platform above. Follow these principles:
-1. Pick ONE angle — a tension, trend, or insight — and commit to it. Don't try to cover everything.
-2. Open with a hook that creates curiosity or contrast. Never open with an announcement.
-3. Build a short narrative arc: hook → insight/story → takeaway → CTA/question.
-4. Write as a person sharing what they've learned, not a brand listing features.
-5. Every line must add value. If a sentence could be deleted without losing meaning, delete it.
-6. Ground all product claims in the company context. Reframe anything unsupported as an industry observation.
-7. Return JSON matching the schema exactly.`;
+  const parts = [
+    `Selected platform: ${args.platform}`,
+    `User prompt: ${args.prompt}`,
+    "",
+    "Company context (source of truth — all product claims must come from here):",
+    args.companyContext,
+    "",
+    "Trend references (use as narrative hooks or framing, never quote or attribute):",
+    formatTrendReferences(args.research),
+  ];
+  if (args.strategy) {
+    parts.push("", "Messaging strategy (use this angle and proof; respect avoid list):", formatStrategyBlock(args.strategy));
+  }
+  parts.push(
+    "",
+    platformTemplate(args.platform),
+    "",
+    PLATFORM_EXAMPLES[args.platform] ?? "",
+    "",
+    "Task:",
+    args.strategy
+      ? "- Write ONE post using the messaging strategy angle and proof; respect the avoid list."
+      : "- Pick ONE angle (either from trend references or company context).",
+    "- Write ONE post that fits the platform format above.",
+    "- Do NOT add facts not supported by company context.",
+    "- Return JSON only matching the schema.",
+  );
+  return parts.join("\n");
 }
 
 export async function generateCampaignOutput(args: {
@@ -200,21 +227,40 @@ export async function generateCampaignOutput(args: {
     prompt: string;
     companyContext: string;
     research: MarketingResearchResult[];
-}) {
-    const chat = new ChatOpenAI({
-        openAIApiKey: process.env.OPENAI_API_KEY,
-        modelName: "gpt-5-mini",
-    });
-
-    const model = chat.withStructuredOutput(MarketingPipelineOutputSchema, {
-        name: "marketing_pipeline_output",
-    });
-
-    const response = await model.invoke([
-        new SystemMessage(SYSTEM_PROMPT),
-        new HumanMessage(buildPrompt(args)),
-    ]);
-
-    return MarketingPipelineOutputSchema.parse(response);
+    strategy?: MessagingStrategy;
+}): Promise<{
+  platform: MarketingPlatform;
+  message: string;
+  "image/video": "image" | "video";
+  competitiveAngle?: string;
+  strategyUsed?: MessagingStrategy;
+}> {
+  const systemPrompt = args.strategy
+    ? SYSTEM_PROMPT_BASE + STRATEGY_RULES
+    : SYSTEM_PROMPT_BASE;
+
+  const chat = getChatModel(MARKETING_MODELS.contentGeneration);
+  const model = chat.withStructuredOutput(MarketingPipelineOutputSchema, {
+    name: "marketing_pipeline_output",
+  });
+
+  const response = await model.invoke([
+    new SystemMessage(systemPrompt),
+    new HumanMessage(buildPrompt(args)),
+  ]);
+
+  const parsed = MarketingPipelineOutputSchema.parse(response);
+  const out: {
+    platform: MarketingPlatform;
+    message: string;
+    "image/video": "image" | "video";
+    competitiveAngle?: string;
+    strategyUsed?: MessagingStrategy;
+  } = { ...parsed };
+  if (args.strategy) {
+    out.competitiveAngle = args.strategy.angle;
+    out.strategyUsed = args.strategy;
+  }
+  return out;
 }
 
diff --git a/src/lib/tools/marketing-pipeline/positioning.ts b/src/lib/tools/marketing-pipeline/positioning.ts
new file mode 100644
index 00000000..77b5774d
--- /dev/null
+++ b/src/lib/tools/marketing-pipeline/positioning.ts
@@ -0,0 +1,65 @@
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+import { getChatModel, MARKETING_MODELS } from "~/lib/models";
+import type {
+  CompanyDNA,
+  CompetitorAnalysis,
+  MessagingStrategy,
+} from "~/lib/tools/marketing-pipeline/types";
+import { MessagingStrategySchema } from "~/lib/tools/marketing-pipeline/types";
+
+/**
+ * Build a single MessagingStrategy from company DNA, competitor analysis, and optional trend summary.
+ */
+export async function buildMessagingStrategy(args: {
+  dna: CompanyDNA;
+  competitors: CompetitorAnalysis;
+  trendsSummary?: string;
+  userPrompt?: string;
+}): Promise<MessagingStrategy> {
+  const { dna, competitors, trendsSummary = "", userPrompt = "" } = args;
+
+  const contextParts: string[] = [
+    "## Company DNA",
+    `Mission: ${dna.coreMission}`,
+    `Differentiators: ${dna.keyDifferentiators.join("; ")}`,
+    `Proven results: ${dna.provenResults.join("; ")}`,
+    `Human story: ${dna.humanStory}`,
+    `Technical edge: ${dna.technicalEdge}`,
+    "",
+    "## Competitor landscape",
+    ...competitors.competitors.map(
+      (c) =>
+        `- ${c.name}: ${c.positioning}. Weaknesses: ${c.weaknesses.join(", ")}`,
+    ),
+    `Our advantages: ${competitors.ourAdvantages.join("; ")}`,
+    `Market gaps: ${competitors.marketGaps.join("; ")}`,
+    `Messaging to avoid: ${competitors.messagingAntiPatterns.join("; ")}`,
+  ];
+  if (trendsSummary.trim()) {
+    contextParts.push("", "## Platform / trend context", trendsSummary.trim());
+  }
+  if (userPrompt.trim()) {
+    contextParts.push("", "## User request", userPrompt.trim());
+  }
+
+  const systemPrompt = `You are a messaging strategist. Given company DNA, competitor analysis, and optional trend context, produce a single MessagingStrategy.
+
+Rules:
+- angle: one clear positioning angle (1–2 sentences) that differentiates us from competitors and fits our DNA.
+- keyProof: 2–4 concrete proof points (metrics, outcomes, differentiators) to support the angle.
+- humanHook: one human story or emotional hook to open or close the message.
+- avoidList: 3–5 phrases or themes we must avoid (clichés, competitor overlap, weak claims).
+
+Use only information from the provided context. Return valid JSON matching the schema.`;
+
+  const chat = getChatModel(MARKETING_MODELS.contentGeneration);
+  const model = chat.withStructuredOutput(MessagingStrategySchema, {
+    name: "messaging_strategy",
+  });
+  const response = await model.invoke([
+    new SystemMessage(systemPrompt),
+    new HumanMessage(contextParts.join("\n")),
+  ]);
+
+  return MessagingStrategySchema.parse(response);
+}
diff --git a/src/lib/tools/marketing-pipeline/run.ts b/src/lib/tools/marketing-pipeline/run.ts
index e0727eea..51811051 100644
--- a/src/lib/tools/marketing-pipeline/run.ts
+++ b/src/lib/tools/marketing-pipeline/run.ts
@@ -1,5 +1,7 @@
-import { buildCompanyKnowledgeContext } from "~/lib/tools/marketing-pipeline/context";
+import { buildCompanyKnowledgeContext, extractCompanyDNA } from "~/lib/tools/marketing-pipeline/context";
 import { generateCampaignOutput } from "~/lib/tools/marketing-pipeline/generator";
+import { analyzeCompetitors } from "~/lib/tools/marketing-pipeline/competitor";
+import { buildMessagingStrategy } from "~/lib/tools/marketing-pipeline/positioning";
 import type {
   MarketingPipelineInput,
   MarketingPipelineResult,
@@ -9,13 +11,16 @@ import type {
 // additional imports for query building and for fetching trend information
 import { eq } from "drizzle-orm";
 import { db } from "~/server/db";
-import { company } from "~/server/db/schema";
+import { company, category } from "~/server/db/schema";
 import { researchPlatformTrends } from "~/lib/tools/marketing-pipeline/research";
 
+const DEFAULT_PROMPT = "Generate a compelling campaign post for this platform.";
+
 function normalizeInput(input: MarketingPipelineInput): MarketingPipelineInput {
+    const prompt = input.prompt?.trim().replace(/\s+/g, " ") ?? DEFAULT_PROMPT;
     return {
         platform: input.platform,
-        prompt: input.prompt.trim().replace(/\s+/g, " "),
+        prompt: prompt || DEFAULT_PROMPT,
         maxResearchResults: input.maxResearchResults ?? 6,
     };
 }
@@ -32,60 +37,139 @@ function normalizeResearch(research: MarketingResearchResult[]): MarketingResear
         }));
 }
 
+function formatTrendsSummary(research: MarketingResearchResult[]): string {
+  if (!research.length) return "";
+  return research
+    .slice(0, 6)
+    .map((r) => `${r.title}: ${r.snippet.slice(0, 180)}`)
+    .join("\n");
+}
+
 export async function runMarketingPipeline(args: {
   companyId: number;
   input: MarketingPipelineInput;
+  debug?: boolean;
 }): Promise<MarketingPipelineResult> {
   const normalizedInput = normalizeInput(args.input);
 
-  // 1) Fetch company name (used for logs / future features)
+  // 1) Fetch company name and categories
   const [companyRow] = await db
     .select({ name: company.name })
     .from(company)
     .where(eq(company.id, args.companyId))
     .limit(1);
-
   const companyName = companyRow?.name ?? "Unknown Company";
 
-  // 2) Build KB context from all company documents
-  const companyContext = await buildCompanyKnowledgeContext({
+  const categoryRows = await db
+    .select({ name: category.name })
+    .from(category)
+    .where(eq(category.companyId, BigInt(args.companyId)))
+    .limit(8);
+  const categories = categoryRows.map((r) => r.name).filter(Boolean);
+
+  // 2) Build KB context (needed for research and generator)
+  const companyContextBase = await buildCompanyKnowledgeContext({
     companyId: args.companyId,
-    prompt: normalizedInput.prompt,
+    prompt: normalizedInput.prompt ?? DEFAULT_PROMPT,
   });
 
-  // 3) Fetch trend references (non-fatal)
+  const platformGuidelines = buildPlatformGuidelines(normalizedInput.platform);
+  const companyContext = `${companyContextBase}
+
+Platform best practices:
+${platformGuidelines}`;
+
+  // 3) Run DNA extraction, competitor analysis, and trend research in parallel
   let research: MarketingResearchResult[] = [];
-  try {
-    research = await researchPlatformTrends({
-      platform: normalizedInput.platform,
-      prompt: normalizedInput.prompt,
+  const [dnaResult, competitors] = await Promise.all([
+    extractCompanyDNA({ companyId: args.companyId, prompt: normalizedInput.prompt ?? DEFAULT_PROMPT }),
+    analyzeCompetitors({
       companyName,
-      companyContext,
-      maxResults: normalizedInput.maxResearchResults ?? 6,
-    });
-    research = normalizeResearch(research);
-  } catch (error) {
-    console.warn("[marketing-pipeline] trend research failed:", error);
-    research = [];
-  }
+      categories,
+      companyContext: companyContextBase,
+    }),
+    (async (): Promise<MarketingResearchResult[]> => {
+      try {
+        const raw = await researchPlatformTrends({
+          platform: normalizedInput.platform,
+          prompt: normalizedInput.prompt ?? DEFAULT_PROMPT,
+          companyName,
+          companyContext,
+          maxResults: normalizedInput.maxResearchResults ?? 6,
+        });
+        return normalizeResearch(raw);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.warn("[marketing-pipeline] trend research failed:", message);
+        return [];
+      }
+    })(),
+  ]).then(([d, c, r]) => {
+    research = r;
+    return [d, c] as const;
+  });
+
+  const { dna, debug: dnaDebug } = dnaResult;
+
+  // 4) Build messaging strategy from DNA + competitors + trends
+  const trendsSummary = formatTrendsSummary(research);
+  const strategy = await buildMessagingStrategy({
+    dna,
+    competitors,
+    trendsSummary,
+    userPrompt: normalizedInput.prompt ?? DEFAULT_PROMPT,
+  });
 
-  // 5) Generate campaign output using KB + trends
+  // 5) Generate campaign output with strategy
   const generated = await generateCampaignOutput({
     platform: normalizedInput.platform,
-    prompt: normalizedInput.prompt,
+    prompt: normalizedInput.prompt ?? DEFAULT_PROMPT,
     companyContext,
     research,
+    strategy,
   });
 
-  // 6) Return final result
+  // 6) Return result with competitiveAngle and strategyUsed
   return {
     ...generated,
     research,
     normalizedInput: {
       platform: normalizedInput.platform,
-      prompt: normalizedInput.prompt,
+      prompt: normalizedInput.prompt ?? DEFAULT_PROMPT,
     },
+    competitiveAngle: generated.competitiveAngle,
+    strategyUsed: generated.strategyUsed,
+    ...(args.debug ? { dnaDebug } : {}),
   };
 }
 
-
+function buildPlatformGuidelines(platform: MarketingPipelineInput["platform"]): string {
+  switch (platform) {
+    case "reddit":
+      return [
+        "- Speak like a real community member, not a brand account.",
+        "- Lead with a specific pain point or story that matches the subreddit.",
+        "- Avoid pure self-promotion: focus on value, insight, or behind-the-scenes context.",
+        "- Use clear, descriptive titles; body can be longer and conversational.",
+        "- Invite discussion with an authentic question at the end.",
+      ].join("\n");
+    case "x":
+      return [
+        "- Keep posts tight and high-signal; front-load the hook in the first line.",
+        "- Use 1–2 sharp talking points instead of long paragraphs.",
+        "- Sprinkle in 1–2 relevant hashtags, but avoid hashtag spam.",
+        "- When appropriate, reference current trends or conversations in the space.",
+        "- Make the call-to-action explicit and easy to understand.",
+      ].join("\n");
+    case "linkedin":
+      return [
+        "- Use a strong first line that clearly states the outcome or insight.",
+        "- Write in short paragraphs or bullet points for easy scanning.",
+        "- Frame the message around business impact, transformation, or a concrete case.",
+        "- Keep the tone professional but human—less hype, more signal.",
+        "- Close with a takeaway or a soft call-to-action tailored to professionals.",
+      ].join("\n");
+    default:
+      return "- Write a clear, concise, value-focused message tailored to this platform.";
+  }
+}
diff --git a/src/lib/tools/marketing-pipeline/types.ts b/src/lib/tools/marketing-pipeline/types.ts
index 90cca09a..f0a3ae59 100644
--- a/src/lib/tools/marketing-pipeline/types.ts
+++ b/src/lib/tools/marketing-pipeline/types.ts
@@ -1,11 +1,68 @@
 import { z } from "zod";
 
+/** Structured company profile distilled from KB for marketing (issue #232). */
+export interface CompanyDNA {
+  coreMission: string;
+  keyDifferentiators: string[];
+  provenResults: string[];
+  humanStory: string;
+  technicalEdge: string;
+}
+
+export const CompanyDNASchema = z.object({
+  coreMission: z.string(),
+  keyDifferentiators: z.array(z.string()),
+  provenResults: z.array(z.string()),
+  humanStory: z.string(),
+  technicalEdge: z.string(),
+});
+
+/** Competitor landscape for marketing (issue #232). */
+export interface CompetitorAnalysis {
+  competitors: Array<{
+    name: string;
+    positioning: string;
+    weaknesses: string[];
+  }>;
+  ourAdvantages: string[];
+  marketGaps: string[];
+  messagingAntiPatterns: string[];
+}
+
+export const CompetitorAnalysisSchema = z.object({
+  competitors: z.array(
+    z.object({
+      name: z.string(),
+      positioning: z.string(),
+      weaknesses: z.array(z.string()),
+    }),
+  ),
+  ourAdvantages: z.array(z.string()),
+  marketGaps: z.array(z.string()),
+  messagingAntiPatterns: z.array(z.string()),
+});
+
+/** Messaging strategy derived from DNA + competitors + trends (issue #232). */
+export interface MessagingStrategy {
+  angle: string;
+  keyProof: string[];
+  humanHook: string;
+  avoidList: string[];
+}
+
+export const MessagingStrategySchema = z.object({
+  angle: z.string(),
+  keyProof: z.array(z.string()),
+  humanHook: z.string(),
+  avoidList: z.array(z.string()),
+});
+
 export const MarketingPlatformEnum = z.enum(["x", "linkedin", "reddit", "bluesky"]);
 export type MarketingPlatform = z.infer<typeof MarketingPlatformEnum>;
 
 export const MarketingPipelineInputSchema = z.object({
     platform: MarketingPlatformEnum,
-    prompt: z.string().min(1).max(2000),
+    prompt: z.string().min(1).max(2000).optional(),
     maxResearchResults: z.number().int().min(1).max(12).optional(),
 });
 export type MarketingPipelineInput = z.infer<typeof MarketingPipelineInputSchema>;
@@ -24,11 +81,24 @@ export const MarketingPipelineOutputSchema = z.object({
 });
 export type MarketingPipelineOutput = z.infer<typeof MarketingPipelineOutputSchema>;
 
+/** Debug info about the DNA extraction source, included when ?debug=true. */
+export interface DNADebugInfo {
+    source: "metadata" | "rag";
+    contextUsed: string;
+    dna: CompanyDNA;
+}
+
 export interface MarketingPipelineResult extends MarketingPipelineOutput {
     research: MarketingResearchResult[];
     normalizedInput: {
         platform: MarketingPlatform;
         prompt: string;
     };
+    /** Positioning angle used for this campaign (issue #232). */
+    competitiveAngle?: string;
+    /** Optional summary of strategy (angle + proof + hook) for transparency. */
+    strategyUsed?: MessagingStrategy;
+    /** Debug info about DNA extraction, included when debug mode is on. */
+    dnaDebug?: DNADebugInfo;
 }
 
diff --git a/src/lib/tools/trend-search/providers/registry.ts b/src/lib/tools/trend-search/providers/registry.ts
index 1f8d423f..1d4cbbdf 100644
--- a/src/lib/tools/trend-search/providers/registry.ts
+++ b/src/lib/tools/trend-search/providers/registry.ts
@@ -1,9 +1,7 @@
 import type { SearchProviderFn } from "./types";
 import { callTavily } from "./tavily";
 import { callSerper } from "./serper";
-
 export const providerRegistry: Record<string, SearchProviderFn> = {
   tavily: callTavily,
   serper: callSerper,
 };
-
diff --git a/src/lib/tools/trend-search/providers/serper.ts b/src/lib/tools/trend-search/providers/serper.ts
index 82f15571..731cb0c8 100644
--- a/src/lib/tools/trend-search/providers/serper.ts
+++ b/src/lib/tools/trend-search/providers/serper.ts
@@ -2,7 +2,9 @@ import { env } from "~/env";
 import type { RawSearchResult } from "~/lib/tools/trend-search/types";
 
 const SERPER_NEWS_URL = "https://google.serper.dev/news";
+const MAX_RESULTS_PER_QUERY = 10;
 
+/** Response shape from Serper Google News API (subset we use). */
 interface SerperNewsItem {
   title?: string;
   link?: string;
@@ -16,6 +18,10 @@ interface SerperNewsResponse {
   news?: SerperNewsItem[];
 }
 
+/**
+ * Calls Serper.dev Google News API for a single query.
+ * @returns RawSearchResult[] or empty array if SERPER_API_KEY not set; throws on non-2xx.
+ */
 export async function callSerper(query: string): Promise<RawSearchResult[]> {
   const apiKey = env.server.SERPER_API_KEY;
   if (!apiKey) {
@@ -31,7 +37,7 @@ export async function callSerper(query: string): Promise<RawSearchResult[]> {
     },
     body: JSON.stringify({
       q: query,
-      num: 10,
+      num: MAX_RESULTS_PER_QUERY,
       gl: "us",
       hl: "en",
     }),
@@ -53,26 +59,26 @@ export async function callSerper(query: string): Promise<RawSearchResult[]> {
     return [];
   }
 
-  const total = items.length;
+  const filtered = items.filter(
+    (item): item is SerperNewsItem & { link: string } => Boolean(item?.link),
+  );
+  if (filtered.length === 0) {
+    console.warn("[web-search] Serper returned no news results.");
+    return [];
+  }
 
-  return items
-    .filter((item): item is SerperNewsItem & { link: string } =>
-      Boolean(item?.link),
-    )
-    .map((item, index) => {
-      const position =
-        typeof item.position === "number" && item.position > 0
-          ? item.position
-          : index + 1;
-      const score = 1 - position / (total + 1);
+  const total = filtered.length;
 
-      return {
-        url: item.link,
-        title: item.title ?? "Untitled",
-        content: item.snippet ?? "",
-        score,
-        ...(item.date && { publishedDate: item.date }),
-      };
-    });
-}
+  return filtered.map((item, index) => {
+    const position = index + 1;
+    const score = Math.max(0, 1 - position / total);
 
+    return {
+      url: item.link,
+      title: item.title ?? "Untitled",
+      content: item.snippet ?? "",
+      score,
+      ...(item.date && { publishedDate: item.date }),
+    };
+  });
+}
diff --git a/src/lib/tools/trend-search/providers/tavily.ts b/src/lib/tools/trend-search/providers/tavily.ts
index 71e0d147..04964f50 100644
--- a/src/lib/tools/trend-search/providers/tavily.ts
+++ b/src/lib/tools/trend-search/providers/tavily.ts
@@ -4,6 +4,7 @@ import type { RawSearchResult } from "~/lib/tools/trend-search/types";
 const TAVILY_SEARCH_URL = "https://api.tavily.com/search";
 const MAX_RESULTS_PER_QUERY = 10;
 
+/** Response shape from Tavily /search API (subset we use). Note: published_date is not in the current Tavily spec; we accept it if present. */
 interface TavilyResultItem {
   title?: string;
   url?: string;
@@ -64,4 +65,3 @@ export async function callTavily(query: string): Promise<RawSearchResult[]> {
       ...(item.published_date != null && { publishedDate: item.published_date }),
     }));
 }
-
diff --git a/src/lib/tools/trend-search/providers/types.ts b/src/lib/tools/trend-search/providers/types.ts
index 8a226746..606370c6 100644
--- a/src/lib/tools/trend-search/providers/types.ts
+++ b/src/lib/tools/trend-search/providers/types.ts
@@ -1,11 +1,22 @@
 import type { RawSearchResult } from "~/lib/tools/trend-search/types";
 
+/** A search provider function: takes a query string, returns normalized results. */
 export type SearchProviderFn = (query: string) => Promise<RawSearchResult[]>;
 
+/** The supported provider strategy names. */
 export type ProviderStrategy = "tavily" | "serper" | "fallback" | "parallel";
 
+/** Which provider(s) produced the merged result (see `executeSearch`). */
+export type SearchProviderUsed =
+  | "tavily"
+  | "serper"
+  | "tavily (fallback)"
+  | "tavily+serper"
+  | "none"
+  | "auto";
+
+/** Extended result from executeSearch, includes which provider was used. */
 export interface SearchExecutionResult {
   results: RawSearchResult[];
-  providerUsed: string;
+  providerUsed: SearchProviderUsed;
 }
-
diff --git a/src/lib/tools/trend-search/web-search.ts b/src/lib/tools/trend-search/web-search.ts
index c53754ee..151bc9f5 100644
--- a/src/lib/tools/trend-search/web-search.ts
+++ b/src/lib/tools/trend-search/web-search.ts
@@ -8,6 +8,7 @@ import type {
   ProviderStrategy,
   SearchExecutionResult,
   SearchProviderFn,
+  SearchProviderUsed,
 } from "~/lib/tools/trend-search/providers/types";
 
 const MAX_RETRIES = 2;
@@ -21,6 +22,10 @@ function normalizeUrl(url: string): string {
   }
 }
 
+/**
+ * Runs all sub-queries through a single provider with retry and URL deduplication.
+ * @returns Combined RawSearchResult[] (deduplicated by URL).
+ */
 async function executeWithProvider(
   subQueries: PlannedQuery[],
   provider: SearchProviderFn,
@@ -111,28 +116,34 @@ export async function executeSearch(
 ): Promise<SearchExecutionResult> {
   const strategy = resolveStrategy(strategyOverride);
 
+  const hasTavilyKey = Boolean(env.server.TAVILY_API_KEY);
+  const hasSerperKey = Boolean(env.server.SERPER_API_KEY);
+
   const useSerper =
-    env.server.SERPER_API_KEY &&
+    hasSerperKey &&
     (strategy === "serper" ||
       strategy === "fallback" ||
       strategy === "parallel");
 
   if (!useSerper && strategy === "serper") {
     console.warn(
-      "[web-search] SERPER_API_KEY not set; falling back to Tavily strategy.",
+      "[web-search] SERPER_API_KEY not set; downgrading strategy to tavily.",
     );
   }
 
   const tavilyProvider = getProvider("tavily");
   const serperProvider = getProvider("serper");
 
-  // Basic single-provider strategies
+  // Basic single-provider strategies (tavily default, or Serper strategies downgraded without key)
   if (strategy === "tavily" || !useSerper) {
     if (!tavilyProvider) {
       return { results: [], providerUsed: "none" };
     }
     const results = await executeWithProvider(subQueries, tavilyProvider);
-    return { results, providerUsed: "tavily" };
+    return {
+      results,
+      providerUsed: hasTavilyKey ? "tavily" : "none",
+    };
   }
 
   if (strategy === "serper") {
@@ -153,7 +164,10 @@ export async function executeSearch(
         return { results: [], providerUsed: "none" };
       }
       const results = await executeWithProvider(subQueries, tavilyProvider);
-      return { results, providerUsed: "tavily" };
+      return {
+        results,
+        providerUsed: hasTavilyKey ? "tavily" : "none",
+      };
     }
 
     const primaryResults = await executeWithProvider(
@@ -168,7 +182,7 @@ export async function executeSearch(
       "[web-search] Serper returned no results for all sub-queries, falling back to Tavily.",
     );
     if (!tavilyProvider) {
-      return { results: [], providerUsed: "serper" };
+      return { results: [], providerUsed: "none" };
     }
 
     const fallbackResults = await executeWithProvider(
@@ -177,7 +191,7 @@ export async function executeSearch(
     );
     return {
       results: fallbackResults,
-      providerUsed: "tavily (fallback)",
+      providerUsed: hasTavilyKey ? "tavily" : "none",
     };
   }
 
@@ -198,24 +212,31 @@ export async function executeSearch(
       })),
     );
 
-    const merged: RawSearchResult[] = [];
-    const bestByUrl = new Map<string, RawSearchResult>();
+    // First URL wins per provider order (Serper then Tavily). Do not compare
+    // `score` across providers — Tavily and Serper use different scales.
+    const byUrl = new Map<string, RawSearchResult>();
 
     for (const { results } of resultsPerProvider) {
       for (const r of results) {
         const normalizedUrl = normalizeUrl(r.url);
-        const existing = bestByUrl.get(normalizedUrl);
-        if (!existing || r.score > existing.score) {
-          bestByUrl.set(normalizedUrl, r);
+        if (normalizedUrl && !byUrl.has(normalizedUrl)) {
+          byUrl.set(normalizedUrl, r);
         }
       }
     }
 
-    for (const value of bestByUrl.values()) {
-      merged.push(value);
+    const merged: RawSearchResult[] = [...byUrl.values()];
+
+    let providerUsed: SearchProviderUsed;
+    if (hasTavilyKey && hasSerperKey) {
+      providerUsed = "tavily+serper";
+    } else if (hasSerperKey) {
+      providerUsed = "serper";
+    } else {
+      providerUsed = "none";
     }
 
-    return { results: merged, providerUsed: "tavily+serper" };
+    return { results: merged, providerUsed };
   }
 
   // Fallback safety – should not reach here
@@ -224,6 +245,11 @@ export async function executeSearch(
     return { results: [], providerUsed: "none" };
   }
   const defaultResults = await executeWithProvider(subQueries, defaultProvider);
-  return { results: defaultResults, providerUsed: "auto" };
+  const providerUsed: SearchProviderUsed =
+    defaultProvider === tavilyProvider
+      ? hasTavilyKey
+        ? "tavily"
+        : "none"
+      : "serper";
+  return { results: defaultResults, providerUsed };
 }
-
diff --git a/src/lib/validation.ts b/src/lib/validation.ts
index 174ffac8..6613feac 100644
--- a/src/lib/validation.ts
+++ b/src/lib/validation.ts
@@ -85,7 +85,7 @@ function assertProviderModelCombination(
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
       path: ["aiModel"],
-      message: `Model \"${model}\" is not available for provider \"${provider}\"`,
+      message: `Model \"${String(model)}\" is not available for provider \"${String(provider)}\"`,
     });
   }
 }
@@ -101,15 +101,13 @@ export const QuestionSchema = z
     enableWebSearch: z.boolean().optional().default(false),
     aiPersona: z.enum(aiPersonaOptions).optional(),
     aiModel: z.enum(aiModelOptions).optional(),
-    provider: z.enum(providerOptions).optional(),
+    provider: z.enum(providerOptions).default("openai"),
     conversationHistory: z.string().optional(),
   })
   .superRefine((data, ctx) => {
-    const provider = (data.provider ?? "openai") as LLMProvider;
-    assertProviderModelCombination(provider, data.aiModel, ctx);
+    assertProviderModelCombination(data.provider, data.aiModel, ctx);
   })
   .transform((data) => {
-    const provider = (data.provider ?? "openai") as LLMProvider;
     return {
       documentId: data.documentId,
       companyId: data.companyId,
@@ -120,7 +118,7 @@ export const QuestionSchema = z
       enableWebSearch: data.enableWebSearch ?? false,
       aiPersona: data.aiPersona ?? "general",
       aiModel: data.aiModel,
-      provider,
+      provider: data.provider,
       conversationHistory: data.conversationHistory,
     };
   });
@@ -226,7 +224,7 @@ export const RLMQuestionSchema = z
     enableWebSearch: z.boolean().optional().default(false),
     aiPersona: z.enum(aiPersonaOptions).optional(),
     aiModel: z.enum(aiModelOptions).optional(),
-    provider: z.enum(providerOptions).optional(),
+    provider: z.enum(providerOptions).default("openai"),
     conversationHistory: z.string().optional(),
     // RLM-specific options
     maxTokens: z.number().int().min(500).max(100000).optional(),
@@ -245,11 +243,9 @@ export const RLMQuestionSchema = z
       .optional(),
   })
   .superRefine((data, ctx) => {
-    const provider = (data.provider ?? "openai") as LLMProvider;
-    assertProviderModelCombination(provider, data.aiModel, ctx);
+    assertProviderModelCombination(data.provider, data.aiModel, ctx);
   })
   .transform((data) => {
-    const provider = (data.provider ?? "openai") as LLMProvider;
     return {
       documentId: data.documentId,
       question: data.question,
@@ -257,7 +253,7 @@ export const RLMQuestionSchema = z
       enableWebSearch: data.enableWebSearch ?? false,
       aiPersona: data.aiPersona ?? "general",
       aiModel: data.aiModel,
-      provider,
+      provider: data.provider,
       conversationHistory: data.conversationHistory,
       maxTokens: data.maxTokens ?? 4000,
       includeOverview: data.includeOverview ?? true,