diff --git a/CHANGELOG.md b/CHANGELOG.md
index b2930d770..3bd71fb19 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,14 @@ and versions follow [Semantic Versioning](https://semver.org/).
 ## [Unreleased]
 
 ### Added
+- **Keep work, personal and project memories apart.** Each memory is now kept for Personal, Work, a project you name,
+  or every chat (for things like your name or how you like answers). Pick a chat's memories from the button at the
+  top of the chat, or before you start one. A work chat then uses your work memories and the ones for every chat,
+  and leaves out your personal memories (like family or health) unless you ask about them; what Sentient learns
+  there is kept for work too. How you like things done (your answer style and other preferences it has picked up)
+  still applies in every chat. Tasks a chat creates keep its memories, and each messaging app can be set to one in
+  Settings. On the Memory page you can show one place at a time, move a memory to another place, and forget
+  everything kept for one place without touching the rest. Everything you had before is in Personal.
 - **Sentient checks what really happened, not what the model says happened.** After it writes a file, sends an
   email or a message, creates a calendar event or runs a Home Assistant action, Sentient checks the result itself: the app said it worked, and
   where it can, it reads it back (the file holds what was written, the email is in your Gmail Sent folder, the event
diff --git a/desktop/src/features/chat/ChatPage.tsx b/desktop/src/features/chat/ChatPage.tsx
index 8ba036f5e..b07cf3c53 100644
--- a/desktop/src/features/chat/ChatPage.tsx
+++ b/desktop/src/features/chat/ChatPage.tsx
@@ -7,7 +7,7 @@ import { Button, EmptyState, IconButton, Skeleton } from '@/components/ui'
 import { useBrowserView } from '@/features/browser/state'
 import { ChannelBadge } from '@/features/channels/meta'
 import { HelpersTray } from './HelpersTray'
-import { useBootstrap, useConfig, useMessages, useRuleProposals, useSessions, useSetChatModel } from '@/hooks/core'
+import { useBootstrap, useConfig, useMessages, useRuleProposals, useSessions, useSetChatModel, useSetChatScope } from '@/hooks/core'
 import { qk } from '@/hooks/queryKeys'
 import { api, errorMessage, isApiError } from '@/lib/api'
 import { foldTranscript, type AttachmentView, type TimelineItem } from '@/lib/chatFold'
@@ -17,6 +17,8 @@ import type { ApprovalDecision, Session } from '@/lib/types'
 import { cn } from '@/lib/utils'
 import { liveItems, useChat } from '@/stores/chat'
 import { AssistantTurn } from './AssistantTurn'
+import { scopeLabel } from '@/features/memory/bits'
+import { ChatScopeMenu } from './ChatScopeMenu'
 import { Composer } from './Composer'
 import { useMemorySaveToasts } from './memoryToasts'
 import { RuleProposalCard } from './RuleProposalCard'
@@ -109,6 +111,28 @@ function ChatView({
     [sessionId, setModel]
   )
 
+  // The memories this chat uses (#155). A new chat keeps the pick here until its first message creates it.
+  const [newChatScope, setNewChatScope] = useState<string>('personal')
+  const setScope = useSetChatScope()
+  const chatScope = sessionId ? ((session?.memory_scope as string | undefined) ?? 'personal') : newChatScope
+  const onChatScopeChange = useCallback(
+    (scope: string) => {
+      if (!sessionId) {
+        setNewChatScope(scope)
+        return
+      }
+      setScope.mutate(
+        { id: sessionId, scope },
+        {
+          onSuccess: () => toast.success(`This chat now uses your ${scopeLabel(scope)} memories`),
+          onError: (e) => toast.error("Couldn't change this chat's memories", { description: errorMessage(e) })
+        }
+      )
+    },
+    [sessionId, setScope]
+  )
+  const newChatOwnScope = newChatScope !== 'personal' ? newChatScope : null
+
   // A brand-new chat navigates to its session once the engine assigns an id.
   useEffect(() => {
     if (!sessionId && resolvedId) navigate(`/chat/${resolvedId}`, { replace: true })
@@ -125,13 +149,13 @@ function ChatView({
 
   const onSend = useCallback(
     async (text: string, files: AttachmentView[]) => {
-      if (!sessionId && newChatModel) {
-        // a new chat with its own model: create it first so even its first reply uses that model (#312)
+      if (!sessionId && (newChatModel || newChatOwnScope)) {
+        // a new chat with its own model (#312) or memories (#155): create it first so even its first reply uses them
         if (creating) return
         let id: string
         setCreating(true) // until this view moves to the new chat, so a second message can't start another one
         try {
-          id = (await api.sessions.create({ incognito: newIncognito, model: newChatModel })).session_id
+          id = (await api.sessions.create({ incognito: newIncognito, model: newChatModel, memory_scope: newChatOwnScope })).session_id
         } catch (err) {
           setCreating(false)
           setInject({ text, nonce: Date.now() }) // the message box was cleared: put the text back
@@ -140,7 +164,16 @@ function ChatView({
         }
         useChat.getState().adopt(id, { incognito: newIncognito })
         const now = new Date().toISOString()
-        const row: Session = { id, title: null, channel: 'desktop', created_at: now, updated_at: now, incognito: newIncognito, model: newChatModel }
+        const row: Session = {
+          id,
+          title: null,
+          channel: 'desktop',
+          created_at: now,
+          updated_at: now,
+          incognito: newIncognito,
+          model: newChatModel,
+          memory_scope: newChatScope
+        }
         queryClient.setQueryData<Session[]>(qk.sessions, (old) => [row, ...(old ?? []).filter((s) => s.id !== id)])
         await send(id, { text, attachments: files })
         navigate(`/chat/${id}`, { replace: true })
@@ -149,7 +182,7 @@ function ChatView({
       const key = await send(sessionId ?? null, { text, attachments: files, incognito: !sessionId && newIncognito })
       if (!sessionId) setPendingKey(key)
     },
-    [send, sessionId, newIncognito, newChatModel, navigate, creating]
+    [send, sessionId, newIncognito, newChatModel, newChatOwnScope, newChatScope, navigate, creating]
   )
 
   const onPick = (s: Pick<Suggestion, 'prompt' | 'autoSend'>) => {
@@ -224,6 +257,7 @@ function ChatView({
           {incognito ? <IncognitoBadge /> : <ChannelBadge channel={session?.channel} withLabel />}
           <span className="flex-1" />
           {streaming && <span className="text-xs text-fg-subtle">{assistantName} is replying…</span>}
+          {sessionId && <ChatScopeMenu value={chatScope} onChange={onChatScopeChange} />}
           <HelpersTray sessionId={sessionId} />
           <IconButton size="sm" label="Browser live view" icon={<IconWorldWww size={16} />} onClick={toggleBrowser} active={browserOpen} />
         </div>
@@ -238,6 +272,10 @@ function ChatView({
               <EmptyChat userName={bootstrap.data?.assistant.user_name} onPick={onPick} />
             )}
             <div className="mt-8">
+              <div className="mb-1.5 flex items-center justify-end gap-1.5 text-xs text-fg-subtle">
+                <span>Memories</span>
+                <ChatScopeMenu value={newChatScope} onChange={onChatScopeChange} />
+              </div>
               <Composer
                 draftKey="new"
                 assistantName={assistantName}
diff --git a/desktop/src/features/chat/ChatScopeMenu.tsx b/desktop/src/features/chat/ChatScopeMenu.tsx
new file mode 100644
index 000000000..a0247173e
--- /dev/null
+++ b/desktop/src/features/chat/ChatScopeMenu.tsx
@@ -0,0 +1,88 @@
+import { IconBriefcase, IconCheck, IconFolder, IconHome } from '@tabler/icons-react'
+import { useState, type ReactNode } from 'react'
+import { Input, Popover, PopoverContent, PopoverTrigger, Tooltip } from '@/components/ui'
+import { ScopeIcon, scopeLabel } from '@/features/memory/bits'
+import { useMemoryScopes } from '@/hooks/memory'
+import { cn } from '@/lib/utils'
+
+/**
+ * Which memories this chat uses (#155): Personal, Work or a project. Recall reads that scope plus the memories kept
+ * for every chat, and new memories from the chat are saved there.
+ */
+export function ChatScopeMenu({ value, onChange, className }: { value: string | null | undefined; onChange: (v: string) => void; className?: string }) {
+  const [open, setOpen] = useState(false)
+  const [custom, setCustom] = useState('')
+  const scopes = useMemoryScopes()
+  const current = value || 'personal'
+  const projects = (scopes.data ?? []).filter((s) => !s.built_in).map((s) => s.name)
+  if (!['personal', 'work', ...projects].includes(current)) projects.unshift(current)
+  const count = (name: string) => scopes.data?.find((s) => s.name === name)?.count
+
+  const pick = (v: string) => {
+    if (v !== current) onChange(v)
+    setOpen(false)
+    setCustom('')
+  }
+
+  return (
+    <Popover open={open} onOpenChange={setOpen}>
+      <Tooltip content={`This chat uses your ${scopeLabel(current)} memories`}>
+        <PopoverTrigger asChild>
+          <button
+            type="button"
+            aria-label="Memories for this chat"
+            data-chat-scope={current}
+            className={cn(
+              'flex h-8 max-w-48 shrink-0 items-center gap-1.5 rounded-lg px-2 text-xs font-medium transition-colors',
+              current === 'personal' ? 'text-fg-subtle hover:bg-hover hover:text-fg' : 'bg-accent/12 text-accent-text hover:bg-accent/18',
+              className
+            )}
+          >
+            <ScopeIcon scope={current} />
+            <span className="truncate">{scopeLabel(current)}</span>
+          </button>
+        </PopoverTrigger>
+      </Tooltip>
+      <PopoverContent align="end" className="w-72 p-1.5">
+        <div className="px-2.5 pb-1.5 pt-1 text-xs text-fg-subtle">
+          Which memories this chat uses. New ones it learns are kept there too. Memories set to every chat are always used.
+        </div>
+        <Option active={current === 'personal'} onClick={() => pick('personal')} icon={<IconHome size={15} />} hint={count('personal')}>
+          Personal
+        </Option>
+        <Option active={current === 'work'} onClick={() => pick('work')} icon={<IconBriefcase size={15} />} hint={count('work')}>
+          Work
+        </Option>
+        {projects.length > 0 && <div className="mx-2.5 mb-1 mt-2 text-2xs font-medium uppercase tracking-wide text-fg-faint">Projects</div>}
+        <div className="max-h-44 overflow-y-auto">
+          {projects.map((p) => (
+            <Option key={p} active={current === p} onClick={() => pick(p)} icon={<IconFolder size={15} />} hint={count(p)}>
+              {p}
+            </Option>
+          ))}
+        </div>
+        <form
+          className="mt-1.5 border-t border-border p-1.5 pt-2"
+          onSubmit={(e) => {
+            e.preventDefault()
+            const name = custom.trim().replace(/\s+/g, ' ').slice(0, 40)
+            if (name && name.toLowerCase() !== 'always') pick(name)
+          }}
+        >
+          <Input size="sm" value={custom} onChange={(e) => setCustom(e.target.value)} placeholder="New project, e.g. Kestrel launch" aria-label="New project" />
+        </form>
+      </PopoverContent>
+    </Popover>
+  )
+}
+
+function Option({ active, onClick, icon, hint, children }: { active: boolean; onClick: () => void; icon: ReactNode; hint?: number; children: ReactNode }) {
+  return (
+    <button type="button" onClick={onClick} className="flex h-8 w-full items-center gap-2 rounded-lg px-2.5 text-left text-sm text-fg hover:bg-active">
+      <span className="shrink-0 text-fg-subtle">{icon}</span>
+      <span className="min-w-0 flex-1 truncate">{children}</span>
+      {hint !== undefined && <span className="text-2xs tabular-nums text-fg-subtle">{hint}</span>}
+      <IconCheck size={14} className={cn('shrink-0 text-accent-text', !active && 'invisible')} />
+    </button>
+  )
+}
diff --git a/desktop/src/features/chat/memoryToasts.ts b/desktop/src/features/chat/memoryToasts.ts
index cc7c8ed8f..e7af229ba 100644
--- a/desktop/src/features/chat/memoryToasts.ts
+++ b/desktop/src/features/chat/memoryToasts.ts
@@ -6,6 +6,7 @@
 import { useEffect } from 'react'
 import { useNavigate } from 'react-router'
 import { toast } from 'sonner'
+import { scopeLabel } from '@/features/memory/bits'
 import { qk } from '@/hooks/queryKeys'
 import { api, errorMessage } from '@/lib/api'
 import { queryClient } from '@/lib/queryClient'
@@ -55,7 +56,9 @@ export function useMemorySaveToasts(sessionId: string | undefined) {
         })
         return
       }
+      const where = d.scope && d.scope !== 'personal' ? (d.scope === 'always' ? 'For every chat' : `In ${scopeLabel(d.scope)}`) : undefined
       toast(`${d.action === 'UPDATE' ? 'Updated' : 'Remembered'}: ${text}`, {
+        description: where, // the memory scope it was saved to (#155), when not Personal
         action: { label: 'Undo', onClick: () => void undo(d) },
         duration: 8000
       })
diff --git a/desktop/src/features/memory/MemoryDetail.tsx b/desktop/src/features/memory/MemoryDetail.tsx
index f16d1af01..63dcf0749 100644
--- a/desktop/src/features/memory/MemoryDetail.tsx
+++ b/desktop/src/features/memory/MemoryDetail.tsx
@@ -1,9 +1,10 @@
 import { IconCalendar, IconCheck, IconClock, IconHistory, IconHourglassHigh, IconPencil, IconTrash, IconX } from '@tabler/icons-react'
 import { useEffect, useState } from 'react'
-import { Alert, Button, ConfirmDialog, Sheet, Textarea } from '@/components/ui'
+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, SourceChip, TopicPill } from './bits'
+import { ExpiryBadge, ScopeIcon, scopeLabel, SourceChip, TopicPill } from './bits'
 import { useNow, useOptimisticMemoryActions } from './hooks'
 import { countdown, expiresInMs, recentRelative, sourceMeta, type MemoryWithHistory } from './meta'
 
@@ -18,7 +19,8 @@ export function MemoryDetail({
   onOpenChange: (open: boolean) => void
   onForgetSource: (source: string) => void
 }) {
-  const { update, remove } = useOptimisticMemoryActions()
+  const { update, remove, move } = useOptimisticMemoryActions()
+  const scopes = useMemoryScopes()
   const [editing, setEditing] = useState(false)
   const [draft, setDraft] = useState('')
   const [confirm, setConfirm] = useState(false)
@@ -108,6 +110,19 @@ export function MemoryDetail({
               </div>
               <div className="text-xs text-fg-subtle">{src.description}</div>
             </Row>
+            <Row icon={<ScopeIcon scope={memory.scope} size={14} />} label="Used in">
+              <Select
+                size="sm"
+                className="w-full"
+                aria-label="Move to"
+                value={memory.scope ?? 'personal'}
+                onValueChange={(v) => v !== (memory.scope ?? 'personal') && move.mutate({ id: memory.id, scope: v })}
+                options={scopeOptions(scopes.data?.map((s) => s.name) ?? [], memory.scope ?? 'personal')}
+              />
+              <div className="mt-1 text-xs text-fg-subtle">
+                {memory.scope === 'always' ? 'Every chat can use it.' : `Only ${scopeLabel(memory.scope)} chats use it, plus anything you ask about directly.`}
+              </div>
+            </Row>
             <Row icon={<IconCalendar size={14} />} label="Learned">
               {formatDateTime(memory.created_at)} {recentRelative(memory.created_at) && <span className="text-fg-subtle">· {recentRelative(memory.created_at)}</span>}
             </Row>
@@ -150,6 +165,12 @@ export function MemoryDetail({
   )
 }
 
+function scopeOptions(names: string[], current: string) {
+  const all = ['personal', 'work', 'always', ...names.filter((n) => !['personal', 'work', 'always'].includes(n))]
+  if (!all.includes(current)) all.push(current)
+  return all.map((n) => ({ value: n, label: scopeLabel(n), icon: <ScopeIcon scope={n} size={14} /> }))
+}
+
 function Row({ icon, label, children }: { icon: React.ReactNode; label: string; children: React.ReactNode }) {
   return (
     <div className="flex gap-3 px-3.5 py-3">
diff --git a/desktop/src/features/memory/MemoryList.tsx b/desktop/src/features/memory/MemoryList.tsx
index 5204af664..78eaa9c47 100644
--- a/desktop/src/features/memory/MemoryList.tsx
+++ b/desktop/src/features/memory/MemoryList.tsx
@@ -3,7 +3,7 @@ import { AnimatePresence, motion } from 'motion/react'
 import { useMemo } from 'react'
 import type { Memory } from '@/lib/types'
 import { cn, formatTime, relativeTime } from '@/lib/utils'
-import { ExpiryBadge, SourceChip, TopicPill } from './bits'
+import { ExpiryBadge, ScopeBadge, SourceChip, TopicPill } from './bits'
 import { useNow } from './hooks'
 import { dayKey, dayLabel, primaryTopic, topicMeta } from './meta'
 
@@ -29,6 +29,7 @@ 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" />
+        <ScopeBadge scope={memory.scope} />
         {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/MemoryPage.tsx b/desktop/src/features/memory/MemoryPage.tsx
index 0410bf147..136124c59 100644
--- a/desktop/src/features/memory/MemoryPage.tsx
+++ b/desktop/src/features/memory/MemoryPage.tsx
@@ -21,13 +21,14 @@ import {
   IconX
 } from '@tabler/icons-react'
 import { useNavigate } from 'react-router'
-import { keepPreviousData, useQuery } from '@tanstack/react-query'
+import { keepPreviousData, useQuery, useQueryClient } from '@tanstack/react-query'
 import { AnimatePresence, motion } from 'motion/react'
 import { lazy, Suspense, useEffect, useMemo, useState, type ReactNode } from 'react'
 import { toast } from 'sonner'
 import {
   Alert,
   Button,
+  ConfirmDialog,
   DropdownMenu,
   DropdownMenuContent,
   DropdownMenuItem,
@@ -55,7 +56,8 @@ import { MemoryList, MemoryTimeline } from '@/features/memory/MemoryList'
 import { EXPIRING_SOON_MS, countdown, expiresInMs, sourceMeta, TOPIC_META, TOPIC_ORDER, topicMeta, topicText, topicTint, type MemoryWithHistory } from '@/features/memory/meta'
 import { ProfileTab } from '@/features/memory/ProfileTab'
 import { ReviewTab } from '@/features/memory/ReviewTab'
-import { useMemories, useMemoryGraph, useMemoryReview, useMemorySummaries, useMemoryTopics } from '@/hooks/memory'
+import { ScopeIcon, scopeLabel } from '@/features/memory/bits'
+import { useMemories, useMemoryGraph, useMemoryReview, useMemoryScopes, useMemorySummaries, useMemoryTopics } from '@/hooks/memory'
 import { qk } from '@/hooks/queryKeys'
 import { api, errorMessage } from '@/lib/api'
 import { getBridge } from '@/lib/bridge'
@@ -77,10 +79,12 @@ export function MemoryPage() {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [q])
 
-  const all = useMemories({ limit: 2000 })
+  // a picked scope (#155) is filtered by the engine, before its limits
+  const scoped = p.scope ? { scope: p.scope } : {}
+  const all = useMemories({ limit: 2000, ...scoped })
   const searched = useQuery({
-    queryKey: qk.memories.list({ q: p.q, limit: 200 }),
-    queryFn: () => api.memories.list({ q: p.q, limit: 200 }),
+    queryKey: qk.memories.list({ q: p.q, limit: 200, ...scoped }),
+    queryFn: () => api.memories.list({ q: p.q, limit: 200, ...scoped }),
     enabled: !!p.q,
     placeholderData: keepPreviousData
   })
@@ -89,6 +93,9 @@ export function MemoryPage() {
   const summaries = useMemorySummaries(100)
   const graph = useMemoryGraph()
   const review = useMemoryReview()
+  const scopes = useMemoryScopes()
+  const qc = useQueryClient()
+  const [confirmReset, setConfirmReset] = useState(false)
   const now = useNow()
 
   const memories = useMemo(() => all.data ?? [], [all.data])
@@ -100,11 +107,33 @@ export function MemoryPage() {
         (m) =>
           (!p.topic || m.topics.includes(p.topic)) &&
           (!p.source || m.source === p.source) &&
+          (!p.scope || (m.scope ?? 'personal') === p.scope) &&
           (p.type === 'all' || m.memory_type === p.type)
       ),
-    [base, p.topic, p.source, p.type]
+    [base, p.topic, p.source, p.scope, p.type]
   )
-  const filtering = !!(p.topic || p.source || p.type !== 'all' || searching)
+  const filtering = !!(p.topic || p.source || p.scope || p.type !== 'all' || searching)
+  const scopeNames = useMemo(() => {
+    const names = ['personal', 'work', 'always', ...(scopes.data ?? []).map((s) => s.name)]
+    memories.forEach((m) => m.scope && names.push(m.scope))
+    if (p.scope) names.push(p.scope)
+    return [...new Set(names)]
+  }, [scopes.data, memories, p.scope])
+  // how many memories each scope holds, from the engine (the list may be one scope or a page of them)
+  const scopeCount = (name: string) => scopes.data?.find((s) => s.name === name)?.count ?? 0
+  const resetScope = async () => {
+    const scope = p.scope
+    if (!scope) return
+    try {
+      const r = await api.memories.resetScope(scope)
+      toast.success(`Forgot ${r.deleted} ${r.deleted === 1 ? 'memory' : 'memories'} from ${scopeLabel(scope)}`)
+      p.set({ scope: null })
+    } catch (e) {
+      toast.error("Couldn't forget those memories", { description: errorMessage(e) })
+    } finally {
+      void qc.invalidateQueries({ queryKey: qk.memories.all })
+    }
+  }
   const matches = useMemo(() => (filtering ? new Set(filtered.map((m) => m.id)) : null), [filtering, filtered])
 
   const sources = useMemo(() => {
@@ -167,7 +196,7 @@ export function MemoryPage() {
   }
   const clearFilters = () => {
     setSearch('')
-    p.set({ topic: null, source: null, type: null, q: null })
+    p.set({ topic: null, source: null, type: null, q: null, scope: null })
   }
 
   return (
@@ -214,6 +243,11 @@ export function MemoryPage() {
                 <DropdownMenuItem icon={<IconTrashX />} danger disabled={!sources.length} onSelect={() => (setForgetInitial(undefined), p.set({ forget: 1 }, false))}>
                   Forget everything from a source…
                 </DropdownMenuItem>
+                {p.scope && (
+                  <DropdownMenuItem icon={<IconTrashX />} danger onSelect={() => setConfirmReset(true)}>
+                    Forget all {scopeLabel(p.scope)} memories…
+                  </DropdownMenuItem>
+                )}
               </DropdownMenuContent>
             </DropdownMenu>
           </>
@@ -243,7 +277,7 @@ export function MemoryPage() {
             </Alert>
           ) : all.isLoading ? (
             <LoadingState />
-          ) : !memories.length ? (
+          ) : !memories.length && !p.scope ? (
             <EmptyState
               icon={<IconBrain />}
               title="Sentient doesn't remember anything yet"
@@ -284,6 +318,16 @@ export function MemoryPage() {
                       )
                     }
                   />
+                  <Select
+                    className="w-40"
+                    aria-label="Used in"
+                    value={p.scope || '__all'}
+                    onValueChange={(v) => p.set({ scope: v === '__all' ? null : v })}
+                    options={[
+                      { value: '__all', label: 'All chats' },
+                      ...scopeNames.map((n) => ({ value: n, label: `${scopeLabel(n)} (${scopeCount(n)})`, icon: <ScopeIcon scope={n} size={14} /> }))
+                    ]}
+                  />
                   <Select
                     className="w-40"
                     aria-label="Source"
@@ -410,7 +454,7 @@ export function MemoryPage() {
           p.set({ m: null, forget: 1 }, false)
         }}
       />
-      <AddMemoryDialog open={p.addOpen} onOpenChange={(o) => p.set({ add: o ? 1 : null })} onShow={(id) => p.set({ add: null, m: id })} />
+      <AddMemoryDialog open={p.addOpen} onOpenChange={(o) => p.set({ add: o ? 1 : null })} onShow={(id) => p.set({ add: null, m: id })} scope={p.scope || undefined} />
       <ImportDialog open={p.importOpen} onOpenChange={(o) => p.set({ import: o ? 1 : null })} />
       <AssistantImportDialog
         open={p.assistantImportOpen}
@@ -418,6 +462,14 @@ export function MemoryPage() {
         initialApp={p.importApp}
         initialPath={p.importPath}
       />
+      <ConfirmDialog
+        open={confirmReset}
+        onOpenChange={setConfirmReset}
+        title={`Forget all ${scopeLabel(p.scope)} memories?`}
+        description={`Sentient forgets the ${scopeCount(p.scope)} ${scopeCount(p.scope) === 1 ? 'memory' : 'memories'} kept for ${scopeLabel(p.scope)}, and any waiting for your review there. Memories in other places stay. This can't be undone.`}
+        confirmLabel="Forget them"
+        onConfirm={() => void resetScope()}
+      />
       <ForgetSourceDialog key={forgetInitial ?? 'none'} open={p.forgetOpen} onOpenChange={(o) => p.set({ forget: o ? 1 : null })} sources={sources} initial={forgetInitial} />
     </div>
   )
diff --git a/desktop/src/features/memory/bits.tsx b/desktop/src/features/memory/bits.tsx
index cce845052..bc2efbcd6 100644
--- a/desktop/src/features/memory/bits.tsx
+++ b/desktop/src/features/memory/bits.tsx
@@ -1,4 +1,4 @@
-import { IconHourglassHigh } from '@tabler/icons-react'
+import { IconBriefcase, IconFolder, IconHome, IconHourglassHigh, IconInfinity } from '@tabler/icons-react'
 import { cn } from '@/lib/utils'
 import type { Memory } from '@/lib/types'
 import { countdown, EXPIRING_SOON_MS, expiresInMs, sourceMeta, topicMeta, topicText, topicTint } from './meta'
@@ -48,3 +48,32 @@ export function ExpiryBadge({ memory, now, className }: { memory: Memory; now: n
     </span>
   )
 }
+
+/** The plain name of a memory scope (#155): Personal, Work, Every chat, or a project's own name. */
+export function scopeLabel(scope: string | null | undefined): string {
+  if (!scope || scope === 'personal') return 'Personal'
+  if (scope === 'work') return 'Work'
+  if (scope === 'always') return 'Every chat'
+  return scope
+}
+
+export function ScopeIcon({ scope, size = 15, className }: { scope: string | null | undefined; size?: number; className?: string }) {
+  if (!scope || scope === 'personal') return <IconHome size={size} className={className} />
+  if (scope === 'work') return <IconBriefcase size={size} className={className} />
+  if (scope === 'always') return <IconInfinity size={size} className={className} />
+  return <IconFolder size={size} className={className} />
+}
+
+/** Where a memory is kept, shown unless it is the default (Personal). */
+export function ScopeBadge({ scope, className }: { scope: string | null | undefined; className?: string }) {
+  if (!scope || scope === 'personal') return null
+  return (
+    <span
+      title={scope === 'always' ? 'Used in every chat' : `Used in ${scopeLabel(scope)} chats`}
+      className={cn('inline-flex h-4.5 max-w-36 shrink-0 items-center gap-1 rounded-full border border-border bg-active px-1.5 text-2xs font-medium text-fg-muted', className)}
+    >
+      <ScopeIcon scope={scope} size={10} className="shrink-0" />
+      <span className="truncate">{scopeLabel(scope)}</span>
+    </span>
+  )
+}
diff --git a/desktop/src/features/memory/dialogs.tsx b/desktop/src/features/memory/dialogs.tsx
index b9ad393d9..037107cb1 100644
--- a/desktop/src/features/memory/dialogs.tsx
+++ b/desktop/src/features/memory/dialogs.tsx
@@ -12,6 +12,7 @@ import { useMutation, useQueryClient } from '@tanstack/react-query'
 import { useRef, useState, type DragEvent } from 'react'
 import { toast } from 'sonner'
 import { Alert, Button, Dialog, Input, ProgressBar, Textarea } from '@/components/ui'
+import { scopeLabel } from '@/features/memory/bits'
 import { qk } from '@/hooks/queryKeys'
 import { api, errorMessage } from '@/lib/api'
 import type { MemoryImportResult, MemoryWriteResult } from '@/lib/types'
@@ -26,12 +27,23 @@ const ACTION_COPY: Record<MemoryWriteResult['action'], { title: string; body: st
   SKIP: { title: 'Already remembered', body: 'Sentient already knows this, so nothing was added.', icon: <IconCopy />, tone: 'warning' }
 }
 
-export function AddMemoryDialog({ open, onOpenChange, onShow }: { open: boolean; onOpenChange: (o: boolean) => void; onShow: (id: number) => void }) {
+/** `scope` (#155): where the memory is kept, the Memory screen's filter when one is picked; Personal otherwise. */
+export function AddMemoryDialog({
+  open,
+  onOpenChange,
+  onShow,
+  scope
+}: {
+  open: boolean
+  onOpenChange: (o: boolean) => void
+  onShow: (id: number) => void
+  scope?: string
+}) {
   const qc = useQueryClient()
   const [content, setContent] = useState('')
   const [result, setResult] = useState<MemoryWriteResult | null>(null)
   const create = useMutation({
-    mutationFn: (text: string) => api.memories.create(text, 'manual'),
+    mutationFn: (text: string) => api.memories.create(text, 'manual', scope || undefined),
     onSuccess: (r) => {
       setResult(r)
       if (r.action !== 'SKIP') setContent('')
@@ -53,7 +65,9 @@ export function AddMemoryDialog({ open, onOpenChange, onShow }: { open: boolean;
       open={open}
       onOpenChange={close}
       title="Add a memory"
-      description="Tell Sentient something about you. It checks for duplicates and updates what it already knows."
+      description={`Tell Sentient something about you. It checks for duplicates and updates what it already knows.${
+        scope && scope !== 'personal' ? ` It is kept for ${scope === 'always' ? 'every chat' : `${scopeLabel(scope)} chats`}.` : ''
+      }`}
       modalLock={!!content}
       footer={
         <>
diff --git a/desktop/src/features/memory/hooks.ts b/desktop/src/features/memory/hooks.ts
index 337736fa5..ce3f13717 100644
--- a/desktop/src/features/memory/hooks.ts
+++ b/desktop/src/features/memory/hooks.ts
@@ -31,6 +31,7 @@ export function useMemoryParams() {
     [setParams]
   )
 
+  const scope = get('scope') // a memory scope (#155), '' for all
   const view = (['graph', 'list', 'timeline'].includes(get('view')) ? get('view') : 'graph') as MemoryView
   const tab = (['memories', 'review', 'conversations', 'profile'].includes(get('tab')) ? get('tab') : 'memories') as MemoryTab
   const type = (['long-term', 'short-term'].includes(get('type')) ? get('type') : 'all') as MemoryTypeFilter
@@ -41,6 +42,7 @@ export function useMemoryParams() {
     tab,
     type,
     topic: get('topic'),
+    scope,
     source: get('source'),
     q: get('q'),
     selected,
@@ -138,7 +140,26 @@ export function useOptimisticMemoryActions() {
     onSettled: settle
   })
 
-  return useMemo(() => ({ update, remove }), [update, remove])
+  const move = useMutation({
+    mutationFn: ({ id, scope }: { id: number; scope: string }) => api.memories.move(id, scope),
+    onMutate: async ({ id, scope }) => {
+      const snap = await snapshot()
+      patchLists((list) => list.map((m) => (m.id === id ? ({ ...m, scope } as Memory) : m)))
+      return snap
+    },
+    onError: (e, _v, snap) => {
+      restore(snap)
+      toast.error("Couldn't move that memory", { description: errorMessage(e) })
+    },
+    onSuccess: (m) => toast.success(m.scope === 'always' ? 'Every chat can use this memory now' : `Moved to ${scopeName(m.scope)}`),
+    onSettled: settle
+  })
+
+  return useMemo(() => ({ update, remove, move }), [update, remove, move])
+}
+
+function scopeName(scope: string | undefined): string {
+  return !scope || scope === 'personal' ? 'Personal' : scope === 'work' ? 'Work' : scope
 }
 
 /** force-graph mutates link ends into node objects. */
diff --git a/desktop/src/hooks/core.ts b/desktop/src/hooks/core.ts
index 993df5575..9bf049e06 100644
--- a/desktop/src/hooks/core.ts
+++ b/desktop/src/hooks/core.ts
@@ -139,6 +139,18 @@ export function useSetChatModel() {
   })
 }
 
+/** The memories one chat uses (#155). */
+export function useSetChatScope() {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: ({ id, scope }: { id: string; scope: string | null }) => api.sessions.setScope(id, scope),
+    onMutate: ({ id, scope }) => {
+      qc.setQueryData<Session[]>(qk.sessions, (old) => old?.map((s) => (s.id === id ? { ...s, memory_scope: scope ?? 'personal' } : s)))
+    },
+    onSettled: () => void qc.invalidateQueries({ queryKey: qk.sessions })
+  })
+}
+
 export function useDeleteSession() {
   const qc = useQueryClient()
   return useMutation({
diff --git a/desktop/src/hooks/memory.ts b/desktop/src/hooks/memory.ts
index 052da10a3..5a1d45733 100644
--- a/desktop/src/hooks/memory.ts
+++ b/desktop/src/hooks/memory.ts
@@ -8,6 +8,21 @@ export function useMemories(query: MemoryQuery = {}) {
   return useQuery({ queryKey: qk.memories.list(query), queryFn: () => api.memories.list(query) })
 }
 
+/** Memory scopes (#155). An older engine without the route has just Personal. */
+export function useMemoryScopes() {
+  return useQuery({
+    queryKey: qk.memories.scopes,
+    queryFn: async () => {
+      try {
+        return await api.memories.scopes()
+      } catch (err) {
+        if (isNotImplemented(err)) return [{ name: 'personal', label: 'Personal', count: 0, built_in: true }]
+        throw err
+      }
+    }
+  })
+}
+
 export function useMemoryTopics() {
   return useQuery({ queryKey: qk.memories.topics, queryFn: api.memories.topics })
 }
diff --git a/desktop/src/hooks/queryKeys.ts b/desktop/src/hooks/queryKeys.ts
index 843a5bb27..a177b6d36 100644
--- a/desktop/src/hooks/queryKeys.ts
+++ b/desktop/src/hooks/queryKeys.ts
@@ -66,6 +66,7 @@ export const qk = {
     workspace: ['memories', 'workspace'] as const,
     personas: ['memories', 'personas'] as const,
     review: ['memories', 'review'] as const,
+    scopes: ['memories', 'scopes'] as const,
     dreams: ['memories', 'dreams'] as const
   },
   userModel: ['user-model'] as const,
diff --git a/desktop/src/lib/api.ts b/desktop/src/lib/api.ts
index a3c0ea2bb..cf0eed568 100644
--- a/desktop/src/lib/api.ts
+++ b/desktop/src/lib/api.ts
@@ -85,6 +85,7 @@ import type {
   MemoryImportResult,
   MemoryQuery,
   MemoryReviewInbox,
+  MemoryScope,
   MemorySummary,
   MemoryTopic,
   MemoryWriteResult,
@@ -453,14 +454,24 @@ export const api = {
 
   sessions: {
     list: (limit = 100) => http.get<Session[]>('/api/sessions', { query: { limit } }),
-    create: (opts: { incognito?: boolean; model?: string | null } = {}) =>
+    create: (opts: { incognito?: boolean; model?: string | null; memory_scope?: string | null } = {}) =>
       http.post<{ session_id: string }>('/api/sessions', undefined, {
-        query: opts.incognito || opts.model ? { ...(opts.incognito ? { incognito: true } : {}), ...(opts.model ? { model: opts.model } : {}) } : undefined
+        query:
+          opts.incognito || opts.model || opts.memory_scope
+            ? {
+                ...(opts.incognito ? { incognito: true } : {}),
+                ...(opts.model ? { model: opts.model } : {}),
+                ...(opts.memory_scope ? { memory_scope: opts.memory_scope } : {})
+              }
+            : undefined
       }),
     rename: (id: string, title: string) => http.patch<OkResponse>(`/api/sessions/${enc(id)}`, { title }),
     /** The chat's own model (#312); null follows the default again. */
     setModel: (id: string, model: string | null) =>
       http.patch<OkResponse & { model: string | null }>(`/api/sessions/${enc(id)}`, { model }),
+    /** The memories this chat uses (#155); null goes back to the default (Personal, or its messaging app's). */
+    setScope: (id: string, memory_scope: string | null) =>
+      http.patch<OkResponse & { memory_scope: string }>(`/api/sessions/${enc(id)}`, { memory_scope }),
     delete: (id: string) => http.delete<OkResponse>(`/api/sessions/${enc(id)}`),
     messages: (id: string, limit = 500) =>
       http.get<TranscriptMessage[]>(`/api/sessions/${enc(id)}/messages`, { query: { limit } }),
@@ -677,7 +688,11 @@ export const api = {
     list: (query: MemoryQuery = {}) => http.get<Memory[]>('/api/memories', { query: { ...query } }),
     topics: () => http.get<MemoryTopic[]>('/api/memories/topics'),
     graph: () => http.get<MemoryGraph>('/api/memories/graph'),
-    create: (content: string, source?: string) => http.post<MemoryWriteResult>('/api/memories', { content, source }),
+    create: (content: string, source?: string, scope?: string) => http.post<MemoryWriteResult>('/api/memories', { content, source, scope }),
+    /** §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 }),
+    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}`),
     deleteBySource: (source: string) => http.delete<{ deleted: number }>(`/api/memories/source/${enc(source)}`),
diff --git a/desktop/src/lib/types.ts b/desktop/src/lib/types.ts
index 9c748c113..f4ab2fa8f 100644
--- a/desktop/src/lib/types.ts
+++ b/desktop/src/lib/types.ts
@@ -410,6 +410,8 @@ export interface Session {
   incognito?: boolean
   /** The model picked for this chat (#312); null or missing follows the default model. */
   model?: string | null
+  /** The memories this chat uses and saves to (#155): "personal", "work" or a project's name. */
+  memory_scope?: string
   [key: string]: unknown
 }
 
@@ -1073,13 +1075,18 @@ export interface MemoryUpdatedData {
   content?: string
   source?: string
   /**
-   * `merged` | `contradicted` | `promoted` | `expired` | `approved` | `discarded` | `review_expired`, or
+   * `merged` | `contradicted` | `promoted` | `expired` | `approved` | `discarded` | `review_expired` | `moved` |
+   * `scope_reset` (#155), or
    * `instruction` on a held memory that reads like an instruction for how Sentient should act (#234)
    */
   reason?: string
   count?: number
   /** `pending`: the memory waits in the review inbox (ADR 0021). */
   status?: 'pending'
+  /** The memory's scope (#155) on a save: where it was kept. With `reason: "moved"`, where it moved to (`previous_scope`
+   * is where it was); with `reason: "scope_reset"`, the scope that was forgotten. */
+  scope?: string
+  previous_scope?: string
   /** An UPDATE's words before it, so the save can be undone (#234). */
   previous?: string
   /** The chat it was learned in; that chat shows "Remembered: ... Undo" (#234). */
@@ -1655,6 +1662,8 @@ export interface Task {
   model: string | null
   /** Named browser profile its browser steps use (§12); `null` is the default one. */
   browser_profile?: string | null
+  /** The memories its runs use and save to (#155): "personal", "work" or a project's name. */
+  memory_scope?: string
   /** Where its notifications go besides the app (§4 "Where results go"). Older engines leave it out (default). */
   deliver_to?: TaskDeliverTo
   /** Recurring tasks: short notes its runs keep for the next run (§4 "Recurring tasks remember"). */
@@ -1674,6 +1683,8 @@ export interface TaskCreateRequest {
   assignee?: 'ai'
   model?: string
   browser_profile?: string
+  /** The memories its runs use (#155); personal when left out. */
+  memory_scope?: string
 }
 
 export interface TaskPreview {
@@ -1702,7 +1713,7 @@ export interface DeliveryChat {
 /** `default`: paired chats with delivery on; `desktop`: the app only; a list: only those chats. */
 export type TaskDeliverTo = 'default' | 'desktop' | DeliveryChat[]
 
-export type TaskPatch = Partial<Pick<Task, 'name' | 'description' | 'priority' | 'schedule' | 'plan' | 'enabled' | 'status' | 'model' | 'browser_profile' | 'deliver_to' | 'notepad' | 'keep_running'>>
+export type TaskPatch = Partial<Pick<Task, 'name' | 'description' | 'priority' | 'schedule' | 'plan' | 'enabled' | 'status' | 'model' | 'browser_profile' | 'memory_scope' | 'deliver_to' | 'notepad' | 'keep_running'>>
 
 /** `GET /api/tasks/away` (#163): routines pause after a long absence and resume with one click. */
 export interface AwayStatus {
@@ -2095,6 +2106,18 @@ export interface Memory {
   /** Listed memories are always `active`; `pending` ones are only in the review inbox. */
   status?: 'active' | 'pending'
   review?: ReviewNote | null
+  /** Where it is kept (#155): "personal" (default), "work", "always" (every chat) or a project's name. */
+  scope?: string
+}
+
+/** One memory scope (#155) from `GET /api/memories/scopes`. */
+export interface MemoryScope {
+  name: string
+  label: string
+  /** Active memories kept there. */
+  count: number
+  /** Always, Personal and Work; projects are the user's own. */
+  built_in: boolean
 }
 
 /** Where a memory waiting for review came from (ADR 0021). */
@@ -2123,6 +2146,8 @@ export interface MemoryReviewItem {
   created_at: ISODate
   /** When it is let go if nobody reviews it. */
   expires_at: ISODate | null
+  /** A fact's memory scope (#155): it is approved into it. Null for insights. */
+  scope?: string | null
 }
 
 export interface MemoryReviewInbox {
@@ -2149,6 +2174,7 @@ export interface MemoryQuery {
   topic?: string
   q?: string
   source?: string
+  scope?: string
   limit?: number
   offset?: number
 }
diff --git a/docs/API.md b/docs/API.md
index e3aa6f7fc..619d5d12d 100644
--- a/docs/API.md
+++ b/docs/API.md
@@ -88,10 +88,10 @@ Envelope: `{"type": "task.updated", "data": {...}, "ts": "..."}`
 | `notification.updated` | full **Notification** after its payload changed (suggestion approved/dismissed, approval answered, task plan approved/declined: a `task` notification with `payload.event = "approval_needed"` gains `payload.status = "approved"\|"declined"`; a task question (`payload.event = "question"`) gains `payload.status = "answered"` with `payload.answer`, or `"cancelled"`) |
 | `notification.read` / `notification.deleted` | `{id}` (`null` = all) |
 | `integration.updated` | **Integration** (§5) |
-| `memory.updated` | `{action: "ADD"\|"UPDATE"\|"DELETE", id, content?, status?: "pending", reason?, previous?, session_id?}`; `status: "pending"` means the memory waits in the review inbox (section 7), with `reason: "instruction"` when it reads like an instruction (#234); `previous` is an UPDATE's words before it and `session_id` the chat a memory was learned in (extraction after a turn, `memory_remember`): that chat shows "Remembered: ... Undo" (Undo is `DELETE /api/memories/{id}`, or `PUT` with `previous` for an update) or "Waiting for your review: ..." with Review (#234); bulk changes (import, delete by source, expiry purge) send `id: null` plus `source?`/`reason?` and `count`. Review sends `reason: "approved"` (ADD, or DELETE with `merged_into` when the same words were already remembered), `"discarded"` (DELETE) and `"review_expired"` (bulk DELETE) |
+| `memory.updated` | `{action: "ADD"\|"UPDATE"\|"DELETE", id, content?, status?: "pending", reason?, previous?, session_id?}`; `status: "pending"` means the memory waits in the review inbox (section 7), with `reason: "instruction"` when it reads like an instruction (#234); `previous` is an UPDATE's words before it and `session_id` the chat a memory was learned in (extraction after a turn, `memory_remember`): that chat shows "Remembered: ... Undo" (Undo is `DELETE /api/memories/{id}`, or `PUT` with `previous` for an update) or "Waiting for your review: ..." with Review (#234); bulk changes (import, delete by source, expiry purge) send `id: null` plus `source?`/`reason?` and `count`. Review sends `reason: "approved"` (ADD, or DELETE with `merged_into` when the same words were already remembered), `"discarded"` (DELETE) and `"review_expired"` (bulk DELETE). Memory scopes (#155, section 7): a save carries `scope` (where it was kept); moving a memory sends UPDATE with `reason: "moved"`, `scope` and `previous_scope`; resetting a scope sends a bulk DELETE with `reason: "scope_reset"`, `scope` and `count` |
 | `skill.updated` | `{name, state: "active"\|"pending_review"\|"stale"\|"archived"\|"rejected"\|"deleted"}` |
 | `mcp.review` | `{server, reason?: "new"\|"changed", tools?: [tool names on the server], needed}`: an MCP server's tools wait for review, or the user answered (section 5) |
-| `session.updated` | `{session_id, title?, model?}`: only what changed. `title` after a rename or an automatic title; `model` (`null` = the default) after the chat's model was picked (section 2) |
+| `session.updated` | `{session_id, title?, model?, memory_scope?}`: only what changed. `title` after a rename or an automatic title; `model` (`null` = the default) after the chat's model was picked; `memory_scope` (the scope it uses now) after its memories were picked (section 2) |
 | `session.deleted` | `{session_id, reason?: "incognito"}`: a chat was deleted (`DELETE /api/sessions/{id}`, or an incognito chat closed by the engine, section 2) |
 | `rule_proposal.updated` | **RuleProposal** (section 2, rules from chat): a new "Make this a rule?" card, or one the user answered |
 | `approval_grants.updated` | `{count}`: a task or timed grant was added, revoked or ran out (section 2, "Scoped answers"); refetch `GET /api/approvals/grants` |
@@ -302,15 +302,20 @@ accept or loosen a rule.
   "From your answer on <date>"). An entry is dropped when its rule is changed or removed.
 
 ### Sessions (chats)
-- `GET /api/sessions?limit=100` → `[{id, title, channel, created_at, updated_at, untrusted, visited_hosts, incognito, model}]` newest first
+- `GET /api/sessions?limit=100` → `[{id, title, channel, created_at, updated_at, untrusted, visited_hosts, incognito, model, memory_scope}]` newest first
   (`untrusted`: the app whose content the chat read, e.g. `"Gmail"`, `""` when clean, `null` before its first turn;
   `visited_hosts`: list of web hosts it loaded, or `null`; section 10; `incognito`: bool, below. The window keeps
-  incognito chats out of its chat list; `model`: the chat's own model, `null` when it follows the default, below)
-- `POST /api/sessions?incognito=false&model=` → `{session_id}` (`model` optional: a new chat that starts on its own
-  model; 422 when it isn't `provider/model`)
-- `PATCH /api/sessions/{id}` `{title?, model?}` → `{ok, title?, model?}`: only the fields sent change. `model`
+  incognito chats out of its chat list; `model`: the chat's own model, `null` when it follows the default, below;
+  `memory_scope`: the memories it uses now, section 7 "Memory scopes": its own, else its messaging app's, else
+  `"personal"`)
+- `POST /api/sessions?incognito=false&model=&memory_scope=` → `{session_id}` (`model` optional: a new chat that starts on its own
+  model; 422 when it isn't `provider/model`. `memory_scope` optional: `personal`, `work` or a project's name; 422 for
+  `always`)
+- `PATCH /api/sessions/{id}` `{title?, model?, memory_scope?}` → `{ok, title?, model?, memory_scope?}`: only the fields sent change. `model`
   `"provider/model"` keeps that model for the chat; `null` or `""` makes it follow the default again ("Use the
-  default"). 404 unknown chat, 422 a `model` that isn't `provider/model`. Publishes `session.updated` with what changed.
+  default"). `memory_scope` picks the chat's memories (#155); `null` or `""` goes back to the default, and the response
+  carries the scope it uses now. 404 unknown chat, 422 a `model` that isn't `provider/model` or `memory_scope: "always"`.
+  Publishes `session.updated` with what changed.
 - **The chat's model** (#312). `sessions.model` is the one place a chat's model is kept: set it with `POST
   /api/sessions?model=` (a new chat) or `PATCH /api/sessions/{id}` `{model}`, or `/model chat <model>` in a messaging
   app (section 14). A `model` on `chat.send` or `POST /api/chat` is for that message only and never changes it.
@@ -757,7 +762,7 @@ Routes:
   "swarm_details": {"goal": "...", "items": [], "total_agents": 0, "completed_agents": 0,
                     "progress_updates": [{"worker_id": "agent-1|aggregator", "timestamp": "...", "status": "processing|completed|error|aggregating", "message": "..."}],
                     "aggregated_results": []} | null,
-  "enabled": true, "keep_running": false, "model": null, "browser_profile": "x-posting|null",
+  "enabled": true, "keep_running": false, "model": null, "browser_profile": "x-posting|null", "memory_scope": "personal",
   "deliver_to": "default" | "desktop" | [{"channel": "telegram|discord|whatsapp", "chat_id": "..."}],
   "notepad": "...|null",
   "original_context": {"source": "manual_creation|chat|proactive|trigger", "...": "..."},
@@ -767,6 +772,8 @@ Routes:
 ```
 `swarm_details` is `null` for single tasks. `script` is `null` unless `task_type` is `script` (section 16).
 `browser_profile` is the browser profile its runs use (section 12); `null` means `default`.
+`memory_scope` is the memories its runs use and save to (section 7, "Memory scopes"): `personal` unless set; a task a
+chat creates (`create_task_from_prompt`) takes that chat's scope.
 `deliver_to` is where the task's notifications go besides the app (see "Where results go" below).
 `notepad` is the notes a recurring task's runs keep for the next run (see "Recurring tasks remember" below); `null` when empty.
 `error` holds the last planning/run failure message (v2 `task.error`).
@@ -838,9 +845,11 @@ A run that called no tool and answers nothing still fails. Chat replies (`done.c
 ### Endpoints
 - `GET /api/tasks` → `[Task]`
 - `GET /api/tasks/{id}` → `Task`
-- `POST /api/tasks` `{prompt, is_swarm?: bool, assignee?: "ai", model?, browser_profile?}` → `Task` (status `planning`; refinement + planning continue in the background and arrive as `task.updated`)
+- `POST /api/tasks` `{prompt, is_swarm?: bool, assignee?: "ai", model?, browser_profile?, memory_scope?}` → `Task` (status `planning`; refinement + planning continue in the background and arrive as `task.updated`)
 - `POST /api/tasks/preview` `{prompt}` → `{name, description, priority, schedule}` (v2 generate-plan)
-- `PATCH /api/tasks/{id}` any of `{name, description, priority, schedule, plan, enabled, status, model, script, browser_profile, deliver_to, notepad, keep_running}` → `Task`
+- `PATCH /api/tasks/{id}` any of `{name, description, priority, schedule, plan, enabled, status, model, script, browser_profile, memory_scope, deliver_to, notepad, keep_running}` → `Task`
+  (`memory_scope`: the memories its runs recall and save to, section 7 "Memory scopes"; `null` or `""` is personal, 400
+  for `always`)
   (`keep_running: true`: never paused while the user is away, see "Routines pause while you are away")
   (`notepad`: text, trimmed and cut to 1500 characters; `null` or `""` clears it)
   (`browser_profile`: a name from `browser.profiles`, 400 for an unknown one; `null`, `""` or `"default"` clear it)
@@ -1535,7 +1544,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}` (`previous_content` is the text before the last UPDATE; `review` says where a held memory came from)
+**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)
 
 **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
@@ -1546,10 +1555,10 @@ 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=&limit=&offset=` → `[Memory]` newest first, 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=&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/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?}` → `{action: "ADD"|"UPDATE"|"DELETE"|"SKIP", id, content, status?: "pending"}` (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
+- `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
 near-duplicate shortcut needs the same person too; names in Devanagari (Hindi) count, and match across scripts
 ("माया" is "Maya", "प्रिया" is not "Riya") (#339). An UPDATE only replaces a fact about the same person and the same action on the same thing ("doesn't want files written" or "doesn't want emails deleted" never replaces "doesn't want files deleted"; it is added instead), and a new fact that an existing one already says in full, with no new name, place or number ("sister lives in a city" next to "sister Meera lives in Lisbon"), returns `SKIP` with that fact. A correction always UPDATEs, decided in code without the model and never skipped as a
 near-duplicate (#364): a new fact about the same person and action that says the same thing about it with a changed
@@ -1559,17 +1568,23 @@ 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)
+- `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)
 - `DELETE /api/memories/source/{source}` → `{deleted: n}`
+- `GET /api/memories/scopes` → `[{name, label, count, built_in}]`: `always`, `personal` and `work` first, then every
+  project a memory, chat, task or messaging app uses, by name; `count` = active memories in it.
+- `DELETE /api/memories/scope/{scope}` → `{deleted: n}`: resets one scope. Every memory in it goes (also ones waiting
+  for review), nothing in any other scope changes.
 - `POST /api/memories/export` `{format: "markdown"|"sqlite"}` → `{path, folder, name, format, memories, about_you,
   waiting}`: writes everything Sentient remembers to a new file in `<home>/files/exports/`
   (`sentient-memory-YYYYMMDD-HHMMSS.md|.db`, never overwriting one). Markdown: active facts grouped by first topic,
-  then insights ("About <name>"), then what waits for review, each line saying where it came from and when. SQLite:
-  tables `memories (id, content, source, topics, memory_type, status, created_at, updated_at, expires_at, came_from)`
+  then insights ("About <name>"), then what waits for review, each line saying where it came from and when (and
+  its scope when it isn't Personal: "Work, a chat, 3 Oct 2026"). SQLite:
+  tables `memories (id, content, source, topics, memory_type, status, created_at, updated_at, expires_at, came_from, scope)`
   and `about_you (id, dimension, statement, confidence, status, source, created_at, updated_at, came_from)`
   (`came_from` = the ReviewNote JSON or null). Retired insights and embeddings are left out. `memories` and
   `about_you` count active ones, `waiting` held ones. 400 for another format. Code: `sentient/memory/export.py`.
-- `POST /api/memories/import` multipart `file` (pdf/txt/md/docx) → `{added, updated, skipped, pending, source}` (`source` = `file:<name>`; the facts wait for review, `pending` counts them, and existing memories are kept; 400 for other types)
+- `POST /api/memories/import?scope=` multipart `file` (pdf/txt/md/docx) → `{added, updated, skipped, pending, source}` (`scope` defaults to `personal`; `source` = `file:<name>`; the facts wait for review, `pending` counts them, and existing memories are kept; 400 for other types)
 - `GET /api/memories/summaries?limit=` → `[{id, content, start_at, end_at, session_id, untrusted}]` (`untrusted` = the app whose content that chat read, else `null`; such summaries are listed here but kept out of other chats, see below)
 - `GET /api/memories/workspace` → `{soul, user, memory, today, yesterday}` (full file contents, not the prompt-budgeted snapshot)
 - `PUT /api/memories/workspace/{soul|user|memory}` `{content}` → `{saved}`
@@ -1579,6 +1594,38 @@ attribute and no word of what it says in common ("a piano recital in July" for "
 
 When sqlite-vec cannot load, list/topics/graph return empty data and write routes return 503.
 
+### Memory scopes (#155)
+Every memory has a `scope`: `personal` (the default, and where every memory saved before scopes went), `work`, a
+project's own name (`"Kestrel launch"`, up to 40 characters; `Work`/`PERSONAL` are read as the built-in names), or
+`always` for the few things every chat should know (the user's name, how they like answers). Code:
+`sentient/memory/scopes.py`.
+- **What a run reads.** A chat (`sessions.memory_scope`), a task (`tasks.memory_scope`) and a messaging app
+  (`channels.<app>.memory_scope`, default `personal`) each have a scope; a chat without its own uses its messaging
+  app's, else personal, and `always` can't be picked for any of them. Recall for the system prompt, `memory_recall`,
+  `memory_search_by_source`, `user_model_ask` and a task's executor prompt reads that scope plus `always`, so a work
+  chat never brings up personal family or health memories. `memory_recall` takes `everywhere: true` for when the user
+  asks about one directly; a result from another scope then says where it is kept (`kept_for`). Scopes filter facts;
+  the rest of the prompt context is shared (below): user-model insights other than relationships, and USER.md
+  without its learned part. A helper a chat
+  started reads its chat's scope. Work not tied to a chat or task (proactive look-ups, dreaming, the user model's
+  refresh, the profile upkeep below) reads every scope.
+- **Personal files.** MEMORY.md and the "## Learned" part of USER.md are built from personal and always memories and
+  summaries of personal chats only (a deleted chat's summary keeps the scope it was written in, `summaries.scope`); moving a memory out of them (or resetting Personal or Always) also removes its
+  line from USER.md's learned part, and MEMORY.md is rewritten at its next upkeep.
+  A work or project chat leaves out MEMORY.md, the daily notes and USER.md's learned part (the rest of USER.md stays),
+  leaves out user-model insights about relationships, and its prompt says which memories it uses.
+- **Saving.** A save goes into the run's scope: facts extracted after a turn, saved when a chat is compressed, and
+  `memory_remember` (personal outside a chat or task). Duplicates, updates and corrections only look at memories in
+  that scope and `always`, so a save never changes a memory in an unrelated scope (`always` memories are shared, so a
+  correction anywhere can update one). `POST /api/memories`, document imports
+  and imports from other assistants (section 19) save to `personal` unless given a scope.
+- **Review.** A held memory keeps the scope it was saved for and is approved into it (ReviewItem `scope`; `null` for
+  insights).
+- **Incognito** chats (section 2) have a scope too; it only decides what they read, as nothing is saved from them.
+- **Dreaming** (section 15) never merges or settles two memories from different scopes.
+- **Backups** (section 20) carry scopes in `sentient.db` (`summaries.scope` too); restoring a backup from before scopes puts every memory in
+  `personal` (`SCHEMA_VERSION` 11).
+
 ### Memories waiting for review (ADR 0021)
 A memory that did not come from the user's own words in a clean chat is held: `status: "pending"` for facts, status
 `pending` for insights (section 15). Held: facts extracted after a turn of a chat marked untrusted (section 10,
@@ -2299,6 +2346,8 @@ A device ("node") is a phone, a pair of smart glasses, a watch, or the desktop a
   - `qr`: WhatsApp only, while `status` is `linking`: the text to render as a QR code (it changes about every 20 s and
     arrives through `channel.updated`); `null` otherwise.
 - **PairedChat** `{chat_id, label, paired_at, deliver: bool, session_id}` (`deliver` defaults to `channels.<id>.deliver_default`).
+- `channels.<id>.memory_scope` (default `personal`, #155): the memories that app's chats use and save to, unless a chat
+  has its own (section 7, "Memory scopes").
 - `GET /api/channels` → `[Channel]` (always all three ids).
 - `POST /api/channels/{id}/connect` `{fields: {bot_token}}` → `Channel`. The token is checked with the service (Telegram
   `getMe`, Discord `GET /users/@me`), stored in the OS keychain as `channel_<id>_token` (never in config, the database or
@@ -2992,6 +3041,11 @@ Sentient takes one:
 - before a restore replaces the data (so a restore can be undone).
 A snapshot that fails is logged and never keeps Sentient from starting.
 
+Memory scopes (#155) are part of `sentient.db` (`facts.scope`, `sessions.memory_scope`, `tasks.memory_scope`,
+`summaries.scope`), so a
+backup keeps them. Restoring a backup made before them (database version 10 or older) adds the columns on the next
+start, with every memory in `personal`.
+
 **Restore** is two steps, so nothing in use is swapped under the running engine: `POST /api/backups/restore` checks the
 archive (manifest, names, SQLite `quick_check`) and unpacks it into `<home>/backups/restore-pending`; the next engine
 start applies it before config or database are opened (the desktop restarts the engine at once). Applying takes a
diff --git a/sentient/agent/loop.py b/sentient/agent/loop.py
index 9c1369f5e..a17f8832e 100644
--- a/sentient/agent/loop.py
+++ b/sentient/agent/loop.py
@@ -90,6 +90,7 @@
     ToolCall,
 )
 from sentient.memory import review as memory_review
+from sentient.memory import scopes as memory_scopes
 from sentient.memory.facts import FactMemory
 from sentient.memory.sources import MemorySources
 from sentient.memory.workspace import Workspace
@@ -583,14 +584,17 @@ def tool_context(self, session_id: str | None, channel: str, *, origin: str | No
             },
         )
 
-    async def _user_model_context(self, user_text: str) -> tuple[str, list[dict]]:
-        """(prompt block, insights in it). Uses ``context_with_sources`` when the user model has it."""
+    async def _user_model_context(self, user_text: str, scope: str | None = None) -> tuple[str, list[dict]]:
+        """(prompt block, insights in it). Uses ``context_with_sources`` when the user model has it. A work or project
+        chat (#155) leaves out what it knows about family and friends."""
         um = getattr(self.app, "user_model", None) if self.app is not None else None
         fn = getattr(um, "context_with_sources", None) or getattr(um, "context_for", None)
         if not callable(fn):
             return "", []
+        personal = memory_scopes.is_personal(scope)
         try:
-            out = await asyncio.wait_for(fn(user_text), timeout=USER_MODEL_TIMEOUT_S)
+            call = fn(user_text) if personal else fn(user_text, leave_out=memory_scopes.PERSONAL_DIMENSIONS)
+            out = await asyncio.wait_for(call, timeout=USER_MODEL_TIMEOUT_S)
         except asyncio.CancelledError:
             raise
         except Exception as exc:  # includes the timeout: the user model must never slow a turn down much
@@ -600,11 +604,12 @@ async def _user_model_context(self, user_text: str) -> tuple[str, list[dict]]:
         text = text.strip() if isinstance(text, str) else ""
         return text, (insights if text and isinstance(insights, list) else [])
 
-    async def _recall(self, user_text: str) -> list[dict]:
+    async def _recall(self, user_text: str, scope: str | None = None) -> list[dict]:
+        """Facts for the prompt: in the chat's scope plus always (#155)."""
         if self.memory is None or self.config.memory.facts_top_k <= 0 or not user_text.strip():
             return []
         try:
-            return await self.memory.recall(user_text)
+            return await self.memory.recall(user_text, scopes=memory_scopes.recall_scopes(scope))
         except asyncio.CancelledError:
             raise
         except Exception as exc:
@@ -637,12 +642,15 @@ async def _system_prompt_with_sources(
     ) -> tuple[str, MemorySources, list[dict]]:
         """The system prompt, the memories put into it (recalled facts, user-model insights) and the pieces of the
         user's notes put into it (#354). An incognito chat (#154) reads memory and notes only while
-        ``chat.incognito_uses_memory`` is on, and is told nothing will be kept."""
+        ``chat.incognito_uses_memory`` is on, and is told nothing will be kept. The chat's memory scope (#155) decides
+        which facts are recalled; a work or project chat also leaves out the personal profile files."""
         incognito = bool((session or {}).get("incognito"))
         reads_memory = not incognito or self.config.chat.incognito_uses_memory
+        scope = memory_scopes.of_session(self.config, session)
+        personal = memory_scopes.is_personal(scope)
         if reads_memory:
             facts, (user_context, insights), notes = await asyncio.gather(
-                self._recall(user_text), self._user_model_context(user_text), self._prompt_notes(user_text)
+                self._recall(user_text, scope), self._user_model_context(user_text, scope), self._prompt_notes(user_text)
             )
         else:
             facts, user_context, insights, notes = [], "", [], []
@@ -652,6 +660,11 @@ async def _system_prompt_with_sources(
         snapshot = self.workspace.snapshot()
         if not reads_memory:  # only the persona: no profile, memory file or daily notes
             snapshot = {k: (v if k == "soul" else "") for k, v in snapshot.items()}
+        elif not personal:  # MEMORY.md, daily notes and USER.md's learned facts come from personal memories (#155)
+            snapshot = {
+                **snapshot, "memory": "", "today": "", "yesterday": "",
+                "user": memory_scopes.without_learned(snapshot.get("user") or ""),
+            }
         prompt = build_system_prompt(
             snapshot=snapshot,
             facts=facts,
@@ -668,6 +681,8 @@ async def _system_prompt_with_sources(
         )
         if session and session.get("context_summary"):
             prompt += "\n\n## Earlier in this conversation\n" + session["context_summary"]
+        if reads_memory and not personal:
+            prompt += "\n\n" + memory_scopes.prompt_note(scope)
         if incognito:
             prompt += "\n\n" + (INCOGNITO_NOTE if reads_memory else INCOGNITO_NO_MEMORY_NOTE)
         return prompt, sources, notes
@@ -1683,6 +1698,7 @@ def release() -> list[str]:
             messages: list[dict] = [{"role": "system", "content": system}, *convo]
             ctx = self.tool_context(session_id, channel)
             ctx.incognito = incognito
+            ctx.memory_scope = memory_scopes.of_session(self.config, session)  # recall and saving use it (#155)
             ctx.user_words = [user_text]  # what the user typed or said, never attachments (#140)
             # outside content read earlier in this chat still counts until a new chat starts (ADR 0018)
             ctx.untrusted = await self._chat_untrusted(session_id, session)
@@ -1790,7 +1806,9 @@ async def persist(role_: str, content: str | None, **fields: Any) -> None:
                 if self.memory is not None and self.config.memory.extract_after_turn and not incognito:
                     # a chat that read outside content holds what it learns for the user's review (ADR 0021)
                     log.info("chat %s: fact extraction started for this turn", session_id)
-                    self._spawn(self._extract(said, memory_review.for_context(ctx), session_id), "memory")
+                    self._spawn(
+                        self._extract(said, memory_review.for_context(ctx), session_id, ctx.memory_scope), "memory"
+                    )
                 if self.config.chat.auto_title and session and (session.get("title") or "") == (user_text or "")[:60]:
                     self._spawn(self._auto_title(session_id, user_text, result.text), "titles")
                 self._spawn(self._maybe_compress(session_id, flush=not incognito), "memory")
@@ -2049,11 +2067,13 @@ def _publish_memory(self, results: Any, session_id: str | None = None) -> None:
                     "memory.updated", {"action": r["action"], "id": r.get("id"), "content": r.get("content"), **extra}
                 )
 
-    async def _extract(self, user_text: str, review: dict | None = None, session_id: str | None = None) -> None:
+    async def _extract(
+        self, user_text: str, review: dict | None = None, session_id: str | None = None, scope: str | None = None
+    ) -> None:
         """Only the user's own words are mined for facts; the assistant's reply is
         mostly restated context (dates, tool output) and produced junk memories.
         With ``review`` (the chat read outside content) a fact is held for the user's review unless the user's own
-        words back all of it (#234); instruction-shaped ones are always held."""
+        words back all of it (#234); instruction-shaped ones are always held. New facts go in the chat's ``scope``."""
         assert self.memory is not None
         if len(user_text.split()) < 4:
             return
@@ -2061,6 +2081,7 @@ async def _extract(self, user_text: str, review: dict | None = None, session_id:
             results = await self.memory.extract_and_store(
                 user_text, self.config.assistant.user_name, own=True, session_id=session_id,
                 **({"review": review} if review else {}),
+                **({"scope": scope} if scope and scope != memory_scopes.PERSONAL else {}),
             )
             self._publish_memory(results, session_id)
         except Exception as exc:
@@ -2083,13 +2104,17 @@ async def _auto_title(self, session_id: str, user_text: str, reply: str) -> None
         except Exception as exc:
             log.debug("auto title failed: %s", exc)
 
-    async def _flush_memory(self, transcript: str, untrusted: str = "", session_id: str | None = None) -> None:
+    async def _flush_memory(
+        self, transcript: str, untrusted: str = "", session_id: str | None = None, scope: str | None = None
+    ) -> None:
         """Let the memory package keep durable facts from turns about to be folded into a summary. In a chat that
         read outside content they are held for the user's review (ADR 0021)."""
         flush = getattr(self.memory, "flush_conversation", None) if self.memory is not None else None
         if not callable(flush):
             return
         held = {"review": memory_review.note(untrusted, session_id=session_id)} if untrusted else {}
+        if scope and scope != memory_scopes.PERSONAL:
+            held["scope"] = scope  # the chat's memory scope (#155)
         try:  # publishes its own memory.updated, with the chat so it can offer Undo (#234)
             await flush(transcript, self.config.assistant.user_name, session_id=session_id, **held)
         except Exception as exc:
@@ -2117,7 +2142,10 @@ async def _maybe_compress(self, session_id: str, *, flush: bool = True) -> None:
                 return
             transcript = "\n".join(f"{r['role']}: {(r['content'] or '')[:800]}" for r in older)
             if flush:
-                await self._flush_memory(transcript, (session or {}).get("untrusted") or "", session_id)
+                await self._flush_memory(
+                    transcript, (session or {}).get("untrusted") or "", session_id,
+                    memory_scopes.of_session(self.config, session),
+                )
             prev = (session or {}).get("context_summary") or ""
             summary = await self.llm.complete_text(
                 "fast",
diff --git a/sentient/config/schema.py b/sentient/config/schema.py
index 787efef2e..40d3b5be7 100644
--- a/sentient/config/schema.py
+++ b/sentient/config/schema.py
@@ -1054,6 +1054,10 @@ class ChannelAppConfig(BaseModel):
     show_tool_activity: bool = Field(
         True, description="Briefly show what the assistant is doing (for example 'Searching the web...')."
     )
+    memory_scope: str = Field(
+        "personal",
+        description="Which memories chats in this app use and save new ones to: personal, work, or a project's name.",
+    )
 
 
 class ChannelsConfig(BaseModel):
diff --git a/sentient/evolution/service.py b/sentient/evolution/service.py
index 42b54c779..0e8ad9d9c 100644
--- a/sentient/evolution/service.py
+++ b/sentient/evolution/service.py
@@ -31,6 +31,7 @@
 from sentient.evolution import prompts
 from sentient.evolution.log import log_event
 from sentient.memory import review as memory_review
+from sentient.memory import scopes as memory_scopes
 from sentient.memory.episodic import CLEAN as CLEAN_SUMMARY
 from sentient.memory.topics import TOPIC_NAMES
 from sentient.memory.vectors import cosine
@@ -44,6 +45,8 @@
 TRANSCRIPT_BUDGET = 14_000
 REVIEW_LOOKBACK_DAYS = 3
 STABLE_TOPICS = set(TOPIC_NAMES) - {"Miscellaneous"}
+# the memory scopes the profile files (MEMORY.md, USER.md) are built from (#155); work and project chats leave them out
+PROFILE_SCOPES = "COALESCE(scope, 'personal') IN ('personal', 'always')"
 DONE_STATUSES = {"completed", "completed_with_errors"}
 FAILED_RUN_STATUSES = {"error", "failed", "completed_with_errors"}
 REPAIR_TRANSCRIPT_BUDGET = 6_000
@@ -858,19 +861,21 @@ async def update_profile(self, now: datetime | None = None, *, force: bool = Fal
         facts_mark = await store.get_meta(PROFILE_FACTS_MARK) or since
         summaries_mark = await store.get_meta(PROFILE_SUMMARIES_MARK) or since
         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'"
             f" AND memory_type = 'long-term' AND {after} AND (expires_at IS NULL OR expires_at > ?)"
-            " ORDER BY updated_at, id",
+            f" AND {PROFILE_SCOPES} ORDER BY updated_at, id",
             (*params, nowiso),
         )
         # chats that read outside content never feed MEMORY.md (ADR 0021): their facts wait for review and their
         # summaries are left out
         after, params = after_watermark(summaries_mark, "created_at", "id")
+        personal, personal_params = memory_scopes.personal_summary_sql(cfg)  # no work or project chat's (#155)
         new_summaries = await store.fetchall(
-            f"SELECT id, content, created_at FROM summaries WHERE {after} AND {CLEAN_SUMMARY}"
+            f"SELECT id, content, created_at FROM summaries WHERE {after} AND {CLEAN_SUMMARY} AND {personal}"
             " ORDER BY created_at, id LIMIT 8",  # in watermark order, so the limit never jumps over a summary
-            params,
+            (*params, *personal_params),
         )
         await store.set_meta("evolution.profile_last_run", nowiso)
         # saved after every read, also an empty one: the next read starts where this one did, never at this run's time
@@ -890,11 +895,13 @@ 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 > ?)"
-            " ORDER BY updated_at DESC, id DESC LIMIT 80",
+            f" AND {PROFILE_SCOPES} ORDER BY updated_at DESC, id DESC LIMIT 80",
             (nowiso,),
         )
         summaries = await store.fetchall(
-            f"SELECT content FROM summaries WHERE {CLEAN_SUMMARY} ORDER BY end_at DESC, rowid DESC LIMIT 8"
+            f"SELECT content FROM summaries WHERE {CLEAN_SUMMARY} AND {personal}"
+            " ORDER BY end_at DESC, rowid DESC LIMIT 8",
+            personal_params,
         )
         current = app.workspace.read_full()["memory"]
         memory_chars = 0
diff --git a/sentient/gateway/routes/core.py b/sentient/gateway/routes/core.py
index bb0f4817e..f6fce07d3 100644
--- a/sentient/gateway/routes/core.py
+++ b/sentient/gateway/routes/core.py
@@ -26,6 +26,7 @@
 from sentient.llm import availability
 from sentient.llm.events import Done, Error
 from sentient.llm.spending import BudgetError
+from sentient.memory import scopes as memory_scopes
 from sentient.memory.personas import render_persona
 from sentient.tools.rules import SCREEN_FOLDER, SELECTION_FOLDER
 
@@ -248,8 +249,10 @@ async def patch_config(request: Request, body: dict):
 # ----------------------------------------------------------------------------- sessions
 @router.get("/api/sessions", dependencies=_auth)
 async def sessions(request: Request, limit: int = 100):
-    rows = await get_core(request).store.list_sessions(limit)
+    s = get_core(request)
+    rows = await s.store.list_sessions(limit)
     for row in rows:  # stored as JSON text; the API gives a list (or null)
+        row["memory_scope"] = memory_scopes.of_session(s.config, row)  # the scope it uses now (#155)
         raw = row.get("visited_hosts")
         try:
             row["visited_hosts"] = json.loads(raw) if raw else None
@@ -267,9 +270,25 @@ def _chat_model(value: str | None) -> str | None:
         raise HTTPException(422, str(exc)) from exc
 
 
+def _chat_scope(value: str | None) -> str | None:
+    """A chat's memory scope (#155): None follows the default; 422 for "always"."""
+    try:
+        return memory_scopes.chat_scope(value)
+    except ValueError as exc:
+        raise HTTPException(422, str(exc)) from exc
+
+
 @router.post("/api/sessions", dependencies=_auth)
-async def create_session(request: Request, channel: str = "desktop", incognito: bool = False, model: str | None = None):
-    sid = await get_core(request).store.create_session(channel=channel, incognito=incognito, model=_chat_model(model))
+async def create_session(
+    request: Request,
+    channel: str = "desktop",
+    incognito: bool = False,
+    model: str | None = None,
+    memory_scope: str | None = None,
+):
+    sid = await get_core(request).store.create_session(
+        channel=channel, incognito=incognito, model=_chat_model(model), memory_scope=_chat_scope(memory_scope)
+    )
     return {"session_id": sid}
 
 
@@ -297,21 +316,30 @@ class SessionPatch(BaseModel):
     title: str | None = None
     # the chat's own model (#312): "provider/model" keeps it for this chat; null or "" follows the default again
     model: str | None = None
+    # the memories it uses (#155): "personal", "work" or a project's name; null or "" follows the default again
+    memory_scope: str | None = None
 
 
 @router.patch("/api/sessions/{session_id}", dependencies=_auth)
 async def update_session(request: Request, session_id: str, body: SessionPatch):
-    """Rename a chat, or pick its model. Only the fields sent change."""
+    """Rename a chat, or pick its model or memory scope. Only the fields sent change."""
     s = get_core(request)
-    if await s.store.get_session(session_id) is None:
+    session = await s.store.get_session(session_id)
+    if session is None:
         raise HTTPException(404, "no such chat")
+    # every field is checked before anything is written, so a 422 changes nothing
+    model = _chat_model(body.model) if "model" in body.model_fields_set else None
+    scope = _chat_scope(body.memory_scope) if "memory_scope" in body.model_fields_set else None
     changed: dict[str, Any] = {}
     if body.title is not None:
         changed["title"] = body.title.strip()[:120]
         await s.store.rename_session(session_id, changed["title"])
     if "model" in body.model_fields_set:
-        changed["model"] = _chat_model(body.model)
-        await s.store.set_session_model(session_id, changed["model"])
+        changed["model"] = model
+        await s.store.set_session_model(session_id, model)
+    if "memory_scope" in body.model_fields_set:
+        await s.store.set_session_scope(session_id, scope)
+        changed["memory_scope"] = memory_scopes.of_session(s.config, {**session, "memory_scope": scope})
     if changed:
         s.bus.publish("session.updated", {"session_id": session_id, **changed})
     return {"ok": True, **changed}
diff --git a/sentient/gateway/routes/memory.py b/sentient/gateway/routes/memory.py
index 510330444..585d7e2d3 100644
--- a/sentient/gateway/routes/memory.py
+++ b/sentient/gateway/routes/memory.py
@@ -11,6 +11,7 @@
 from sentient.gateway.deps import AUTH, get_core
 from sentient.memory import export as memory_export
 from sentient.memory import review as memory_review
+from sentient.memory import scopes as memory_scopes
 from sentient.memory.episodic import EpisodicMemory
 from sentient.memory.personas import PERSONAS, render_persona
 from sentient.memory.topics import TOPICS
@@ -18,6 +19,7 @@
 router = APIRouter(prefix="/api/memories", tags=["memory"], dependencies=AUTH)
 
 IMPORT_SUFFIXES = {".pdf", ".txt", ".md", ".markdown", ".docx"}
+PROFILE_SCOPES = (memory_scopes.PERSONAL, memory_scopes.ALWAYS)  # what USER.md and MEMORY.md are built from
 
 
 def _memory(request: Request):
@@ -29,16 +31,39 @@ def _memory(request: Request):
 
 @router.get("")
 async def list_memories(
-    request: Request, topic: str = "", q: str = "", source: str = "", limit: int = 500, offset: int = 0
+    request: Request, topic: str = "", q: str = "", source: str = "", limit: int = 500, offset: int = 0,
+    scope: str = "",
 ):
     s = get_core(request)
     if s.memory is None:
         return []
     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
+        max(1, min(limit, 2000)), max(0, offset), topic=topic or None, source=source or None, q=q or None,
+        scope=scope or None,
     )
 
 
+@router.get("/scopes")
+async def scopes(request: Request):
+    """Always, Personal and Work, then every project in use, each with how many memories it holds (#155)."""
+    return await memory_scopes.list_scopes(get_core(request))
+
+
+@router.delete("/scope/{scope:path}")
+async def reset_scope(request: Request, scope: str):
+    """Forget every memory in one scope, and nothing else (#155)."""
+    target = memory_scopes.normalize(scope)
+    if not target:
+        raise HTTPException(400, "scope is required")
+    mem = _memory(request)
+    rows = await get_core(request).store.fetchall("SELECT content FROM facts WHERE scope = ?", (target,))
+    gone = [r["content"] for r in rows]  # all of them, not one page
+    deleted = await mem.forget_scope(target)
+    if target in PROFILE_SCOPES:
+        get_core(request).workspace.remove_learned(gone)
+    return {"deleted": deleted}
+
+
 @router.get("/topics")
 async def topics(request: Request):
     s = get_core(request)
@@ -108,7 +133,7 @@ async def personas(request: Request):
 
 
 @router.post("/import")
-async def import_document(request: Request, file: UploadFile = File(...)):
+async def import_document(request: Request, file: UploadFile = File(...), scope: str = ""):
     s = get_core(request)
     mem = _memory(request)
     name = Path(file.filename or "document.txt").name
@@ -120,7 +145,9 @@ async def import_document(request: Request, file: UploadFile = File(...)):
         with path.open("wb") as fh:
             shutil.copyfileobj(file.file, fh)
         try:
-            return await mem.import_document(path, username=s.config.assistant.user_name, source=f"file:{name}")
+            return await mem.import_document(
+                path, username=s.config.assistant.user_name, source=f"file:{name}", scope=scope or None
+            )
         except ValueError as exc:
             raise HTTPException(400, str(exc)) from exc
 
@@ -198,7 +225,8 @@ async def create_memory(request: Request, body: dict):
     content = str(body.get("content", "")).strip()
     if not content:
         raise HTTPException(400, "content is required")
-    return await mem.remember(content, source=str(body.get("source") or "manual"), notify=True)
+    scope = memory_scopes.normalize(body.get("scope"), memory_scopes.PERSONAL)  # #155
+    return await mem.remember(content, source=str(body.get("source") or "manual"), notify=True, scope=scope)
 
 
 @router.put("/{memory_id}")
@@ -213,6 +241,25 @@ async def update_memory(request: Request, memory_id: int, body: dict):
         raise HTTPException(404, f"memory {memory_id} not found") from exc
 
 
+@router.patch("/{memory_id}")
+async def move_memory(request: Request, memory_id: int, body: dict):
+    """Move a memory to another scope (#155): ``{scope}``."""
+    mem = _memory(request)
+    scope = memory_scopes.normalize(body.get("scope"))
+    if not scope:
+        raise HTTPException(400, "scope is required")
+    try:
+        before = await mem.scope_of(memory_id)
+        moved = await mem.set_scope(memory_id, scope)
+    except KeyError as exc:
+        raise HTTPException(404, f"memory {memory_id} not found") from exc
+    if before in PROFILE_SCOPES and moved["scope"] not in PROFILE_SCOPES:
+        # USER.md's learned facts are personal: one moved to work or a project leaves it. MEMORY.md is rewritten
+        # from personal memories at its next upkeep.
+        get_core(request).workspace.remove_learned([moved["content"]])
+    return moved
+
+
 @router.delete("/{memory_id}")
 async def delete_memory(request: Request, memory_id: int):
     mem = _memory(request)
diff --git a/sentient/gateway/routes/tasks.py b/sentient/gateway/routes/tasks.py
index 2eb3c5c35..4f256a0b8 100644
--- a/sentient/gateway/routes/tasks.py
+++ b/sentient/gateway/routes/tasks.py
@@ -21,6 +21,7 @@ class CreateTaskBody(BaseModel):
     assignee: str | None = "ai"
     model: str | None = None
     browser_profile: str | None = None
+    memory_scope: str | None = None  # #155: personal (default), work or a project's name
 
 
 class PreviewBody(BaseModel):
@@ -69,7 +70,8 @@ async def list_tasks(request: Request):
 @router.post("")
 async def create_task(request: Request, body: CreateTaskBody):
     return await _guard(_tasks(request).create_task(
-        body.prompt, is_swarm=body.is_swarm, model=body.model, browser_profile=body.browser_profile
+        body.prompt, is_swarm=body.is_swarm, model=body.model, browser_profile=body.browser_profile,
+        memory_scope=body.memory_scope,
     ))
 
 
diff --git a/sentient/memory/dreaming.py b/sentient/memory/dreaming.py
index 1dc016dcc..4acbc3813 100644
--- a/sentient/memory/dreaming.py
+++ b/sentient/memory/dreaming.py
@@ -383,6 +383,8 @@ def find(x: int) -> int:
             return x
 
         for i, j, _sim in similar_pairs(facts, cfg.merge_similarity):
+            if facts[i].get("scope") != facts[j].get("scope"):
+                continue  # memory scopes stay apart (#155): a work memory never folds into a personal one
             a, b = facts[i]["content"], facts[j]["content"]
             if word_overlap(a, b) < cfg.merge_min_overlap:
                 continue
@@ -474,7 +476,7 @@ async def _language_step(self, stats: dict, notes: dict, budget: list[int]) -> N
             if budget[0] <= 0 or calls <= 0:
                 break
             hindi, other = facts[i], facts[j]
-            if hindi["id"] in gone or other["id"] in gone:
+            if hindi["id"] in gone or other["id"] in gone or hindi.get("scope") != other.get("scope"):
                 continue
             ids = tuple(sorted((hindi["id"], other["id"])))
             if ids in kept_apart:
@@ -598,7 +600,7 @@ async def _contradiction_step(self, stats: dict, notes: dict, budget: list[int])
             if budget[0] <= 0:
                 break
             older, newer = sorted((facts[i], facts[j]), key=lambda f: (f["updated_at"], f["id"]))
-            if older["id"] in gone or newer["id"] in gone:
+            if older["id"] in gone or newer["id"] in gone or older.get("scope") != newer.get("scope"):
                 continue
             pair_key = f"{older['id']}@{older['updated_at']}|{newer['id']}@{newer['updated_at']}"
             if pair_key in checked:
diff --git a/sentient/memory/episodic.py b/sentient/memory/episodic.py
index c193b611a..8130a0c2c 100644
--- a/sentient/memory/episodic.py
+++ b/sentient/memory/episodic.py
@@ -20,6 +20,7 @@
 from sentient.config.schema import SentientConfig
 from sentient.llm.provider import LLMProvider
 from sentient.memory import prompts
+from sentient.memory import scopes as memory_scopes
 from sentient.memory.vectors import VecTable, pack
 from sentient.store.db import NOT_INCOGNITO, Store, new_id, now_iso
 
@@ -128,12 +129,16 @@ async def add_summary(self, session_id: str | None, content: str, chunk: list[di
         sid = new_id()
         ids = [m["id"] for m in chunk]
         start_at, end_at = chunk[0]["created_at"], chunk[-1]["created_at"]
-        session = await self.store.fetchone("SELECT untrusted FROM sessions WHERE id = ?", (session_id,))
+        session = await self.store.fetchone(
+            "SELECT untrusted, channel, memory_scope FROM sessions WHERE id = ?", (session_id,)
+        )
         untrusted = (session["untrusted"] or "") if session else ""
+        # the chat's memory scope (#155), kept so the summary stays out of the personal profile after the chat is gone
+        scope = memory_scopes.of_session(self.config, dict(session)) if session else memory_scopes.PERSONAL
         cur = await self.store.execute(
-            "INSERT INTO summaries(id, session_id, content, start_at, end_at, message_ids, created_at, untrusted)"
-            " VALUES(?,?,?,?,?,?,?,?)",
-            (sid, session_id, content, start_at, end_at, json.dumps(ids), now_iso(), untrusted),
+            "INSERT INTO summaries(id, session_id, content, start_at, end_at, message_ids, created_at, untrusted, scope)"
+            " VALUES(?,?,?,?,?,?,?,?,?)",
+            (sid, session_id, content, start_at, end_at, json.dumps(ids), now_iso(), untrusted, scope),
         )
         try:
             [vec] = await self._embed([content])
diff --git a/sentient/memory/export.py b/sentient/memory/export.py
index 7651be4f1..ee69e215d 100644
--- a/sentient/memory/export.py
+++ b/sentient/memory/export.py
@@ -20,6 +20,7 @@
 from typing import Any
 
 from sentient import paths
+from sentient.memory import scopes as memory_scopes
 from sentient.memory.schema import ensure_memory_schema
 from sentient.memory.topics import DEFAULT_TOPIC, TOPIC_NAMES
 
@@ -54,7 +55,7 @@ def _day(iso: str | None) -> str:
 async def _rows(app: Any) -> tuple[list[dict], list[dict]]:
     await ensure_memory_schema(app.store)
     facts = [dict(r) for r in await app.store.fetchall(
-        "SELECT id, content, source, topics, memory_type, status, created_at, updated_at, expires_at, review"
+        "SELECT id, content, source, topics, memory_type, status, created_at, updated_at, expires_at, review, scope"
         " FROM facts ORDER BY created_at, id"
     )]
     insights = [dict(r) for r in await app.store.fetchall(
@@ -72,8 +73,10 @@ def _topics(raw: str) -> list[str]:
     return found or [DEFAULT_TOPIC]
 
 
-def _line(text: str, source: str, at: str | None, review: str | None = None) -> str:
+def _line(text: str, source: str, at: str | None, review: str | None = None, scope: str | None = None) -> str:
     where = source_words(source)
+    if scope and scope != memory_scopes.PERSONAL:  # #155: Work, Always or a project
+        where = f"{memory_scopes.label(scope)}, {where}"
     try:
         note = json.loads(review) if review else None
     except (TypeError, ValueError):
@@ -99,14 +102,17 @@ def markdown(user: str, facts: list[dict], insights: list[dict], now: datetime)
     for topic in TOPIC_NAMES:
         rows = [f for f in active if _topics(f["topics"])[0] == topic]
         if rows:
-            out += [f"## {topic}", "", *(_line(f["content"], f["source"], f["created_at"]) for f in rows), ""]
+            out += [
+                f"## {topic}", "",
+                *(_line(f["content"], f["source"], f["created_at"], scope=f.get("scope")) for f in rows), "",
+            ]
     if known:
         out += [f"## About {name}", ""]
         out += [_line(i["statement"], i["source"], i["created_at"]) for i in known] + [""]
     if waiting:
         out += ["## Waiting for your review", "", "Sentient doesn't use these until you approve them.", ""]
-        out += [_line(w.get("content") or w.get("statement"), w["source"], w["created_at"], w.get("review"))
-                for w in waiting] + [""]
+        out += [_line(w.get("content") or w.get("statement"), w["source"], w["created_at"], w.get("review"),
+                      w.get("scope")) for w in waiting] + [""]
     if not active and not known and not waiting:
         out += ["Sentient doesn't remember anything yet.", ""]
     return "\n".join(out)
@@ -118,15 +124,16 @@ def _sqlite(path: Path, facts: list[dict], insights: list[dict]) -> None:
         con.executescript(
             """
             CREATE TABLE memories (id INTEGER PRIMARY KEY, content TEXT NOT NULL, source TEXT, topics TEXT,
-                memory_type TEXT, status TEXT, created_at TEXT, updated_at TEXT, expires_at TEXT, came_from TEXT);
+                memory_type TEXT, status TEXT, created_at TEXT, updated_at TEXT, expires_at TEXT, came_from TEXT,
+                scope TEXT);
             CREATE TABLE about_you (id TEXT PRIMARY KEY, dimension TEXT, statement TEXT NOT NULL, confidence REAL,
                 status TEXT, source TEXT, created_at TEXT, updated_at TEXT, came_from TEXT);
             """
         )
         con.executemany(
-            "INSERT INTO memories VALUES (?,?,?,?,?,?,?,?,?,?)",
+            "INSERT INTO memories VALUES (?,?,?,?,?,?,?,?,?,?,?)",
             [(f["id"], f["content"], f["source"], f["topics"], f["memory_type"], f["status"], f["created_at"],
-              f["updated_at"], f["expires_at"], f["review"]) for f in facts],
+              f["updated_at"], f["expires_at"], f["review"], f.get("scope") or memory_scopes.PERSONAL) for f in facts],
         )
         con.executemany(
             "INSERT INTO about_you VALUES (?,?,?,?,?,?,?,?,?)",
diff --git a/sentient/memory/facts.py b/sentient/memory/facts.py
index 6cd2b11af..5081e4a55 100644
--- a/sentient/memory/facts.py
+++ b/sentient/memory/facts.py
@@ -13,6 +13,9 @@
 - Expired facts are filtered at query time as well as purged hourly.
 - Importing a document adds to memory instead of wiping it (v2 build_initial_memory).
 - Search by source works (v2 formatted a prompt with a missing key and crashed).
+- Every fact has a scope (#155, ``memory.scopes``): personal, work, always or a project. Recall reads the scopes it
+  is given (a chat's own plus always); saving puts the fact in one scope and only compares it with facts in that scope
+  and always, so a save never changes a memory in another scope.
 - Memories from outside content, unprompted work or imports are held for review (``status = 'pending'``, ADR
   0021): they have no vector, and every read here except ``pending_facts`` skips them, so recall, prompts,
   proactivity, the user model and dreaming never see one until the user approves it.
@@ -35,6 +38,7 @@
 from sentient.llm.provider import LLMProvider
 from sentient.memory import prompts
 from sentient.memory import review as reviews
+from sentient.memory import scopes as memory_scopes
 from sentient.memory.episodic import EpisodicMemory
 from sentient.memory.schema import ensure_memory_schema
 from sentient.memory.scripts import (
@@ -67,7 +71,8 @@
 _TAUTOLOGY_RE = re.compile(r"^\s*(?P<n>[\w .'-]+?)['\u2019]s name is (?P=n)\s*\.?\s*$", re.IGNORECASE)
 
 MEMORY_COLUMNS = (
-    "id, content, source, topics, memory_type, created_at, updated_at, expires_at, previous_content, status, review"
+    "id, content, source, topics, memory_type, created_at, updated_at, expires_at, previous_content, status, review,"
+    " scope"
 )
 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``
@@ -605,12 +610,20 @@ def _row_to_memory(r: Any, similarity: float | None = None) -> dict:
         "previous_content": r["previous_content"] if "previous_content" in r.keys() else None,  # noqa: SIM118 - sqlite Row, where `in row` checks values
         "status": r["status"] if "status" in r.keys() else "active",  # noqa: SIM118
         "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
     }
     if similarity is not None:
         d["similarity"] = round(similarity, 4)
     return d
 
 
+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:
+        return "1", []
+    return f"{col} IN ({','.join('?' * len(scopes))})", list(scopes)
+
+
 def _analysis_from(raw: Any) -> tuple[list[str] | None, str, str | None]:
     """Accept both the v2 nested ``analysis`` object and flat keys."""
     if not isinstance(raw, dict):
@@ -677,14 +690,17 @@ async def embed_query(self, text: str) -> list[float]:
         return vec
 
     # ------------------------------------------------------------------ recall
-    async def _keyword_ids(self, tokens: list[str], limit: int, source: str | None) -> list[int]:
+    async def _keyword_ids(
+        self, tokens: list[str], limit: int, source: str | None, scopes: list[str] | None = None
+    ) -> list[int]:
         if not tokens:
             return []
+        in_scope, scope_params = _in_scopes(scopes, "f.scope")
         sql = (
             "SELECT f.id FROM facts_fts JOIN facts f ON f.id = facts_fts.rowid"
-            " WHERE facts_fts MATCH ? AND f.status = 'active'"
+            f" WHERE facts_fts MATCH ? AND f.status = 'active' AND {in_scope}"
         )
-        params: list[Any] = [" OR ".join(f'"{t}"' for t in tokens)]
+        params: list[Any] = [" OR ".join(f'"{t}"' for t in tokens), *scope_params]
         if source is not None:
             sql += " AND f.source = ?"
             params.append(source)
@@ -697,28 +713,31 @@ async def _keyword_ids(self, tokens: list[str], limit: int, source: str | None)
             return []
 
     async def _search(
-        self, query: str, k: int, min_sim: float, source: str | None = None
+        self, query: str, k: int, min_sim: float, source: str | None = None, scopes: list[str] | None = None
     ) -> 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."""
+        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."""
         await self.ensure_schema()
         qvec = await self.embed_query(query)
         now = now_iso()
         pool = max(k * 3, 10)
-        if source is None:
+        in_scope, scope_params = _in_scopes(scopes, "f.scope")
+        if source is None and scopes is None:
             sims = dict(await self.vec.knn(qvec, pool))
         else:
+            by_source = "f.source = ?" if source is not None else "1"
             rows = await self.store.fetchall(
                 "SELECT f.id, vec_distance_cosine(v.embedding, ?) AS distance"
-                " FROM facts f JOIN facts_vec v ON v.rowid = f.id WHERE f.source = ? AND f.status = 'active'"
-                " ORDER BY distance LIMIT ?",
-                (pack(qvec), source, pool),
+                f" FROM facts f JOIN facts_vec v ON v.rowid = f.id WHERE {by_source} AND {in_scope}"
+                " AND f.status = 'active' ORDER BY distance LIMIT ?",
+                (pack(qvec), *([source] if source is not None else []), *scope_params, pool),
             )
             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) if weight > 0 else []
+        kw_ids = await self._keyword_ids(tokens, pool, source, scopes) if weight > 0 else []
         missing = [i for i in kw_ids if i not in sims]
         if missing:
             marks = ",".join("?" * len(missing))
@@ -731,8 +750,10 @@ async def _search(
         if not sims:
             return []
         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}", list(sims)
+            f"SELECT {MEMORY_COLUMNS} FROM facts WHERE id IN ({marks}) AND {ACTIVE} AND {in_scope}",
+            [*sims, *scope_params],
         )
         qset = set(tokens)
         scored = []
@@ -757,15 +778,17 @@ async def recall(
         *,
         source: str | None = None,
         track: bool = True,
+        scopes: list[str] | None = None,
     ) -> list[dict]:
         """Relevant facts for ``query``. ``track`` counts the recall (dreaming promotes
-        short-term facts that keep being recalled); internal lookups pass False."""
+        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."""
         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)
+            out = await self._search(query, top_k, min_sim, source, scopes)
         except Exception as exc:
             log.warning("memory recall skipped: %s", exc)
             return []
@@ -779,8 +802,10 @@ async def recall(
                 )
         return out
 
-    async def search_by_source(self, query: str, source: str, top_k: int = 5) -> list[dict]:
-        return await self.recall(query, top_k=top_k, min_similarity=0.0, source=source, track=False)
+    async def search_by_source(
+        self, query: str, source: str, top_k: int = 5, scopes: list[str] | None = None
+    ) -> list[dict]:
+        return await self.recall(query, top_k=top_k, min_similarity=0.0, source=source, track=False, scopes=scopes)
 
     # ------------------------------------------------------------------ write paths
     async def _insert(
@@ -793,17 +818,18 @@ async def _insert(
         memory_type: str,
         duration: str | None,
         review: dict | None = None,
+        scope: str = memory_scopes.PERSONAL,
     ) -> int:
         """A held fact (``review`` set) is saved as pending without a vector, so recall cannot find it."""
         await self.ensure_schema()
         ts = now_iso()
         cur = await self.store.execute(
             "INSERT INTO facts(content, source, topics, memory_type, created_at, updated_at, expires_at, embedding_model,"
-            " status, review) VALUES(?,?,?,?,?,?,?,?,?,?)",
+            " status, review, scope) VALUES(?,?,?,?,?,?,?,?,?,?,?)",
             (
                 content, source, json.dumps(topics), memory_type, ts, ts,
                 expires_for(memory_type, duration), self.llm.model_for("embedding"),
-                "pending" if review is not None else "active", reviews.dump(review),
+                "pending" if review is not None else "active", reviews.dump(review), scope,
             ),
         )
         fid = int(cur.lastrowid)
@@ -864,7 +890,44 @@ async def forget_source(self, source: str) -> int:
             self.publish("DELETE", None, None, source=source, count=len(rows))
         return len(rows)
 
-    async def _related_facts(self, fact: str, exclude: set[int]) -> list[dict]:
+    async def set_scope(self, fid: int, scope: str) -> dict:
+        """Move a memory to another scope (#155). KeyError when it doesn't exist, ValueError for an empty scope."""
+        target = memory_scopes.normalize(scope)
+        if not target:
+            raise ValueError("scope is empty")
+        row = await self.store.fetchone("SELECT content, scope FROM facts WHERE id = ?", (fid,))
+        if row is None:
+            raise KeyError(fid)
+        if row["scope"] != target:
+            await self.store.execute(
+                "UPDATE facts SET scope = ?, updated_at = ? WHERE id = ?", (target, now_iso(), fid)
+            )
+            self.publish("UPDATE", fid, row["content"], scope=target, previous_scope=row["scope"], reason="moved")
+        fact = await self.get_fact(fid)
+        assert fact is not None
+        return fact
+
+    async def forget_scope(self, scope: str) -> int:
+        """Reset one scope: delete every memory in it (also ones waiting for review), and nothing else."""
+        target = memory_scopes.normalize(scope)
+        if not target:
+            return 0
+        rows = await self.store.fetchall(
+            "SELECT id FROM facts WHERE scope = ? AND status IN ('active', 'pending')", (target,)
+        )
+        for r in rows:
+            await self.forget(int(r["id"]))
+        if rows:
+            self.publish("DELETE", None, None, scope=target, reason="scope_reset", count=len(rows))
+        return len(rows)
+
+    async def scope_of(self, fid: int) -> str | None:
+        row = await self.store.fetchone("SELECT scope FROM facts WHERE id = ?", (fid,))
+        return (row["scope"] or memory_scopes.PERSONAL) if row else None
+
+    async def _related_facts(
+        self, fact: str, exclude: set[int], scopes: list[str] | None = None
+    ) -> list[dict]:
         """Up to 3 facts about the same subject and attribute family as ``fact``, found by keyword rather
         than embedding ("moved to Bengaluru last month" scores low against "lives in Pune")."""
         user = self.config.assistant.user_name
@@ -874,7 +937,9 @@ async def _related_facts(self, fact: str, exclude: set[int]) -> list[dict]:
         terms = [t for s in sorted(prof.subjects) for t in keyword_tokens(s)]
         for fam in sorted(prof.families):
             terms.extend(FAMILY_TERMS.get(fam, []))
-        ids = [i for i in await self._keyword_ids(list(dict.fromkeys(terms))[:24], 60, None) if i not in exclude]
+        ids = [
+            i for i in await self._keyword_ids(list(dict.fromkeys(terms))[:24], 60, None, scopes) if i not in exclude
+        ]
         if not ids:
             return []
         marks = ",".join("?" * len(ids))
@@ -930,17 +995,20 @@ async def remember(
         review: dict | None = None,
         own_words: str | None = None,
         session_id: str | None = None,
+        scope: str | None = None,
     ) -> dict[str, Any]:
-        """Store one fact with dedup / CUD logic. Returns {action, id, content} (an UPDATE adds ``previous``, the
-        words it replaced, so the save can be undone).
+        """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``).
 
         With ``review`` (``memory.review.note``) the fact is held for the user's review instead: it is only ever
         added (never updates or deletes another fact), and the result carries ``status: "pending"``. ``own_words`` is
         what the user typed or said in the chat it came from: a fact those words fully back is saved even in a chat
         that read outside content (#234, ``review.grounded``). A fact from a chat that reads like an instruction for
         how Sentient should act is always held (``review.instruction_shaped``). ``session_id`` goes on the
-        ``memory.updated`` event, so that chat can show "Remembered: ... Undo"."""
+        ``memory.updated`` event, so that chat can show "Remembered: ... Undo". Duplicates, updates and corrections
+        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
         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
@@ -951,9 +1019,11 @@ async def remember(
             else:  # held for outside content already: it keeps that source, and says it is an instruction too
                 review = {**review, "reason": reviews.INSTRUCTION}
         if review is not None:
-            result = await self._hold(fact, source=source, use_llm=use_llm, review=review)
+            result = await self._hold(fact, source=source, use_llm=use_llm, review=review, scope=scope)
         else:
-            result = await self._remember(fact, source=source, use_llm=use_llm)
+            result = await self._remember(fact, source=source, use_llm=use_llm, scope=scope)
+        if result["action"] == "ADD":
+            result["scope"] = scope
         if notify and result["action"] in {"ADD", "UPDATE", "DELETE"}:
             self.publish(result["action"], result["id"], result["content"], **self.event_extra(result, session_id))
         return result
@@ -971,38 +1041,52 @@ def event_extra(result: dict, session_id: str | None = None) -> dict[str, Any]:
             extra["previous"] = result["previous"]
         if session_id:
             extra["session_id"] = session_id
+        if result.get("scope"):
+            extra["scope"] = result["scope"]
         return extra
 
-    async def _hold(self, fact: str, *, source: str, use_llm: bool, review: dict) -> dict[str, Any]:
-        """Save ``fact`` as pending. Duplicates of any fact (held or not) are skipped; nothing else changes."""
+    async def _hold(
+        self, fact: str, *, source: str, use_llm: bool, review: dict, scope: str = memory_scopes.PERSONAL
+    ) -> dict[str, Any]:
+        """Save ``fact`` as pending. Duplicates of any fact (held or not) in its scope or always are skipped; nothing
+        else changes."""
         fact = fact.strip()
         if not fact:
             return {"action": "SKIP", "id": None, "content": fact}
         await self.ensure_schema()
-        exact = await self.store.fetchone("SELECT id FROM facts WHERE content = ? COLLATE NOCASE", (fact,))
+        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)
+        )
         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)
+        neighbours = await self.recall(fact, top_k=1, min_similarity=0.0, track=False, scopes=family)
         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)
         fid = await self._insert(
-            fact, [], source=source, topics=topics, memory_type=memory_type, duration=duration, review=review
+            fact, [], source=source, topics=topics, memory_type=memory_type, duration=duration, review=review,
+            scope=scope,
         )
         held = {"action": "ADD", "id": fid, "content": fact, "status": "pending"}
         return {**held, "reason": review["reason"]} if review.get("reason") else held
 
-    async def _remember(self, fact: str, *, source: str, use_llm: bool) -> dict[str, Any]:
+    async def _remember(
+        self, fact: str, *, source: str, use_llm: bool, scope: str = memory_scopes.PERSONAL
+    ) -> dict[str, Any]:
         fact = fact.strip()
         if not fact:
             return {"action": "SKIP", "id": None, "content": fact}
+        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}", (fact,)
+            f"SELECT id FROM facts WHERE content = ? COLLATE NOCASE AND {ACTIVE} 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)
+        neighbours = await self.recall(fact, top_k=5, min_similarity=0.0, track=False, scopes=family)
         # "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:
@@ -1020,7 +1104,7 @@ async def _remember(self, fact: str, *, source: str, use_llm: bool) -> dict[str,
         others = {n["id"] for n in close if not same_subject(fact, n["content"], user)}
         if use_llm:
             try:
-                related = await self._related_facts(fact, {n["id"] for n in close})
+                related = await self._related_facts(fact, {n["id"] for n in close}, family)
             except Exception as exc:
                 log.debug("related-fact lookup skipped: %s", exc)
             others |= {r["id"] for r in related if not same_subject(fact, r["content"], user)}
@@ -1130,7 +1214,7 @@ async def _remember(self, fact: str, *, source: str, use_llm: bool) -> dict[str,
         if content != fact:
             [vec] = await self._embed([content])
         new_id = await self._insert(
-            content, vec, source=source, topics=topics, memory_type=memory_type, duration=duration
+            content, vec, source=source, topics=topics, memory_type=memory_type, duration=duration, scope=scope
         )
         return {"action": "ADD", "id": new_id, "content": content}
 
@@ -1241,7 +1325,13 @@ def size(items: list[tuple[str, str]]) -> int:
         return text[-max_chars:] if len(text) > max_chars else text
 
     async def flush_conversation(
-        self, transcript: str, user_name: str, *, review: dict | None = None, session_id: str | None = None
+        self,
+        transcript: str,
+        user_name: str,
+        *,
+        review: dict | None = None,
+        session_id: str | None = None,
+        scope: str | None = None,
     ) -> list[dict]:
         """Save lasting facts from chat turns that are about to be compressed (docs/API.md section 10).
 
@@ -1272,7 +1362,7 @@ async def flush_conversation(
             try:
                 results.append(await self.remember(
                     fact, source="conversation", notify=True, review=reviews.with_snippet(review, text, fact),
-                    session_id=session_id,
+                    session_id=session_id, scope=scope,
                 ))
             except Exception as exc:
                 log.warning("memory flush could not store %r: %s", fact, exc)
@@ -1280,7 +1370,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,
+        review: dict | None = None, own: bool = False, session_id: str | None = None, scope: str | 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
@@ -1295,13 +1385,15 @@ async def extract_and_store(
             try:
                 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,
+                    own_words=text if own else None, session_id=session_id, scope=scope,
                 ))
             except Exception as exc:
                 log.warning("failed to store fact %r: %s", f, exc)
         return results
 
-    async def import_document(self, path: Path, *, username: str, source: str | None = None) -> dict:
+    async def import_document(
+        self, path: Path, *, username: str, source: str | None = None, scope: str | None = None
+    ) -> dict:
         """v2 build_initial_memory for one file, without wiping existing memories. The facts are held for the
         user's review (``pending`` counts them), so nothing already remembered changes."""
         from sentient.files.extract import extract_text
@@ -1312,7 +1404,7 @@ async def import_document(self, path: Path, *, username: str, source: str | None
         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):
+            for r in await self.extract_and_store(chunk, username, source=source, review=review, scope=scope):
                 key = {"ADD": "added", "UPDATE": "updated", "DELETE": "updated"}.get(r["action"], "skipped")
                 counts[key] += 1
                 counts["pending"] += r.get("status") == "pending"
@@ -1335,13 +1427,17 @@ async def list_facts(
         topic: str | None = None,
         source: str | None = None,
         q: str | None = None,
+        scope: str | None = None,
     ) -> list[dict]:
+        """Active facts, newest first. ``scope`` keeps one scope only (the Memory screen's filter, #155)."""
         if topic:
             topic = normalize_topics([topic])[0]
+        one = memory_scopes.normalize(scope)
         if q and q.strip():
             try:
                 hits = await self._search(
-                    q, min(offset + limit, 500) * (3 if topic else 1), self.config.memory.min_similarity, source
+                    q, min(offset + limit, 500) * (3 if topic else 1), self.config.memory.min_similarity, source,
+                    [one] if one else None,
                 )
                 if topic:
                     hits = [h for h in hits if topic in h["topics"]]
@@ -1353,6 +1449,9 @@ async def list_facts(
         if source:
             where.append("source = ?")
             params.append(source)
+        if one:
+            where.append("scope = ?")
+            params.append(one)
         if topic:
             where.append("EXISTS (SELECT 1 FROM json_each(facts.topics) WHERE value = ?)")
             params.append(topic)
@@ -1468,8 +1567,10 @@ async def approve(self, fid: int, content: str | None = None) -> dict | None:
         if row is None:
             return None
         text = " ".join(str(content or "").split()) or row["content"]
+        # it is approved into the scope it was held in (#155): only a memory there or in always counts as the same
+        in_scope, scope_params = _in_scopes(memory_scopes.recall_scopes(await self.scope_of(fid)))
         same = await self.store.fetchone(
-            f"SELECT id FROM facts WHERE content = ? COLLATE NOCASE AND {ACTIVE}", (text,)
+            f"SELECT id FROM facts WHERE content = ? COLLATE NOCASE AND {ACTIVE} AND {in_scope}", (text, *scope_params)
         )
         if same is not None:
             await self.forget(fid)
diff --git a/sentient/memory/review.py b/sentient/memory/review.py
index 0570ff198..5c89ccc83 100644
--- a/sentient/memory/review.py
+++ b/sentient/memory/review.py
@@ -200,9 +200,13 @@ def _expires(created_at: str | None, days: int) -> str | None:
     return (dt + timedelta(days=days)).isoformat()
 
 
-def _item(kind: str, mid: Any, text: str, source: str, review: dict | None, created_at: str, days: int) -> dict:
+def _item(
+    kind: str, mid: Any, text: str, source: str, review: dict | None, created_at: str, days: int,
+    scope: str | None = None,
+) -> dict:
     review = review or {}
     return {
+        "scope": scope,  # a fact's memory scope (#155): it is approved into it; null for insights
         "kind": kind, "id": mid, "text": text, "source": source,
         "from": review.get("from") or source, "snippet": review.get("snippet"), "session_id": review.get("session_id"),
         "title": review.get("title"), "dated": review.get("dated"), "export": review.get("export"),
@@ -215,7 +219,9 @@ async def _items(app: Any, limit: int) -> list[dict]:
     items: list[dict] = []
     if app.memory is not None:
         for f in await app.memory.pending_facts(limit):
-            items.append(_item("fact", f["id"], f["content"], f["source"], f["review"], f["created_at"], days))
+            items.append(
+                _item("fact", f["id"], f["content"], f["source"], f["review"], f["created_at"], days, f.get("scope"))
+            )
     um = getattr(app, "user_model", None)
     if um is not None:
         for i in await um.pending_insights(limit):
diff --git a/sentient/memory/scopes.py b/sentient/memory/scopes.py
new file mode 100644
index 000000000..59c6ade02
--- /dev/null
+++ b/sentient/memory/scopes.py
@@ -0,0 +1,173 @@
+"""Memory scopes (#155): keep work, personal and project memories apart.
+
+Every fact has a ``scope``: ``personal`` (the default, and where older memories went), ``work``, a project's own name
+("Kestrel launch"), or ``always`` for the few things every chat should know (the user's name, how they like answers).
+A chat (``sessions.memory_scope``), a task (``tasks.memory_scope``) or a messaging app
+(``channels.<app>.memory_scope``) has a scope too. Recall then reads that scope plus ``always``, and saving puts a new
+memory in it, so a work chat never brings up personal health or family memories unless the user asks
+(``memory_recall(everywhere=true)``). Work not tied to a chat or task (proactive look-ups, dreaming, the user model)
+reads every scope.
+
+Personal chats keep the profile files (MEMORY.md, the learned part of USER.md, daily notes), which are built from
+personal and always memories only; work and project chats leave them out.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import re
+from typing import Any
+
+PERSONAL = "personal"
+WORK = "work"
+ALWAYS = "always"
+BUILT_IN = (ALWAYS, PERSONAL, WORK)
+LABELS = {ALWAYS: "Always", PERSONAL: "Personal", WORK: "Work"}
+MAX_LEN = 40
+# a chat, task or messaging app can't be "always": that scope is only for memories every chat reads
+CHAT_SCOPES_EXCLUDE = frozenset({ALWAYS})
+# insight dimensions a work or project chat leaves out of its prompt (family and friends are personal)
+PERSONAL_DIMENSIONS = frozenset({"relationships"})
+_LEARNED_RE = re.compile(r"^## Learned\s*$", re.IGNORECASE | re.MULTILINE)
+
+
+def normalize(raw: Any, default: str | None = None) -> str | None:
+    """A scope as stored: built-in names in lowercase ("Work" -> "work"), a project's name as typed with spaces
+    tidied, at most 40 characters. ``default`` for an empty value."""
+    text = " ".join(str(raw or "").split())[:MAX_LEN].strip()
+    if not text:
+        return default
+    low = text.lower()
+    return low if low in BUILT_IN else text
+
+
+def label(scope: str | None) -> str:
+    scope = normalize(scope, PERSONAL) or PERSONAL
+    return LABELS.get(scope, scope)
+
+
+def recall_scopes(scope: str | None) -> list[str] | None:
+    """The scopes recall reads for a run in ``scope``: it plus ``always``. None (every scope) when ``scope`` is None."""
+    if scope is None:
+        return None
+    scope = normalize(scope, PERSONAL) or PERSONAL
+    return [ALWAYS] if scope == ALWAYS else [scope, ALWAYS]
+
+
+def is_personal(scope: str | None) -> bool:
+    return scope is None or normalize(scope, PERSONAL) == PERSONAL
+
+
+def chat_scope(raw: Any) -> str | None:
+    """A scope a chat, task or messaging app may use: None for "the default", ValueError for ``always``."""
+    scope = normalize(raw)
+    if scope in CHAT_SCOPES_EXCLUDE:
+        raise ValueError("A chat or task can't use the Always scope. Pick Personal, Work or a project.")
+    return scope
+
+
+def channel_scope(config: Any, channel: str | None) -> str | None:
+    """The scope set for a messaging app (``channels.<app>.memory_scope``), or None for other channels."""
+    channels = getattr(config, "channels", None)
+    app = getattr(channels, str(channel or ""), None) if channels is not None else None
+    raw = getattr(app, "memory_scope", None)
+    scope = normalize(raw) if isinstance(raw, str) else None
+    return None if scope in CHAT_SCOPES_EXCLUDE else scope
+
+
+def of_session(config: Any, session: dict | None) -> str:
+    """A chat's scope: its own (``sessions.memory_scope``), else its messaging app's, else personal."""
+    session = session or {}
+    own = normalize(session.get("memory_scope"))
+    if own and own not in CHAT_SCOPES_EXCLUDE:
+        return own
+    return channel_scope(config, session.get("channel")) or PERSONAL
+
+
+def of_task(task: dict | None) -> str:
+    scope = normalize((task or {}).get("memory_scope"))
+    return scope if scope and scope not in CHAT_SCOPES_EXCLUDE else PERSONAL
+
+
+async def for_context(ctx: Any) -> str | None:
+    """The scope of a tool call: the run's (``ctx.memory_scope``, set for chat turns and task runs), else its chat's
+    (a helper a chat started), else None: work not tied to a chat or task reads every scope."""
+    scope = normalize(getattr(ctx, "memory_scope", None))
+    if scope:
+        return scope
+    session_id = getattr(ctx, "session_id", None)
+    get = getattr(getattr(ctx, "store", None), "get_session", None)
+    if session_id and callable(get):
+        try:
+            return of_session(ctx.config, await get(session_id))
+        except Exception:
+            return PERSONAL
+    return None
+
+
+def without_learned(user_md: str) -> str:
+    """USER.md without its "## Learned" section (facts Sentient appended from personal memories)."""
+    m = _LEARNED_RE.search(user_md or "")
+    if m is None:
+        return user_md
+    rest = user_md[m.end():]
+    nxt = re.search(r"^#{1,2} ", rest, re.MULTILINE)
+    return (user_md[: m.start()] + (rest[nxt.start():] if nxt else "")).strip()
+
+
+def personal_summary_sql(config: Any) -> tuple[str, list[str]]:
+    """SQL condition (with parameters) on ``summaries`` that keeps summaries of personal chats: the profile files never
+    read a work or project chat's summary. A chat that still exists counts with its scope now (:func:`of_session`,
+    messaging-app fallback included); for one that was deleted, the scope it had when the summary was written
+    (``summaries.scope``) counts."""
+    apps = [(app, scope) for app in ("telegram", "discord", "whatsapp") if (scope := channel_scope(config, app))]
+    case = "CASE s.channel " + " ".join("WHEN ? THEN ?" for _ in apps) + " ELSE 'personal' END" if apps else "'personal'"
+    params = [x for pair in apps for x in pair]
+    sql = (
+        "(CASE WHEN EXISTS (SELECT 1 FROM sessions s WHERE s.id = summaries.session_id)"
+        " THEN NOT EXISTS (SELECT 1 FROM sessions s WHERE s.id = summaries.session_id"
+        f" AND COALESCE(NULLIF(s.memory_scope, ''), {case}) NOT IN ('personal', 'always'))"
+        " ELSE COALESCE(summaries.scope, 'personal') IN ('personal', 'always') END)"
+    )
+    return sql, params
+
+
+def prompt_note(scope: str) -> str:
+    name = label(scope)
+    return (
+        "## Memory scope\n"
+        f"This chat uses the user's {name} memories plus the ones kept for every chat. Their personal memories (family, "
+        "health, home) are left out. Don't guess about them; if the user asks about one, call memory_recall with "
+        "everywhere=true."
+    )
+
+
+async def list_scopes(app: Any) -> list[dict]:
+    """``[{name, label, count, built_in}]``: Always, Personal and Work, then every project a memory, chat, task or
+    messaging app uses (by name). ``count`` = active memories in it."""
+    store = app.store
+    counts: dict[str, int] = {}
+    names: list[str] = []
+    try:
+        for r in await store.fetchall(
+            "SELECT scope, COUNT(*) AS n FROM facts WHERE status = 'active' GROUP BY scope"
+        ):
+            name = normalize(r["scope"], PERSONAL) or PERSONAL
+            counts[name] = counts.get(name, 0) + int(r["n"])
+            names.append(name)
+    except Exception:  # memory unavailable
+        pass
+    for sql in (
+        "SELECT DISTINCT memory_scope AS s FROM sessions WHERE memory_scope IS NOT NULL",
+        "SELECT DISTINCT memory_scope AS s FROM tasks WHERE memory_scope IS NOT NULL",
+    ):
+        with contextlib.suppress(Exception):  # an older database without the column
+            names += [n for r in await store.fetchall(sql) if (n := normalize(r["s"]))]
+    for app_name in ("telegram", "discord", "whatsapp"):
+        if scope := channel_scope(app.config, app_name):
+            names.append(scope)
+    projects = sorted({n for n in names if n not in BUILT_IN}, key=str.lower)
+    return [
+        {"name": n, "label": label(n), "count": counts.get(n, 0), "built_in": n in BUILT_IN}
+        for n in (*BUILT_IN, *projects)
+    ]
diff --git a/sentient/memory/usermodel.py b/sentient/memory/usermodel.py
index 1a7debe17..13883df61 100644
--- a/sentient/memory/usermodel.py
+++ b/sentient/memory/usermodel.py
@@ -946,8 +946,11 @@ async def context_for(self, text: str) -> str:
         """Short markdown block for the system prompt (no model call). Empty when disabled or unknown."""
         return (await self.context_with_sources(text))[0]
 
-    async def context_with_sources(self, text: str) -> tuple[str, list[dict]]:
-        """``context_for`` plus the insights that made it into the block (public shape), for memory sources."""
+    async def context_with_sources(
+        self, text: str, leave_out: frozenset[str] | set[str] = frozenset()
+    ) -> tuple[str, list[dict]]:
+        """``context_for`` plus the insights that made it into the block (public shape), for memory sources.
+        ``leave_out``: dimensions a work or project chat doesn't get (#155, relationships)."""
         cfg = self.cfg
         if not cfg.enabled or cfg.context_max_chars <= 0:
             return "", []
@@ -964,6 +967,8 @@ async def context_with_sources(self, text: str) -> tuple[str, list[dict]]:
         shown: list[dict] = []
         used = len(header)
         for ins in [*confirmed, *active]:
+            if ins.get("dimension") in leave_out:
+                continue
             line = f"- {ins['statement']}" + (" (likely)" if not protected(ins) and ins["confidence"] < 0.6 else "")
             if used + len(line) + 1 > budget:
                 continue
@@ -973,8 +978,9 @@ async def context_with_sources(self, text: str) -> tuple[str, list[dict]]:
         return (header + "\n".join(lines), shown) if lines else ("", [])
 
     # ------------------------------------------------------------------ tool
-    async def ask(self, question: str) -> dict:
-        """Answer "what would the user want" from insights and facts with one model call."""
+    async def ask(self, question: str, scopes: list[str] | None = None) -> dict:
+        """Answer "what would the user want" from insights and facts with one model call. ``scopes``: the facts it
+        reads (a chat's memory scope plus always, #155); None reads every scope."""
         if not self.cfg.enabled:
             return {"error": "The user model is turned off in settings."}
         question = " ".join(str(question or "").split())
@@ -985,7 +991,7 @@ async def ask(self, question: str) -> dict:
         facts: list[str] = []
         if self.app.memory is not None:
             with contextlib.suppress(Exception):
-                facts = [f["content"] for f in await self.app.memory.recall(question, top_k=6)]
+                facts = [f["content"] for f in await self.app.memory.recall(question, top_k=6, scopes=scopes)]
         summary = await self.app.store.get_meta("user_model.summary") or ""
         name = self.user_name or "the user"
         if not insights and not facts and not summary:
diff --git a/sentient/memory/workspace.py b/sentient/memory/workspace.py
index 265ac7fec..2b27f1a74 100644
--- a/sentient/memory/workspace.py
+++ b/sentient/memory/workspace.py
@@ -151,6 +151,26 @@ def append_learned(self, facts: list[str], heading: str = "## Learned") -> list[
         self.user.write_text(body, encoding="utf-8")
         return new
 
+    def remove_learned(self, facts: list[str], heading: str = "## Learned") -> int:
+        """Remove bullets that say exactly these facts from USER.md's Learned section (a memory moved out of
+        Personal, #155). The user's own text is never touched. Returns how many lines went."""
+        if not facts or not self.user.exists():
+            return 0
+        gone = {f.strip().lower() for f in facts if f.strip()}
+        lines = self.user.read_text(encoding="utf-8", errors="replace").splitlines()
+        out: list[str] = []
+        inside, removed = False, 0
+        for line in lines:
+            if line.startswith("#"):
+                inside = line.strip().lower() == heading.lower()
+            if inside and line.startswith("- ") and line[2:].strip().lower() in gone:
+                removed += 1
+                continue
+            out.append(line)
+        if removed:
+            self.user.write_text("\n".join(out) + "\n", encoding="utf-8")
+        return removed
+
     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/db.py b/sentient/store/db.py
index 9e4485a1a..d09234beb 100644
--- a/sentient/store/db.py
+++ b/sentient/store/db.py
@@ -27,9 +27,11 @@
 # Feature packages own their tables. Each file must be idempotent. Order matters for foreign keys.
 # Bump when a change to a schema.sql or an ensure_column needs existing databases updated. Opening a database
 # with another version takes a snapshot first (issue #151); so does the first column added to an existing one.
-SCHEMA_VERSION = 10  # 2: sessions.incognito (#154); 3: messages.sources (#290); 4: tasks.notepad (#292); 5: sessions.model (#312)
+SCHEMA_VERSION = 11  # 2: sessions.incognito (#154); 3: messages.sources (#290); 4: tasks.notepad (#292); 5: sessions.model (#312)
 # 6: approval_grants (#139); 7: usage.cost_usd (#148); 8: evolution_reviews.activity_mark (#297)
 # 9: messages.approval and the activity timeline's indexes (#147); 10: try runs and file snapshots (#142)
+# 11: memory scopes: facts.scope, sessions.memory_scope, tasks.memory_scope, summaries.scope (#155); also
+#     messages.checks and task_runs.checks (#165), which arrived without a bump
 PACKAGE_SCHEMAS = [
     "tasks", "integrations", "proactivity", "evolution", "voice", "memory", "nodes", "channels", "browser", "sandbox",
     "folders", "reminders", "snapshots",
@@ -154,6 +156,7 @@ async def open(self) -> Store:
         await self.ensure_column("sessions", "visited_hosts", "TEXT")
         await self.ensure_column("sessions", "incognito", "INTEGER NOT NULL DEFAULT 0")
         await self.ensure_column("sessions", "model", "TEXT")
+        await self.ensure_column("sessions", "memory_scope", "TEXT")  # #155
         await self.ensure_column("messages", "attachments", "TEXT")
         await self.ensure_column("messages", "interjection", "INTEGER NOT NULL DEFAULT 0")
         await self.ensure_column("messages", "memory_sources", "TEXT")
@@ -162,9 +165,13 @@ async def open(self) -> Store:
         await self.ensure_column("messages", "checks", "TEXT")
         await self.ensure_column("facts", "status", "TEXT NOT NULL DEFAULT 'active'")
         await self.ensure_column("facts", "review", "TEXT")
+        # memory scopes (#155): every memory saved before them is personal
+        await self.ensure_column("facts", "scope", "TEXT NOT NULL DEFAULT 'personal'")
         await self.ensure_column("summaries", "untrusted", "TEXT")
+        await self.ensure_column("summaries", "scope", "TEXT")  # the chat's memory scope when written (#155)
         await self.ensure_column("usage", "cost_usd", "REAL")
         # the activity timeline's spending lines (#147); after ensure_column: older databases get cost_usd above
+        await self.db.execute("CREATE INDEX IF NOT EXISTS idx_facts_scope ON facts(scope, status)")
         await self.db.execute("CREATE INDEX IF NOT EXISTS idx_usage_paid ON usage(created_at) WHERE cost_usd > 0")
         # summaries written before the mark existed take it from their chat (ADR 0021)
         await self.db.execute(
@@ -223,16 +230,28 @@ async def set_meta(self, key: str, value: str) -> None:
 
     # ------------------------------------------------------------------ sessions & messages
     async def create_session(
-        self, channel: str = "web", title: str | None = None, *, incognito: bool = False, model: str | None = None
+        self,
+        channel: str = "web",
+        title: str | None = None,
+        *,
+        incognito: bool = False,
+        model: str | None = None,
+        memory_scope: str | None = None,
     ) -> str:
         sid = new_id()
         ts = now_iso()
         await self.execute(
-            "INSERT INTO sessions(id, title, channel, created_at, updated_at, incognito, model) VALUES(?,?,?,?,?,?,?)",
-            (sid, title, channel, ts, ts, int(bool(incognito)), model or None),
+            "INSERT INTO sessions(id, title, channel, created_at, updated_at, incognito, model, memory_scope)"
+            " VALUES(?,?,?,?,?,?,?,?)",
+            (sid, title, channel, ts, ts, int(bool(incognito)), model or None, memory_scope or None),
         )
         return sid
 
+    async def set_session_scope(self, session_id: str, scope: str | None) -> bool:
+        """The memories one chat uses (#155); None makes it follow its app's scope, else personal. False: no such chat."""
+        cur = await self.execute("UPDATE sessions SET memory_scope = ? WHERE id = ?", (scope or None, session_id))
+        return cur.rowcount > 0
+
     async def set_session_model(self, session_id: str, model: str | None) -> bool:
         """Pick the model for one chat (#312); None (or "") makes it follow the default again. False: no such chat."""
         cur = await self.execute("UPDATE sessions SET model = ? WHERE id = ?", (model or None, session_id))
diff --git a/sentient/store/schema.sql b/sentient/store/schema.sql
index 711acc4c8..af8acbf24 100644
--- a/sentient/store/schema.sql
+++ b/sentient/store/schema.sql
@@ -23,7 +23,8 @@ CREATE TABLE IF NOT EXISTS sessions (
     untrusted       TEXT,                         -- app whose content this chat read ("Gmail"); sends then ask (ADR 0018)
     visited_hosts   TEXT,                         -- JSON list of web hosts this chat loaded (ADR 0018)
     incognito       INTEGER NOT NULL DEFAULT 0,   -- 1: nothing is learned from it and it is deleted when closed (#154)
-    model           TEXT                          -- the model picked for this chat; NULL follows the default (#312)
+    model           TEXT,                         -- the model picked for this chat; NULL follows the default (#312)
+    memory_scope    TEXT                          -- the memories this chat uses (#155); NULL: its app's, else personal
 );
 
 CREATE TABLE IF NOT EXISTS messages (
@@ -69,8 +70,9 @@ CREATE TABLE IF NOT EXISTS summaries (
     end_at        TEXT NOT NULL,
     message_ids   TEXT NOT NULL,                  -- JSON list
     created_at    TEXT NOT NULL,
-    untrusted     TEXT                            -- app whose content the chat had read (ADR 0018/0021): kept out of
+    untrusted     TEXT,                           -- app whose content the chat had read (ADR 0018/0021): kept out of
                                                   -- other chats, proactivity and MEMORY.md; "" or NULL = clean
+    scope         TEXT                            -- the chat's memory scope when written (#155); NULL = personal
 );
 
 -- ---------------------------------------------------------------- semantic memory (atomic facts)
@@ -86,7 +88,8 @@ CREATE TABLE IF NOT EXISTS facts (
     embedding_model TEXT,
     previous_content TEXT,                                  -- kept on UPDATE so edits are auditable
     status          TEXT NOT NULL DEFAULT 'active',         -- active | pending (held for the user's review, ADR 0021)
-    review          TEXT                                    -- JSON {from, snippet, session_id}: where a held memory came from
+    review          TEXT,                                   -- JSON {from, snippet, session_id}: where a held memory came from
+    scope           TEXT NOT NULL DEFAULT 'personal'        -- personal | work | always | a project's name (#155)
 );
 CREATE INDEX IF NOT EXISTS idx_facts_expires ON facts(expires_at) WHERE expires_at IS NOT NULL;
 CREATE INDEX IF NOT EXISTS idx_facts_source ON facts(source);
diff --git a/sentient/tasks/executor.py b/sentient/tasks/executor.py
index d9ded59d2..c78cc1f61 100644
--- a/sentient/tasks/executor.py
+++ b/sentient/tasks/executor.py
@@ -32,6 +32,7 @@
 from sentient.agent.sources import AnswerSources
 from sentient.llm.events import TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, Usage
 from sentient.llm.provider import ToolCall
+from sentient.memory import scopes as memory_scopes
 from sentient.memory.sources import MemorySources
 from sentient.tasks import ask, continuity, limits, stuck
 from sentient.tasks.jsonio import complete_json_object
@@ -251,7 +252,8 @@ async def _executor_system_prompt(
             str(x) for x in (task.get("name"), task.get("description"), (run.get("trigger_data") or {}).get("subject")) if x
         )[:500]
         try:
-            facts = [f for f in await app.memory.recall(query) if f.get("content")]
+            scopes = memory_scopes.recall_scopes(memory_scopes.of_task(task))  # the task's scope plus always (#155)
+            facts = [f for f in await app.memory.recall(query, scopes=scopes) if f.get("content")]
         except Exception as exc:
             log.debug("memory recall for task %s skipped: %s", task["id"], exc)
     earlier, remembered = await _earlier_section(svc, task, run)
@@ -386,6 +388,7 @@ async def alive(event: Any) -> None:
                 })
 
             ctx = app.agent.tool_context(None, "task")
+            ctx.memory_scope = memory_scopes.of_task(task)  # what it recalls and saves (#155)
             # CAN_PAUSE_KEY: an "ask" rule holds the call and the run pauses to ask, instead of failing (#139)
             ctx.extra.update({"task_id": task_id, "run_id": run_id, ask.STATE_KEY: asking, CAN_PAUSE_KEY: True})
             if task.get("browser_profile"):  # the browser tools use the task's profile (docs/API.md section 12)
@@ -584,6 +587,7 @@ async def execute_fixed_call(svc: TaskService, task: dict, run: dict, *, resume:
     ctx = app.agent.tool_context(None, "task") if app.agent is not None else None
     if ctx is not None:
         ctx.extra.update({"task_id": task_id, "run_id": run_id})
+        ctx.memory_scope = memory_scopes.of_task(task)
         if task.get("browser_profile"):
             ctx.extra["browser_profile"] = task["browser_profile"]
     if tool.plugin in app.approvals.read_only():  # a Read only connection (#141) refuses it like a "never" rule
diff --git a/sentient/tasks/repo.py b/sentient/tasks/repo.py
index 8deadc806..1f8efbf06 100644
--- a/sentient/tasks/repo.py
+++ b/sentient/tasks/repo.py
@@ -19,7 +19,7 @@
     "name", "description", "status", "priority", "task_type", "schedule", "plan", "original_prompt",
     "source", "enabled", "assignee", "model", "chat_history", "clarifying_questions", "swarm_details",
     "original_context", "script", "error", "next_execution_at", "last_execution_at", "created_at", "updated_at",
-    "browser_profile", "deliver_to", "notepad", "keep_running",
+    "browser_profile", "deliver_to", "notepad", "keep_running", "memory_scope",
 }
 TASK_BOOL_FIELDS = {"enabled", "keep_running"}
 RUN_JSON_FIELDS = {
@@ -47,6 +47,7 @@
     "deliver_to": "TEXT",
     "notepad": "TEXT",
     "keep_running": "INTEGER NOT NULL DEFAULT 0",  # never paused while the user is away (#163)
+    "memory_scope": "TEXT",  # the memories its runs use and save to (#155); NULL: personal
 }
 _ADDED_RUN_COLUMNS = {
     "plan": "TEXT", "resume_count": "INTEGER NOT NULL DEFAULT 0", "retry_of": "TEXT", "pending_question": "TEXT",
@@ -390,6 +391,7 @@ def task_to_api(task: dict, runs: list[dict]) -> dict:
             "keep_running": bool(task.get("keep_running")),
             "model": task.get("model"),
             "browser_profile": task.get("browser_profile"),
+            "memory_scope": task.get("memory_scope") or "personal",
             "deliver_to": from_stored(task.get("deliver_to")),
             "notepad": task.get("notepad") or None,
             "original_context": task.get("original_context") or {"source": "manual_creation"},
diff --git a/sentient/tasks/schema.sql b/sentient/tasks/schema.sql
index 8f11a6b1a..28e81720c 100644
--- a/sentient/tasks/schema.sql
+++ b/sentient/tasks/schema.sql
@@ -26,6 +26,7 @@ CREATE TABLE IF NOT EXISTS tasks (
     browser_profile       TEXT,                       -- named browser profile the task's browser calls use (NULL: default)
     deliver_to            TEXT,                       -- JSON (tasks/delivery.py): "desktop" or [{channel, chat_id}]; NULL: default
     notepad               TEXT,                       -- recurring tasks: notes the runs keep for the next run (tasks/continuity.py)
+    memory_scope          TEXT,                       -- the memories its runs use and save to (#155); NULL: personal
     error                 TEXT,
     next_execution_at     TEXT,                       -- UTC ISO-8601, seconds precision (lexicographically comparable)
     last_execution_at     TEXT,
diff --git a/sentient/tasks/service.py b/sentient/tasks/service.py
index e245053c6..c545d1e77 100644
--- a/sentient/tasks/service.py
+++ b/sentient/tasks/service.py
@@ -39,6 +39,7 @@
 from sentient.agent import grants as grant_rules
 from sentient.llm.jobs import detached
 from sentient.llm.provider import PlainProviderError, ProviderError
+from sentient.memory import scopes as memory_scopes
 from sentient.services import Service, cancel_tasks
 from sentient.tasks import ask, away, catchup, continuity, executor, limits, scripts, stuck, swarm
 from sentient.tasks.away import AwayWatch
@@ -76,7 +77,7 @@
 }
 UPDATABLE_FIELDS = {
     "name", "description", "priority", "schedule", "plan", "enabled", "status", "model", "assignee", "script",
-    "browser_profile", "deliver_to", "notepad", "keep_running",
+    "browser_profile", "deliver_to", "notepad", "keep_running", "memory_scope",
 }
 SANDBOX_RESULT = {
     "ok": False, "backend": None, "stdout": "", "stderr": "", "result": None, "files_created": [],
@@ -334,11 +335,13 @@ async def create_task(
         model: str | None = None,
         auto_approve: bool = False,
         browser_profile: str | None = None,
+        memory_scope: str | None = None,
     ) -> dict:
         prompt = (prompt or "").strip()
         if not prompt:
             raise ValueError("A prompt is required.")
         browser_profile = self._browser_profile(browser_profile)
+        memory_scope = memory_scopes.chat_scope(memory_scope)
         context = dict(original_context or {})
         context.setdefault("source", "manual_creation" if source == "user" else source)
         now = self.now_iso()
@@ -353,6 +356,7 @@ async def create_task(
             "enabled": True,
             "model": model or None,
             "browser_profile": browser_profile,
+            "memory_scope": memory_scope,
             "original_context": context,
             "plan": [],
             "chat_history": [],
@@ -570,6 +574,11 @@ async def update(self, task_id: str, fields: dict, *, reapprove_script: bool = F
             changes["model"] = data["model"] or None
         if "browser_profile" in data:
             changes["browser_profile"] = self._browser_profile(data["browser_profile"])
+        if "memory_scope" in data:  # #155: None or "" goes back to personal; "always" is refused (ValueError)
+            scope = memory_scopes.chat_scope(data["memory_scope"])
+            if scope != task.get("memory_scope") and task["status"] in BUSY:  # a run keeps the scope it started with
+                raise TaskConflict("This task is running right now. Try again when the run has finished.")
+            changes["memory_scope"] = scope
         if "deliver_to" in data:
             changes["deliver_to"] = stored(data["deliver_to"])
         if "notepad" in data:
@@ -706,7 +715,8 @@ async def rerun(self, task_id: str) -> dict:
         task = await self._require(task_id)
         now = self.now_iso()
         keep = ("name", "description", "priority", "task_type", "schedule", "original_prompt", "source",
-                "assignee", "model", "browser_profile", "deliver_to", "original_context", "chat_history")
+                "assignee", "model", "browser_profile", "memory_scope", "deliver_to", "original_context",
+                "chat_history")
         fields = {k: task.get(k) for k in keep}
         fields.update(status="planning", enabled=True, plan=[], clarifying_questions=[], error=None,
                       created_at=now, updated_at=now)
diff --git a/sentient/tasks/swarm.py b/sentient/tasks/swarm.py
index 7696eee34..fbce4cd22 100644
--- a/sentient/tasks/swarm.py
+++ b/sentient/tasks/swarm.py
@@ -15,6 +15,7 @@
 
 from sentient.agent.loop import Budget, LoopResult
 from sentient.llm.provider import parse_json_loose
+from sentient.memory import scopes as memory_scopes
 from sentient.tasks.executor import run_budget, select_tools
 from sentient.tasks.jsonio import complete_json
 from sentient.tasks.prompts import (
@@ -134,6 +135,7 @@ async def run_worker(
             },
         ]
         ctx = app.agent.tool_context(None, "task")
+        ctx.memory_scope = memory_scopes.of_task(task)  # #155
         ctx.extra.update({"task_id": task_id, "run_id": run_id, "worker_id": worker_id})
         result = LoopResult()
         async for _event in app.agent.run_loop(
diff --git a/sentient/tasks/tools.py b/sentient/tasks/tools.py
index 219495e2b..6b6be2f35 100644
--- a/sentient/tasks/tools.py
+++ b/sentient/tasks/tools.py
@@ -8,6 +8,7 @@
 import json
 from typing import Any
 
+from sentient.memory import scopes as memory_scopes
 from sentient.tools.base import Risk, ToolContext, ToolPlugin, tool
 
 
@@ -79,7 +80,12 @@ async def create_task_from_prompt(ctx: ToolContext, prompt: str, is_swarm: bool
     context = {"source": "chat"}
     if ctx.session_id:
         context["session_id"] = ctx.session_id
-    task = await svc.create_task(prompt, is_swarm=is_swarm, source="chat", original_context=context)
+    # a task made in a work chat uses work memories (#155); personal ones stay the default
+    scope = await memory_scopes.for_context(ctx)
+    task = await svc.create_task(
+        prompt, is_swarm=is_swarm, source="chat", original_context=context,
+        memory_scope=None if scope in (None, memory_scopes.PERSONAL, memory_scopes.ALWAYS) else scope,
+    )
     short = prompt[:50] + "..." if len(prompt) > 50 else prompt
     return {
         "status": "success",
diff --git a/sentient/tools/base.py b/sentient/tools/base.py
index ba84b0467..cab5424aa 100644
--- a/sentient/tools/base.py
+++ b/sentient/tools/base.py
@@ -123,6 +123,9 @@ class ToolContext:
     # attachments. Set in code by the chat turn only (empty for tasks, subagents and other work); an "Only if I asked"
     # rule (#140) runs a tool without asking only when these words ask for it.
     user_words: list[str] = field(default_factory=list)
+    # the memory scope of this run (#155): a chat's or a task's ("personal", "work", a project). Empty: the chat's own,
+    # or every scope for work not tied to a chat (``memory.scopes.for_context``)
+    memory_scope: str = ""
 
     async def is_incognito(self) -> bool:
         """True when this run belongs to an incognito chat (#154)."""
diff --git a/sentient/tools/builtin/memory_tool.py b/sentient/tools/builtin/memory_tool.py
index 8a2331cda..eccb70a99 100644
--- a/sentient/tools/builtin/memory_tool.py
+++ b/sentient/tools/builtin/memory_tool.py
@@ -10,6 +10,7 @@
 import re
 
 from sentient.memory import review
+from sentient.memory import scopes as memory_scopes
 from sentient.memory.episodic import EpisodicMemory
 from sentient.tools.base import Risk, ToolContext, ToolPlugin, tool
 from sentient.tools.rules import brings_untrusted
@@ -44,14 +45,21 @@ def _fts_query(text: str, joiner: str) -> str:
 
 
 @tool("memory_recall", risk=Risk.read)
-async def memory_recall(ctx: ToolContext, query: str, limit: int = 8) -> list[dict]:
+async def memory_recall(ctx: ToolContext, query: str, limit: int = 8, everywhere: bool = False) -> list[dict]:
     """Search what you remember about the user. Use when a question depends on personal
-    context (their preferences, people, projects, routines) that is not already in your prompt."""
+    context (their preferences, people, projects, routines) that is not already in your prompt.
+    It searches this chat's memories (for example Work) and the ones kept for every chat. Set everywhere=true only
+    when the user asks about something from another part of their life, like family or health in a work chat."""
     if ctx.memory is None or await _memory_closed(ctx):
         return []
-    facts = await ctx.memory.recall(query, top_k=limit)
+    scope = await memory_scopes.for_context(ctx)
+    facts = await ctx.memory.recall(
+        query, top_k=limit, scopes=None if everywhere else memory_scopes.recall_scopes(scope)
+    )
     return [
-        {"id": f["id"], "fact": f["content"], "topics": f["topics"], "similarity": f["similarity"]} for f in facts
+        {"id": f["id"], "fact": f["content"], "topics": f["topics"], "similarity": f["similarity"]}
+        | ({"kept_for": memory_scopes.label(f.get("scope"))} if scope and f.get("scope") not in (scope, memory_scopes.ALWAYS) else {})
+        for f in facts
     ]
 
 
@@ -71,7 +79,8 @@ async def memory_remember(ctx: ToolContext, fact: str) -> dict:
     # instruction's review card shows what the user said (#234)
     own = None if review.is_unprompted_note(held) else await _own_words(ctx)
     out = await ctx.memory.remember(
-        fact, source="conversation", notify=True, review=held, own_words=own, session_id=ctx.session_id
+        fact, source="conversation", notify=True, review=held, own_words=own, session_id=ctx.session_id,
+        scope=await memory_scopes.for_context(ctx),  # the chat's or task's scope (#155); personal when neither
     )
     if out.get("status") == "pending":
         return {**out, "note": INSTRUCTION_NOTE if out.get("reason") == review.INSTRUCTION else HELD_NOTE}
@@ -172,7 +181,8 @@ async def memory_search_by_source(ctx: ToolContext, query: str, source: str, lim
     "conversation" or "manual". Use when the user asks what you learned from a specific document."""
     if ctx.memory is None or await _memory_closed(ctx):
         return []
-    facts = await ctx.memory.search_by_source(query, source, top_k=limit)
+    scopes = memory_scopes.recall_scopes(await memory_scopes.for_context(ctx))
+    facts = await ctx.memory.search_by_source(query, source, top_k=limit, scopes=scopes)
     return [{"id": f["id"], "fact": f["content"], "similarity": f["similarity"]} for f in facts]
 
 
@@ -242,7 +252,7 @@ async def user_model_ask(ctx: ToolContext, question: str) -> dict:
     um = getattr(app, "user_model", None)
     if um is None or not hasattr(um, "ask"):
         return {"error": "user model unavailable"}
-    return await um.ask(question)
+    return await um.ask(question, scopes=memory_scopes.recall_scopes(await memory_scopes.for_context(ctx)))
 
 
 class MemoryPlugin(ToolPlugin):
diff --git a/tests/memory/test_review.py b/tests/memory/test_review.py
index b10308ce6..263b29358 100644
--- a/tests/memory/test_review.py
+++ b/tests/memory/test_review.py
@@ -94,7 +94,7 @@ async def test_a_fact_learned_after_reading_an_email_waits_and_is_never_used(cha
         "kind": "fact", "id": held["id"], "text": FACT, "source": "conversation", "from": "Mail",
         "snippet": held["review"]["snippet"], "session_id": held["review"]["session_id"],
         "title": None, "dated": None, "export": None, "reason": None,
-        "created_at": held["created_at"], "expires_at": None,
+        "created_at": held["created_at"], "expires_at": None, "scope": "personal",
     }
 
 
diff --git a/tests/memory/test_review_followups.py b/tests/memory/test_review_followups.py
index 1e3894750..4ea6ea323 100644
--- a/tests/memory/test_review_followups.py
+++ b/tests/memory/test_review_followups.py
@@ -115,7 +115,7 @@ async def test_an_instruction_from_a_clean_chat_waits_for_review(chat):
     updates = [e["data"] for e in events if e["type"] == "memory.updated"]
     pending = next(u for u in updates if u.get("status") == "pending")
     assert pending == {"action": "ADD", "id": held["id"], "content": instruction, "status": "pending",
-                       "reason": "instruction", "session_id": sid}
+                       "reason": "instruction", "session_id": sid, "scope": "personal"}
     # approving it is the user's yes: then it is used
     assert await review.approve(chat, "fact", str(held["id"]))
     assert (await chat.memory.get_fact(held["id"]))["status"] == "active"
@@ -158,7 +158,7 @@ async def test_own_words_are_kept_after_the_chat_read_mail(chat):
     [held] = await chat.memory.pending_facts()
     assert held["content"] == "Maya's flight to Berlin leaves on Friday at 6am" and held["review"]["from"] == "Mail"
     saved = next(e["data"] for e in events if e["type"] == "memory.updated" and e["data"].get("id") == kept["id"])
-    assert saved == {"action": "ADD", "id": kept["id"], "content": kept["content"], "session_id": sid}
+    assert saved == {"action": "ADD", "id": kept["id"], "content": kept["content"], "session_id": sid, "scope": "personal"}
 
 
 async def test_the_model_saving_the_users_own_words_after_reading_mail(chat):
diff --git a/tests/memory/test_scopes.py b/tests/memory/test_scopes.py
new file mode 100644
index 000000000..6b1d99599
--- /dev/null
+++ b/tests/memory/test_scopes.py
@@ -0,0 +1,405 @@
+"""Memory scopes (#155): work, personal and project memories stay apart, always ones are everywhere."""
+
+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 export as memory_export
+from sentient.memory import review, scopes
+from sentient.store.db import SCHEMA_VERSION
+from sentient.tasks import executor
+from sentient.tasks.service import TaskConflict
+from tests.conftest import FakeProvider
+from tests.memory.helpers import drain
+
+SISTER = "Maya's sister Meera lives in Lisbon"
+HEALTH = "Maya has asthma and uses an inhaler"
+KESTREL = "Maya leads Project Kestrel, a payments launch"
+ARJUN = "Arjun is Maya's engineering manager on Kestrel"
+NAME = "Maya prefers short, direct answers"
+ATLAS = "Project Atlas ships the new onboarding flow"
+
+
+async def _put(mem, content: str, scope: str) -> int:
+    out = await mem.remember(content, use_llm=False, scope=scope)
+    assert out["action"] == "ADD", out
+    return out["id"]
+
+
+async def _seed(mem) -> dict[str, int]:
+    return {
+        "sister": await _put(mem, SISTER, "personal"),
+        "health": await _put(mem, HEALTH, "personal"),
+        "kestrel": await _put(mem, KESTREL, "work"),
+        "arjun": await _put(mem, ARJUN, "work"),
+        "name": await _put(mem, NAME, "always"),
+        "atlas": await _put(mem, ATLAS, "Atlas"),
+    }
+
+
+def _texts(facts: list[dict]) -> set[str]:
+    return {f["content"] for f in facts}
+
+
+# ---------------------------------------------------------------- helpers
+def test_scope_names_and_recall_sets():
+    assert scopes.normalize(" Work ") == "work" and scopes.normalize("ALWAYS") == "always"
+    assert scopes.normalize("  Kestrel   launch ") == "Kestrel launch"
+    assert scopes.normalize("", "personal") == "personal" and scopes.normalize(None) is None
+    assert scopes.recall_scopes("work") == ["work", "always"]
+    assert scopes.recall_scopes("always") == ["always"] and scopes.recall_scopes(None) is None
+    assert scopes.label("work") == "Work" and scopes.label("Kestrel") == "Kestrel" and scopes.label(None) == "Personal"
+    with pytest.raises(ValueError):
+        scopes.chat_scope("always")
+    assert scopes.of_session(None, {"memory_scope": None, "channel": "desktop"}) == "personal"
+    user = "# About Maya\n\nMy words.\n\n## Learned\n\n- Maya has asthma\n\n## Later\n- kept\n"
+    assert scopes.without_learned(user) == "# About Maya\n\nMy words.\n\n## Later\n- kept"
+
+
+# ---------------------------------------------------------------- recall and saving
+async def test_recall_reads_the_scope_plus_always(app):
+    mem = app.memory
+    await _seed(mem)
+    query = "what do you know about Maya sister health Kestrel Arjun answers Atlas"
+    work = _texts(await mem.recall(query, top_k=20, min_similarity=0.0, scopes=scopes.recall_scopes("work")))
+    assert work == {KESTREL, ARJUN, NAME}
+    personal = _texts(await mem.recall(query, top_k=20, min_similarity=0.0, scopes=scopes.recall_scopes("personal")))
+    assert personal == {SISTER, HEALTH, NAME}
+    atlas = _texts(await mem.recall(query, top_k=20, min_similarity=0.0, scopes=scopes.recall_scopes("Atlas")))
+    assert atlas == {ATLAS, NAME}  # a project's memory is never recalled in another project, and vice versa
+    everywhere = _texts(await mem.recall(query, top_k=20, min_similarity=0.0))
+    assert everywhere == {SISTER, HEALTH, KESTREL, ARJUN, NAME, ATLAS}
+    assert _texts(await mem.list_facts(scope="work")) == {KESTREL, ARJUN}
+    assert _texts(await mem.list_facts(scope="Work", q="Kestrel")) == {KESTREL, ARJUN}
+
+
+async def test_saving_lands_in_its_scope_and_never_changes_another(app):
+    mem = app.memory
+    await _put(mem, "Maya lives in Pune", "personal")
+    # the same words in work are a work memory of their own, not a duplicate of the personal one
+    again = await mem.remember("Maya lives in Pune", use_llm=False, scope="work")
+    assert again["action"] == "ADD" and again["scope"] == "work"
+    # a correction in a work chat updates the work memory, never the personal one
+    moved = await mem.remember("Maya lives in Mumbai", use_llm=True, scope="work")
+    assert moved["action"] == "UPDATE" and moved["id"] == again["id"]
+    rows = {f["scope"]: f["content"] for f in await mem.list_facts()}
+    assert rows == {"personal": "Maya lives in Pune", "work": "Maya lives in Mumbai"}
+    # an always memory is shared, so a save anywhere still finds it
+    name = await _put(mem, NAME, "always")
+    assert (await mem.remember(NAME, use_llm=False, scope="work")) == {"action": "SKIP", "id": name, "content": NAME}
+
+
+async def test_move_and_reset_a_scope(app):
+    mem = app.memory
+    ids = await _seed(mem)
+    async with app.bus.subscribe() as q:
+        moved = await mem.set_scope(ids["arjun"], "Kestrel")
+        events = drain(q)
+    assert moved["scope"] == "Kestrel"
+    assert events[-1]["data"] | {"id": None} == {
+        "action": "UPDATE", "id": None, "content": ARJUN, "scope": "Kestrel", "previous_scope": "work", "reason": "moved"
+    }
+    with pytest.raises(KeyError):
+        await mem.set_scope(99999, "work")
+    # resetting work deletes only work (also what waits for review there)
+    held = await mem.remember("Maya's standup moved to 9:30", scope="work", use_llm=False, review=review.note("Gmail"))
+    assert held["status"] == "pending"
+    assert await mem.forget_scope("work") == 2
+    assert _texts(await mem.list_facts()) == {SISTER, HEALTH, NAME, ATLAS, ARJUN}
+    assert await mem.pending_facts() == []
+    assert await mem.forget_scope("nothing here") == 0
+
+
+async def test_a_held_memory_is_approved_into_its_scope(app):
+    mem = app.memory
+    held = await mem.remember(KESTREL, scope="work", use_llm=False, review=review.note("Gmail"))
+    [item] = (await review.inbox(app))["items"]
+    assert item["scope"] == "work"
+    await review.approve(app, "fact", str(held["id"]))
+    assert (await mem.get_fact(held["id"]))["scope"] == "work"
+
+
+# ---------------------------------------------------------------- chats
+async def _turn(app, sid: str, text: str) -> list:
+    events = [ev async for ev in app.agent.run_turn(sid, text, channel="desktop")]
+    await app.agent.drain(timeout=5)
+    return events
+
+
+async def test_a_work_chat_uses_work_memories_and_saves_into_work(app):
+    mem, llm = app.memory, app.fake
+    await _seed(mem)
+    app.workspace.write("memory", "# Long-term memory\n\n- Maya's sister Meera visits in May\n")
+    app.workspace.write("user", "# About Maya\n\nMaya Rao, product lead.\n\n## Learned\n\n- Maya has asthma\n")
+    app.config.memory.min_similarity = 0.0
+    app.config.memory.extract_after_turn = True
+    await app.user_model.add_insight("Maya is very close to her sister Meera", "relationships")
+    await app.user_model.add_insight("Maya likes answers as short bullet points", "communication")
+    work = await app.store.create_session(channel="desktop", memory_scope="work")
+    llm.replies.append("You lead Kestrel and Arjun is your manager.")
+    llm.json_replies.extend([
+        {"facts": ["Maya's Kestrel launch review is on Thursday"]},
+        {"action": "ADD", "fact_id": None, "content": "Maya's Kestrel launch review is on Thursday",
+         "analysis": {"topics": ["Work & Learning"], "memory_type": "long-term", "duration": None}},
+    ])
+    await _turn(app, work, "What do you know about me? My Kestrel launch review is on Thursday.")
+    prompt = llm.calls[0]["messages"][0]["content"]
+    assert KESTREL in prompt and ARJUN in prompt and NAME in prompt
+    for personal in (SISTER, HEALTH, "Meera visits in May", "Maya has asthma", "close to her sister"):
+        assert personal not in prompt
+    assert "short bullet points" in prompt  # how she likes things still holds at work
+    assert "Maya Rao, product lead." in prompt  # the user's own words in USER.md stay
+    assert "This chat uses the user's Work memories" in prompt
+    saved = next(f for f in await mem.list_facts() if "review is on Thursday" in f["content"])
+    assert saved["scope"] == "work"
+
+    # a personal chat sees personal memories and the profile files, and nothing from work
+    llm.calls.clear()
+    llm.replies.append("Your sister Meera lives in Lisbon.")
+    personal = await app.store.create_session(channel="desktop")
+    app.config.memory.extract_after_turn = False
+    await _turn(app, personal, "What do you know about me and my sister and Kestrel?")
+    prompt = llm.calls[0]["messages"][0]["content"]
+    assert SISTER in prompt and NAME in prompt and "Meera visits in May" in prompt and "close to her sister" in prompt
+    assert KESTREL not in prompt and ARJUN not in prompt and "Memory scope" not in prompt
+
+
+async def test_tools_follow_the_chats_scope_unless_asked_everywhere(app):
+    mem = app.memory
+    await _seed(mem)
+    app.config.memory.min_similarity = 0.0
+    work = await app.store.create_session(channel="desktop", memory_scope="work")
+    ctx = app.agent.tool_context(work, "subagent")  # a helper the chat started carries only its id
+    recall = app.registry.get("memory_recall")
+    found = await recall.call(ctx, {"query": "Maya sister asthma Kestrel Arjun answers", "limit": 20})
+    assert {f["fact"] for f in found} == {KESTREL, ARJUN, NAME}
+    found = await recall.call(ctx, {"query": "Maya sister asthma", "limit": 20, "everywhere": True})
+    health = next(f for f in found if f["fact"] == HEALTH)
+    assert health["kept_for"] == "Personal"
+    out = await app.registry.get("memory_remember").call(ctx, {"fact": "Maya's Kestrel demo is on Friday"})
+    assert (await mem.get_fact(out["id"]))["scope"] == "work"
+    # work not tied to a chat or task reads every scope
+    proactive = app.agent.tool_context(None, "proactive", origin="proactive")
+    found = await recall.call(proactive, {"query": "Maya sister asthma Kestrel", "limit": 20})
+    assert {SISTER, KESTREL} <= {f["fact"] for f in found}
+
+
+async def test_a_messaging_app_can_be_set_to_a_scope(app):
+    app.config.channels.telegram.memory_scope = "Work"
+    sid = await app.store.create_session(channel="telegram")
+    assert scopes.of_session(app.config, await app.store.get_session(sid)) == "work"
+    await app.store.set_session_scope(sid, "Atlas")  # the chat's own pick wins
+    assert scopes.of_session(app.config, await app.store.get_session(sid)) == "Atlas"
+    other = await app.store.create_session(channel="discord")
+    assert scopes.of_session(app.config, await app.store.get_session(other)) == "personal"
+
+
+async def test_an_incognito_work_chat_reads_work_and_saves_nothing(app):
+    mem, llm = app.memory, app.fake
+    await _seed(mem)
+    app.config.memory.min_similarity = 0.0
+    sid = await app.store.create_session(channel="desktop", incognito=True, memory_scope="work")
+    llm.replies.append("ok")
+    await _turn(app, sid, "Tell me about Kestrel and my sister's health")
+    prompt = llm.calls[0]["messages"][0]["content"]
+    assert KESTREL in prompt and SISTER not in prompt and "incognito chat" in prompt
+    assert len(await mem.list_facts()) == 6
+
+
+# ---------------------------------------------------------------- tasks
+async def test_tasks_keep_the_scope_of_the_chat_that_made_them(app, monkeypatch):
+    mem = app.memory
+    await _seed(mem)
+    app.config.memory.min_similarity = 0.0
+    monkeypatch.setattr(app.tasks, "_spawn", lambda coro, name: coro.close())  # no planning in the background
+    work = await app.store.create_session(channel="desktop", memory_scope="work")
+    out = await app.registry.get("create_task_from_prompt").call(
+        app.agent.tool_context(work, "desktop"), {"prompt": "Every Friday summarise Kestrel and Arjun's notes"}
+    )
+    assert (await app.tasks.get(out["task_id"]))["memory_scope"] == "work"
+    task = await app.tasks.repo.get_task(out["task_id"])
+    _, facts, _ = await executor._executor_system_prompt(app.tasks, task, {"id": "run1"}, [], {})
+    assert _texts(facts) <= {KESTREL, ARJUN, NAME} and KESTREL in _texts(facts)
+    plain = await app.tasks.create_task("Summarise my week, my sister and Kestrel")
+    assert plain["memory_scope"] == "personal"
+    with pytest.raises(ValueError):
+        await app.tasks.update(plain["task_id"], {"memory_scope": "always"})
+    updated = await app.tasks.update(plain["task_id"], {"memory_scope": "Atlas"})
+    assert updated["memory_scope"] == "Atlas"
+    await app.tasks.repo.update_task(plain["task_id"], {"status": "processing"})
+    with pytest.raises(TaskConflict):  # a run keeps the memories it started with
+        await app.tasks.update(plain["task_id"], {"memory_scope": "work"})
+
+
+# ---------------------------------------------------------------- the rest of memory
+async def test_dreaming_never_merges_across_scopes(app):
+    mem = app.memory
+    app.config.user_model.enabled = False
+    a = await _put(mem, "Maya drinks black coffee every morning", "personal")
+    b = await mem.remember("Every morning Maya drinks black coffee.", use_llm=False, scope="work")
+    dream = await app.dreaming.run()
+    assert dream["stats"]["merged"] == 0
+    assert await mem.get_fact(a) is not None and await mem.get_fact(b["id"]) is not None
+
+
+async def test_profile_files_are_built_from_personal_and_always_only(app):
+    mem = app.memory
+    for content, scope in ((HEALTH, "personal"), (KESTREL, "work"), (NAME, "always")):
+        fid = await _put(mem, content, scope)
+        await app.store.execute("UPDATE facts SET topics = ? WHERE id = ?", ('["Personal Identity"]', fid))
+    app.fake.text_replies.append("# Long-term memory\n\n- notes\n")
+    await app.evolution.update_profile(force=True)
+    sent = app.fake.text_calls[-1]["messages"][1]["content"]
+    assert HEALTH in sent and NAME in sent and KESTREL not in sent
+    learned = app.workspace.user.read_text(encoding="utf-8")
+    assert HEALTH in learned and KESTREL not in learned
+
+
+async def test_export_says_where_each_memory_is_kept(app):
+    await _seed(app.memory)
+    md = await memory_export.export(app, "markdown")
+    text = Path(md["path"]).read_text(encoding="utf-8")
+    assert f"- {KESTREL} _(Work, " in text and f"- {SISTER} _(a chat" in text
+    db = await memory_export.export(app, "sqlite")
+    con = sqlite3.connect(db["path"])
+    try:
+        rows = dict(con.execute("SELECT content, scope FROM memories").fetchall())
+    finally:
+        con.close()
+    assert rows[KESTREL] == "work" and rows[SISTER] == "personal" and rows[ATLAS] == "Atlas"
+
+
+async def test_older_memories_become_personal(config, isolated_home):
+    """An older database (and a backup made by an older build) gets every memory in personal."""
+    app = SentientApp(config, llm=FakeProvider(), enable_background=False)
+    await app.start()
+    await app.stop()
+    con = sqlite3.connect(paths.db_file())
+    con.execute("DROP INDEX idx_facts_scope")
+    con.execute("ALTER TABLE facts DROP COLUMN scope")
+    con.execute("ALTER TABLE sessions DROP COLUMN memory_scope")
+    con.execute(
+        "INSERT INTO facts(content, source, topics, memory_type, created_at, updated_at) VALUES"
+        " ('Maya has asthma', 'conversation', '[]', 'long-term', '2026-01-01', '2026-01-01')"
+    )
+    con.execute("PRAGMA user_version = 10")
+    con.commit()
+    con.close()
+    app = SentientApp(config, llm=FakeProvider(), enable_background=False)
+    await app.start()
+    try:
+        row = await app.store.fetchone("SELECT scope FROM facts WHERE content = 'Maya has asthma'")
+        assert row["scope"] == "personal"
+        sid = await app.store.create_session(channel="desktop")
+        assert (await app.store.get_session(sid))["memory_scope"] is None
+    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")
+    llm = FakeProvider(replies=["one", "two", "three"])
+    core = SentientApp(config, llm=llm, db_path=isolated_home / "scopes.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_scopes_over_rest(client):
+    personal = client.post("/api/memories", json={"content": SISTER, "source": "manual"}).json()
+    work = client.post("/api/memories", json={"content": KESTREL, "scope": "Work"}).json()
+    atlas = client.post("/api/memories", json={"content": ATLAS, "scope": "Atlas"}).json()
+    assert [m["content"] for m in client.get("/api/memories", params={"scope": "work"}).json()] == [KESTREL]
+    listed = {s["name"]: s for s in client.get("/api/memories/scopes").json()}
+    assert list(listed)[:3] == ["always", "personal", "work"]
+    assert listed["work"]["count"] == 1 and listed["Atlas"] == {
+        "name": "Atlas", "label": "Atlas", "count": 1, "built_in": False
+    }
+    moved = client.patch(f"/api/memories/{personal['id']}", json={"scope": "always"}).json()
+    assert moved["scope"] == "always" and moved["content"] == SISTER
+    assert client.patch(f"/api/memories/{personal['id']}", json={"scope": ""}).status_code == 400
+    assert client.patch("/api/memories/99999", json={"scope": "work"}).status_code == 404
+    assert client.delete("/api/memories/scope/work").json() == {"deleted": 1}
+    assert client.get("/api/memories/scopes").json()[2] | {"count": 0} == {
+        "name": "work", "label": "Work", "count": 0, "built_in": True
+    }
+    assert {m["id"] for m in client.get("/api/memories").json()} == {personal["id"], atlas["id"]}
+    assert work["id"] not in {m["id"] for m in client.get("/api/memories").json()}
+
+
+def test_a_chats_scope_over_rest(client):
+    sid = client.post("/api/sessions", params={"memory_scope": "Work"}).json()["session_id"]
+    row = next(s for s in client.get("/api/sessions").json() if s["id"] == sid)
+    assert row["memory_scope"] == "work"
+    with client.websocket_connect("/ws?token=test-token") as ws:
+        assert ws.receive_json()["type"] == "hello"
+        assert client.patch(f"/api/sessions/{sid}", json={"memory_scope": "Kestrel"}).json() == {
+            "ok": True, "memory_scope": "Kestrel"
+        }
+        ev = ws.receive_json()
+        while ev.get("type") != "session.updated":
+            ev = ws.receive_json()
+        assert ev["data"] == {"session_id": sid, "memory_scope": "Kestrel"}
+    assert client.patch(f"/api/sessions/{sid}", json={"memory_scope": None}).json()["memory_scope"] == "personal"
+    assert client.patch(f"/api/sessions/{sid}", json={"memory_scope": "always"}).status_code == 422
+    assert client.post("/api/sessions", params={"memory_scope": "always"}).status_code == 422
+    plain = client.post("/api/sessions").json()["session_id"]
+    assert next(s for s in client.get("/api/sessions").json() if s["id"] == plain)["memory_scope"] == "personal"
+    assert json.dumps(client.get("/api/memories/review").json()["items"]) == "[]"
+
+
+async def test_profile_upkeep_leaves_out_work_chat_summaries(app):
+    app.config.channels.telegram.memory_scope = "work"
+    personal = await app.store.create_session(channel="desktop")
+    work = await app.store.create_session(channel="desktop", memory_scope="Kestrel")
+    telegram = await app.store.create_session(channel="telegram")  # work through its app's scope
+    for sid, text in ((personal, "We planned Meera's visit"), (work, "We reviewed the Kestrel launch plan"),
+                      (telegram, "We triaged Arjun's payment bugs")):
+        await app.store.execute(
+            "INSERT INTO summaries(id, session_id, content, start_at, end_at, message_ids, created_at)"
+            " VALUES(?,?,?,?,?,?,?)",
+            (f"s-{sid}", sid, text, "2026-10-01", "2026-10-01", "[]", "2026-10-01T00:00:00+00:00"),
+        )
+    # a deleted chat's summary keeps the scope it was written in
+    gone = await app.store.create_session(channel="desktop", memory_scope="work")
+    await app.store.add_message(gone, "user", "Plan the Kestrel retro")
+    [msg] = await app.store.recent_messages(gone, 5)
+    await app.memory.episodic.add_summary(gone, "We planned the Kestrel retro", [msg])
+    assert (await app.store.fetchone("SELECT scope FROM summaries WHERE session_id = ?", (gone,)))["scope"] == "work"
+    await app.store.execute("DELETE FROM sessions WHERE id = ?", (gone,))
+    await _put(app.memory, HEALTH, "personal")
+    app.fake.text_replies.append("# Long-term memory\n\n- notes\n")
+    await app.evolution.update_profile(force=True)
+    sent = app.fake.text_calls[-1]["messages"][1]["content"]
+    assert "Meera's visit" in sent and "Kestrel launch plan" not in sent and "payment bugs" not in sent
+    assert "Kestrel retro" not in sent
+
+
+async def test_moving_a_memory_out_of_personal_takes_it_out_of_user_md(client):
+    core = client.core
+    added = client.post("/api/memories", json={"content": HEALTH}).json()
+    core.workspace.write("user", f"# About Maya\n\n- {HEALTH} (my words)\n\n## Learned\n\n- {HEALTH}\n- {SISTER}\n")
+    client.patch(f"/api/memories/{added['id']}", json={"scope": "work"})
+    text = core.workspace.user.read_text(encoding="utf-8")
+    assert f"- {SISTER}" in text and f"- {HEALTH} (my words)" in text and f"- {HEALTH}\n" not in text
+
+
+def test_a_bad_scope_changes_nothing_else(client):
+    sid = client.post("/api/sessions").json()["session_id"]
+    r = client.patch(f"/api/sessions/{sid}", json={"title": "Renamed", "memory_scope": "always"})
+    assert r.status_code == 422
+    assert next(s for s in client.get("/api/sessions").json() if s["id"] == sid)["title"] != "Renamed"
diff --git a/tests/tasks/test_routes.py b/tests/tasks/test_routes.py
index 0898dd562..ac550132f 100644
--- a/tests/tasks/test_routes.py
+++ b/tests/tasks/test_routes.py
@@ -12,7 +12,7 @@
     "task_id", "name", "description", "status", "priority", "assignee", "task_type", "schedule", "plan", "runs",
     "chat_history", "clarifying_questions", "swarm_details", "enabled", "model", "original_context", "error",
     "next_execution_at", "last_execution_at", "created_at", "updated_at", "script", "browser_profile", "deliver_to", "notepad",
-    "keep_running",
+    "keep_running", "memory_scope",
 }
 RUN_KEYS = {
     "run_id", "status", "created_at", "execution_start_time", "finished_at", "plan", "trigger_event_data",