diff --git a/AGENTS.md b/AGENTS.md
index 626e22d..f304b6a 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,5 +1,16 @@
 # EasyDocs
 
+## Product direction
+
+See `ROADMAP.md` for the wedge and pillars. One boundary matters when touching
+the dashboard: it is the **local, producer-side cockpit** for the generated
+spec (review/edit/approve, version history + diff, sensitive-field badges,
+docs-vs-reality drift). It is deliberately **not** a hosted, consumer-facing
+docs portal — no multi-tenant hosting, custom domains, theming, or a published
+"try it out" aimed at your API's external consumers (that is ceded to
+ReadMe/Mintlify/Scalar). Keep dashboard work serving the developer producing
+the spec, not the external API consumer.
+
 ## Release
 
 Run `pnpm release` (or `release:minor` / `release:major`). The script
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b159122..3b04cd3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,36 @@ All notable changes to this project are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+- Docs-vs-reality drift detection: a new `easydocs drift <spec>` command compares
+  a committed OpenAPI spec against the spec EasyDocs derives from real traffic and
+  reports where documentation has diverged from reality — endpoints/fields observed
+  but undocumented, documented but never observed, and values that contradict what
+  traffic shows. With one argument it reads observed traffic from the local capture
+  DB; with two it compares spec files directly. Takes `--project` and `--markdown`
+  (for PR comments), and, like `diff`, is informational and never fails the build.
+  The engine is exported from `@easydocs/core` (`computeDrift` / `renderDrift`, also
+  at the `@easydocs/core/spec/drift` subpath).
+- Dashboard drift view: the dashboard now surfaces docs-vs-reality drift. It reads
+  the committed spec from `EASYDOCS_SPEC_PATH` (default `./openapi.json`), compares
+  it against observed traffic, badges each drifted endpoint in the sidebar, and
+  shows a panel breaking down undocumented / mismatch / unobserved findings. Served
+  by a new local `/api/drift` route — the comparison never leaves the machine.
+- Strict offline mode (`privacy.offline: true`): a hard local-first guarantee for
+  regulated / air-gapped setups. EasyDocs pins itself to a local Ollama model,
+  ignores any hosted API keys present in the environment, and fails fast at startup
+  if a hosted provider is explicitly configured — so no captured payload can ever
+  reach a third-party service. `isHostedProvider` is exported from `@easydocs/core`.
+- Redaction audit: EasyDocs can now show exactly which fields it protects. A new
+  `collectSensitiveFields` helper (exported from `@easydocs/core` and the pure
+  `@easydocs/core/privacy/audit` subpath) reads the `x-easydocs-sensitive` markers
+  back out of a spec, and the dashboard surfaces them in a "Sensitive fields" panel
+  grouped by endpoint — making the PII-safe promise provable, not just a claim.
+  A new `easydocs audit` command lists the same inventory from the terminal (with
+  `--project` and `--markdown`), so a pipeline can assert what is being protected.
+
 ## [0.8.1] - 2026-07-02
 
 ### Changed
diff --git a/README.md b/README.md
index 39f57ac..3ccc668 100644
--- a/README.md
+++ b/README.md
@@ -110,6 +110,27 @@ the PR when the spec changes cross that threshold; the comment is still posted.
 
 ---
 
+## Catch drift between your docs and reality
+
+`diff` compares two spec *files*. **`drift` compares your committed spec against
+what your API actually does** — the spec EasyDocs derives from real traffic. It
+answers "is my spec still true?", not "did my spec change?".
+
+```bash
+npx easydocs drift openapi.json              # against locally captured traffic
+npx easydocs drift openapi.json --markdown   # PR-comment Markdown
+npx easydocs drift committed.json live.json  # or compare two files directly
+```
+
+It surfaces three kinds of divergence: endpoints and fields **observed in traffic
+but missing from your spec** (your docs are stale), things **documented but never
+observed** (dead or un-exercised), and values where your spec **contradicts**
+reality. This is the one check only EasyDocs can run — it's the only tool holding
+both the committed spec and the live traffic at the same time. Like `diff`, it's
+informational and never fails the build.
+
+---
+
 ## How it works
 
 1. Middleware (or proxy) intercepts every request and response
@@ -179,6 +200,7 @@ easydocs({
   },
   privacy: {
     enabled: true, // on by default; detect & redact PII/secrets
+    offline: false, // strict local-first: only ever use a local Ollama model
     placeholder: "[REDACTED]", // value substituted for sensitive fields
     allowlist: ["public_token"], // key names never to flag
     customRules: {
@@ -198,6 +220,12 @@ to a **hosted** provider (OpenAI/Anthropic/DeepSeek); with local Ollama nothing
 the machine, so real values are kept for accuracy. Flagged fields are marked in the
 spec with `x-easydocs-sensitive` and shown with a badge in the dashboard.
 
+For regulated or air-gapped environments, set `privacy.offline: true` for a hard
+guarantee: EasyDocs pins itself to a local Ollama model, **ignores any hosted API
+keys in the environment**, and refuses to start if a hosted provider is explicitly
+configured. Nothing captured can ever reach a third-party service — redaction becomes
+moot because no payload leaves the machine at all.
+
 ---
 
 ## Multiple projects
diff --git a/ROADMAP.md b/ROADMAP.md
new file mode 100644
index 0000000..8ad4a51
--- /dev/null
+++ b/ROADMAP.md
@@ -0,0 +1,140 @@
+# EasyDocs Roadmap
+
+> This is a direction document, not a backlog. It states the wedge we are
+> betting on, the pillars that defend it (in priority order), and — just as
+> importantly — what we will deliberately **not** build. Tactical issues should
+> trace back to a pillar here; anything that doesn't, we say no to.
+
+## North Star
+
+**The OpenAPI spec you never have to write, and never have to trust a cloud with.**
+
+EasyDocs generates accurate, always-current OpenAPI from real traffic, entirely
+on your own infrastructure. We own the *source-of-truth generation* layer — the
+accurate spec — and let everyone else own presentation and codegen.
+
+## The gap we are filling
+
+Look at the field and almost every competitor lands in one of two camps, and
+**nobody covers the intersection**:
+
+- **Spec consumers** — Speakeasy, Fern, ReadMe, Mintlify, Scalar, Stoplight.
+  They assume you already have a correct OpenAPI file. They don't generate it.
+  Their blind spot: *the input spec is usually stale or missing.*
+- **Traffic-based SaaS** — Postman (Akita), Treblle, Optic Cloud. They capture
+  traffic, but **your traffic leaves your machine**. Their blind spot:
+  *anyone who cannot ship production traffic to someone else's cloud* — health,
+  fintech, public sector, on-prem, air-gapped.
+
+The empty intersection is: **generate the spec from real traffic, accurately,
+without the data ever leaving your infrastructure.** That is exactly what
+EasyDocs already is. The strategy is not to invent a new direction — it is to
+*refuse to dilute this one* by chasing features from either camp.
+
+## Pillars, in priority order
+
+The order is the strategy. When two efforts compete for the same week, the
+higher pillar wins.
+
+### 1. Privacy / local-first — the defensible base (C)
+
+The one thing SaaS competitors **cannot copy without cannibalizing their own
+business model.** Postman and Treblle will not stop being cloud. This is our
+terrain, and it is what unlocks the regulated segment (health, fintech, gov,
+on-prem) that is structurally locked out of the alternatives.
+
+Today: PII/secret detection + redaction before anything reaches a hosted
+provider; fully offline path via Ollama; deterministic, offline detection.
+
+Direction: make "nothing leaves the machine" a *provable*, first-class product
+promise — not a bullet point. Audit trails of what was redacted, stronger
+guarantees and defaults, and positioning aimed squarely at teams that cannot use
+a traffic SaaS at all.
+
+### 2. Drift: docs-vs-reality — the feature only we can build (A)
+
+Every competitor diffs **spec-against-spec**. We are the only ones who hold, at
+the same time, **the committed spec *and* the observed production traffic.**
+That enables something no one else can offer:
+
+> Your `openapi.json` says X, but your API in production actually does Y.
+
+This is not "did the spec change?" — it is "is the spec still true?" It is
+uniquely enabled by having both halves, and it composes directly with what
+already exists (traffic capture + `easydocs diff` + the GitHub Action).
+
+Direction: turn the existing traffic capture and diff machinery into a
+drift detector — compare committed spec vs. observed reality and surface where
+documentation has diverged, in the dashboard and in CI as an informational
+signal.
+
+### 3. Measurable accuracy — the moat that makes 1 and 2 credible (B)
+
+Replacing a hand-written spec, and claiming "your docs are wrong," both require
+*trust*. Trust comes from being **demonstrably** the most accurate generator of
+OpenAPI from traffic. We already have the scaffolding: `apps/evals` and the
+cross-provider accuracy `gate`.
+
+Direction: double down on the eval harness as a moat, not a test. Expand
+fixtures and the accuracy scoreboard, keep the cross-provider gate honest, and
+make accuracy a number we can publish and defend.
+
+### 4. Interoperable upstream — the distribution (D)
+
+We are the source of truth; others are the presentation. Do not build a walled
+garden — feed the ecosystem. EasyDocs should produce the clean OpenAPI that
+Scalar / ReadMe / Speakeasy / Fern consume.
+
+Direction: first-class, frictionless export and integrations *into* those tools,
+so adopting EasyDocs upstream is the obvious choice regardless of which docs
+portal or SDK generator a team already uses.
+
+## Where the dashboard fits
+
+The local dashboard is the **producer-side cockpit for the source-of-truth
+layer**, not a consumer-facing docs site. It runs on your machine, reads from
+your database, and is where you review, edit, and approve generated specs, see
+version history and field-level diffs, and inspect what was flagged as
+sensitive. It is the surface where the pillars become visible: redaction badges
+make pillar 1's "nothing leaves the machine" promise tangible, and docs-vs-reality
+drift (pillar 2) needs exactly this kind of surface to render. Keeping it local
+and producer-facing reinforces the wedge; letting it drift toward a hosted,
+consumer-facing portal would cross the anti-goal below.
+
+## What we will deliberately NOT do
+
+Saying no here is what keeps the wedge sharp.
+
+- **No hosted, consumer-facing docs portal.** No multi-tenant hosting, custom
+  domains, theming, or a published "try it out" aimed at your API's external
+  consumers. Cede that to ReadMe / Mintlify / Scalar — integrate with them
+  (pillar 4) instead of competing. This is **not** the local dashboard (see
+  below), which stays and is central to the wedge.
+- **No SDK / client generation.** That is Speakeasy / Fern territory. Be their
+  input, not their rival.
+- **No build-blocking CI gatekeeping** for breaking changes. Crowded (Optic,
+  Bump.sh). Our diff stays informational; our differentiated CI signal is
+  *drift* (pillar 2), not gating.
+
+## Phasing
+
+Rough sequencing, anchored to the pillars above rather than to dates.
+
+- **Now** — Harden pillar 1 (privacy as a provable promise) and pillar 3 (grow
+  the eval harness / accuracy scoreboard). These are the foundation the rest
+  stands on.
+- **Next** — Ship pillar 2 (docs-vs-reality drift) on top of the existing
+  capture + diff + Action, since accuracy (3) is what makes its signal
+  trustworthy.
+- **Later** — Broaden pillar 4 (export/integrations into the docs & SDK
+  ecosystem) and extend framework/language coverage where it serves the wedge.
+
+## How we measure the direction is working
+
+- Regulated / on-prem teams adopting *because* traffic never leaves — a segment
+  the SaaS camp cannot serve.
+- Drift detection surfacing real doc-vs-reality divergences that spec-to-spec
+  tools structurally cannot see.
+- A published, defensible cross-provider accuracy number.
+- EasyDocs specs feeding downstream tools (Scalar/ReadMe/Speakeasy/Fern) as the
+  common upstream.
diff --git a/apps/dashboard/src/app/api/drift/route.ts b/apps/dashboard/src/app/api/drift/route.ts
new file mode 100644
index 0000000..cf8584f
--- /dev/null
+++ b/apps/dashboard/src/app/api/drift/route.ts
@@ -0,0 +1,7 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { fetchDrift } from '@/lib/db'
+
+export async function GET(req: NextRequest) {
+  const project = req.nextUrl.searchParams.get('project') ?? undefined
+  return NextResponse.json(await fetchDrift(project))
+}
diff --git a/apps/dashboard/src/components/Dashboard.tsx b/apps/dashboard/src/components/Dashboard.tsx
index 61c7376..54f39d2 100644
--- a/apps/dashboard/src/components/Dashboard.tsx
+++ b/apps/dashboard/src/components/Dashboard.tsx
@@ -1,10 +1,14 @@
 'use client'
 
-import { useState, useMemo } from 'react'
+import { useState, useMemo, useEffect } from 'react'
 import { useRouter } from 'next/navigation'
 import { MethodBadge } from './MethodBadge'
 import { EndpointDetail } from './EndpointDetail'
+import { DriftSummary } from './DriftSummary'
+import { RedactionAudit, type AuditItem } from './RedactionAudit'
+import { collectSensitiveFields } from '@easydocs/core/privacy/audit'
 import type { Endpoint, Project } from '@easydocs/core/schema'
+import type { DriftData } from '@/lib/db'
 
 interface Props {
   endpoints: Endpoint[]
@@ -16,6 +20,28 @@ export function Dashboard({ endpoints, projects, currentProject }: Props) {
   const router = useRouter()
   const [selected, setSelected] = useState<Endpoint | null>(endpoints[0] ?? null)
   const [search, setSearch] = useState('')
+  const [drift, setDrift] = useState<DriftData | null>(null)
+  const [panel, setPanel] = useState<'drift' | 'audit' | null>(null)
+
+  const audit = useMemo(() => {
+    const items: AuditItem[] = []
+    for (const e of endpoints) {
+      const spec = e.isManuallyEdited && e.manualSpec ? e.manualSpec : e.spec
+      const fields = spec ? collectSensitiveFields(spec) : []
+      if (fields.length > 0) items.push({ endpoint: e, fields })
+    }
+    return { items, total: items.reduce((s, x) => s + x.fields.length, 0) }
+  }, [endpoints])
+
+  useEffect(() => {
+    const q = currentProject ? `?project=${currentProject}` : ''
+    let active = true
+    fetch(`/api/drift${q}`)
+      .then((r) => r.json())
+      .then((d: DriftData) => { if (active) setDrift(d) })
+      .catch(() => { /* drift is best-effort; ignore fetch errors */ })
+    return () => { active = false }
+  }, [currentProject])
 
   const filtered = useMemo(
     () =>
@@ -54,6 +80,42 @@ export function Dashboard({ endpoints, projects, currentProject }: Props) {
             <span className="text-xs text-zinc-500">{endpoints.length} endpoints</span>
           </div>
 
+          {drift?.configured && (
+            <button
+              onClick={() => setPanel((p) => (p === 'drift' ? null : 'drift'))}
+              className={`w-full flex items-center justify-between rounded-md px-2 py-1.5 text-xs transition-colors ${
+                panel === 'drift'
+                  ? 'bg-zinc-800 text-zinc-100'
+                  : drift.total > 0
+                    ? 'bg-rose-500/10 text-rose-300 hover:bg-rose-500/20'
+                    : 'bg-zinc-900 text-zinc-500 hover:text-zinc-300'
+              }`}
+            >
+              <span>{drift.total > 0 ? 'Docs-vs-reality drift' : 'In sync with spec'}</span>
+              {drift.total > 0 && (
+                <span className="rounded-full bg-rose-500/20 px-1.5 py-0.5 text-rose-300">
+                  {drift.total}
+                </span>
+              )}
+            </button>
+          )}
+
+          {audit.total > 0 && (
+            <button
+              onClick={() => setPanel((p) => (p === 'audit' ? null : 'audit'))}
+              className={`w-full flex items-center justify-between rounded-md px-2 py-1.5 text-xs transition-colors ${
+                panel === 'audit'
+                  ? 'bg-zinc-800 text-zinc-100'
+                  : 'bg-emerald-500/10 text-emerald-300 hover:bg-emerald-500/20'
+              }`}
+            >
+              <span>Sensitive fields</span>
+              <span className="rounded-full bg-emerald-500/20 px-1.5 py-0.5 text-emerald-300">
+                {audit.total}
+              </span>
+            </button>
+          )}
+
           {projects.length > 1 && (
             <select
               value={currentProject ?? '__all'}
@@ -110,6 +172,12 @@ export function Dashboard({ endpoints, projects, currentProject }: Props) {
                   >
                     <MethodBadge method={e.method} />
                     <span className="text-xs font-mono truncate flex-1">{e.path}</span>
+                    {drift?.byEndpoint[e.id] && (
+                      <span
+                        title={`${drift.byEndpoint[e.id]} drift finding(s)`}
+                        className="w-1.5 h-1.5 rounded-full bg-rose-400 flex-shrink-0"
+                      />
+                    )}
                     {e.hasConflict && (
                       <span className="w-1.5 h-1.5 rounded-full bg-amber-400 flex-shrink-0" />
                     )}
@@ -138,7 +206,11 @@ export function Dashboard({ endpoints, projects, currentProject }: Props) {
 
       {/* Main */}
       <main className="flex-1 overflow-hidden">
-        {selected ? (
+        {panel === 'drift' && drift?.configured ? (
+          <DriftSummary report={drift.report} specPath={drift.specPath} />
+        ) : panel === 'audit' ? (
+          <RedactionAudit items={audit.items} total={audit.total} />
+        ) : selected ? (
           <EndpointDetail key={selected.id} endpoint={selected} />
         ) : (
           <div className="flex items-center justify-center h-full text-zinc-500 text-sm">
diff --git a/apps/dashboard/src/components/DriftSummary.tsx b/apps/dashboard/src/components/DriftSummary.tsx
new file mode 100644
index 0000000..f1506e3
--- /dev/null
+++ b/apps/dashboard/src/components/DriftSummary.tsx
@@ -0,0 +1,108 @@
+'use client'
+
+import type { DriftReport, DriftFinding } from '@easydocs/core'
+
+interface Props {
+  report: DriftReport
+  specPath: string
+}
+
+function fmt(value: unknown): string {
+  return typeof value === 'string' ? value : JSON.stringify(value)
+}
+
+function Section({
+  title,
+  hint,
+  accent,
+  findings,
+  render,
+}: {
+  title: string
+  hint: string
+  accent: string
+  findings: DriftFinding[]
+  render: (f: DriftFinding) => React.ReactNode
+}) {
+  if (findings.length === 0) return null
+  return (
+    <section className="mb-6">
+      <div className="flex items-baseline gap-2 mb-2">
+        <h3 className={`text-sm font-semibold ${accent}`}>{title}</h3>
+        <span className="text-xs text-zinc-500">{findings.length}</span>
+      </div>
+      <p className="text-xs text-zinc-500 mb-3">{hint}</p>
+      <ul className="space-y-1">
+        {findings.map((f, i) => (
+          <li
+            key={`${f.path}-${i}`}
+            className="rounded-md bg-zinc-900 border border-zinc-800 px-3 py-2 text-xs font-mono text-zinc-300 break-all"
+          >
+            {render(f)}
+          </li>
+        ))}
+      </ul>
+    </section>
+  )
+}
+
+export function DriftSummary({ report, specPath }: Props) {
+  const total = report.undocumented.length + report.unobserved.length + report.mismatch.length
+
+  return (
+    <div className="h-full overflow-y-auto p-6">
+      <header className="mb-6">
+        <h2 className="text-lg font-semibold text-zinc-100">Docs-vs-reality drift</h2>
+        <p className="text-sm text-zinc-500 mt-1">
+          Comparing <span className="text-zinc-300 font-mono">{specPath}</span> against the spec
+          derived from observed traffic.
+        </p>
+      </header>
+
+      {total === 0 ? (
+        <div className="rounded-md border border-emerald-500/30 bg-emerald-500/10 px-4 py-3 text-sm text-emerald-300">
+          Your spec matches observed traffic. No drift.
+        </div>
+      ) : (
+        <>
+          <Section
+            title="Undocumented"
+            hint="Observed in traffic but missing from your spec — your docs are stale."
+            accent="text-rose-400"
+            findings={report.undocumented}
+            render={(f) => (
+              <>
+                <span className="text-rose-400">+ </span>
+                {f.path} <span className="text-zinc-500">→ {fmt(f.observed)}</span>
+              </>
+            )}
+          />
+          <Section
+            title="Mismatch"
+            hint="Your spec contradicts what traffic actually shows."
+            accent="text-amber-400"
+            findings={report.mismatch}
+            render={(f) => (
+              <>
+                <span className="text-amber-400">~ </span>
+                {f.path}: <span className="text-zinc-500">{fmt(f.documented)} → {fmt(f.observed)}</span>
+              </>
+            )}
+          />
+          <Section
+            title="Documented but unobserved"
+            hint="In your spec but never seen in traffic — possibly dead or un-exercised."
+            accent="text-zinc-400"
+            findings={report.unobserved}
+            render={(f) => (
+              <>
+                <span className="text-zinc-500">− </span>
+                {f.path} <span className="text-zinc-500">(documented {fmt(f.documented)})</span>
+              </>
+            )}
+          />
+        </>
+      )}
+    </div>
+  )
+}
diff --git a/apps/dashboard/src/components/RedactionAudit.tsx b/apps/dashboard/src/components/RedactionAudit.tsx
new file mode 100644
index 0000000..45dc22c
--- /dev/null
+++ b/apps/dashboard/src/components/RedactionAudit.tsx
@@ -0,0 +1,60 @@
+'use client'
+
+import { MethodBadge } from './MethodBadge'
+import type { Endpoint } from '@easydocs/core/schema'
+import type { SensitiveField } from '@easydocs/core/privacy/audit'
+
+export interface AuditItem {
+  endpoint: Endpoint
+  fields: SensitiveField[]
+}
+
+interface Props {
+  items: AuditItem[]
+  total: number
+}
+
+export function RedactionAudit({ items, total }: Props) {
+  const endpointCount = items.length
+
+  return (
+    <div className="h-full overflow-y-auto p-6">
+      <header className="mb-6">
+        <h2 className="text-lg font-semibold text-zinc-100">Sensitive fields</h2>
+        <p className="text-sm text-zinc-500 mt-1">
+          {total === 0 ? (
+            'No sensitive fields detected in the captured traffic.'
+          ) : (
+            <>
+              <span className="text-zinc-300">{total}</span> field{total === 1 ? '' : 's'} across{' '}
+              <span className="text-zinc-300">{endpointCount}</span> endpoint
+              {endpointCount === 1 ? '' : 's'} were detected and flagged. Values are redacted
+              before any payload reaches a hosted AI provider — and kept local when using an
+              offline model.
+            </>
+          )}
+        </p>
+      </header>
+
+      {items.map(({ endpoint, fields }) => (
+        <section key={endpoint.id} className="mb-4">
+          <div className="flex items-center gap-2 mb-2">
+            <MethodBadge method={endpoint.method} />
+            <span className="text-sm font-mono text-zinc-300">{endpoint.path}</span>
+          </div>
+          <ul className="flex flex-wrap gap-2">
+            {fields.map((f, i) => (
+              <li
+                key={`${f.location}-${f.field}-${i}`}
+                className="inline-flex items-center gap-1.5 rounded-md bg-emerald-500/10 border border-emerald-500/20 px-2 py-1 text-xs"
+              >
+                <span className="font-mono text-emerald-300">{f.field}</span>
+                <span className="text-emerald-500/70">{f.location}</span>
+              </li>
+            ))}
+          </ul>
+        </section>
+      ))}
+    </div>
+  )
+}
diff --git a/apps/dashboard/src/lib/db.ts b/apps/dashboard/src/lib/db.ts
index 0d0d45e..16e3f34 100644
--- a/apps/dashboard/src/lib/db.ts
+++ b/apps/dashboard/src/lib/db.ts
@@ -1,3 +1,6 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import yaml from 'js-yaml'
 import {
   createDB,
   getAllEndpoints,
@@ -5,9 +8,11 @@ import {
   getAllProjects,
   findOrCreateProject,
   buildFullSpec,
+  computeDrift,
 } from '@easydocs/core'
 export { buildFullSpec }
 import type { Endpoint, Project } from '@easydocs/core/schema'
+import type { DriftReport } from '@easydocs/core'
 
 let db: ReturnType<typeof createDB> | null = null
 
@@ -26,3 +31,47 @@ export async function fetchEndpoints(projectSlug?: string): Promise<Endpoint[]>
   const projectId = await findOrCreateProject(db, projectSlug)
   return getEndpointsByProject(db, projectId)
 }
+
+export interface DriftData {
+  /** False when no committed spec was found to compare against. */
+  configured: boolean
+  /** Path (relative to cwd) EasyDocs looked for the committed spec. */
+  specPath: string
+  report: DriftReport
+  /** Endpoint id → number of drift findings on it, for badging the sidebar. */
+  byEndpoint: Record<string, number>
+  total: number
+}
+
+const EMPTY_REPORT: DriftReport = { undocumented: [], unobserved: [], mismatch: [] }
+
+/**
+ * Compare the committed spec (EASYDOCS_SPEC_PATH, default ./openapi.json)
+ * against the spec derived from observed traffic. This is the producer-side
+ * surface for docs-vs-reality drift — it never leaves the local machine.
+ */
+export async function fetchDrift(projectSlug?: string): Promise<DriftData> {
+  const specPath = process.env.EASYDOCS_SPEC_PATH ?? 'openapi.json'
+
+  let documented: unknown
+  try {
+    // YAML is a JSON superset, so this reads .json and .yaml alike.
+    documented = yaml.load(readFileSync(resolve(process.cwd(), specPath), 'utf8'))
+  } catch {
+    return { configured: false, specPath, report: EMPTY_REPORT, byEndpoint: {}, total: 0 }
+  }
+
+  const endpoints = await fetchEndpoints(projectSlug)
+  const observed = buildFullSpec(endpoints, projectSlug)
+  const report = computeDrift(documented, observed)
+
+  const all = [...report.undocumented, ...report.unobserved, ...report.mismatch]
+  const byEndpoint: Record<string, number> = {}
+  for (const e of endpoints) {
+    const prefix = `paths.${e.path}.${e.method.toLowerCase()}`
+    const count = all.filter((f) => f.path === prefix || f.path.startsWith(`${prefix}.`)).length
+    if (count > 0) byEndpoint[e.id] = count
+  }
+
+  return { configured: true, specPath, report, byEndpoint, total: all.length }
+}
diff --git a/packages/cli/README.md b/packages/cli/README.md
index 7ec1eae..2f228b1 100644
--- a/packages/cli/README.md
+++ b/packages/cli/README.md
@@ -42,14 +42,53 @@ npx @easydocs/cli export --project=my-api
 npx @easydocs/cli export > openapi.json
 ```
 
+## Check drift — is your committed spec still true?
+
+`drift` compares a committed spec against reality — the spec EasyDocs derives
+from observed traffic. It answers "is my spec still true?", not "did my spec
+change?". Only EasyDocs can do this, because it holds both the committed spec and
+the live traffic at once.
+
+```bash
+# Compare a committed spec against traffic captured locally
+npx @easydocs/cli drift openapi.json
+
+# Scope to a project
+npx @easydocs/cli drift openapi.json --project=my-api
+
+# Markdown output (for PR comments)
+npx @easydocs/cli drift openapi.json --markdown
+
+# Compare two spec files directly (no DB needed)
+npx @easydocs/cli drift committed.json observed.json
+```
+
+It reports three kinds of divergence — endpoints/fields **observed in traffic
+but undocumented**, **documented but never observed**, and values where the docs
+**contradict** what traffic shows. Like `diff`, it's informational and always
+exits 0.
+
+## Audit sensitive fields
+
+`audit` lists every field EasyDocs flagged as sensitive across the stored specs —
+the scriptable/CI counterpart to the dashboard's "Sensitive fields" panel. Useful
+to prove, in a pipeline, exactly what is being protected.
+
+```bash
+npx @easydocs/cli audit                 # all projects
+npx @easydocs/cli audit --project=my-api
+npx @easydocs/cli audit --markdown      # for a PR comment
+```
+
 ## Flags
 
 | Flag | Command | Default | Description |
 |------|---------|---------|-------------|
 | `--port=<n>` | proxy | `3999` | Port for the proxy server |
 | `--port=<n>` | dashboard | `4999` | Port for the dashboard |
-| `--project=<slug>` | proxy, export | `default` | Scope to a project |
+| `--project=<slug>` | proxy, export, drift, audit | `default` | Scope to a project |
 | `--yaml` | export | — | Output YAML instead of JSON |
+| `--markdown` | diff, drift, audit | — | Emit Markdown (for PR comments) |
 | `--prod` | dashboard | — | Run `next start` instead of `next dev` |
 
 ## Environment variables
diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.ts
index c6a6cab..e7788dd 100644
--- a/packages/cli/src/index.ts
+++ b/packages/cli/src/index.ts
@@ -1,7 +1,7 @@
 import { createDB, getAllEndpoints, getEndpointsByProject, findOrCreateProject, buildFullSpec } from '@easydocs/core'
 import { createCapturer, parseConfig, diffSpecs, classifyDiff, shouldFail, renderClassifiedDiff } from '@easydocs/core'
-import type { FailOn } from '@easydocs/core'
-import type { HttpMethod } from '@easydocs/core'
+import { computeDrift, renderDrift, collectSensitiveFields, renderAudit } from '@easydocs/core'
+import type { FailOn, HttpMethod, EndpointAudit } from '@easydocs/core'
 import { createServer } from 'http'
 import { createRequire } from 'module'
 import { existsSync, readFileSync } from 'fs'
@@ -21,13 +21,19 @@ switch (command) {
   case 'diff':
     runDiff(args)
     break
+  case 'drift':
+    await runDrift(args)
+    break
+  case 'audit':
+    await runAudit(args)
+    break
   case 'proxy':
   case undefined:
     await runProxy(args)
     break
   default:
     console.error(
-      `Unknown command: ${command}\n\nUsage:\n  easydocs [proxy]           Start proxy server\n  easydocs dashboard         Start the docs dashboard\n  easydocs export            Export spec to stdout\n  easydocs diff <a> <b>      Diff two spec files (JSON or YAML)\n\nFlags:\n  --project=<slug>           Scope to a project (default: all)\n  --port=<n>                 Port for proxy (default: 3999) or dashboard (default: 4999)\n  --yaml                     Export as YAML instead of JSON\n  --markdown                 Diff: emit Markdown (for PR comments) instead of plain text\n  --fail-on=<policy>         Diff: exit 3 when changes cross a threshold (none|breaking|any, default none)\n  --prod                     Dashboard: run next start instead of next dev`
+      `Unknown command: ${command}\n\nUsage:\n  easydocs [proxy]           Start proxy server\n  easydocs dashboard         Start the docs dashboard\n  easydocs export            Export spec to stdout\n  easydocs diff <a> <b>      Diff two spec files (JSON or YAML)\n  easydocs drift <spec>      Check a committed spec against observed traffic\n  easydocs audit             List sensitive fields detected across the specs\n\nFlags:\n  --project=<slug>           Scope to a project (default: all)\n  --port=<n>                 Port for proxy (default: 3999) or dashboard (default: 4999)\n  --yaml                     Export as YAML instead of JSON\n  --markdown                 Diff/drift/audit: emit Markdown (for PR comments) instead of plain text\n  --fail-on=<policy>         Diff: exit 3 when changes cross a threshold (none|breaking|any, default none)\n  --prod                     Dashboard: run next start instead of next dev`
     )
     process.exit(1)
 }
@@ -166,6 +172,59 @@ function runDiff(args: string[]) {
   if (shouldFail(classified, failOn)) process.exit(3)
 }
 
+// ─── Drift ────────────────────────────────────────────────────────────────────
+
+// Compare a committed spec against reality: the spec EasyDocs derives from
+// observed traffic. With one argument, "reality" is read from the local capture
+// DB (like export). With two, both sides come from files (handy for tests/CI).
+async function runDrift(args: string[]) {
+  const positionals = args.filter((a) => !a.startsWith('--'))
+  const [documentedPath, observedPath] = positionals
+  if (!documentedPath) {
+    console.error('Usage: easydocs drift <spec> [observed-spec] [--project=<slug>] [--markdown]')
+    process.exit(2)
+  }
+
+  const documented = loadSpecFile(documentedPath)
+
+  let observed: unknown
+  if (observedPath) {
+    observed = loadSpecFile(observedPath)
+  } else {
+    const projectSlug = getFlag(args, 'project')
+    const db = createDB(process.env.EASYDOCS_DB_URL)
+    const endpoints = projectSlug
+      ? await getEndpointsByProject(db, await findOrCreateProject(db, projectSlug))
+      : await getAllEndpoints(db)
+    observed = buildFullSpec(endpoints, projectSlug ?? undefined)
+  }
+
+  const markdown = args.includes('--markdown')
+  // Drift is an informational signal, never a build gate — always exit 0.
+  process.stdout.write(renderDrift(computeDrift(documented, observed), { markdown }) + '\n')
+}
+
+// ─── Audit ────────────────────────────────────────────────────────────────────
+
+// List every field EasyDocs flagged sensitive across the stored specs — the
+// scriptable/CI counterpart to the dashboard's "Sensitive fields" panel.
+async function runAudit(args: string[]) {
+  const projectSlug = getFlag(args, 'project')
+  const db = createDB(process.env.EASYDOCS_DB_URL)
+  const endpoints = projectSlug
+    ? await getEndpointsByProject(db, await findOrCreateProject(db, projectSlug))
+    : await getAllEndpoints(db)
+
+  const items: EndpointAudit[] = endpoints
+    .map((e) => {
+      const spec = e.isManuallyEdited && e.manualSpec ? e.manualSpec : e.spec
+      return { path: e.path, method: e.method, fields: spec ? collectSensitiveFields(spec) : [] }
+    })
+    .sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method))
+
+  process.stdout.write(renderAudit(items, { markdown: args.includes('--markdown') }) + '\n')
+}
+
 // ─── Proxy ────────────────────────────────────────────────────────────────────
 
 async function runProxy(args: string[]) {
diff --git a/packages/core/package.json b/packages/core/package.json
index 6f70ec4..a00b8e0 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -30,6 +30,16 @@
       "import": "./dist/spec/diff.js",
       "require": "./dist/spec/diff.cjs",
       "types": "./dist/spec/diff.d.ts"
+    },
+    "./spec/drift": {
+      "import": "./dist/spec/drift.js",
+      "require": "./dist/spec/drift.cjs",
+      "types": "./dist/spec/drift.d.ts"
+    },
+    "./privacy/audit": {
+      "import": "./dist/privacy/audit.js",
+      "require": "./dist/privacy/audit.cjs",
+      "types": "./dist/privacy/audit.d.ts"
     }
   },
   "scripts": {
diff --git a/packages/core/src/__tests__/audit.test.ts b/packages/core/src/__tests__/audit.test.ts
new file mode 100644
index 0000000..240d18b
--- /dev/null
+++ b/packages/core/src/__tests__/audit.test.ts
@@ -0,0 +1,99 @@
+import { describe, it, expect } from 'vitest'
+import { collectSensitiveFields, renderAudit } from '../privacy/audit.js'
+import type { EndpointAudit } from '../privacy/audit.js'
+import { markSensitiveProperties } from '../privacy/detect.js'
+import type { Operation } from '../spec/schema.js'
+
+function baseOperation(): Operation {
+  return {
+    parameters: [
+      { name: 'token', in: 'query', required: false },
+      { name: 'page', in: 'query', required: false },
+    ],
+    requestBody: {
+      content: {
+        'application/json': {
+          schema: {
+            type: 'object',
+            properties: {
+              email: { type: 'string' },
+              password: { type: 'string' },
+              profile: { type: 'object', properties: { ssn: { type: 'string' } } },
+            },
+          },
+        },
+      },
+    },
+    responses: {
+      '200': {
+        description: 'OK',
+        content: {
+          'application/json': {
+            schema: { type: 'object', properties: { id: { type: 'string' }, apiKey: { type: 'string' } } },
+          },
+        },
+      },
+    },
+  }
+}
+
+describe('collectSensitiveFields', () => {
+  it('collects fields flagged across parameters, requestBody, and responses', () => {
+    const op = baseOperation()
+    markSensitiveProperties(op, new Set(['token', 'password', 'ssn', 'apiKey']))
+
+    const fields = collectSensitiveFields(op)
+    const byField = Object.fromEntries(fields.map((f) => [f.field, f.location]))
+
+    expect(byField.token).toBe('query')
+    expect(byField.password).toBe('requestBody')
+    expect(byField.ssn).toBe('requestBody') // nested property
+    expect(byField.apiKey).toBe('response:200')
+    // Non-sensitive fields are not reported.
+    expect(fields.some((f) => f.field === 'page')).toBe(false)
+    expect(fields.some((f) => f.field === 'id')).toBe(false)
+  })
+
+  it('returns an empty array when nothing is flagged', () => {
+    expect(collectSensitiveFields(baseOperation())).toEqual([])
+  })
+
+  it('renders a per-endpoint audit in plain text and markdown', () => {
+    const items: EndpointAudit[] = [
+      { path: '/auth/login', method: 'POST', fields: [{ location: 'requestBody', field: 'password' }] },
+      { path: '/products', method: 'GET', fields: [] }, // no sensitive fields → omitted
+    ]
+    const txt = renderAudit(items)
+    expect(txt).toMatch(/1 sensitive field across 1 endpoint/)
+    expect(txt).toContain('POST /auth/login')
+    expect(txt).toContain('password (requestBody)')
+    expect(txt).not.toContain('/products')
+
+    const md = renderAudit(items, { markdown: true })
+    expect(md).toContain('`POST /auth/login`')
+    expect(md).toContain('- `password` (requestBody)')
+  })
+
+  it('renders a no-fields message in both modes', () => {
+    expect(renderAudit([])).toContain('No sensitive fields')
+    expect(renderAudit([], { markdown: true })).toContain('No sensitive fields')
+  })
+
+  it('de-duplicates by location and field', () => {
+    const op: Operation = {
+      responses: {
+        '200': {
+          description: 'OK',
+          content: {
+            'application/json': { schema: { type: 'object', properties: { token: { type: 'string' } } } },
+            'application/xml': { schema: { type: 'object', properties: { token: { type: 'string' } } } },
+          },
+        },
+      },
+    }
+    markSensitiveProperties(op, new Set(['token']))
+    const fields = collectSensitiveFields(op)
+    expect(fields).toHaveLength(1)
+    expect(fields[0]).toEqual({ location: 'response:200', field: 'token' })
+  })
+})
diff --git a/packages/core/src/__tests__/capture-privacy.test.ts b/packages/core/src/__tests__/capture-privacy.test.ts
index b0d00ac..ea3842d 100644
--- a/packages/core/src/__tests__/capture-privacy.test.ts
+++ b/packages/core/src/__tests__/capture-privacy.test.ts
@@ -102,6 +102,38 @@ describe('capture pipeline + privacy', () => {
     expect(props.password['x-easydocs-sensitive']).toBe(true)
   })
 
+  it('offline mode keeps values local even with a hosted key present, and never redacts', async () => {
+    const url = tmpDbUrl()
+    const capturer = createCapturer({
+      storage: { type: 'sqlite', url },
+      // A stray hosted key must not cause egress once offline mode is on.
+      ai: { apiKey: 'test-key' },
+      privacy: { offline: true },
+    })
+
+    capturer.capture(userSignup())
+    const endpoint = await waitForEndpoint(url)
+
+    // Pinned to a local model, so the real value is kept (nothing left the machine).
+    expect(prompts).toHaveLength(1)
+    expect(prompts[0]).toContain('hunter2')
+    expect(prompts[0]).not.toContain('[REDACTED]')
+
+    // Still flagged in the stored spec.
+    const props = endpoint.spec!.responses['200'].content!['application/json'].schema!.properties
+    expect(props.password['x-easydocs-sensitive']).toBe(true)
+  })
+
+  it('offline mode fails fast when a hosted provider is explicitly configured', () => {
+    expect(() =>
+      createCapturer({
+        storage: { type: 'sqlite', url: tmpDbUrl() },
+        ai: { provider: 'anthropic', apiKey: 'test-key' },
+        privacy: { offline: true },
+      })
+    ).toThrow(/offline/i)
+  })
+
   it('sends raw values when privacy is disabled', async () => {
     const url = tmpDbUrl()
     const capturer = createCapturer({
diff --git a/packages/core/src/__tests__/drift.test.ts b/packages/core/src/__tests__/drift.test.ts
new file mode 100644
index 0000000..ce81b9a
--- /dev/null
+++ b/packages/core/src/__tests__/drift.test.ts
@@ -0,0 +1,91 @@
+import { describe, it, expect } from 'vitest'
+import { computeDrift, renderDrift, isEmptyDrift, driftCount } from '../spec/drift.js'
+
+// "documented" = the spec you committed; "observed" = what EasyDocs saw in traffic.
+const documented = {
+  info: { title: 'My API', version: '1.0.0' },
+  paths: {
+    '/users': {
+      get: {
+        summary: 'List users',
+        responses: { '200': { description: 'OK' } },
+      },
+    },
+  },
+}
+
+const observed = {
+  info: { title: 'API Documentation', version: '1.0.0' }, // metadata differs — must be ignored
+  paths: {
+    '/users': {
+      get: {
+        summary: 'List users',
+        responses: { '200': { description: 'Success' } }, // contradicts the docs
+      },
+    },
+    '/orders': {
+      post: { summary: 'Create an order' }, // seen in traffic, undocumented
+    },
+  },
+}
+
+describe('computeDrift', () => {
+  it('flags endpoints observed in traffic but missing from the spec', () => {
+    const report = computeDrift(documented, observed)
+    expect(report.undocumented.some((f) => f.path.includes('/orders'))).toBe(true)
+  })
+
+  it('flags fields documented but contradicted by traffic', () => {
+    const report = computeDrift(documented, observed)
+    const mismatch = report.mismatch.find((f) => f.path.endsWith('200.description'))
+    expect(mismatch?.documented).toBe('OK')
+    expect(mismatch?.observed).toBe('Success')
+  })
+
+  it('flags endpoints documented but never observed', () => {
+    // Drop /orders from the observed side: now it is documented-but-unobserved.
+    const report = computeDrift(observed, documented)
+    expect(report.unobserved.some((f) => f.path.includes('/orders'))).toBe(true)
+  })
+
+  it('ignores metadata differences outside the endpoint contract by default', () => {
+    const report = computeDrift(documented, observed)
+    const all = [...report.undocumented, ...report.unobserved, ...report.mismatch]
+    expect(all.every((f) => f.path.startsWith('paths.'))).toBe(true)
+    expect(all.some((f) => f.path.includes('info.title'))).toBe(false)
+  })
+
+  it('honors a custom scope of "" to compare the whole document', () => {
+    const report = computeDrift(documented, observed, { scope: '' })
+    expect(report.mismatch.some((f) => f.path.includes('info.title'))).toBe(true)
+  })
+
+  it('reports no drift for a spec that matches its traffic', () => {
+    const report = computeDrift(documented, documented)
+    expect(isEmptyDrift(report)).toBe(true)
+    expect(driftCount(report)).toBe(0)
+  })
+})
+
+describe('renderDrift', () => {
+  it('renders a no-drift message in both modes', () => {
+    const report = computeDrift(documented, documented)
+    expect(renderDrift(report)).toContain('No API drift')
+    expect(renderDrift(report, { markdown: true })).toContain('No API drift')
+  })
+
+  it('renders plain-text sections with a total count', () => {
+    const txt = renderDrift(computeDrift(documented, observed))
+    expect(txt).toMatch(/API drift: \d+ finding/)
+    expect(txt).toContain('Undocumented')
+    expect(txt).toContain('Mismatch')
+    expect(txt).not.toContain('**')
+  })
+
+  it('renders markdown sections for PR comments', () => {
+    const md = renderDrift(computeDrift(documented, observed), { markdown: true })
+    expect(md).toContain('**API drift:')
+    expect(md).toContain('**Undocumented')
+    expect(md).toContain('→')
+  })
+})
diff --git a/packages/core/src/__tests__/provider.test.ts b/packages/core/src/__tests__/provider.test.ts
index 8288934..a22b269 100644
--- a/packages/core/src/__tests__/provider.test.ts
+++ b/packages/core/src/__tests__/provider.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { resolveModel } from '../ai/provider.js'
+import { resolveModel, resolveProvider } from '../ai/provider.js'
 
 type ConcreteModel = { modelId: string; provider: string }
 const concrete = (m: ReturnType<typeof resolveModel>) => m as unknown as ConcreteModel
@@ -121,4 +121,27 @@ describe('resolveModel', () => {
       })
     })
   })
+
+  describe('offline mode', () => {
+    it('pins to local ollama even when a hosted key is present in the env', () => {
+      withEnv({ ...NO_KEYS, ANTHROPIC_API_KEY: 'sk-ant-test' }, () => {
+        expect(resolveProvider(undefined, true)).toBe('ollama')
+        const model = concrete(resolveModel(undefined, true))
+        expect(model.modelId).toBe('llama3.2')
+      })
+    })
+
+    it('allows an explicit ollama provider', () => {
+      withEnv(NO_KEYS, () => {
+        expect(resolveProvider({ provider: 'ollama' }, true)).toBe('ollama')
+      })
+    })
+
+    it('throws when a hosted provider is explicitly configured', () => {
+      withEnv(NO_KEYS, () => {
+        expect(() => resolveProvider({ provider: 'openai', apiKey: 'sk-test' }, true)).toThrow(/offline/i)
+        expect(() => resolveModel({ provider: 'anthropic', apiKey: 'sk-test' }, true)).toThrow(/offline/i)
+      })
+    })
+  })
 })
diff --git a/packages/core/src/ai/provider.ts b/packages/core/src/ai/provider.ts
index fefc995..a817ef4 100644
--- a/packages/core/src/ai/provider.ts
+++ b/packages/core/src/ai/provider.ts
@@ -27,13 +27,33 @@ function detectProvider(hasExplicitApiKey: boolean): Provider {
   return 'ollama'
 }
 
-/** Resolve which provider a config maps to, mirroring resolveModel's selection. */
-export function resolveProvider(config?: AIConfig): Provider {
+/** The hosted providers that receive captured data over the network. Ollama is local. */
+export function isHostedProvider(provider: Provider): boolean {
+  return provider !== 'ollama'
+}
+
+/**
+ * Resolve which provider a config maps to, mirroring resolveModel's selection.
+ * In `offline` mode the provider is pinned to the local Ollama model (env keys are
+ * ignored), and an explicitly configured hosted provider is a hard error — nothing
+ * captured may ever leave the machine.
+ */
+export function resolveProvider(config?: AIConfig, offline?: boolean): Provider {
+  if (offline) {
+    if (config?.provider && isHostedProvider(config.provider)) {
+      throw new Error(
+        `[EasyDocs] privacy.offline is enabled but ai.provider is "${config.provider}", a hosted provider. ` +
+        'In offline mode EasyDocs only uses a local Ollama model so nothing leaves the machine. ' +
+        'Remove ai.provider or set it to "ollama".'
+      )
+    }
+    return 'ollama'
+  }
   return config?.provider ?? detectProvider(!!config?.apiKey)
 }
 
-export function resolveModel(config?: AIConfig): LanguageModel {
-  const provider: Provider = resolveProvider(config)
+export function resolveModel(config?: AIConfig, offline?: boolean): LanguageModel {
+  const provider: Provider = resolveProvider(config, offline)
   const model = config?.model ?? DEFAULT_MODELS[provider]
 
   switch (provider) {
diff --git a/packages/core/src/capture.ts b/packages/core/src/capture.ts
index 75d94db..787f81d 100644
--- a/packages/core/src/capture.ts
+++ b/packages/core/src/capture.ts
@@ -4,7 +4,7 @@ import { createAdapter } from './storage/adapter.js'
 import { hashShape } from './shape.js'
 import { maybeStartDashboard } from './dashboard.js'
 import { detect, markSensitiveProperties } from './privacy/detect.js'
-import { resolveProvider } from './ai/provider.js'
+import { resolveProvider, isHostedProvider } from './ai/provider.js'
 import type { CaptureEvent, EasyDocsConfig } from './types.js'
 
 const DEFAULT_PROJECT = 'default'
@@ -42,7 +42,18 @@ export interface Capturer {
 export function createCapturer(config: EasyDocsConfig): Capturer {
   const adapter = createAdapter(config.storage)
   const queue = new CaptureQueue()
-  warnIfNoAIKey(config)
+  const offline = config.privacy?.offline === true
+
+  if (offline) {
+    // Fail fast on a contradictory hosted provider, before any traffic is captured.
+    resolveProvider(config.ai, true)
+    console.warn(
+      '\n[EasyDocs] Offline mode enabled — using a local Ollama model only.\n' +
+      '  No captured data will be sent to a hosted AI provider.\n'
+    )
+  } else {
+    warnIfNoAIKey(config)
+  }
 
   return {
     capture(event: CaptureEvent) {
@@ -71,10 +82,12 @@ export function createCapturer(config: EasyDocsConfig): Capturer {
         if (privacyEnabled) {
           const result = detect(event, config.privacy)
           sensitivePaths = result.sensitivePaths
-          if (resolveProvider(config.ai) !== 'ollama') eventForAI = result.redactedEvent
+          // Only a hosted provider receives payloads, so only then do we swap in the
+          // redacted event. Offline mode is always local, so real values are kept.
+          if (isHostedProvider(resolveProvider(config.ai, offline))) eventForAI = result.redactedEvent
         }
 
-        const spec = await buildOperation(eventForAI, existing?.spec ?? null, config.ai)
+        const spec = await buildOperation(eventForAI, existing?.spec ?? null, config.ai, offline)
         markSensitiveProperties(spec, sensitivePaths)
         await adapter.upsertEndpoint(projectId, event.path, event.method, spec, responseHash)
       })
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 5bec1c1..d43b839 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -25,6 +25,14 @@ export { buildOperation } from './spec/builder.js'
 export { buildFullSpec } from './spec/assemble.js'
 export { diffSpecs, renderDiff, isEmptyDiff, classifyDiff, shouldFail, renderClassifiedDiff } from './spec/diff.js'
 export type { SpecDiff, RenderDiffOptions, Severity, ClassifiedEntry, EndpointGroup, ClassifiedDiff, FailOn } from './spec/diff.js'
+export { computeDrift, renderDrift, isEmptyDrift, driftCount } from './spec/drift.js'
+export type {
+  DriftReport,
+  DriftFinding,
+  DriftKind,
+  ComputeDriftOptions,
+  RenderDriftOptions,
+} from './spec/drift.js'
 export { OperationSchema } from './spec/schema.js'
 export type { Operation } from './spec/schema.js'
 export { buildCaptureEvent, tryParseJson } from './event.js'
@@ -33,3 +41,7 @@ export { parseConfig, EasyDocsConfigSchema } from './types.js'
 export type { CaptureEvent, EasyDocsConfig, HttpMethod, AIConfig, StorageConfig, PrivacyConfig } from './types.js'
 export { detect, markSensitiveProperties } from './privacy/detect.js'
 export type { DetectResult } from './privacy/detect.js'
+export { collectSensitiveFields, renderAudit } from './privacy/audit.js'
+export type { SensitiveField, EndpointAudit, RenderAuditOptions } from './privacy/audit.js'
+export { resolveModel, resolveProvider, isHostedProvider } from './ai/provider.js'
+export type { Provider } from './ai/provider.js'
diff --git a/packages/core/src/privacy/audit.ts b/packages/core/src/privacy/audit.ts
new file mode 100644
index 0000000..75c8a49
Binary files /dev/null and b/packages/core/src/privacy/audit.ts differ
diff --git a/packages/core/src/spec/builder.ts b/packages/core/src/spec/builder.ts
index 36c5c3e..36a020a 100644
--- a/packages/core/src/spec/builder.ts
+++ b/packages/core/src/spec/builder.ts
@@ -50,9 +50,10 @@ const MAX_ATTEMPTS = 3
 export async function buildOperation(
   event: CaptureEvent,
   existingSpec: unknown | null,
-  aiConfig?: AIConfig
+  aiConfig?: AIConfig,
+  offline?: boolean
 ): Promise<Operation> {
-  const model = resolveModel(aiConfig)
+  const model = resolveModel(aiConfig, offline)
   const trimmedResponse = trimResponse(event.response)
   const detectedAuth = detectAuthSchemes(event.requestHeaders, event.query)
 
diff --git a/packages/core/src/spec/drift.ts b/packages/core/src/spec/drift.ts
new file mode 100644
index 0000000..bfbb1e1
--- /dev/null
+++ b/packages/core/src/spec/drift.ts
@@ -0,0 +1,147 @@
+// Docs-vs-reality drift. Unlike `diffSpecs` (which compares two specs
+// symmetrically), drift is directional: one side is the spec you *documented*
+// (a committed openapi.json), the other is the spec EasyDocs *observed* from
+// real traffic. It answers "is my spec still true?", not "did my spec change?".
+//
+// This is the one comparison only EasyDocs can make, because it is the only tool
+// that holds both halves — the committed spec and the live traffic — at once.
+// It reuses the field-level `diffSpecs` engine and reinterprets the result:
+//
+//   observed but not documented  → undocumented (your spec is stale)
+//   documented but not observed  → unobserved   (dead or un-exercised)
+//   documented value ≠ observed  → mismatch     (your spec contradicts reality)
+
+import { diffSpecs } from './diff.js'
+
+export type DriftKind = 'undocumented' | 'unobserved' | 'mismatch'
+
+export interface DriftFinding {
+  path: string
+  /** Value in the committed spec (present for `unobserved` and `mismatch`). */
+  documented?: unknown
+  /** Value seen in observed traffic (present for `undocumented` and `mismatch`). */
+  observed?: unknown
+}
+
+export interface DriftReport {
+  /** Observed in traffic but missing from the committed spec — the spec is stale. */
+  undocumented: DriftFinding[]
+  /** Present in the committed spec but never observed — possibly dead or un-exercised. */
+  unobserved: DriftFinding[]
+  /** Documented value contradicts what traffic actually shows. */
+  mismatch: DriftFinding[]
+}
+
+export interface ComputeDriftOptions {
+  /**
+   * Only consider leaf paths under this prefix. Defaults to `'paths.'` so drift
+   * focuses on the endpoint contract and ignores expected metadata differences
+   * (info.title, openapi version, components layout) between a hand-written spec
+   * and a generated one. Pass `''` to compare the whole document.
+   */
+  scope?: string
+}
+
+/**
+ * Compare a documented spec against an observed one and classify the divergence.
+ * Pure and deterministic — no I/O.
+ */
+export function computeDrift(
+  documented: unknown,
+  observed: unknown,
+  opts: ComputeDriftOptions = {}
+): DriftReport {
+  const scope = opts.scope ?? 'paths.'
+  const inScope = (p: string) => scope === '' || p.startsWith(scope)
+
+  // diffSpecs(documented, observed): `added` is in observed-not-documented,
+  // `removed` is in documented-not-observed, `changed` is both-but-differ.
+  const diff = diffSpecs(documented, observed)
+
+  return {
+    undocumented: diff.added
+      .filter((f) => inScope(f.path))
+      .map((f) => ({ path: f.path, observed: f.value })),
+    unobserved: diff.removed
+      .filter((f) => inScope(f.path))
+      .map((f) => ({ path: f.path, documented: f.value })),
+    mismatch: diff.changed
+      .filter((f) => inScope(f.path))
+      .map((f) => ({ path: f.path, documented: f.before, observed: f.after })),
+  }
+}
+
+export function isEmptyDrift(report: DriftReport): boolean {
+  return (
+    report.undocumented.length === 0 &&
+    report.unobserved.length === 0 &&
+    report.mismatch.length === 0
+  )
+}
+
+export function driftCount(report: DriftReport): number {
+  return report.undocumented.length + report.unobserved.length + report.mismatch.length
+}
+
+function fmt(value: unknown): string {
+  return typeof value === 'string' ? value : JSON.stringify(value)
+}
+
+export interface RenderDriftOptions {
+  markdown?: boolean
+}
+
+/** Render a DriftReport as a human-readable terminal summary, or PR-comment Markdown. */
+export function renderDrift(report: DriftReport, opts: RenderDriftOptions = {}): string {
+  if (isEmptyDrift(report)) {
+    return opts.markdown
+      ? '**No API drift** — your spec matches observed traffic.'
+      : 'No API drift — your spec matches observed traffic.'
+  }
+
+  const total = driftCount(report)
+  const undoc = 'Undocumented — observed in traffic, missing from your spec'
+  const unobs = 'Documented but unobserved — in your spec, never seen in traffic'
+  const mism = 'Mismatch — your spec contradicts observed traffic'
+
+  if (opts.markdown) {
+    const lines: string[] = [
+      `**API drift: ${total} finding${total === 1 ? '' : 's'}** — your spec is out of sync with observed traffic.`,
+      '',
+    ]
+    if (report.undocumented.length) {
+      lines.push(`**${undoc}** (${report.undocumented.length})`, '')
+      for (const f of report.undocumented) lines.push(`- \`${f.path}\` → ${fmt(f.observed)}`)
+      lines.push('')
+    }
+    if (report.unobserved.length) {
+      lines.push(`**${unobs}** (${report.unobserved.length})`, '')
+      for (const f of report.unobserved) lines.push(`- \`${f.path}\` (documented ${fmt(f.documented)})`)
+      lines.push('')
+    }
+    if (report.mismatch.length) {
+      lines.push(`**${mism}** (${report.mismatch.length})`, '')
+      for (const f of report.mismatch) lines.push(`- \`${f.path}\`: ${fmt(f.documented)} → ${fmt(f.observed)}`)
+      lines.push('')
+    }
+    return lines.join('\n').trimEnd()
+  }
+
+  const lines: string[] = [
+    `API drift: ${total} finding${total === 1 ? '' : 's'} — your spec is out of sync with observed traffic.`,
+    '',
+  ]
+  if (report.undocumented.length) {
+    lines.push(`${undoc} (${report.undocumented.length}):`)
+    for (const f of report.undocumented) lines.push(`  + ${f.path}  ${fmt(f.observed)}`)
+  }
+  if (report.unobserved.length) {
+    lines.push(`${unobs} (${report.unobserved.length}):`)
+    for (const f of report.unobserved) lines.push(`  - ${f.path}  ${fmt(f.documented)}`)
+  }
+  if (report.mismatch.length) {
+    lines.push(`${mism} (${report.mismatch.length}):`)
+    for (const f of report.mismatch) lines.push(`  ~ ${f.path}: ${fmt(f.documented)} -> ${fmt(f.observed)}`)
+  }
+  return lines.join('\n').trimEnd()
+}
diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
index c63f3c1..3ad4760 100644
--- a/packages/core/src/types.ts
+++ b/packages/core/src/types.ts
@@ -46,6 +46,10 @@ const PrivacyRulesSchema = z.object({
 
 const PrivacyConfigSchema = z.object({
   enabled: z.boolean().optional(),
+  // Strict local-first guarantee: only ever use a local Ollama model, never send
+  // captured data to a hosted provider. Pins the provider to ollama (ignoring env
+  // keys) and fails fast if a hosted provider is explicitly configured.
+  offline: z.boolean().optional(),
   placeholder: z.string().optional(),
   allowlist: z.array(z.string()).optional(),
   customRules: PrivacyRulesSchema.optional(),
diff --git a/packages/core/tsup.config.ts b/packages/core/tsup.config.ts
index 9a54f0b..216ae57 100644
--- a/packages/core/tsup.config.ts
+++ b/packages/core/tsup.config.ts
@@ -6,6 +6,8 @@ export default defineConfig({
     'storage/schema': 'src/storage/schema.ts',
     'spec/schema': 'src/spec/schema.ts',
     'spec/diff': 'src/spec/diff.ts',
+    'spec/drift': 'src/spec/drift.ts',
+    'privacy/audit': 'src/privacy/audit.ts',
     dashboard: 'src/dashboard.ts',
   },
   format: ['esm', 'cjs'],