diff --git a/changes/152.added.md b/changes/152.added.md
new file mode 100644
index 00000000..b10b70fe
--- /dev/null
+++ b/changes/152.added.md
@@ -0,0 +1,6 @@
+**Every memory shows where it came from, how sure Sentient is, and whether it still holds.** Open a memory to see each
+place that told Sentient, with the words it said, and jump straight to that chat message, email or note. Sentient gets
+surer each time something says it again, and you can mark a memory as not right so it stays out of chats and tasks.
+When a newer memory replaces an old one, the old one is kept as history instead of disappearing. Deleting a memory now
+also removes what was built from it: chat summaries, the nightly journal's notes, insights about you and the lines in
+USER.md and MEMORY.md. Memories learned in Telegram, Discord, WhatsApp or on a device before this update now say so.
diff --git a/desktop/src/features/chat/ChatPage.tsx b/desktop/src/features/chat/ChatPage.tsx
index 25436cfd..2e65382d 100644
--- a/desktop/src/features/chat/ChatPage.tsx
+++ b/desktop/src/features/chat/ChatPage.tsx
@@ -145,6 +145,27 @@ function ChatView({
     return [...history, ...liveItems(liveSession)]
   }, [messages.data, liveSession])
 
+  // ?message=<id> (a memory's source, #152): scroll to that message once it is on screen, and mark it a moment
+  const focusId = new URLSearchParams(useLocation().search).get("message")
+  const loadedAll = !messages.isFetching
+  const focused = useRef<string | null>(null) // done once per link, not again when the chat refetches
+  useEffect(() => {
+    if (!focusId || items.length === 0 || !loadedAll || focused.current === focusId) return
+    const t = window.setTimeout(() => {
+      focused.current = focusId
+      const el = document.querySelector<HTMLElement>(`[data-message-id="${CSS.escape(focusId)}"]`)
+      if (!el) {
+        // this view shows a chat's newest 500 messages: say so rather than leave the user guessing
+        if (!(messages.data ?? []).some((m) => m.id === focusId)) toast.info('That message is further back in this chat than Sentient shows here.')
+        return
+      }
+      el.scrollIntoView({ block: 'center' })
+      el.classList.add('ring-2', 'ring-accent/60')
+      window.setTimeout(() => el.classList.remove('ring-2', 'ring-accent/60'), 2400)
+    }, 350)
+    return () => window.clearTimeout(t)
+  }, [focusId, items.length, loadedAll])
+
   const streaming = !!liveSession?.streaming
   const lastAssistantIndex = items.map((i) => i.kind).lastIndexOf('assistant')
 
@@ -397,8 +418,9 @@ function Timeline({ items, streaming, loading, children }: { items: TimelineItem
     el.scrollTo({ top: el.scrollHeight, behavior: smooth ? 'smooth' : 'auto' })
   }, [])
 
-  // `?at=top` keeps the first message in view (deep links from search, screenshots).
-  const atTop = useRef(/(^|[?&])at=top\b/.test(useLocation().search))
+  // `?at=top` keeps the first message in view (deep links from search, screenshots); `?message=` (a memory's source,
+  // #152) doesn't jump to the bottom either, so the page can scroll to that message.
+  const atTop = useRef(/(^|[?&])(at=top\b|message=)/.test(useLocation().search))
   if (atTop.current) stick.current = false
 
   useLayoutEffect(() => {
diff --git a/desktop/src/features/chat/UserMessage.tsx b/desktop/src/features/chat/UserMessage.tsx
index 4c68c2a5..8dc2de9e 100644
--- a/desktop/src/features/chat/UserMessage.tsx
+++ b/desktop/src/features/chat/UserMessage.tsx
@@ -38,7 +38,7 @@ export function AttachmentChip({ a, className }: { a: AttachmentView; className?
 export const UserMessage = memo(function UserMessage({ message, onRestore }: { message: UserMessageView; onRestore?: (text: string) => void }) {
   const [copied, setCopied] = useState(false)
   return (
-    <div className={cn('group/user flex flex-col items-end gap-1.5', message.pending && 'opacity-80')}>
+    <div data-message-id={message.id} className={cn('group/user flex flex-col items-end gap-1.5 rounded-xl transition-shadow', message.pending && 'opacity-80')}>
       {message.attachments.length > 0 && (
         <div className="flex max-w-[85%] flex-wrap justify-end gap-1.5">
           {message.attachments.map((a) => (
diff --git a/desktop/src/features/memory/MemoryDetail.tsx b/desktop/src/features/memory/MemoryDetail.tsx
index 63dcf074..b78619de 100644
--- a/desktop/src/features/memory/MemoryDetail.tsx
+++ b/desktop/src/features/memory/MemoryDetail.tsx
@@ -1,12 +1,13 @@
-import { IconCalendar, IconCheck, IconClock, IconHistory, IconHourglassHigh, IconPencil, IconTrash, IconX } from '@tabler/icons-react'
+import { IconCalendar, IconCheck, IconClock, IconGauge, IconHistory, IconHourglassHigh, IconMoodConfuzed, IconPencil, IconReplace, IconRoute, IconTrash, IconX } from '@tabler/icons-react'
 import { useEffect, useState } from 'react'
 import { Alert, Button, ConfirmDialog, Select, Sheet, Textarea } from '@/components/ui'
 import { useMemoryScopes } from '@/hooks/memory'
 import { useHotkey } from '@/hooks/useHotkey'
 import { formatDateTime } from '@/lib/utils'
-import { ExpiryBadge, ScopeIcon, scopeLabel, SourceChip, TopicPill } from './bits'
+import { ExpiryBadge, ScopeIcon, scopeLabel, TopicPill } from './bits'
 import { useNow, useOptimisticMemoryActions } from './hooks'
 import { countdown, expiresInMs, recentRelative, sourceMeta, type MemoryWithHistory } from './meta'
+import { Confidence, SourceLinks } from './SourceLinks'
 
 export function MemoryDetail({
   memory,
@@ -19,7 +20,7 @@ export function MemoryDetail({
   onOpenChange: (open: boolean) => void
   onForgetSource: (source: string) => void
 }) {
-  const { update, remove, move } = useOptimisticMemoryActions()
+  const { update, remove, move, setState } = useOptimisticMemoryActions()
   const scopes = useMemoryScopes()
   const [editing, setEditing] = useState(false)
   const [draft, setDraft] = useState('')
@@ -91,6 +92,24 @@ export function MemoryDetail({
             <ExpiryBadge memory={memory} now={now} />
           </div>
 
+          {memory.state === 'disputed' && (
+            <Alert tone="warning" icon={<IconMoodConfuzed />} title="You said this isn't right">
+              Sentient keeps it here but leaves it out of chats and tasks. Edit it, forget it, or{' '}
+              <button type="button" className="font-medium underline underline-offset-2" onClick={() => setState.mutate({ id: memory.id, state: 'current' })}>
+                say it's right after all
+              </button>
+              .
+            </Alert>
+          )}
+          {memory.state === 'superseded' && (
+            <Alert tone="info" icon={<IconReplace />} title="Replaced by a newer memory">
+              {memory.superseded_by_content ? `Now: "${memory.superseded_by_content}". ` : ''}Sentient keeps this one as history and doesn't use it.{' '}
+              <button type="button" className="font-medium underline underline-offset-2" onClick={() => setState.mutate({ id: memory.id, state: 'current' })}>
+                It's still true
+              </button>
+            </Alert>
+          )}
+
           {memory.previous_content && memory.previous_content !== memory.content && (
             <div className="rounded-xl border border-border bg-sunken/60 p-3.5">
               <div className="mb-1.5 flex items-center gap-1.5 text-xs font-medium text-fg-muted">
@@ -100,15 +119,25 @@ export function MemoryDetail({
             </div>
           )}
 
+          <section aria-label="Where it came from" className="space-y-2">
+            <h3 className="flex items-center gap-1.5 text-xs font-medium text-fg-muted">
+              <IconRoute size={13} /> Where it came from
+            </h3>
+            <SourceLinks memory={memory} onForgetSource={onForgetSource} />
+          </section>
+
           <dl className="divide-y divide-border rounded-xl border border-border bg-surface text-sm">
-            <Row icon={<src.icon size={14} />} label="Source">
-              <div className="flex items-center justify-between gap-2">
-                <SourceChip source={memory.source} className="text-sm text-fg" />
-                <button type="button" onClick={() => onForgetSource(memory.source)} className="text-xs text-fg-subtle underline-offset-2 hover:text-danger hover:underline">
-                  Forget all from this source
+            <Row icon={<IconGauge size={14} />} label="How sure">
+              <Confidence memory={memory} />
+              {memory.state !== 'disputed' && memory.state !== 'superseded' && (
+                <button
+                  type="button"
+                  onClick={() => setState.mutate({ id: memory.id, state: 'disputed' })}
+                  className="mt-1.5 text-xs text-fg-subtle underline-offset-2 hover:text-warning hover:underline"
+                >
+                  This isn't right
                 </button>
-              </div>
-              <div className="text-xs text-fg-subtle">{src.description}</div>
+              )}
             </Row>
             <Row icon={<ScopeIcon scope={memory.scope} size={14} />} label="Used in">
               <Select
diff --git a/desktop/src/features/memory/MemoryList.tsx b/desktop/src/features/memory/MemoryList.tsx
index e0e4a22b..7c6619c7 100644
--- a/desktop/src/features/memory/MemoryList.tsx
+++ b/desktop/src/features/memory/MemoryList.tsx
@@ -29,6 +29,22 @@ function MemoryCard({ memory, selected, onSelect, now, compact }: { memory: Memo
           <TopicPill key={t} topic={t} size="xs" />
         ))}
         <ExpiryBadge memory={memory} now={now} className="h-4.5" />
+        {memory.state === 'disputed' && (
+          <span className="rounded-full bg-warning/15 px-1.5 text-2xs font-medium text-warning" title="You said this isn't right: left out of chats and tasks">
+            Not right?
+          </span>
+        )}
+        {memory.state === 'superseded' && <span className="rounded-full bg-sunken px-1.5 text-2xs font-medium text-fg-subtle">Replaced</span>}
+        {memory.state !== 'disputed' && typeof memory.confidence === 'number' && memory.confidence < 0.7 && (
+          <span className="rounded-full bg-sunken px-1.5 text-2xs font-medium text-fg-subtle" title={`Sentient is ${Math.round(memory.confidence * 100)}% sure`}>
+            Not sure yet
+          </span>
+        )}
+        {(memory.sources?.length ?? 0) > 1 && (
+          <span className="rounded-full bg-sunken px-1.5 text-2xs font-medium text-fg-subtle" title={memory.sources!.map((s) => s.source).join(', ')}>
+            {memory.sources!.length} sources
+          </span>
+        )}
         {typeof memory.similarity === 'number' && (
           <span className="rounded-full bg-accent/12 px-1.5 text-2xs font-medium text-accent-text">{Math.round(memory.similarity * 100)}% match</span>
         )}
diff --git a/desktop/src/features/memory/SourceLinks.tsx b/desktop/src/features/memory/SourceLinks.tsx
new file mode 100644
index 00000000..144989a2
--- /dev/null
+++ b/desktop/src/features/memory/SourceLinks.tsx
@@ -0,0 +1,106 @@
+/**
+ * Where a memory came from, exactly (#152): every source with the words it said, each opening what it points at
+ * (the chat message, the email, the note). And how sure Sentient is of it.
+ */
+import { IconArrowUpRight, IconQuote } from '@tabler/icons-react'
+import { useNavigate } from 'react-router'
+import { getBridge } from '@/lib/bridge'
+import type { Memory, MemorySourceLink, MemorySourceRef } from '@/lib/types'
+import { cn, relativeTime } from '@/lib/utils'
+import { SourceChip } from './bits'
+
+/** What opening a source does, or null when there's nothing to open. */
+function opener(ref: MemorySourceRef | null, navigate: (to: string) => void): { label: string; open: () => void } | null {
+  if (!ref) return null
+  if (ref.kind === 'message' && ref.session_id) {
+    const to = `/chat/${ref.session_id}${ref.message_id ? `?message=${encodeURIComponent(ref.message_id)}` : ''}`
+    return { label: 'Open the chat', open: () => navigate(to) }
+  }
+  if (ref.url && /^(https?|obsidian):\/\//.test(ref.url)) {
+    return { label: ref.kind === 'email' ? 'Open the email' : ref.kind === 'note' ? 'Open the note' : 'Open', open: () => void getBridge().openExternal(ref.url!) }
+  }
+  if (ref.session_id) return { label: 'Open the chat that read it', open: () => navigate(`/chat/${ref.session_id}`) }
+  return null
+}
+
+function where(link: MemorySourceLink): string | null {
+  const ref = link.ref
+  if (!ref) return null
+  if (ref.kind === 'email' && ref.title) return `Email: ${ref.title}`
+  if (ref.kind === 'note') return ref.title ? `Note: ${ref.title}` : ref.path ?? null
+  if (ref.kind === 'file' && ref.file) return ref.file
+  if (ref.kind === 'app' && ref.title) return ref.title
+  return null
+}
+
+export function SourceLinks({ memory, onForgetSource }: { memory: Memory; onForgetSource: (source: string) => void }) {
+  const navigate = useNavigate()
+  const links: MemorySourceLink[] =
+    memory.sources && memory.sources.length > 0 ? memory.sources : [{ source: memory.source, ref: memory.ref ?? null, at: memory.created_at, own: true }]
+  return (
+    <ul className="space-y-2.5">
+      {links.map((link) => {
+        const go = opener(link.ref, navigate)
+        const place = where(link)
+        return (
+          <li key={link.source} className="rounded-lg border border-border bg-sunken/40 px-3 py-2.5">
+            <div className="flex items-center gap-2">
+              <SourceChip source={link.source} className="text-sm text-fg" />
+              <span className="shrink-0 text-xs text-fg-subtle">· {relativeTime(link.at)}</span>
+              {go && (
+                <button
+                  type="button"
+                  onClick={go.open}
+                  className="ml-auto inline-flex shrink-0 items-center gap-0.5 text-xs text-accent-text underline-offset-2 hover:underline"
+                >
+                  {go.label} <IconArrowUpRight size={12} />
+                </button>
+              )}
+            </div>
+            {place && <div className="mt-1 truncate text-xs text-fg-muted">{place}</div>}
+            {link.ref?.quote && (
+              <p className="mt-1.5 flex gap-1.5 text-sm italic text-fg-muted">
+                <IconQuote size={13} className="mt-0.5 shrink-0 text-fg-faint" />
+                <span className="selectable">{link.ref.quote}</span>
+              </p>
+            )}
+            {link.own && (
+              <button
+                type="button"
+                onClick={() => onForgetSource(link.source)}
+                className="mt-1.5 text-xs text-fg-subtle underline-offset-2 hover:text-danger hover:underline"
+              >
+                Forget all from this source
+              </button>
+            )}
+          </li>
+        )
+      })}
+    </ul>
+  )
+}
+
+export function confidenceWords(c: number): string {
+  if (c >= 0.9) return 'Very sure'
+  if (c >= 0.7) return 'Fairly sure'
+  return 'Not sure yet'
+}
+
+export function Confidence({ memory, className }: { memory: Memory; className?: string }) {
+  const c = memory.confidence ?? 0.8
+  const n = memory.sources?.length ?? 1
+  return (
+    <div className={cn('space-y-1.5', className)}>
+      <div className="flex items-center justify-between text-sm">
+        <span className="text-fg">{confidenceWords(c)}</span>
+        <span className="tabular-nums text-fg-subtle">{Math.round(c * 100)}%</span>
+      </div>
+      <div className="h-1.5 overflow-hidden rounded-full bg-sunken" role="meter" aria-valuemin={0} aria-valuemax={100} aria-valuenow={Math.round(c * 100)} aria-label="How sure Sentient is">
+        <div className={cn('h-full rounded-full', c >= 0.9 ? 'bg-success' : c >= 0.7 ? 'bg-accent' : 'bg-warning')} style={{ width: `${Math.round(c * 100)}%` }} />
+      </div>
+      <div className="text-xs text-fg-subtle">
+        {n > 1 ? `${n} places told Sentient this.` : 'One place told Sentient this.'} It gets surer each time you or another source say it again.
+      </div>
+    </div>
+  )
+}
diff --git a/desktop/src/features/memory/hooks.ts b/desktop/src/features/memory/hooks.ts
index ce3f1371..6103efa0 100644
--- a/desktop/src/features/memory/hooks.ts
+++ b/desktop/src/features/memory/hooks.ts
@@ -155,7 +155,23 @@ export function useOptimisticMemoryActions() {
     onSettled: settle
   })
 
-  return useMemo(() => ({ update, remove, move }), [update, remove, move])
+  const setState = useMutation({
+    mutationFn: ({ id, state }: { id: number; state: 'current' | 'disputed' }) => api.memories.setState(id, state),
+    onMutate: async ({ id, state }) => {
+      const snap = await snapshot()
+      patchLists((list) => list.map((m) => (m.id === id ? ({ ...m, state, ...(state === 'current' ? { confidence: 1 } : {}) } as Memory) : m)))
+      return snap
+    },
+    onError: (e, _v, snap) => {
+      restore(snap)
+      toast.error("Couldn't change that memory", { description: errorMessage(e) })
+    },
+    onSuccess: (m) =>
+      toast.success(m.state === 'disputed' ? 'Sentient will leave this out of chats and tasks' : 'Sentient will use this memory again'),
+    onSettled: settle
+  })
+
+  return useMemo(() => ({ update, remove, move, setState }), [update, remove, move, setState])
 }
 
 function scopeName(scope: string | undefined): string {
diff --git a/desktop/src/lib/api.ts b/desktop/src/lib/api.ts
index 18d92e9b..47edda93 100644
--- a/desktop/src/lib/api.ts
+++ b/desktop/src/lib/api.ts
@@ -707,6 +707,10 @@ export const api = {
     /** §7 memory scopes (#155): Always, Personal, Work and the user's projects, with counts. */
     scopes: () => http.get<MemoryScope[]>('/api/memories/scopes'),
     move: (id: number, scope: string) => http.patch<Memory>(`/api/memories/${id}`, { scope }),
+    /** #152: one memory with every source and exactly where it said it. */
+    get: (id: number) => http.get<Memory>(`/api/memories/${id}`),
+    /** #152: the user says a memory isn't right (`disputed`, kept out of chats and tasks) or is (`current`). */
+    setState: (id: number, state: 'current' | 'disputed') => http.patch<Memory>(`/api/memories/${id}`, { state }),
     resetScope: (scope: string) => http.delete<{ deleted: number }>(`/api/memories/scope/${enc(scope)}`),
     update: (id: number, content: string) => http.put<Memory>(`/api/memories/${id}`, { content }),
     delete: (id: number) => http.delete<{ deleted: boolean }>(`/api/memories/${id}`),
diff --git a/desktop/src/lib/types.ts b/desktop/src/lib/types.ts
index 85b42a67..88e3c1f4 100644
--- a/desktop/src/lib/types.ts
+++ b/desktop/src/lib/types.ts
@@ -2140,6 +2140,43 @@ export interface Memory {
   review?: ReviewNote | null
   /** Where it is kept (#155): "personal" (default), "work", "always" (every chat) or a project's name. */
   scope?: string
+  /** #152: how sure Sentient is (0..1), from where it came and how often it was learned again. */
+  confidence?: number
+  /** #152: only `current` memories go into chats and tasks. */
+  state?: MemoryState
+  /** The memory that replaced it (state `superseded`). */
+  superseded_by?: number | null
+  /** Its words, on `GET /api/memories/{id}` of a superseded memory. */
+  superseded_by_content?: string | null
+  /** Exactly where its own source said it. */
+  ref?: MemorySourceRef | null
+  /** Every source, its own first (#152). */
+  sources?: MemorySourceLink[]
+}
+
+export type MemoryState = 'current' | 'disputed' | 'superseded'
+
+/** Exactly where a source said a memory (#152): a chat message, an email or app result, a note, a file. */
+export interface MemorySourceRef {
+  kind?: 'message' | 'email' | 'app' | 'note' | 'file' | string
+  session_id?: string
+  message_id?: string
+  quote?: string | null
+  title?: string
+  url?: string
+  id?: string
+  app?: string
+  path?: string
+  folder_id?: string
+  file?: string
+}
+
+export interface MemorySourceLink {
+  source: string
+  ref: MemorySourceRef | null
+  at: string
+  /** its own source (the first one) */
+  own: boolean
 }
 
 /** One memory scope (#155) from `GET /api/memories/scopes`. */
@@ -2207,6 +2244,8 @@ export interface MemoryQuery {
   q?: string
   source?: string
   scope?: string
+  /** None: current and disputed; `all` adds superseded ones (#152). */
+  state?: MemoryState | 'all'
   limit?: number
   offset?: number
 }
diff --git a/docs/API.md b/docs/API.md
index b42f5d38..ae2bc349 100644
--- a/docs/API.md
+++ b/docs/API.md
@@ -1594,7 +1594,7 @@ offered to proactive look-ups.
 
 ## 7. Memory
 
-**Memory** `{id: int, content, topics: string[], source, memory_type: "long-term|short-term", created_at, updated_at, expires_at, previous_content: string|null, status: "active"|"pending", review: ReviewNote|null, scope}` (`previous_content` is the text before the last UPDATE; `review` says where a held memory came from; `scope`: where it is kept, below)
+**Memory** `{id: int, content, topics: string[], source, memory_type: "long-term|short-term", created_at, updated_at, expires_at, previous_content: string|null, status: "active"|"pending", review: ReviewNote|null, scope, confidence, state, superseded_by, ref: SourceRef|null, sources?: [SourceLink]}` (`previous_content` is the text before the last UPDATE; `review` says where a held memory came from; `scope`: where it is kept, below; `confidence`, `state`, `ref` and `sources`: "Source links, confidence and state" below)
 
 **ReviewNote** `{from, snippet: string|null, session_id: string|null, title?, dated?, export?}`: `from` names the source
 in plain words ("Gmail", "Hermes", "ChatGPT", "resume.pdf", "a proactive check"), `snippet` is the text it came from
@@ -1605,7 +1605,9 @@ conversation, note or file it was in, such as "10K training plan" or "Saved memo
 Topics are the v2 set: Personal Identity, Interests & Lifestyle, Work & Learning, Health & Wellbeing,
 Relationships & Social Life, Financial, Goals & Challenges, Miscellaneous.
 
-- `GET /api/memories?topic=&q=&source=&scope=&limit=&offset=` → `[Memory]` newest first (`scope`: one scope only), expired short-term facts and memories waiting for review excluded (`q` = hybrid search when embeddings are available: vector neighbours plus FTS5 keyword matches, ordered by `score` = `similarity` + `memory.keyword_weight` × share of query words present, each result carrying `similarity` and `score`; falls back to a keyword match)
+- `GET /api/memories?topic=&q=&source=&scope=&state=&limit=&offset=` → `[Memory]` with `sources`, newest first
+  (`scope`: one scope only; `state`: `current`, `disputed`, `superseded` or `all`, default current and disputed;
+  `source` also finds memories that source said again), expired short-term facts and memories waiting for review excluded (`q` = hybrid search when embeddings are available: vector neighbours plus FTS5 keyword matches, ordered by `score` = `similarity` + `memory.keyword_weight` × share of query words present, each result carrying `similarity` and `score`; falls back to a keyword match)
 - `GET /api/memories/topics` → `[{name, description, count}]`
 - `GET /api/memories/graph` → `{nodes: [{id, label, title, content, topics, memory_type, source, created_at}], links: [{source, target, value}]}` (`label` = content truncated to 25 chars, `title` = full content, as in v2; a link means cosine similarity ≥ `memory.graph_link_similarity`, `value` is that similarity)
 - `POST /api/memories` `{content, source?, scope?}` → `{action: "ADD"|"UPDATE"|"DELETE"|"SKIP", id, content, status?: "pending", scope?}` (`scope` defaults to `personal`; runs the CUD decision, so a duplicate returns `SKIP` with the existing id; `source` defaults to `manual`. The decision also sees up to 3 facts about the same person and attribute found by keyword (where they live, job, relationship, diet, health, ownership, routine), and a new current residence ("moved to Bengaluru") always UPDATEs the old one ("lives in Pune") rather than adding a second home; past-tense facts are left alone. Facts that name someone else are never offered to the model, so it can't update, skip or delete them, and the
@@ -1618,11 +1620,41 @@ result carries `previous` as any update does. Looser cases are marked `changes_v
 correction is never `SKIP`. An UPDATE the model picks for something unrelated about the same person, with no
 attribute and no word of what it says in common ("a piano recital in July" for "starts school in July"), is added instead)
 - `PUT /api/memories/{id}` `{content}` → `Memory` (id kept; topics, long/short-term and expiry re-analyzed; embedding refreshed; 404 if missing)
+- `GET /api/memories/{id}` → `Memory` with `sources`, and `superseded_by_content` (the words that replaced it) when
+  superseded. 404 if missing.
 - `PATCH /api/memories/{id}` `{scope}` → `Memory`: moves it to another scope (below). 400 empty `scope`, 404 if missing.
-- `DELETE /api/memories/{id}` → `{deleted: true}` (404 if missing)
+  `{state: "disputed"|"current"}` → `Memory`: the user says it isn't right (kept, out of every prompt) or is (current,
+  `confidence` 1.0; a superseded memory comes back). 400 another state.
+- `DELETE /api/memories/{id}` → `{deleted: true}` (404 if missing), with everything derived from it (below)
 - `DELETE /api/memories/source/{source}` → `{deleted, unlinked}`: forgets the memories learned from `source`. A memory
   another source backs too is not deleted: it loses this source and keeps the others (`unlinked`), see "Sources and
   forgetting" below.
+**Source links, confidence and state (#152).**
+
+- A memory points at exactly where it was said: `ref` (its own source) and `sources`, every source in the order they
+  came, `{source, ref, at, own}`. A **SourceRef** is `{kind: "message", session_id, message_id?, quote?}` for a chat (the
+  user's message that says it; just the chat when no single message does), `{kind: "email"|"app", app, id?, title, url?, session_id, quote}` for what a chat read
+  in an app, `{kind: "note", folder_id, path, title, url?, session_id, quote}` for a note, `{kind: "file", file,
+  quote}` for an imported file; `quote` is the sentence that says it. Older memories may have none.
+- `confidence` (0..1) starts from the source: 1.0 what the user typed in Memory or edited, 0.9 what they said in a
+  chat (or onboarding), 0.8 their notes, 0.7 files, imports and tasks, 0.6 what an app said and anything held for
+  review. Each new source that says it again adds 0.1, approving it from review makes it at least 0.9, and saying it is
+  right makes it 1.0.
+- `state`: `current`, `disputed` (the user said it isn't right) or `superseded` (`superseded_by`: the nightly tidy-up
+  found a newer memory that contradicts it). Only current memories are recalled into chats, tasks, proactivity, the
+  user model, USER.md and MEMORY.md (a memory that becomes disputed or superseded also leaves those two files); dedup
+  still sees disputed ones, so saying one again in a chat makes it current.
+  A superseded memory stays as history (out of recall, not listed unless `state` asks for it).
+- Deleting a memory (`DELETE /api/memories/{id}`, the `memory_forget` tool, discarding one from review, resetting a
+  scope, forgetting a source) also removes everything derived from it: its vector, merged copies and source links, its
+  earlier wording, chat summaries made of the message it came from that repeat it (with their vectors), the nightly
+  journal's lines about it, the user model's evidence from it (an inferred insight with nothing else behind it goes),
+  the memory chips on replies and task runs that had it in mind, its USER.md bullet and the MEMORY.md lines that repeat
+  it. The chats themselves stay. The tidy-up's own merges and contradictions don't count as deletes.
+- Migration 0015 gives memories saved before #153 from a messaging app or a device chat their real source (found from
+  the review note of a held memory, the `memory_remember` call that saved it, or the one message in such a chat, up to
+  30 minutes before it, that says it), so forgetting that app covers them too.
+
 - `GET /api/memories/forget-preview?source=` → **ForgetCounts**: what "Also forget what Sentient learned from it" would
   delete for `source`, before the user disconnects it. Nothing changes. 400 for a source that can't be disconnected.
 
@@ -1787,7 +1819,7 @@ facts of that source too. Engine: `sentient.memory.review` (`for_context(ctx)`,
 
 Engine notes: recall used by the system prompt and `memory_recall` is hybrid (same ranking as `q` above) and
 counts each recalled fact (`facts.recall_count`, `last_recalled_at`; dreaming promotes often-recalled short-term
-facts). Bulk and consolidation changes publish `memory.updated` with `reason` (`merged` | `contradicted` |
+facts). Saying a memory isn't right or is publishes UPDATE with `state` and `reason: "disputed"|"confirmed"` (#152). Bulk and consolidation changes publish `memory.updated` with `reason` (`merged` | `contradicted` (the older one is superseded, #152) |
 `promoted` | `expired`) and, for merges/contradictions, `merged_into` / `superseded_by`.
 
 ---
diff --git a/sentient/agent/second_look.py b/sentient/agent/second_look.py
index ac0fd13b..5cf063fc 100644
--- a/sentient/agent/second_look.py
+++ b/sentient/agent/second_look.py
@@ -404,8 +404,8 @@ async def known_addresses(store: Any, items: Iterable[str]) -> set[str]:
             continue
         try:
             rows = await store.fetchall(
-                "SELECT content FROM facts WHERE status = 'active' AND (expires_at IS NULL OR expires_at > ?)"
-                " AND lower(content) LIKE ? LIMIT 20",
+                "SELECT content FROM facts WHERE status = 'active' AND state = 'current'"
+                " AND (expires_at IS NULL OR expires_at > ?) AND lower(content) LIKE ? LIMIT 20",
                 (now_iso(), f"%{item.lower()}%"),
             )
         except Exception as exc:  # no memory table (bare tests): nothing is known
diff --git a/sentient/app.py b/sentient/app.py
index 75865c32..04e49f9e 100644
--- a/sentient/app.py
+++ b/sentient/app.py
@@ -178,6 +178,9 @@ def save_config(self, config: SentientConfig | None = None) -> None:
             self.llm.config = self.config  # type: ignore[attr-defined]
         if self.agent is not None:
             self.agent.config = self.config
+        if self.memory is not None:  # the user's name, recall and dedup settings take effect at once (#152)
+            self.memory.config = self.config
+            self.memory.episodic.config = self.config
         self.approvals.config = self.config.tools.approvals
         self.registry.set_hidden("subagents", not self.config.subagents.enabled)
         self.bus.publish("config.updated", {"sections": list(self.config.model_dump().keys())})
@@ -272,6 +275,17 @@ async def delete_chat(self, session_id: str, *, reason: str | None = None) -> No
                 log.exception("removing the saved results of incognito chat %s failed", session_id)
         self.bus.publish("session.deleted", {"session_id": session_id, **({"reason": reason} if reason else {})})
 
+    def _after_memory_erased(self, texts: list[str]) -> None:
+        """A memory was deleted (#152): its words leave USER.md and MEMORY.md, and the user model reads its insights
+        again (some may be gone with it)."""
+        try:
+            self.workspace.scrub(texts, self.config.assistant.user_name)
+        except OSError:
+            log.exception("removing a deleted memory from the workspace files failed")
+        model = getattr(self, "user_model", None)
+        if model is not None:
+            model._vectors = None
+
     def tool_extra(self) -> dict[str, Any]:
         return {"app": self, "skills": self.skills, "workspace": self.workspace, "registry": self.registry}
 
@@ -292,6 +306,8 @@ async def start(self) -> SentientApp:
         self.memory = FactMemory(self.store, self.llm, self.config) if self.store.vec_available else None
         if self.memory is None:
             log.warning("sqlite-vec unavailable: semantic memory disabled")
+        else:
+            self.memory.on_erase = self._after_memory_erased
 
         with as_kind(self.notifications.model_kind):
             await self.notifications.start()
diff --git a/sentient/evolution/service.py b/sentient/evolution/service.py
index 10721e88..58fa3232 100644
--- a/sentient/evolution/service.py
+++ b/sentient/evolution/service.py
@@ -895,7 +895,7 @@ async def update_profile(self, now: datetime | None = None, *, force: bool = Fal
         after, params = after_watermark(facts_mark, "updated_at", "id")
         # MEMORY.md and USER.md are personal: work and project memories never go in them (#155)
         new_facts = await store.fetchall(
-            "SELECT id, content, topics, source, updated_at FROM facts WHERE status = 'active'"
+            "SELECT id, content, topics, source, updated_at FROM facts WHERE status = 'active' AND state = 'current'"
             f" AND memory_type = 'long-term' AND {after} AND (expires_at IS NULL OR expires_at > ?)"
             f" AND {PROFILE_SCOPES} ORDER BY updated_at, id",
             (*params, nowiso),
@@ -926,7 +926,8 @@ async def update_profile(self, now: datetime | None = None, *, force: bool = Fal
 
         budget = cfg.memory.workspace_budget_chars
         all_facts = await store.fetchall(
-            "SELECT content FROM facts WHERE status = 'active' AND (expires_at IS NULL OR expires_at > ?)"
+            "SELECT content FROM facts WHERE status = 'active' AND state = 'current'"
+            " AND (expires_at IS NULL OR expires_at > ?)"
             f" AND {PROFILE_SCOPES} ORDER BY updated_at DESC, id DESC LIMIT 80",
             (nowiso,),
         )
diff --git a/sentient/gateway/routes/memory.py b/sentient/gateway/routes/memory.py
index 3a54b100..aae64193 100644
--- a/sentient/gateway/routes/memory.py
+++ b/sentient/gateway/routes/memory.py
@@ -33,14 +33,16 @@ def _memory(request: Request):
 @router.get("")
 async def list_memories(
     request: Request, topic: str = "", q: str = "", source: str = "", limit: int = 500, offset: int = 0,
-    scope: str = "",
+    scope: str = "", state: str = "",
 ):
     s = get_core(request)
     if s.memory is None:
         return []
+    if state and state not in {"all", "current", "disputed", "superseded"}:
+        raise HTTPException(400, "state must be current, disputed, superseded or all")
     return await s.memory.list_facts(
         max(1, min(limit, 2000)), max(0, offset), topic=topic or None, source=source or None, q=q or None,
-        scope=scope or None,
+        scope=scope or None, state=state or None,
     )
 
 
@@ -257,10 +259,30 @@ async def update_memory(request: Request, memory_id: int, body: dict):
         raise HTTPException(404, f"memory {memory_id} not found") from exc
 
 
+@router.get("/{memory_id}")
+async def get_memory(request: Request, memory_id: int):
+    """One memory with every source and exactly where it said it (#152), and what replaced it when superseded."""
+    fact = await _memory(request).get_fact(memory_id)
+    if fact is None:
+        raise HTTPException(404, f"memory {memory_id} not found")
+    if fact.get("superseded_by"):
+        newer = await _memory(request).get_fact(int(fact["superseded_by"]))
+        fact["superseded_by_content"] = newer["content"] if newer else None
+    return fact
+
+
 @router.patch("/{memory_id}")
 async def move_memory(request: Request, memory_id: int, body: dict):
-    """Move a memory to another scope (#155): ``{scope}``."""
+    """Move a memory to another scope (#155): ``{scope}``; or say it isn't right or is (#152): ``{state:
+    "disputed"|"current"}``."""
     mem = _memory(request)
+    if "state" in body:
+        try:
+            return await mem.set_state(memory_id, str(body.get("state") or ""))
+        except KeyError as exc:
+            raise HTTPException(404, f"memory {memory_id} not found") from exc
+        except ValueError as exc:
+            raise HTTPException(400, str(exc)) from exc
     scope = memory_scopes.normalize(body.get("scope"))
     if not scope:
         raise HTTPException(400, "scope is required")
@@ -279,7 +301,7 @@ async def move_memory(request: Request, memory_id: int, body: dict):
 @router.delete("/{memory_id}")
 async def delete_memory(request: Request, memory_id: int):
     mem = _memory(request)
-    deleted = await mem.forget(memory_id, notify=True)
+    deleted = await mem.erase(memory_id, notify=True)  # with everything derived from it (#152)
     if not deleted:
         raise HTTPException(404, f"memory {memory_id} not found")
     return {"deleted": True}
diff --git a/sentient/memory/facts.py b/sentient/memory/facts.py
index f63917ad..eb419e3f 100644
--- a/sentient/memory/facts.py
+++ b/sentient/memory/facts.py
@@ -72,10 +72,16 @@
 
 MEMORY_COLUMNS = (
     "id, content, source, topics, memory_type, created_at, updated_at, expires_at, previous_content, status, review,"
-    " scope"
+    " scope, confidence, state, superseded_by, source_ref"
 )
 KEPT_APART_META = "memory.kept_apart"  # pairs the user split again after the tidy-up merged them (#353)
 ACTIVE = "status = 'active'"  # held memories (``pending``) are left out of every read but ``pending_facts``
+# #152: a memory is current, disputed (the user said it isn't right) or superseded (a newer one replaced it). Only
+# current ones go into prompts; superseded ones are history and never count as the same thing as a new fact.
+STATES = ("current", "disputed", "superseded")
+IN_USE = "status = 'active' AND state = 'current'"
+LIVE = "state != 'superseded'"
+RELEARNED_BOOST = 0.1  # confidence gained each time another source says the same thing
 
 _TOKEN_RE = re.compile(r"[a-z0-9]+")
 STOPWORDS = frozenset(
@@ -612,11 +618,25 @@ def _row_to_memory(r: Any, similarity: float | None = None) -> dict:
         "review": reviews.load(r["review"]) if "review" in r.keys() else None,  # noqa: SIM118
         "scope": (r["scope"] if "scope" in r.keys() else None) or memory_scopes.PERSONAL,  # noqa: SIM118
     }
+    keys = r.keys()
+    if "state" in keys:
+        d["confidence"] = round(float(r["confidence"] if r["confidence"] is not None else 0.8), 2)
+        d["state"] = r["state"] or "current"
+        d["superseded_by"] = r["superseded_by"]
+        d["ref"] = _load_ref(r["source_ref"])
     if similarity is not None:
         d["similarity"] = round(similarity, 4)
     return d
 
 
+def _load_ref(raw: Any) -> dict | None:
+    try:
+        ref = json.loads(raw) if raw else None
+    except (TypeError, ValueError):
+        return None
+    return ref if isinstance(ref, dict) else None
+
+
 def _in_scopes(scopes: list[str] | None, col: str = "scope") -> tuple[str, list[str]]:
     """SQL condition (with its parameters) that keeps facts in ``scopes``; ``("1", [])`` for every scope."""
     if scopes is None:
@@ -646,6 +666,9 @@ def __init__(self, store: Store, llm: LLMProvider, config: SentientConfig, bus:
         self.vec = VecTable(store, "facts_vec")
         self.episodic = EpisodicMemory(store, llm, config)
         self._qcache: OrderedDict[tuple[str, str], list[float]] = OrderedDict()
+        # set by the app: also scrub the words of erased memories from the workspace files and the user model's
+        # caches (#152); called with the texts that went
+        self.on_erase: Any = None
 
     async def ensure_schema(self) -> None:
         await ensure_memory_schema(self.store)
@@ -691,14 +714,16 @@ async def embed_query(self, text: str) -> list[float]:
 
     # ------------------------------------------------------------------ recall
     async def _keyword_ids(
-        self, tokens: list[str], limit: int, source: str | None, scopes: list[str] | None = None
+        self, tokens: list[str], limit: int, source: str | None, scopes: list[str] | None = None,
+        current_only: bool = False,
     ) -> list[int]:
         if not tokens:
             return []
         in_scope, scope_params = _in_scopes(scopes, "f.scope")
+        state = "f.state = 'current'" if current_only else "f.state != 'superseded'"
         sql = (
             "SELECT f.id FROM facts_fts JOIN facts f ON f.id = facts_fts.rowid"
-            f" WHERE facts_fts MATCH ? AND f.status = 'active' AND {in_scope}"
+            f" WHERE facts_fts MATCH ? AND f.status = 'active' AND {state} AND {in_scope}"
         )
         params: list[Any] = [" OR ".join(f'"{t}"' for t in tokens), *scope_params]
         if source is not None:
@@ -713,12 +738,15 @@ async def _keyword_ids(
             return []
 
     async def _search(
-        self, query: str, k: int, min_sim: float, source: str | None = None, scopes: list[str] | None = None
+        self, query: str, k: int, min_sim: float, source: str | None = None, scopes: list[str] | None = None,
+        current_only: bool = True,
     ) -> list[dict]:
         """Hybrid recall: vector neighbours plus FTS5 keyword matches, ranked by
         ``similarity + keyword_weight * share of query words present``. Embedding models
         compress similarities (unrelated text still scores ~0.65), so exact words help ordering.
-        ``scopes`` keeps facts in those scopes only (#155); None reads every scope."""
+        ``scopes`` keeps facts in those scopes only (#155); None reads every scope. ``current_only``: leave out
+        disputed memories too (superseded ones are always left out), as everything that goes into a prompt does."""
+        state = "state = 'current'" if current_only else LIVE
         await self.ensure_schema()
         qvec = await self.embed_query(query)
         now = now_iso()
@@ -737,7 +765,7 @@ async def _search(
             sims = {int(r["id"]): 1.0 - float(r["distance"]) for r in rows}
         weight = self.config.memory.keyword_weight
         tokens = keyword_tokens(query)
-        kw_ids = await self._keyword_ids(tokens, pool, source, scopes) if weight > 0 else []
+        kw_ids = await self._keyword_ids(tokens, pool, source, scopes, current_only) if weight > 0 else []
         missing = [i for i in kw_ids if i not in sims]
         if missing:
             marks = ",".join("?" * len(missing))
@@ -752,7 +780,7 @@ async def _search(
         marks = ",".join("?" * len(sims))
         in_scope, scope_params = _in_scopes(scopes)
         rows = await self.store.fetchall(
-            f"SELECT {MEMORY_COLUMNS} FROM facts WHERE id IN ({marks}) AND {ACTIVE} AND {in_scope}",
+            f"SELECT {MEMORY_COLUMNS} FROM facts WHERE id IN ({marks}) AND {ACTIVE} AND {state} AND {in_scope}",
             [*sims, *scope_params],
         )
         qset = set(tokens)
@@ -779,16 +807,18 @@ async def recall(
         source: str | None = None,
         track: bool = True,
         scopes: list[str] | None = None,
+        current_only: bool = True,
     ) -> list[dict]:
         """Relevant facts for ``query``. ``track`` counts the recall (dreaming promotes
         short-term facts that keep being recalled); internal lookups pass False. ``scopes``: only facts in these
-        scopes (``memory.scopes.recall_scopes``: a chat's scope plus always); None reads every scope."""
+        scopes (``memory.scopes.recall_scopes``: a chat's scope plus always); None reads every scope.
+        ``current_only``: only current memories (#152), as prompts get; dedup also sees disputed ones."""
         top_k = top_k if top_k is not None else self.config.memory.facts_top_k
         min_sim = min_similarity if min_similarity is not None else self.config.memory.min_similarity
         if top_k <= 0 or not query.strip():
             return []
         try:
-            out = await self._search(query, top_k, min_sim, source, scopes)
+            out = await self._search(query, top_k, min_sim, source, scopes, current_only)
         except Exception as exc:
             log.warning("memory recall skipped: %s", exc)
             return []
@@ -886,29 +916,214 @@ async def forget(self, fid: int, *, notify: bool = False) -> bool:
             self.publish("DELETE", fid, row["content"] if row else None)
         return deleted
 
+    async def erase(self, fid: int, *, notify: bool = False) -> bool:
+        """Delete a memory the user (or a forget) took away, with everything derived from it (#152): its vector, its
+        merged copies and source links (:meth:`forget`), the chat summaries made of the messages it came from that
+        repeat it, the nightly journal's lines about it, the user model's evidence from it (an inferred insight with
+        nothing else behind it goes), the memory chips on replies and task runs that had it in mind, and (through
+        ``on_erase``) the lines of USER.md and MEMORY.md that say it. Its own previous wording goes with it."""
+        await self.ensure_schema()
+        row = await self.store.fetchone(
+            "SELECT id, content, previous_content, source_ref FROM facts WHERE id = ?", (fid,)
+        )
+        if row is None:
+            return False
+        copies = await self.store.fetchall(
+            "SELECT id, content, previous_content, source_ref FROM facts WHERE merged_into = ? AND status = 'merged'",
+            (fid,),
+        )
+        links = await self.store.fetchall(
+            "SELECT ref FROM fact_sources WHERE fact_id = ?"
+            " OR fact_id IN (SELECT id FROM facts WHERE merged_into = ? AND status = 'merged')",
+            (fid, fid),
+        )
+        if not await self.forget(fid, notify=notify):
+            return False
+        rows = [row, *copies]
+        texts = list(dict.fromkeys(t for r in rows for t in (r["content"], r["previous_content"]) if t))
+        refs = [_load_ref(r["source_ref"]) for r in rows] + [_load_ref(r["ref"]) for r in links]
+        try:
+            await self._cascade([int(r["id"]) for r in rows], texts, [r for r in refs if r])
+        except Exception:  # the memory itself is gone; a leftover is logged, never a failed delete
+            log.exception("cleaning up after memory %s failed", fid)
+        return True
+
+    async def _cascade(self, ids: list[int], texts: list[str], refs: list[dict]) -> None:
+        store, user = self.store, self.config.assistant.user_name
+
+        def repeats(text: str) -> bool:
+            return any(origins.says(t, text or "", user) for t in texts)
+
+        # chat summaries made of the messages it came from, that repeat it, and their vectors
+        said_in = {str(r["message_id"]) for r in refs if r.get("message_id")}
+        if said_in:
+            for r in await store.fetchall("SELECT rowid, id, content, message_ids FROM summaries"):
+                try:
+                    made_of = {str(m) for m in json.loads(r["message_ids"] or "[]")}
+                except ValueError:
+                    continue
+                if made_of & said_in and repeats(r["content"]):
+                    await store.execute("DELETE FROM summaries WHERE id = ?", (r["id"],))
+                    await self.episodic.vec.delete(int(r["rowid"]))
+        # the nightly journal's lines about it
+        for r in await store.fetchall("SELECT id, journal_md FROM dreams WHERE journal_md != ''"):
+            lines = str(r["journal_md"]).splitlines()
+            kept = ["- (a memory you deleted)" if line.lstrip().startswith(("-", "*")) and repeats(line) else line
+                    for line in lines]
+            if kept != lines:
+                await store.execute("UPDATE dreams SET journal_md = ? WHERE id = ?", ("\n".join(kept), r["id"]))
+        # the user model's evidence from it
+        wanted = {str(i) for i in ids}
+        try:
+            insights = await store.fetchall("SELECT rid, id, source, evidence FROM user_insights")
+        except Exception:
+            insights = []
+        for r in insights:
+            try:
+                evidence = json.loads(r["evidence"] or "[]")
+            except ValueError:
+                continue
+            if not isinstance(evidence, list):
+                continue
+            kept = [e for e in evidence if not (isinstance(e, dict) and (
+                (e.get("kind") == "fact" and str(e.get("ref")) in wanted) or (e.get("quote") and repeats(e["quote"]))
+            ))]
+            if len(kept) == len(evidence):
+                continue
+            if not kept and r["source"] == "inferred":
+                await store.execute("DELETE FROM user_questions WHERE insight_id = ?", (r["id"],))
+                await store.execute("DELETE FROM user_insights WHERE id = ?", (r["id"],))
+                with contextlib.suppress(Exception):
+                    await store.execute("DELETE FROM user_insights_vec WHERE rowid = ?", (int(r["rid"]),))
+            else:
+                await store.execute("UPDATE user_insights SET evidence = ? WHERE id = ?", (json.dumps(kept), r["id"]))
+        # the memory chips on replies and task runs that had it in mind
+        for table in ("messages", "task_runs"):
+            for fid in ids:
+                try:
+                    rows = await store.fetchall(
+                        f"SELECT rowid, memory_sources FROM {table} WHERE memory_sources LIKE ?", (f'%"id": {fid}%',)
+                    )
+                except Exception:  # no task runs table (a test store)
+                    break
+                for r in rows:
+                    try:
+                        items = json.loads(r["memory_sources"] or "[]")
+                    except ValueError:
+                        continue
+                    kept = [m for m in items if not (isinstance(m, dict) and m.get("kind") == "fact" and m.get("id") == fid)]
+                    if len(kept) != len(items):
+                        await store.execute(
+                            f"UPDATE {table} SET memory_sources = ? WHERE rowid = ?", (json.dumps(kept), r["rowid"])
+                        )
+        if self.on_erase is not None:
+            res = self.on_erase(texts)
+            if hasattr(res, "__await__"):
+                await res
+
+    async def _out_of_prompts(self, texts: list[str]) -> None:
+        """A memory left the prompts (disputed or superseded): its lines leave USER.md and MEMORY.md too, which go
+        into every prompt (``on_erase``)."""
+        if self.on_erase is None:
+            return
+        try:
+            res = self.on_erase(texts)
+            if hasattr(res, "__await__"):
+                await res
+        except Exception:
+            log.exception("removing a memory from the workspace files failed")
+
+    # ------------------------------------------------------------------ state and confidence (#152)
+    async def set_state(self, fid: int, state: str) -> dict:
+        """The user says a memory isn't right (``disputed``: kept, but out of every prompt) or is (``current``:
+        Sentient is as sure as it gets). KeyError when it doesn't exist, ValueError for another state."""
+        if state not in {"current", "disputed"}:
+            raise ValueError("state must be current or disputed")
+        row = await self.store.fetchone("SELECT content, state, status FROM facts WHERE id = ?", (fid,))
+        if row is None:
+            raise KeyError(fid)
+        if state == "current":
+            await self.store.execute(
+                "UPDATE facts SET state = 'current', superseded_by = NULL, confidence = 1.0, updated_at = ?"
+                " WHERE id = ?",
+                (now_iso(), fid),
+            )
+            if row["state"] == "superseded" and row["status"] == "active":  # back in recall
+                [vec] = await self._embed([row["content"]])
+                await self.vec.upsert(fid, vec)
+        elif row["state"] != "disputed":
+            await self.store.execute(
+                "UPDATE facts SET state = 'disputed', updated_at = ? WHERE id = ?", (now_iso(), fid)
+            )
+            await self._out_of_prompts([row["content"]])
+        if row["state"] != state:
+            self.publish("UPDATE", fid, row["content"], state=state, reason="confirmed" if state == "current" else "disputed")
+        fact = await self.get_fact(fid)
+        assert fact is not None
+        return fact
+
     # ------------------------------------------------------------------ sources (#153)
-    async def link_sources(self, fid: int, sources: list[str], *, merged_from: int | None = None) -> None:
+    async def link_sources(
+        self, fid: int, sources: list[str], *, merged_from: int | None = None, refs: dict[str, dict] | None = None
+    ) -> None:
         """Record that fact ``fid`` was also learned from ``sources`` (its own ``source`` is never linked twice).
         ``merged_from``: the links come with fact ``merged_from`` merged into it, and :meth:`unmerge` takes exactly
-        those away again. A source learned for ``fid`` itself is never one a merge brought, even if a merge had."""
+        those away again. A source learned for ``fid`` itself is never one a merge brought, even if a merge had.
+        ``refs``: exactly where each source said it (#152), kept with its link; a source that wasn't one of its
+        sources yet makes Sentient surer of it (``RELEARNED_BOOST``)."""
         await self.ensure_schema()
-        row = await self.store.fetchone("SELECT source FROM facts WHERE id = ?", (fid,))
+        row = await self.store.fetchone("SELECT source, source_ref FROM facts WHERE id = ?", (fid,))
         if row is None:
             return
+        refs = refs or {}
+        own = refs.get(str(row["source"]))
+        if own and not row["source_ref"] and str(row["source"]) in sources:
+            await self.store.execute("UPDATE facts SET source_ref = ? WHERE id = ?", (json.dumps(own), fid))
         ts = now_iso()
         for src in dict.fromkeys(s for s in sources if s and s != row["source"]):
+            ref = json.dumps(refs[src]) if refs.get(src) else None
+            new = await self.store.fetchone(
+                "SELECT 1 AS x FROM fact_sources WHERE fact_id = ? AND source = ?", (fid, src)
+            ) is None
             if merged_from is None:
                 await self.store.execute(
-                    "INSERT INTO fact_sources(fact_id, source, linked_at) VALUES(?,?,?)"
-                    " ON CONFLICT(fact_id, source) DO UPDATE SET merged_from = NULL",
-                    (fid, src, ts),
+                    "INSERT INTO fact_sources(fact_id, source, linked_at, ref) VALUES(?,?,?,?)"
+                    " ON CONFLICT(fact_id, source) DO UPDATE SET merged_from = NULL,"
+                    " ref = COALESCE(fact_sources.ref, excluded.ref)",
+                    (fid, src, ts, ref),
                 )
+                if new:
+                    await self.store.execute(
+                        "UPDATE facts SET confidence = MIN(1.0, confidence + ?) WHERE id = ?", (RELEARNED_BOOST, fid)
+                    )
             else:  # a link it already had stays its own
                 await self.store.execute(
-                    "INSERT OR IGNORE INTO fact_sources(fact_id, source, linked_at, merged_from) VALUES(?,?,?,?)",
-                    (fid, src, ts, merged_from),
+                    "INSERT OR IGNORE INTO fact_sources(fact_id, source, linked_at, merged_from, ref) VALUES(?,?,?,?,?)",
+                    (fid, src, ts, merged_from, ref),
                 )
 
+    async def source_links(self, fids: list[int]) -> dict[int, list[dict]]:
+        """Every source of each fact with exactly where it said it (#152): ``{id: [{source, ref, at, own}]}``, its own
+        source first, then the others in the order they came."""
+        if not fids:
+            return {}
+        await self.ensure_schema()
+        marks = ",".join("?" * len(fids))
+        out: dict[int, list[dict]] = {}
+        for r in await self.store.fetchall(
+            f"SELECT id, source, source_ref, created_at FROM facts WHERE id IN ({marks})", list(fids)
+        ):
+            out[int(r["id"])] = [{"source": r["source"], "ref": _load_ref(r["source_ref"]), "at": r["created_at"],
+                                  "own": True}]
+        for r in await self.store.fetchall(
+            f"SELECT fact_id, source, ref, linked_at FROM fact_sources WHERE fact_id IN ({marks}) ORDER BY rowid",
+            list(fids),
+        ):
+            out.setdefault(int(r["fact_id"]), []).append(
+                {"source": r["source"], "ref": _load_ref(r["ref"]), "at": r["linked_at"], "own": False}
+            )
+        return out
+
     async def _linked(self, fid: int) -> list[str]:
         rows = await self.store.fetchall(
             "SELECT source FROM fact_sources WHERE fact_id = ? ORDER BY rowid", (fid,)
@@ -971,13 +1186,17 @@ async def purge_source(self, source: str, gone: list[int] | None = None) -> dict
                 others.insert(0, str(row["source"]))
             if not others:
                 deleted += 0 if merged else 1
-                await self.forget(fid)
+                await self.erase(fid)
                 if gone is not None:
                     gone.append(fid)
                 continue
             await self.store.execute("DELETE FROM fact_sources WHERE fact_id = ? AND source = ?", (fid, source))
-            if row["source"] == source:  # its next source becomes its own
-                await self.store.execute("UPDATE facts SET source = ? WHERE id = ?", (others[0], fid))
+            if row["source"] == source:  # its next source becomes its own, with where it said it
+                await self.store.execute(
+                    "UPDATE facts SET source = ?, source_ref = (SELECT ref FROM fact_sources WHERE fact_id = ?"
+                    " AND source = ?) WHERE id = ?",
+                    (others[0], fid, others[0], fid),
+                )
                 await self.store.execute("DELETE FROM fact_sources WHERE fact_id = ? AND source = ?", (fid, others[0]))
             unlinked += 0 if merged else 1
         return {"deleted": deleted, "unlinked": unlinked}
@@ -1015,7 +1234,7 @@ async def forget_scope(self, scope: str) -> int:
             "SELECT id FROM facts WHERE scope = ? AND status IN ('active', 'pending')", (target,)
         )
         for r in rows:
-            await self.forget(int(r["id"]))
+            await self.erase(int(r["id"]))
         if rows:
             self.publish("DELETE", None, None, scope=target, reason="scope_reset", count=len(rows))
         return len(rows)
@@ -1043,7 +1262,7 @@ async def _related_facts(
             return []
         marks = ",".join("?" * len(ids))
         rows = await self.store.fetchall(
-            f"SELECT {MEMORY_COLUMNS} FROM facts WHERE id IN ({marks}) AND {ACTIVE}"
+            f"SELECT {MEMORY_COLUMNS} FROM facts WHERE id IN ({marks}) AND {ACTIVE} AND {LIVE}"
             " AND (expires_at IS NULL OR expires_at > ?)",
             [*ids, now_iso()],
         )
@@ -1095,6 +1314,7 @@ async def remember(
         own_words: str | None = None,
         session_id: str | None = None,
         scope: str | None = None,
+        ref: dict | None = None,
     ) -> dict[str, Any]:
         """Store one fact with dedup / CUD logic in ``scope`` (#155; personal when None). Returns {action, id, content}
         (an UPDATE adds ``previous``, the words it replaced, so the save can be undone; an ADD adds ``scope``).
@@ -1108,6 +1328,7 @@ async def remember(
         only look at facts in ``scope`` and always: a save never changes a memory in another scope."""
         user = self.config.assistant.user_name
         scope = memory_scopes.normalize(scope, memory_scopes.PERSONAL) or memory_scopes.PERSONAL
+        refs: dict[str, dict] = {source: ref} if ref else {}
         if review is not None and own_words and reviews.grounded(fact, own_words, user):
             log.info("kept from the user's own words although the chat read outside content: %r", fact)
             review = None
@@ -1125,6 +1346,7 @@ async def remember(
             try:
                 first, read = await origins.of_session(self.store, session_id)
                 source, *others = origins.sources_for(fact, first, read, held=outside, user_name=user)
+                refs.update(await origins.spans(self.store, fact, [source, *others], session_id, read, user))
             except Exception as exc:
                 log.debug("sources of chat %s unknown: %s", session_id, exc)
         if review is not None:
@@ -1132,8 +1354,22 @@ async def remember(
         else:
             result = await self._remember(fact, source=source, use_llm=use_llm, scope=scope)
         if result.get("id") is not None and result["action"] in {"ADD", "UPDATE", "SKIP"}:
+            fid = int(result["id"])
+            sure = origins.confidence(source, held=outside)
+            if result["action"] == "ADD":  # where exactly it was said, and how sure Sentient is of it (#152)
+                await self.store.execute(
+                    "UPDATE facts SET confidence = ?, source_ref = ? WHERE id = ?",
+                    (sure, json.dumps(refs[source]) if refs.get(source) else None, fid),
+                )
+            elif result["action"] == "UPDATE" or (not outside and origins.is_chat(source)):
+                # a correction, or the user saying it again: it is current, whatever was said about it before
+                await self.store.execute(
+                    "UPDATE facts SET state = 'current', superseded_by = NULL, confidence = MAX(confidence, ?)"
+                    " WHERE id = ? AND state != 'superseded'",
+                    (sure, fid),
+                )
             # learned here too: forgetting one of its sources keeps it while another still backs it (#153)
-            await self.link_sources(int(result["id"]), [source, *others])
+            await self.link_sources(fid, [source, *others], refs=refs)
         if result["action"] == "ADD":
             result["scope"] = scope
         if notify and result["action"] in {"ADD", "UPDATE", "DELETE"}:
@@ -1169,11 +1405,11 @@ async def _hold(
         family = memory_scopes.recall_scopes(scope)
         in_scope, scope_params = _in_scopes(family)
         exact = await self.store.fetchone(
-            f"SELECT id FROM facts WHERE content = ? COLLATE NOCASE AND {in_scope}", (fact, *scope_params)
+            f"SELECT id FROM facts WHERE content = ? COLLATE NOCASE AND {LIVE} AND {in_scope}", (fact, *scope_params)
         )
         if exact:
             return {"action": "SKIP", "id": int(exact["id"]), "content": fact}
-        neighbours = await self.recall(fact, top_k=1, min_similarity=0.0, track=False, scopes=family)
+        neighbours = await self.recall(fact, top_k=1, min_similarity=0.0, track=False, scopes=family, current_only=False)
         if neighbours and self._duplicate(fact, neighbours[0]) and not self._corrects(fact, neighbours[0]):
             return {"action": "SKIP", "id": neighbours[0]["id"], "content": neighbours[0]["content"]}
         topics, memory_type, duration = await self.analyze(fact) if use_llm else ([DEFAULT_TOPIC], "long-term", None)
@@ -1193,12 +1429,15 @@ async def _remember(
         family = memory_scopes.recall_scopes(scope)
         in_scope, scope_params = _in_scopes(family)
         exact = await self.store.fetchone(
-            f"SELECT id FROM facts WHERE content = ? COLLATE NOCASE AND {ACTIVE} AND {in_scope}", (fact, *scope_params)
+            f"SELECT id FROM facts WHERE content = ? COLLATE NOCASE AND {ACTIVE} AND {LIVE} AND {in_scope}",
+            (fact, *scope_params),
         )
         if exact:
             return {"action": "SKIP", "id": int(exact["id"]), "content": fact}
         [vec] = await self._embed([fact])
-        neighbours = await self.recall(fact, top_k=5, min_similarity=0.0, track=False, scopes=family)
+        neighbours = await self.recall(
+            fact, top_k=5, min_similarity=0.0, track=False, scopes=family, current_only=False
+        )
         # "Mira starts school in July" embeds almost exactly like "... in June": a correction is never a duplicate
         dup = next((n for n in neighbours if self._duplicate(fact, n) and not self._corrects(fact, n)), None)
         if dup is not None:
@@ -1316,7 +1555,7 @@ async def _remember(
                 log.info("CUD ADD turned into UPDATE of residence fact %s for %r", peer["id"], fact)
                 action, fid = "UPDATE", peer["id"]
         if action == "DELETE":
-            await self.forget(int(fid))  # type: ignore[arg-type]
+            await self.erase(int(fid))  # type: ignore[arg-type]
             return {"action": "DELETE", "id": int(fid), "content": content}  # type: ignore[arg-type]
         if topics is None:
             topics, memory_type, duration = await self.analyze(content) if use_llm else ([DEFAULT_TOPIC], "long-term", None)
@@ -1363,6 +1602,10 @@ async def update_content(self, fid: int, content: str, *, use_llm: bool = True)
         )
         [vec] = await self._embed([content])
         await self._update(fid, content, vec, topics, memory_type, duration)
+        # the user wrote it: as sure as it gets, and current (#152)
+        await self.store.execute(
+            "UPDATE facts SET confidence = 1.0, state = 'current', superseded_by = NULL WHERE id = ?", (fid,)
+        )
         self.publish("UPDATE", fid, content)
         fact = await self.get_fact(fid)
         assert fact is not None
@@ -1483,6 +1726,7 @@ async def flush_conversation(
     async def extract_and_store(
         self, text: str, username: str, source: str = "conversation", *, notify: bool = False,
         review: dict | None = None, own: bool = False, session_id: str | None = None, scope: str | None = None,
+        ref: dict | None = None,
     ) -> list[dict]:
         """Pull atomic facts out of text and remember each (v2 cud_memory). With ``review`` they are held for review,
         each with the sentence of ``text`` it most likely came from. ``own``: ``text`` is the user's own words (a chat
@@ -1498,6 +1742,7 @@ async def extract_and_store(
                 results.append(await self.remember(
                     f, source=source, notify=notify, review=reviews.with_snippet(review, text, f),
                     own_words=text if own else None, session_id=session_id, scope=scope,
+                    ref={**ref, "quote": origins.quote(text, f) or None} if ref else None,
                 ))
             except Exception as exc:
                 log.warning("failed to store fact %r: %s", f, exc)
@@ -1516,7 +1761,9 @@ async def import_document(
         counts = {"added": 0, "updated": 0, "skipped": 0, "pending": 0}
         review = reviews.note(path.name)
         for chunk in chunk_text(text, self.config.memory.import_chunk_chars):
-            for r in await self.extract_and_store(chunk, username, source=source, review=review, scope=scope):
+            for r in await self.extract_and_store(
+                chunk, username, source=source, review=review, scope=scope, ref={"kind": "file", "file": path.name}
+            ):
                 key = {"ADD": "added", "UPDATE": "updated", "DELETE": "updated"}.get(r["action"], "skipped")
                 counts[key] += 1
                 counts["pending"] += r.get("status") == "pending"
@@ -1529,7 +1776,11 @@ async def import_document(
     # ------------------------------------------------------------------ reads
     async def get_fact(self, fid: int) -> dict | None:
         r = await self.store.fetchone(f"SELECT {MEMORY_COLUMNS} FROM facts WHERE id = ?", (fid,))
-        return _row_to_memory(r) if r else None
+        if r is None:
+            return None
+        m = _row_to_memory(r)
+        m["sources"] = (await self.source_links([fid])).get(fid, [])
+        return m
 
     async def list_facts(
         self,
@@ -1540,27 +1791,43 @@ async def list_facts(
         source: str | None = None,
         q: str | None = None,
         scope: str | None = None,
+        state: str | None = None,
     ) -> list[dict]:
-        """Active facts, newest first. ``scope`` keeps one scope only (the Memory screen's filter, #155)."""
+        """Active facts, newest first, each with its ``sources`` (#152). ``scope`` keeps one scope only (the Memory
+        screen's filter, #155). ``state``: current, disputed or superseded only; ``all``; None is current and
+        disputed (superseded ones are history). ``source`` also finds facts that source said again."""
+        out = await self._list_facts(limit, offset, topic=topic, source=source, q=q, scope=scope, state=state)
+        links = await self.source_links([m["id"] for m in out])
+        for m in out:
+            m["sources"] = links.get(m["id"], [])
+        return out
+
+    async def _list_facts(
+        self, limit: int, offset: int, *, topic: str | None, source: str | None, q: str | None, scope: str | None,
+        state: str | None,
+    ) -> list[dict]:
+        state_sql, state_params = (LIVE, []) if state is None else ("1", []) if state == "all" else ("state = ?", [state])
         if topic:
             topic = normalize_topics([topic])[0]
         one = memory_scopes.normalize(scope)
-        if q and q.strip():
+        if q and q.strip() and state not in {"superseded", "all"}:  # superseded ones have no vector: matched by words
             try:
                 hits = await self._search(
                     q, min(offset + limit, 500) * (3 if topic else 1), self.config.memory.min_similarity, source,
-                    [one] if one else None,
+                    [one] if one else None, current_only=False,
                 )
                 if topic:
                     hits = [h for h in hits if topic in h["topics"]]
+                if state not in {None, "all"}:
+                    hits = [h for h in hits if h.get("state") == state]
                 return hits[offset : offset + limit]
             except Exception as exc:
                 log.debug("semantic list search unavailable, using keyword match: %s", exc)
-        where = [ACTIVE, "(expires_at IS NULL OR expires_at > ?)"]
-        params: list[Any] = [now_iso()]
+        where = [ACTIVE, state_sql, "(expires_at IS NULL OR expires_at > ?)"]
+        params: list[Any] = [*state_params, now_iso()]
         if source:
-            where.append("source = ?")
-            params.append(source)
+            where.append("(source = ? OR id IN (SELECT fact_id FROM fact_sources WHERE source = ?))")
+            params += [source, source]
         if one:
             where.append("scope = ?")
             params.append(one)
@@ -1697,8 +1964,9 @@ async def approve(self, fid: int, content: str | None = None) -> dict | None:
                 " WHERE id = ?",
                 (text, row["content"], json.dumps(topics), memory_type, expires_for(memory_type, duration), fid),
             )
-        await self.store.execute(
-            "UPDATE facts SET status = 'active', updated_at = ?, embedding_model = ? WHERE id = ?",
+        await self.store.execute(  # the user looked at it and said yes: surer (#152)
+            "UPDATE facts SET status = 'active', updated_at = ?, embedding_model = ?, confidence = MAX(confidence, 0.9)"
+            " WHERE id = ?",
             (now_iso(), self.llm.model_for("embedding"), fid),
         )
         await self.vec.upsert(fid, vec)
@@ -1734,7 +2002,7 @@ async def reword_pending(self, fid: int, content: str, review: dict | None = Non
     async def discard(self, fid: int) -> bool:
         """The user turned a held fact down: it is deleted. False when ``fid`` is not pending."""
         row = await self.store.fetchone("SELECT content FROM facts WHERE id = ? AND status = 'pending'", (fid,))
-        if row is None or not await self.forget(fid):
+        if row is None or not await self.erase(fid):
             return False
         self.publish("DELETE", fid, row["content"], reason="discarded")
         return True
@@ -1755,7 +2023,7 @@ async def active_facts(self, limit: int = 500) -> list[dict]:
         """Unexpired facts, most recently updated first, with ``recall_count`` and ``vector`` (or None)."""
         await self.ensure_schema()
         rows = await self.store.fetchall(
-            f"SELECT {MEMORY_COLUMNS}, recall_count FROM facts WHERE {ACTIVE}"
+            f"SELECT {MEMORY_COLUMNS}, recall_count FROM facts WHERE {IN_USE}"
             " AND (expires_at IS NULL OR expires_at > ?) ORDER BY updated_at DESC, id DESC LIMIT ?",
             (now_iso(), limit),
         )
@@ -1821,15 +2089,22 @@ async def merge_facts(self, keep_id: int, content: str, drop_ids: list[int]) ->
         return await self.get_fact(keep_id)
 
     async def supersede(self, keep_id: int, drop_id: int) -> bool:
-        """Latest wins: delete ``drop_id`` and record its text as ``previous_content`` of ``keep_id``."""
+        """Latest wins: ``drop_id`` is superseded by ``keep_id`` (#152). It stays as history, out of recall and every
+        prompt, and its text is also kept as ``previous_content`` of ``keep_id``."""
         drop = await self.store.fetchone("SELECT content FROM facts WHERE id = ?", (drop_id,))
         keep = await self.store.fetchone("SELECT id FROM facts WHERE id = ?", (keep_id,))
         if drop is None or keep is None:
             return False
+        ts = now_iso()
+        await self.store.execute(
+            "UPDATE facts SET previous_content = ?, updated_at = ? WHERE id = ?", (drop["content"], ts, keep_id)
+        )
         await self.store.execute(
-            "UPDATE facts SET previous_content = ?, updated_at = ? WHERE id = ?", (drop["content"], now_iso(), keep_id)
+            "UPDATE facts SET state = 'superseded', superseded_by = ?, updated_at = ? WHERE id = ?",
+            (keep_id, ts, drop_id),
         )
-        await self.forget(drop_id)
+        await self.vec.delete(drop_id)
+        await self._out_of_prompts([drop["content"]])
         self.publish("DELETE", drop_id, drop["content"], reason="contradicted", superseded_by=keep_id)
         return True
 
diff --git a/sentient/memory/origins.py b/sentient/memory/origins.py
index e4be5622..dbb02e7c 100644
--- a/sentient/memory/origins.py
+++ b/sentient/memory/origins.py
@@ -93,10 +93,13 @@ def _folder_of(item: dict, folders: list[tuple[str, str, str]]) -> str | None:
     return same[0][0] if len(same) == 1 else None
 
 
-def from_answer_sources(items: list, folders: list[tuple[str, str, str]]) -> list[tuple[str, str]]:
+Read = tuple[str, str, dict]  # (source, what was read: title and excerpt, the answer source item)
+
+
+def from_answer_sources(items: list, folders: list[tuple[str, str, str]]) -> list[Read]:
     """The disconnectable sources among one reply's answer sources (``AnswerSources.items()``), each with what was
-    read from it (title and excerpt)."""
-    out: list[tuple[str, str]] = []
+    read from it (title and excerpt) and the item itself."""
+    out: list[Read] = []
     for item in items if isinstance(items, list) else []:
         if not isinstance(item, dict):
             continue
@@ -108,11 +111,11 @@ def from_answer_sources(items: list, folders: list[tuple[str, str, str]]) -> lis
         elif kind in {"email", "app"} and app and app not in NOT_APPS:
             found = f"app:{app}"
         if found:
-            out.append((found, f"{item.get('title') or ''} {item.get('snippet') or ''}"))
+            out.append((found, f"{item.get('title') or ''} {item.get('snippet') or ''}", item))
     return out
 
 
-async def of_session(store: Any, session_id: str | None) -> tuple[str, list[tuple[str, str]]]:
+async def of_session(store: Any, session_id: str | None) -> tuple[str, list[Read]]:
     """``(the chat's own source, what it read)`` for chat ``session_id``: its app (desktop, messaging app or device),
     and every app and folder its replies read, each ``(source, excerpt)`` in order."""
     if not session_id:
@@ -134,7 +137,7 @@ async def of_session(store: Any, session_id: str | None) -> tuple[str, list[tupl
         " ORDER BY created_at",
         (session_id,),
     )
-    read: list[tuple[str, str]] = []
+    read: list[Read] = []
     if rows:
         folders = await _folders(store)
         for r in rows:
@@ -146,13 +149,104 @@ async def of_session(store: Any, session_id: str | None) -> tuple[str, list[tupl
     return first, read
 
 
-def sources_for(fact: str, first: str, read: list[tuple[str, str]], *, held: bool, user_name: str = "") -> list[str]:
+def sources_for(fact: str, first: str, read: list[Read], *, held: bool, user_name: str = "") -> list[str]:
     """The sources of ``fact`` learned in a chat (:func:`of_session`), its own first. Held for review because the chat
     read outside content: what it read that says it (else everything it read). Otherwise the chat's, plus every
     folder whose notes say it."""
-    said = list(dict.fromkeys(k for k, text in read if backs(fact, text, user_name)))
+    said = list(dict.fromkeys(r[0] for r in read if backs(fact, r[1], user_name)))
     if held:
-        chosen = said or list(dict.fromkeys(k for k, _ in read))
+        chosen = said or list(dict.fromkeys(r[0] for r in read))
         if chosen:
             return chosen
     return [first, *(k for k in said if k.startswith("folder:") and k != first)]
+
+
+# ---------------------------------------------------------------------- spans and confidence (#152)
+QUOTE_CHARS = 200
+_SENTENCE = re.compile(r"(?<=[.!?])\s+|\n+")
+_ABBREVIATION = re.compile(r"(?:\b(?:Dr|Mr|Mrs|Ms|Prof|St|Jr|Sr|vs|etc|No|e\.g|i\.e)|\b[A-Z])\.$")
+
+
+def quote(text: str, fact: str) -> str:
+    """The sentence of ``text`` that says most of ``fact`` (its start when none does), short."""
+    parts: list[str] = []
+    for p in (p.strip() for p in _SENTENCE.split(str(text or ""))):
+        if p and parts and _ABBREVIATION.search(parts[-1]):  # "Dr. Mehta" is one sentence
+            parts[-1] = f"{parts[-1]} {p}"
+        elif p:
+            parts.append(p)
+    if not parts:
+        return ""
+    want = _words(fact)
+    best = max(parts, key=lambda p: len(want & _words(p)))
+    best = " ".join(best.split())
+    return best if len(best) <= QUOTE_CHARS else best[: QUOTE_CHARS - 1].rstrip() + "…"
+
+
+def says(fact: str, text: str, user_name: str = "") -> bool:
+    """Whether ``text`` repeats ``fact``: most of its words (three in five, at least two), besides the user's own
+    name. Stricter than :func:`backs`: it decides what is scrubbed when a memory is deleted."""
+    want = _words(fact) - _words(user_name)
+    if len(want) < 2:
+        return False
+    have = _words(text)
+    return len(want & have) >= max(2, -(-len(want) * 3 // 5))
+
+
+def confidence(source: str, *, held: bool = False) -> float:
+    """How sure Sentient is of a fact when it is first learned, from where it came: the user's own words most, what
+    it read in an app least."""
+    if held:
+        return 0.6
+    kind, _ = split(source)
+    if source in {"manual", "user"}:
+        return 1.0
+    if is_chat(source) or source == "onboarding":
+        return 0.9
+    if kind == "folder":
+        return 0.8
+    if kind == "app":
+        return 0.6
+    return 0.7  # files, imports, tasks, the user model
+
+
+def _item_ref(item: dict, session_id: str, fact: str, folder_id: str | None = None) -> dict:
+    keep = {k: item.get(k) for k in ("kind", "title", "url", "id", "app", "path") if item.get(k)}
+    if keep.get("kind") == "file":
+        keep["kind"] = "note"
+    if folder_id:
+        keep["folder_id"] = folder_id
+    text = f"{item.get('snippet') or ''}"
+    return {**keep, "session_id": session_id, "quote": quote(text, fact) or None}
+
+
+async def spans(
+    store: Any, fact: str, sources: list[str], session_id: str, read: list[Read], user_name: str = ""
+) -> dict[str, dict]:
+    """Exactly where each of ``sources`` said ``fact`` in chat ``session_id``: the user's message for the chat
+    itself (the newest of its last 40 that says it, else just the chat), the email, app result or note for what the
+    chat read. ``{source: ref}``; a source with nothing to point at is left out."""
+    out: dict[str, dict] = {}
+    for src in sources:
+        if is_chat(src):
+            rows = await store.fetchall(
+                "SELECT id, content FROM messages WHERE session_id = ? AND role = 'user'"
+                " ORDER BY created_at DESC, rowid DESC LIMIT 40",
+                (session_id,),
+            )
+            if not rows:
+                continue
+            best = next((r for r in rows if backs(fact, r["content"] or "", user_name)), None)
+            if best is None:  # no message says it (a summary of several, a rewording): the chat itself
+                out[src] = {"kind": "message", "session_id": session_id}
+            else:
+                out[src] = {"kind": "message", "session_id": session_id, "message_id": best["id"],
+                            "quote": quote(best["content"] or "", fact) or None}
+            continue
+        items = [r for r in read if r[0] == src]
+        if not items:
+            continue
+        item = next((r for r in reversed(items) if backs(fact, r[1], user_name)), items[-1])
+        kind, ident = split(src)
+        out[src] = _item_ref(item[2], session_id, fact, ident if kind == "folder" else None)
+    return out
diff --git a/sentient/memory/schema.sql b/sentient/memory/schema.sql
index 02f90bef..f4c50aa3 100644
--- a/sentient/memory/schema.sql
+++ b/sentient/memory/schema.sql
@@ -74,6 +74,7 @@ CREATE TABLE IF NOT EXISTS fact_sources (
     source     TEXT NOT NULL,
     linked_at  TEXT NOT NULL,
     merged_from INTEGER,                  -- the fact whose merge brought this link (#353): undoing that merge removes it
+    ref        TEXT,                      -- JSON: exactly where this source said it (#152), as facts.source_ref
     PRIMARY KEY (fact_id, source)
 );
 CREATE INDEX IF NOT EXISTS idx_fact_sources_source ON fact_sources(source);
diff --git a/sentient/memory/usermodel.py b/sentient/memory/usermodel.py
index 13883df6..f3731056 100644
--- a/sentient/memory/usermodel.py
+++ b/sentient/memory/usermodel.py
@@ -637,7 +637,7 @@ async def _gather(
             mark = marks.get("facts")
             after, params = after_watermark(mark, "updated_at", "id")
             rows = await store.fetchall(
-                f"SELECT id, content, updated_at FROM facts WHERE status = 'active' AND {after}"
+                f"SELECT id, content, updated_at FROM facts WHERE status = 'active' AND state = 'current' AND {after}"
                 " AND (expires_at IS NULL OR expires_at > ?) ORDER BY updated_at DESC, id DESC LIMIT ?",
                 (*params, now_iso(), cfg.recent_facts),
             )
diff --git a/sentient/memory/workspace.py b/sentient/memory/workspace.py
index 2b27f1a7..a4a440d5 100644
--- a/sentient/memory/workspace.py
+++ b/sentient/memory/workspace.py
@@ -171,6 +171,24 @@ def remove_learned(self, facts: list[str], heading: str = "## Learned") -> int:
             self.user.write_text("\n".join(out) + "\n", encoding="utf-8")
         return removed
 
+    def scrub(self, facts: list[str], user_name: str = "") -> int:
+        """A memory was deleted (#152): its bullet goes from USER.md's Learned section, and every bullet of MEMORY.md
+        (written from memories by the nightly upkeep) that repeats it (``origins.says``). The user's own text in
+        USER.md is never touched. Returns how many lines went."""
+        from sentient.memory import origins
+
+        removed = self.remove_learned(facts)
+        if not facts or not self.memory.exists():
+            return removed
+        lines = self.memory.read_text(encoding="utf-8", errors="replace").splitlines()
+        kept = [
+            line for line in lines
+            if not (line.lstrip().startswith(("- ", "* ")) and any(origins.says(f, line, user_name) for f in facts))
+        ]
+        if len(kept) != len(lines):
+            self.memory.write_text("\n".join(kept) + "\n", encoding="utf-8")
+        return removed + len(lines) - len(kept)
+
     def append_note(self, text: str, day: date | None = None) -> Path:
         day = day or date.today()
         p = self.note(day)
diff --git a/sentient/store/migrations/0015_fact_links.py b/sentient/store/migrations/0015_fact_links.py
new file mode 100644
index 00000000..f1afedbf
--- /dev/null
+++ b/sentient/store/migrations/0015_fact_links.py
@@ -0,0 +1,128 @@
+"""Source links, confidence and state for memories (#152).
+
+Adds where exactly a fact came from (``facts.source_ref``, ``fact_sources.ref``), how sure Sentient is of it
+(``confidence``) and whether it is still current (``state``, ``superseded_by``). Existing facts get a confidence from
+their source.
+
+It also gives facts saved before #153 from a messaging app or a device chat their real source. Those say
+``conversation``; the chat they came from is found in what is kept: the review note of a memory held for review, the
+``memory_remember`` call that saved it, or else the one user message in a messaging-app or device chat that says the
+same thing and came shortly before it. A fact no chat explains keeps ``conversation``.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timedelta
+from typing import Any
+
+CHANNELS = ("discord", "telegram", "whatsapp")  # sentient.memory.origins.CHANNELS (imported late: no import cycle)
+WINDOW = timedelta(minutes=30)  # extraction runs in the background, a little after the message it reads
+CONFIDENCE = (  # sentient.memory.origins.confidence, in the same order
+    "CASE WHEN status = 'pending' THEN 0.6"
+    " WHEN source IN ('manual', 'user') THEN 1.0"
+    " WHEN source IN ('conversation', 'onboarding') OR source LIKE 'channel:%' OR source LIKE 'device:%' THEN 0.9"
+    " WHEN source LIKE 'folder:%' THEN 0.8"
+    " WHEN source LIKE 'app:%' THEN 0.6"
+    " ELSE 0.7 END"
+)
+
+
+def _when(value: Any) -> datetime | None:
+    try:
+        return datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+    except (TypeError, ValueError):
+        return None
+
+
+def _source_of(row: Any) -> str | None:
+    channel = str(row["channel"] or "")
+    if channel in CHANNELS:
+        return f"channel:{channel}"
+    node = str(row["node_id"] or "") if "node_id" in row.keys() else ""  # noqa: SIM118 - sqlite Row
+    return f"device:{node}" if node else None
+
+
+async def _session(store: Any, sid: str) -> Any:
+    return await store.fetchone("SELECT * FROM sessions WHERE id = ?", (sid,))
+
+
+async def _saved_by_tool(store: Any) -> dict[int, tuple[str, str]]:
+    """fact id -> (session id, message id) for facts a chat's ``memory_remember`` call saved."""
+    out: dict[int, tuple[str, str]] = {}
+    rows = await store.fetchall(
+        "SELECT id, session_id, content FROM messages WHERE role = 'tool' AND name = 'memory_remember'"
+    )
+    for r in rows:
+        try:
+            res = json.loads(r["content"] or "{}")
+        except ValueError:
+            continue
+        if isinstance(res, dict) and isinstance(res.get("id"), int) and res.get("action") in {"ADD", "UPDATE"}:
+            out.setdefault(int(res["id"]), (str(r["session_id"]), ""))
+    return out
+
+
+async def _backfill(store: Any) -> None:
+    from sentient.memory import origins
+
+    facts = await store.fetchall(
+        "SELECT id, content, created_at, review FROM facts WHERE source = 'conversation' AND status IN ('active',"
+        " 'pending', 'merged')"
+    )
+    if not facts:
+        return
+    by_tool = await _saved_by_tool(store)
+    marks = ",".join("?" * len(CHANNELS))
+    said = await store.fetchall(
+        "SELECT m.id, m.session_id, m.content, m.created_at, s.channel, s.node_id FROM messages m"
+        " JOIN sessions s ON s.id = m.session_id WHERE m.role = 'user'"
+        f" AND (s.channel IN ({marks}) OR (s.node_id IS NOT NULL AND s.node_id != ''))",
+        CHANNELS,
+    )
+    for f in facts:
+        source = ref = None
+        sid = None
+        try:
+            review = json.loads(f["review"]) if f["review"] else None
+        except ValueError:
+            review = None
+        if isinstance(review, dict) and review.get("session_id"):
+            sid = str(review["session_id"])
+        elif int(f["id"]) in by_tool:
+            sid = by_tool[int(f["id"])][0]
+        if sid:
+            row = await _session(store, sid)
+            source = _source_of(row) if row is not None else None
+            if source:
+                ref = {"kind": "message", "session_id": sid}
+        else:
+            at = _when(f["created_at"])
+            near = [
+                m for m in said
+                if at is not None and (t := _when(m["created_at"])) is not None and t <= at <= t + WINDOW
+                and origins.backs(f["content"], m["content"] or "")
+            ]
+            if len({m["session_id"] for m in near}) == 1:  # one chat says it: that's where it came from
+                m = max(near, key=lambda m: m["created_at"])
+                source = _source_of(m)
+                ref = {"kind": "message", "session_id": m["session_id"], "message_id": m["id"]}
+        if source:
+            await store.execute(
+                "UPDATE facts SET source = ?, source_ref = COALESCE(source_ref, ?) WHERE id = ?",
+                (source, json.dumps(ref) if ref else None, f["id"]),
+            )
+
+
+async def migrate(store: Any) -> None:
+    await store.ensure_column("facts", "confidence", "REAL NOT NULL DEFAULT 0.8")
+    await store.ensure_column("facts", "state", "TEXT NOT NULL DEFAULT 'current'")
+    await store.ensure_column("facts", "superseded_by", "INTEGER")
+    await store.ensure_column("facts", "source_ref", "TEXT")
+    await store.ensure_column("fact_sources", "ref", "TEXT")
+    cols = await store.columns("facts")
+    if "confidence" not in cols:  # no facts table (a very old database): the schema files make it
+        return
+    if await store.columns("sessions") and await store.columns("messages"):
+        await _backfill(store)
+    await store.execute(f"UPDATE facts SET confidence = {CONFIDENCE} WHERE confidence = 0.8")
diff --git a/sentient/store/schema.sql b/sentient/store/schema.sql
index a9b9082f..d3512992 100644
--- a/sentient/store/schema.sql
+++ b/sentient/store/schema.sql
@@ -99,7 +99,11 @@ CREATE TABLE IF NOT EXISTS facts (
     last_recalled_at TEXT,
     merged_into     INTEGER,                                -- the memory the nightly tidy-up merged this one into (#353)
     merged_at       TEXT,                                   -- kept for undo
-    merged_by       TEXT
+    merged_by       TEXT,
+    source_ref      TEXT,                                   -- JSON: exactly where its source said it (#152)
+    confidence      REAL NOT NULL DEFAULT 0.8,              -- 0..1: how sure Sentient is of it (#152)
+    state           TEXT NOT NULL DEFAULT 'current',        -- current | disputed | superseded: only current in prompts
+    superseded_by   INTEGER                                 -- the memory that replaced it (#152)
 );
 CREATE INDEX IF NOT EXISTS idx_facts_scope ON facts(scope, status);
 CREATE INDEX IF NOT EXISTS idx_facts_expires ON facts(expires_at) WHERE expires_at IS NOT NULL;
diff --git a/sentient/tools/builtin/memory_tool.py b/sentient/tools/builtin/memory_tool.py
index c4b224fb..b3e54cf2 100644
--- a/sentient/tools/builtin/memory_tool.py
+++ b/sentient/tools/builtin/memory_tool.py
@@ -171,7 +171,7 @@ async def memory_forget(ctx: ToolContext, fact_id: int) -> dict:
     """Permanently delete a remembered fact by id (from memory_recall). Use when the user asks you to forget something."""
     if ctx.memory is None:
         return {"error": "memory unavailable"}
-    ok = await ctx.memory.forget(fact_id, notify=True)
+    ok = await ctx.memory.erase(fact_id, notify=True)
     return {"deleted": ok, "id": fact_id}
 
 
diff --git a/tests/memory/test_dreaming.py b/tests/memory/test_dreaming.py
index 49dcf066..2719557b 100644
--- a/tests/memory/test_dreaming.py
+++ b/tests/memory/test_dreaming.py
@@ -43,6 +43,14 @@ def test_subjects_and_families():
 ]
 
 
+async def superseded(mem, fid: int, *, by: int) -> bool:
+    """A contradiction's loser stays as history (#152): superseded by the winner, and recall never finds it."""
+    old, new = await mem.get_fact(fid), await mem.get_fact(by)
+    hits = await mem.recall(old["content"], top_k=10, min_similarity=0.0, track=False)
+    return (old["state"] == "superseded" and old["superseded_by"] == by and new["state"] == "current"
+            and fid not in [h["id"] for h in hits])
+
+
 @pytest.mark.parametrize(("old_text", "new_text"), EXAMPLES)
 async def test_contradictions_found_without_shared_wording(app, old_text, new_text):
     mem, llm = app.memory, app.fake
@@ -54,7 +62,7 @@ async def test_contradictions_found_without_shared_wording(app, old_text, new_te
     llm.json_replies.append({"conflict": True, "current": "B", "change": "it changed"})
     dream = await app.dreaming.run()
     assert dream["stats"]["contradictions_resolved"] == 1
-    assert await mem.get_fact(old) is None and await mem.get_fact(new) is not None
+    assert await superseded(mem, old, by=new)  # kept as history, out of every prompt (#152)
     assert _json_calls(llm) == 1
     prompt = llm.calls[-1]["messages"][1]["content"]
     assert prompt.index(old_text) < prompt.index(new_text)  # A is the older memory
@@ -67,13 +75,13 @@ async def test_older_fact_wins_only_with_explicit_recent_wording(app):
     stale = await add_fact(mem, "Maya lives in Bengaluru")  # e.g. re-imported from an old document
     llm.json_replies.append({"conflict": True, "current": "A"})
     await app.dreaming.run()
-    assert await mem.get_fact(stale) is None and await mem.get_fact(older) is not None
+    assert await superseded(mem, stale, by=older)
 
     a = await add_fact(mem, "Riya works at Infosys", updated_at="2025-01-01T00:00:00+00:00")
     b = await add_fact(mem, "Riya works at Google now")
     llm.json_replies.append({"conflict": True, "current": "A"})  # no recent wording on A: newer still wins
     await app.dreaming.run()
-    assert await mem.get_fact(a) is None and await mem.get_fact(b) is not None
+    assert await superseded(mem, a, by=b)
 
 
 async def test_pure_duplicates_merge_without_model(app):
@@ -132,7 +140,7 @@ async def test_contradiction_latest_wins_after_model_confirms(app):
         dream = await app.dreaming.run()
         events = drain(q)
     assert dream["stats"]["contradictions_resolved"] == 1
-    assert await mem.get_fact(old) is None
+    assert await superseded(mem, old, by=new)
     assert (await mem.get_fact(new))["previous_content"] == "Maya lives in Pune"
     assert 'I used to remember "Maya lives in Pune", but now "Maya lives in Mumbai"' in dream["journal_md"]
     assert "moved from Pune to Mumbai" in dream["journal_md"]
diff --git a/tests/memory/test_source_links.py b/tests/memory/test_source_links.py
new file mode 100644
index 00000000..66dc5730
--- /dev/null
+++ b/tests/memory/test_source_links.py
@@ -0,0 +1,316 @@
+"""Source links, confidence and state, and deletes that cascade (#152).
+
+Each fact points at exactly where it was said (a chat message, an email, a note, a file), knows how sure Sentient is of
+it, and is current, disputed or superseded. Only current facts go into prompts. Deleting a fact takes everything derived
+from it with it.
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+from sentient import paths
+from sentient.app import SentientApp
+from sentient.gateway.app import create_app
+from sentient.memory import review as reviews
+from sentient.store.db import SCHEMA_VERSION, now_iso
+from tests.conftest import FakeProvider
+
+NOTE = "My dentist is Dr. Mehta at Smile Care in Pune. Next checkup in March."
+
+
+async def _folder(app, tmp_path: Path) -> Path:
+    root = tmp_path / "Notes"
+    root.mkdir(exist_ok=True)
+    await app.store.execute(
+        "INSERT INTO folders(id, path, name, added_at) VALUES('fold1', ?, 'Notes', ?)", (str(root), now_iso())
+    )
+    return root
+
+
+async def _ids(app, sql: str, params: tuple = ()) -> list:
+    return [r[0] for r in await app.store.fetchall(sql, params)]
+
+
+# ---------------------------------------------------------------- spans
+async def test_a_chat_fact_points_at_the_message_that_said_it(app, tmp_path):
+    mem, store = app.memory, app.store
+    root = await _folder(app, tmp_path)
+    tg = await store.create_session(channel="telegram")
+    said = await store.add_message(tg, "user", "Hi! I'm allergic to peanuts, by the way.")
+    await store.add_message(tg, "assistant", "Noted.")
+    await store.add_message(tg, "user", "Also, what does my health note say about my dentist?")
+    await store.add_message(tg, "assistant", "Dr. Mehta at Smile Care.", sources=[
+        {"kind": "file", "title": "health", "path": str(root / "health.md"), "folder": "Notes", "app": "folders",
+         "tool": "folder_search", "snippet": NOTE},
+    ])
+    await store.add_message(tg, "user", "Right, my dentist is Dr. Mehta in Pune.")
+    allergy = await mem.remember("Maya is allergic to peanuts", use_llm=False, session_id=tg)
+    fact = await mem.get_fact(allergy["id"])
+    assert fact["ref"] == {"kind": "message", "session_id": tg, "message_id": said,
+                           "quote": "I'm allergic to peanuts, by the way."}
+    dentist = await mem.get_fact((await mem.remember("Maya's dentist is Dr. Mehta in Pune", use_llm=False,
+                                                     session_id=tg))["id"])
+    assert [s["source"] for s in dentist["sources"]] == ["channel:telegram", "folder:fold1"]
+    note = dentist["sources"][1]["ref"]
+    assert note["kind"] == "note" and note["folder_id"] == "fold1" and note["path"].endswith("health.md")
+    assert note["quote"] == "My dentist is Dr. Mehta at Smile Care in Pune."
+
+
+async def test_a_held_fact_points_at_the_email(app):
+    mem, store = app.memory, app.store
+    desk = await store.create_session(channel="desktop")
+    await store.add_message(desk, "assistant", "Your inbox", sources=[
+        {"kind": "email", "title": "Flight update", "from": "air@example.com", "id": "m-42", "app": "gmail",
+         "tool": "gmail_search", "url": "https://mail.example.com/m-42",
+         "snippet": "Your flight to Lisbon lands at 9:40. Seat 14C."},
+    ])
+    held = await mem.remember("Maya's flight to Lisbon lands at 9:40", use_llm=False, session_id=desk,
+                              review=reviews.note("Gmail", session_id=desk))
+    fact = await mem.get_fact(held["id"])
+    assert fact["source"] == "app:gmail" and fact["confidence"] == 0.6
+    assert fact["ref"]["kind"] == "email" and fact["ref"]["id"] == "m-42"
+    assert fact["ref"]["url"] == "https://mail.example.com/m-42" and fact["ref"]["quote"] == "Your flight to Lisbon lands at 9:40."
+
+
+async def test_an_imported_file_fact_points_at_the_file(app, tmp_path):
+    mem, llm = app.memory, app.fake
+    path = tmp_path / "cv.txt"
+    path.write_text("I studied design at NID. I like hiking.", encoding="utf-8")
+    llm.json_replies.append({"facts": ["Maya studied design at NID"]})
+    await mem.import_document(path, username="Maya")
+    row = await app.store.fetchone("SELECT source, source_ref FROM facts")
+    assert row["source"] == "file:cv.txt"
+    assert json.loads(row["source_ref"]) == {"kind": "file", "file": "cv.txt", "quote": "I studied design at NID."}
+
+
+# ---------------------------------------------------------------- confidence
+async def test_confidence_comes_from_the_source_and_grows_when_learned_again(app):
+    mem, store = app.memory, app.store
+    tg = await store.create_session(channel="telegram")
+    await store.add_message(tg, "user", "I run 5 km every Sunday")
+    told = await mem.remember("Maya runs 5 km every Sunday", use_llm=False, session_id=tg)
+    assert (await mem.get_fact(told["id"]))["confidence"] == 0.9
+    manual = await mem.remember("Maya's cat is called Biscuit", source="manual", use_llm=False)
+    assert (await mem.get_fact(manual["id"]))["confidence"] == 1.0
+    # said again in another chat: one more source, a little surer
+    desk = await store.create_session(channel="desktop")
+    await store.add_message(desk, "user", "I run 5 km every Sunday")
+    again = await mem.remember("Maya runs 5 km every Sunday", use_llm=False, session_id=desk)
+    assert again["action"] == "SKIP"
+    fact = await mem.get_fact(told["id"])
+    assert fact["confidence"] == 1.0 and [s["source"] for s in fact["sources"]] == ["channel:telegram", "conversation"]
+    assert fact["sources"][1]["ref"]["session_id"] == desk
+    # the same source again adds nothing
+    await mem.remember("Maya runs 5 km every Sunday", use_llm=False, session_id=desk)
+    assert len((await mem.get_fact(told["id"]))["sources"]) == 2
+
+
+# ---------------------------------------------------------------- state
+async def test_disputed_and_superseded_memories_stay_out_of_prompts(app):
+    mem = app.memory
+    pune = await mem.remember("Maya lives in Pune", source="manual", use_llm=False)
+    chai = await mem.remember("Maya drinks masala chai every morning", source="manual", use_llm=False)
+    assert pune["id"] in [h["id"] for h in await mem.recall("Where does Maya live?", min_similarity=0.0)]
+    disputed = await mem.set_state(pune["id"], "disputed")
+    assert disputed["state"] == "disputed"
+    assert pune["id"] not in [h["id"] for h in await mem.recall("Where does Maya live?", min_similarity=0.0)]
+    tool = app.registry.get("memory_recall")
+    ctx = app.agent.tool_context(None, "desktop")
+    assert pune["id"] not in [r["id"] for r in await tool.call(ctx, {"query": "Where does Maya live?"})]
+    # still on the Memory screen
+    assert pune["id"] in [m["id"] for m in await mem.list_facts()]
+    # the user says it's right after all
+    back = await mem.set_state(pune["id"], "current")
+    assert back["state"] == "current" and back["confidence"] == 1.0
+    # superseded by a newer one: history, never recalled, not listed unless asked for
+    assert await mem.supersede(chai["id"], pune["id"])
+    assert pune["id"] not in [h["id"] for h in await mem.recall("Where does Maya live?", min_similarity=0.0)]
+    assert pune["id"] not in [m["id"] for m in await mem.list_facts()]
+    assert pune["id"] in [m["id"] for m in await mem.list_facts(state="superseded")]
+    with pytest.raises(ValueError):
+        await mem.set_state(chai["id"], "superseded")
+
+
+async def test_saying_a_disputed_memory_again_makes_it_current(app):
+    mem, store = app.memory, app.store
+    fid = (await mem.remember("Maya lives in Pune", source="manual", use_llm=False))["id"]
+    await mem.set_state(fid, "disputed")
+    desk = await store.create_session(channel="desktop")
+    await store.add_message(desk, "user", "I live in Pune")
+    again = await mem.remember("Maya lives in Pune", use_llm=False, session_id=desk)
+    assert again["id"] == fid and (await mem.get_fact(fid))["state"] == "current"
+
+
+async def test_a_memory_out_of_prompts_also_leaves_the_workspace_files(app):
+    mem, ws = app.memory, app.workspace
+    pune = (await mem.remember("Maya lives in Pune", source="manual", use_llm=False))["id"]
+    tea = (await mem.remember("Maya drinks masala chai every morning", source="manual", use_llm=False))["id"]
+    ws.append_learned(["Maya lives in Pune", "Maya drinks masala chai every morning"])
+    await mem.set_state(pune, "disputed")
+    assert "Pune" not in ws.user.read_text(encoding="utf-8") and "chai" in ws.user.read_text(encoding="utf-8")
+    await mem.supersede(pune, tea)
+    assert "chai" not in ws.user.read_text(encoding="utf-8")
+    # history is found by its words
+    hits = await mem.list_facts(q="chai", state="all")
+    assert [h["id"] for h in hits] == [tea] and hits[0]["state"] == "superseded"
+
+
+async def test_no_message_saying_it_points_at_the_chat_only(app):
+    mem, store = app.memory, app.store
+    tg = await store.create_session(channel="telegram")
+    await store.add_message(tg, "user", "ok see you tomorrow")
+    fid = (await mem.remember("Maya's sister Riya lives in Lisbon", use_llm=False, session_id=tg))["id"]
+    assert (await mem.get_fact(fid))["ref"] == {"kind": "message", "session_id": tg}
+
+
+# ---------------------------------------------------------------- correct, then delete
+async def test_correct_then_delete_leaves_nothing_derived(app):
+    mem, store, ws = app.memory, app.store, app.workspace
+    tg = await store.create_session(channel="telegram")
+    said = await store.add_message(tg, "user", "Btw my sister Riya lives in Lisbon now")
+    reply = await store.add_message(tg, "assistant", "Lovely!", memory_sources=[])
+    other = await store.add_message(tg, "user", "Also I'm learning the veena on weekends")
+    fid = (await mem.remember("Maya's sister Riya lives in Lisbon", use_llm=False, session_id=tg))["id"]
+    keep = (await mem.remember("Maya is learning the veena on weekends", use_llm=False, session_id=tg))["id"]
+    assert (await mem.get_fact(fid))["ref"]["message_id"] == said
+    # the user corrects it
+    await mem.update_content(fid, "Maya's sister Riya lives in Porto", use_llm=False)
+    fact = await mem.get_fact(fid)
+    assert fact["previous_content"] == "Maya's sister Riya lives in Lisbon" and fact["confidence"] == 1.0
+    # what was derived from it meanwhile
+    await store.execute("UPDATE messages SET memory_sources = ? WHERE id = ?", (json.dumps([
+        {"kind": "fact", "id": fid, "text": "Maya's sister Riya lives in Porto", "source": "channel:telegram", "via": "prompt"},
+        {"kind": "fact", "id": keep, "text": "Maya is learning the veena on weekends", "source": "channel:telegram", "via": "prompt"},
+    ]), reply))
+    msgs = await store.recent_messages(tg, 10)
+    gone_summary = await mem.episodic.add_summary(tg, "Maya said her sister Riya lives in Lisbon now.", msgs[:2])
+    kept_summary = await mem.episodic.add_summary(tg, "Maya is learning the veena.", [m for m in msgs if m["id"] == other])
+    users = app.user_model
+    only = await users._insert("Maya's family lives abroad", "relationships", confidence=0.6, status="active",
+                               source="inferred", evidence=[{"kind": "fact", "ref": str(fid), "quote": "x"}])
+    mixed = await users._insert("Maya keeps in touch with family", "relationships", confidence=0.6, status="active",
+                                source="inferred", evidence=[{"kind": "fact", "ref": str(fid), "quote": "x"},
+                                                             {"kind": "fact", "ref": str(keep), "quote": "y"}])
+    await store.execute(
+        "INSERT INTO dreams(id, started_at, status, trigger, stats, journal_md) VALUES('d1', ?, 'completed', 'manual',"
+        " '{}', ?)",
+        (now_iso(), "Tonight I tidied up.\n- I used to remember \"Maya's sister Riya lives in Lisbon\", but now "
+                    "\"Maya's sister Riya lives in Porto\"\n- Maya is learning the veena"),
+    )
+    ws.append_learned(["Maya's sister Riya lives in Porto", "Maya is learning the veena on weekends"])
+    ws.memory.write_text("# Memory\n- Riya, Maya's sister, lives in Porto\n- Maya plays the veena\n", encoding="utf-8")
+
+    # the user deletes it
+    assert await mem.erase(fid, notify=True)
+
+    assert await mem.get_fact(fid) is None
+    assert fid not in await _ids(app, "SELECT rowid FROM facts_vec")
+    assert await _ids(app, "SELECT fact_id FROM fact_sources WHERE fact_id = ?", (fid,)) == []
+    for word in ("Porto", "Lisbon"):
+        assert await _ids(app, "SELECT rowid FROM facts_fts WHERE facts_fts MATCH ?", (word,)) == []
+    summaries = await _ids(app, "SELECT id FROM summaries")
+    assert gone_summary["id"] not in summaries and kept_summary["id"] in summaries
+    assert len(await _ids(app, "SELECT rowid FROM summaries_vec")) == 1
+    journal = (await store.fetchone("SELECT journal_md FROM dreams WHERE id = 'd1'"))["journal_md"]
+    assert "Riya" not in journal and "veena" in journal and "(a memory you deleted)" in journal
+    insights = {r["id"]: json.loads(r["evidence"]) for r in await store.fetchall("SELECT id, evidence FROM user_insights")}
+    assert only["id"] not in insights and [e["ref"] for e in insights[mixed["id"]]] == [str(keep)]
+    chips = json.loads((await store.fetchone("SELECT memory_sources FROM messages WHERE id = ?", (reply,)))["memory_sources"])
+    assert [c["id"] for c in chips] == [keep]
+    assert "Porto" not in ws.user.read_text(encoding="utf-8") and "veena" in ws.user.read_text(encoding="utf-8")
+    assert "Porto" not in ws.memory.read_text(encoding="utf-8") and "veena" in ws.memory.read_text(encoding="utf-8")
+    # the chat itself is the user's own record and stays
+    assert said in await _ids(app, "SELECT id FROM messages")
+
+
+# ---------------------------------------------------------------- the one-off backfill (#153 left them as chats)
+async def test_older_messaging_app_and_device_facts_get_their_source(config, isolated_home):
+    app = SentientApp(config, llm=FakeProvider(), enable_background=False)
+    await app.start()
+    store = app.store
+    tg = await store.create_session(channel="telegram")
+    await store.add_message(tg, "user", "I'm allergic to peanuts")
+    dev = await store.create_session(channel="glasses", node_id="node-1")
+    await store.execute(
+        "INSERT INTO messages(id, session_id, role, content, name, created_at) VALUES('t1', ?, 'tool', ?,"
+        " 'memory_remember', ?)",
+        (dev, json.dumps({"action": "ADD", "id": 2, "content": "Maya parks on level 3"}), now_iso()),
+    )
+    desk = await store.create_session(channel="desktop")
+    await store.add_message(desk, "user", "I drink masala chai")
+    await app.stop()
+    con = sqlite3.connect(paths.db_file())
+    for col in ("source_ref", "confidence", "state", "superseded_by"):  # what a #153 build had
+        con.execute(f"ALTER TABLE facts DROP COLUMN {col}")
+    soon = now_iso()
+    for content in ("Maya is allergic to peanuts", "Maya parks on level 3", "Maya drinks masala chai"):
+        con.execute(
+            "INSERT INTO facts(content, source, topics, memory_type, created_at, updated_at) VALUES"
+            " (?, 'conversation', '[]', 'long-term', ?, ?)",
+            (content, soon, soon),
+        )
+    con.execute("PRAGMA user_version = 14")
+    con.commit()
+    con.close()
+    app = SentientApp(config, llm=FakeProvider(), enable_background=False)
+    await app.start()
+    try:
+        rows = {r["content"]: dict(r) for r in await app.store.fetchall(
+            "SELECT content, source, source_ref, confidence, state FROM facts")}
+        assert rows["Maya is allergic to peanuts"]["source"] == "channel:telegram"
+        assert json.loads(rows["Maya is allergic to peanuts"]["source_ref"])["session_id"] == tg
+        assert rows["Maya parks on level 3"]["source"] == "device:node-1"
+        assert rows["Maya drinks masala chai"]["source"] == "conversation"  # a desktop chat stays one
+        assert {r["confidence"] for r in rows.values()} == {0.9} and {r["state"] for r in rows.values()} == {"current"}
+        assert await app.memory.forget_source("channel:telegram") == 1  # so forgetting Telegram covers it now
+    finally:
+        await app.stop()
+    con = sqlite3.connect(paths.db_file())
+    assert con.execute("PRAGMA user_version").fetchone()[0] == SCHEMA_VERSION
+    con.close()
+
+
+# ---------------------------------------------------------------- REST
+@pytest.fixture
+def client(config, isolated_home, monkeypatch):
+    monkeypatch.setenv("SENTIENT_GATEWAY_TOKEN", "test-token")
+    core = SentientApp(config, llm=FakeProvider(), db_path=isolated_home / "links.db", enable_background=False)
+    with TestClient(create_app(core)) as c:
+        c.headers.update({"Authorization": "Bearer test-token"})
+        c.core = core
+        yield c
+
+
+def test_memory_routes_show_sources_and_change_state(client):
+    mem, store = client.core.memory, client.core.store
+
+    async def setup():
+        tg = await store.create_session(channel="telegram")
+        await store.add_message(tg, "user", "I'm allergic to peanuts")
+        a = await mem.remember("Maya is allergic to peanuts", use_llm=False, session_id=tg)
+        b = await mem.remember("Maya likes cashews", source="manual", use_llm=False)
+        await mem.supersede(b["id"], a["id"])
+        return tg, a["id"], b["id"]
+
+    tg, old, new = client.portal.call(setup)
+    one = client.get(f"/api/memories/{old}").json()
+    assert one["state"] == "superseded" and one["superseded_by_content"] == "Maya likes cashews"
+    assert one["sources"][0]["source"] == "channel:telegram" and one["sources"][0]["ref"]["session_id"] == tg
+    assert client.get("/api/memories/9999").status_code == 404
+    listed = client.get("/api/memories").json()
+    assert [m["id"] for m in listed] == [new] and listed[0]["sources"][0]["source"] == "manual"
+    assert [m["id"] for m in client.get("/api/memories", params={"state": "all"}).json()] == [new, old]
+    assert client.get("/api/memories", params={"state": "nope"}).status_code == 400
+    assert client.patch(f"/api/memories/{new}", json={"state": "disputed"}).json()["state"] == "disputed"
+    assert client.patch(f"/api/memories/{new}", json={"state": "maybe"}).status_code == 400
+    assert client.patch("/api/memories/9999", json={"state": "disputed"}).status_code == 404
+    assert client.delete(f"/api/memories/{new}").json() == {"deleted": True}
+    # a new name in Settings reaches memory at once (what it scrubs on a delete depends on it)
+    assert client.patch("/api/config", json={"assistant": {"user_name": "Riya"}}).status_code == 200
+    assert client.core.memory.config.assistant.user_name == "Riya"