diff --git a/apps/desktop/src/App.tsx b/apps/desktop/src/App.tsx
index a8d43b60..c9f90780 100644
--- a/apps/desktop/src/App.tsx
+++ b/apps/desktop/src/App.tsx
@@ -24,6 +24,7 @@ const ArchivedPage = lazy(() => import("@/pages/chat/archived-page"));
 const AgentsPage = lazy(() => import("@/pages/agents/agents-page"));
 const AgentNewPage = lazy(() => import("@/pages/agents/agent-new"));
 const AgentDetailPage = lazy(() => import("@/pages/agents/agent-detail"));
+const FilesPage = lazy(() => import("@/pages/files/files-page"));
 const AutomationsPage = lazy(() => import("@/pages/automations/automations-page"));
 const PluginsPage = lazy(() => import("@/pages/plugins/plugins-page"));
 const ActivityPage = lazy(() => import("@/pages/activity/activity-page"));
@@ -202,6 +203,8 @@ export function App() {
           <Route path="/agents" element={<AgentsPage />} />
           <Route path="/agents/new" element={<AgentNewPage />} />
           <Route path="/agents/:agentId/*" element={<AgentDetailPage />} />
+          <Route path="/files" element={<FilesPage />} />
+          <Route path="/files/:agentId" element={<FilesPage />} />
           <Route path="/tasks" element={<TasksPage />} />
           <Route path="/my-tasks" element={<HumanTasksPage />} />
           <Route path="/automations" element={<AutomationsPage />} />
diff --git a/apps/desktop/src/components/agents/detail/memory-tab.tsx b/apps/desktop/src/components/agents/detail/memory-tab.tsx
index 256e136a..5901ac8f 100644
--- a/apps/desktop/src/components/agents/detail/memory-tab.tsx
+++ b/apps/desktop/src/components/agents/detail/memory-tab.tsx
@@ -1,34 +1,14 @@
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useMemo, useState } from "react";
 import { Link } from "react-router";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useQuery } from "@tanstack/react-query";
 import { toast } from "sonner";
-import { formatDistanceToNowStrict } from "date-fns";
-import {
-  Brain,
-  ChevronRight,
-  Eye,
-  FileCode2,
-  FileJson,
-  FileText,
-  Folder,
-  FolderOpen,
-  Lock,
-  Moon,
-  PencilLine,
-  RotateCcw,
-  Save,
-} from "lucide-react";
+import { ChevronRight, Folder, FolderOpen, FolderSearch } from "lucide-react";
 import type { Agent, AgentFileEntry } from "@godmode/shared";
-import { api, ApiRequestError, errorMessage } from "@/lib/api";
+import { api, errorMessage } from "@/lib/api";
 import { qk } from "@/lib/queryKeys";
-import { isMac, modKey } from "@/lib/desktop";
 import { cn } from "@/lib/utils";
-import { Kbd } from "@/components/common";
-import { Markdown } from "@/components/chat/markdown";
 import { Button } from "@/components/ui/button";
 import { Skeleton } from "@/components/ui/skeleton";
-import { Spinner } from "@/components/ui/spinner";
-import { ToggleGroup, ToggleGroupItem } from "@/components/ui/toggle-group";
 import {
   AlertDialog,
   AlertDialogAction,
@@ -39,39 +19,11 @@ import {
   AlertDialogHeader,
   AlertDialogTitle,
 } from "@/components/ui/alert-dialog";
+import { FileEditor, fileIcon, nameOf, parentOf } from "@/components/files/file-editor";
 import { DreamsPanel, useDreamingNow } from "./dreams-panel";
-import { BrokenLinks, brokenMemoryLinks, MemoryBudget, memoryLinkTarget, memorySections, SectionMenu, type MemorySection } from "./memory-editor-parts";
 
 const PINNED = ["MEMORY.md", "CLAUDE.md"];
 const HIDDEN = new Set([".git"]);
-const MAX_EDITABLE = 512 * 1024;
-
-/** Why a file can't be edited here (null = editable). */
-function readOnlyReason(path: string, size: number): string | null {
-  if (path === "CLAUDE.md") return "Generated from the agent's settings — edit the instructions in Settings instead.";
-  if (path.startsWith("state/")) return "Snapshot written by Godmode — changes would be overwritten.";
-  if (path.startsWith("runs/")) return "Raw run log — read-only.";
-  if (path.startsWith("conversations/")) return "Conversation transcript — read-only.";
-  if (size > MAX_EDITABLE) return "This file is too large to edit here.";
-  return null;
-}
-
-/** MEMORY.md and memory/** — a running dream owns these (the core refuses edits meanwhile). */
-function isMemoryPath(path: string) {
-  return path === "MEMORY.md" || path.startsWith("memory/");
-}
-
-/** The file changed on the server since the draft started — saving would overwrite someone else's edit. */
-class StaleDraftError extends Error {}
-
-function parentOf(path: string) {
-  const i = path.lastIndexOf("/");
-  return i === -1 ? "" : path.slice(0, i);
-}
-
-function nameOf(path: string) {
-  return path.slice(path.lastIndexOf("/") + 1);
-}
 
 /** Normalise listing entries to repo-relative paths directly inside `dir`. */
 function childrenOf(entries: AgentFileEntry[], dir: string): AgentFileEntry[] {
@@ -96,20 +48,6 @@ function childrenOf(entries: AgentFileEntry[], dir: string): AgentFileEntry[] {
   });
 }
 
-function fileIcon(path: string) {
-  if (path === "MEMORY.md") return <Brain className="size-4 text-foreground" />;
-  if (path === "CLAUDE.md") return <Lock className="size-4 text-muted-foreground" />;
-  if (/\.(json|jsonl)$/.test(path)) return <FileJson className="size-4 text-muted-foreground" />;
-  if (/\.(ts|tsx|js|py|sh|yaml|yml|toml)$/.test(path)) return <FileCode2 className="size-4 text-muted-foreground" />;
-  return <FileText className="size-4 text-muted-foreground" />;
-}
-
-function formatSize(n: number) {
-  if (n < 1024) return `${n} B`;
-  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
-  return `${(n / 1024 / 1024).toFixed(1)} MB`;
-}
-
 export function MemoryTab({ agent }: { agent: Agent }) {
   const [selected, setSelected] = useState<{ path: string; size: number } | null>({ path: "MEMORY.md", size: 0 });
   const [expanded, setExpanded] = useState<Set<string>>(() => new Set(["memory"]));
@@ -140,11 +78,23 @@ export function MemoryTab({ agent }: { agent: Agent }) {
       <DreamsPanel agent={agent} />
       <div className="grid min-h-[32rem] grid-cols-1 gap-4 @3xl:grid-cols-[260px_minmax(0,1fr)]">
         <aside className="flex max-h-[70vh] min-h-0 flex-col rounded-xl border bg-card shadow-card">
-          <div className="flex items-center justify-between border-b px-4 py-3">
+          <div className="flex items-center justify-between gap-2 border-b px-4 py-3">
             <div>
               <h2 className="text-sm font-medium tracking-[-0.01em]">Files</h2>
               <p className="text-xs text-muted-foreground">Agent repository</p>
             </div>
+            <Button asChild variant="ghost" size="xs" title="Sizes, cleanup suggestions, moves and deletes">
+              <Link
+                to={`/files/${agent.id}`}
+                onClick={(e) => {
+                  if (!dirty) return;
+                  e.preventDefault();
+                  toast.warning("Save or revert your edits first", { description: `${selected?.path ?? "The file"} has unsaved changes.` });
+                }}
+              >
+                <FolderSearch /> Tidy up
+              </Link>
+            </Button>
           </div>
           <nav aria-label="Agent files" className="min-h-0 flex-1 overflow-y-auto p-2">
             <Tree agentId={agent.id} dir="" depth={0} expanded={expanded} onToggle={toggleDir} selected={selected?.path ?? null} onSelect={select} />
@@ -278,239 +228,3 @@ function Tree({
     </ul>
   );
 }
-
-function FileEditor({
-  agentId,
-  agentName,
-  path,
-  size,
-  dreaming,
-  onDirtyChange,
-  onOpenFile,
-}: {
-  agentId: string;
-  agentName: string;
-  path: string;
-  size: number;
-  /** A dream of the agent is running: memory files are locked until it ends. */
-  dreaming: boolean;
-  onDirtyChange: (dirty: boolean) => void;
-  /** A link in the preview points at another note in the repository. */
-  onOpenFile: (path: string) => void;
-}) {
-  const qc = useQueryClient();
-  const file = useQuery({ queryKey: qk.agentFile(agentId, path), queryFn: () => api.agents.readFile(agentId, path) });
-  const original = file.data?.content ?? "";
-  /** The edit and the file content it started from, so a rewrite underneath (e.g. by a dream) isn't silently overwritten. */
-  const [draft, setDraft] = useState<{ text: string; base: string } | null>(null);
-  const value = draft?.text ?? original;
-  const dirty = draft !== null && draft.text !== original;
-  const conflict = dirty && draft.base !== original;
-  const isMarkdown = /\.(md|markdown)$/i.test(path);
-  const fixedReason = readOnlyReason(path, Math.max(size, original.length));
-  const dreamLock = dreaming && isMemoryPath(path);
-  const readOnly = fixedReason ?? (dreamLock ? `${agentName} is dreaming — editing is paused until the dream ends.` : null);
-  const [view, setView] = useState<"edit" | "preview">(isMarkdown && fixedReason ? "preview" : "edit");
-  const edit = (text: string) => setDraft((d) => ({ text, base: d && d.text !== original ? d.base : original }));
-  const textareaRef = useRef<HTMLTextAreaElement>(null);
-  const previewRef = useRef<HTMLDivElement>(null);
-  const isMemory = path === "MEMORY.md";
-  const memory = useQuery({ queryKey: qk.agentMemory(agentId), queryFn: () => api.agents.memory(agentId), enabled: isMemory });
-  const sections = useMemo(() => (isMarkdown ? memorySections(value) : []), [isMarkdown, value]);
-  const broken = useMemo(() => (isMemory && memory.data ? brokenMemoryLinks(value, memory.data.topics) : []), [isMemory, memory.data, value]);
-
-  const jumpTo = (section: MemorySection) => {
-    if (view === "preview") {
-      const headings = previewRef.current?.querySelectorAll("h1, h2, h3");
-      headings?.[sections.indexOf(section)]?.scrollIntoView({ block: "start", behavior: "smooth" });
-      return;
-    }
-    const el = textareaRef.current;
-    if (!el) return;
-    const offset = value.split("\n").slice(0, section.line).reduce((n, l) => n + l.length + 1, 0);
-    el.focus();
-    el.setSelectionRange(offset, offset);
-    const lineHeight = parseFloat(getComputedStyle(el).lineHeight) || 21;
-    el.scrollTop = Math.max(0, section.line * lineHeight - 12);
-  };
-
-  useEffect(() => onDirtyChange(dirty), [dirty, onDirtyChange]);
-  useEffect(() => () => onDirtyChange(false), [onDirtyChange]);
-
-  const save = useMutation({
-    mutationFn: async ({ content, base }: { content: string; base: string | null }) => {
-      // Not every writer announces itself (a chat run may rewrite MEMORY.md): check the file is still what the draft started from.
-      if (base !== null) {
-        const fresh = await api.agents.readFile(agentId, path).catch((err) => {
-          if (err instanceof ApiRequestError && err.status === 404) return { path, content: "" };
-          throw err;
-        });
-        if (fresh.content !== base) {
-          qc.setQueryData(qk.agentFile(agentId, path), fresh);
-          throw new StaleDraftError();
-        }
-      }
-      await api.agents.writeFile(agentId, path, content);
-      return content;
-    },
-    onSuccess: (content) => {
-      qc.setQueryData(qk.agentFile(agentId, path), { path, content });
-      qc.invalidateQueries({ queryKey: qk.agentCommits(agentId) });
-      qc.invalidateQueries({ queryKey: qk.agentFiles(agentId, parentOf(path)) });
-      if (isMemory) {
-        qc.invalidateQueries({ queryKey: qk.agentDreams(agentId) });
-        qc.invalidateQueries({ queryKey: qk.agentMemory(agentId) });
-      }
-      setDraft(null);
-      toast.success(`Saved ${nameOf(path)}`);
-    },
-    onError: (err) => {
-      if (err instanceof StaleDraftError) warnConflict();
-      else toast.error(`Couldn't save ${nameOf(path)}`, { description: errorMessage(err) });
-    },
-  });
-  const warnConflict = () =>
-    toast.warning(`${nameOf(path)} changed while you were editing`, { description: "Reload it, or overwrite it with your version." });
-
-  const saveRef = useRef<() => void>(() => {});
-  saveRef.current = () => {
-    if (!dirty || readOnly || save.isPending || !draft) return;
-    if (conflict) warnConflict();
-    else save.mutate({ content: value, base: draft.base });
-  };
-  useEffect(() => {
-    const onKey = (e: KeyboardEvent) => {
-      const mod = isMac ? e.metaKey : e.ctrlKey;
-      if (mod && e.key.toLowerCase() === "s") {
-        e.preventDefault();
-        saveRef.current();
-      }
-    };
-    window.addEventListener("keydown", onKey);
-    return () => window.removeEventListener("keydown", onKey);
-  }, []);
-
-  const lines = value ? value.split("\n").length : 0;
-  const missing = file.isError && (file.error as { status?: number }).status === 404;
-
-  return (
-    <>
-      <div className="flex flex-wrap items-center gap-2 border-b px-4 py-2.5">
-        <span className="shrink-0">{fileIcon(path)}</span>
-        <span className="min-w-0 truncate font-mono text-[13px]">{path}</span>
-        {dirty && <span className="size-2 shrink-0 rounded-full bg-warning" aria-label="Unsaved changes" title="Unsaved changes" />}
-        <div className="ml-auto flex items-center gap-2">
-          <SectionMenu sections={sections} onPick={jumpTo} />
-          {isMarkdown && (
-            <ToggleGroup type="single" size="sm" variant="outline" value={view} onValueChange={(v) => v && setView(v as "edit" | "preview")} aria-label="View mode">
-              <ToggleGroupItem value="edit" aria-label={readOnly ? "Source" : "Edit"} className="gap-1 px-2 text-xs">
-                <PencilLine className="size-3.5" /> {readOnly ? "Source" : "Edit"}
-              </ToggleGroupItem>
-              <ToggleGroupItem value="preview" aria-label="Preview" className="gap-1 px-2 text-xs">
-                <Eye className="size-3.5" /> Preview
-              </ToggleGroupItem>
-            </ToggleGroup>
-          )}
-          {!fixedReason && (
-            <>
-              <Button variant="ghost" size="sm" disabled={!dirty} onClick={() => setDraft(null)}>
-                <RotateCcw /> Revert
-              </Button>
-              <Button size="sm" disabled={!dirty || !!readOnly || conflict || save.isPending} onClick={() => saveRef.current()}>
-                {save.isPending ? <Spinner /> : <Save />} Save
-                <Kbd>{modKey}S</Kbd>
-              </Button>
-            </>
-          )}
-        </div>
-      </div>
-
-      {readOnly && (
-        <div className={cn("flex items-center gap-2 border-b px-4 py-2 text-xs text-muted-foreground", fixedReason ? "bg-paper-2" : "bg-dream-soft")} role={fixedReason ? undefined : "status"}>
-          {fixedReason ? <Lock className="size-3.5 shrink-0" /> : <Moon className="size-3.5 shrink-0 text-dream" aria-hidden />}
-          <span>{readOnly}</span>
-          {path === "CLAUDE.md" && (
-            <Link to={`/agents/${agentId}/settings`} className="ml-auto shrink-0 font-medium text-foreground underline decoration-foreground/25 underline-offset-[3px] hover:decoration-foreground">
-              Open settings
-            </Link>
-          )}
-        </div>
-      )}
-
-      {conflict && (
-        <div role="alert" className="flex flex-wrap items-center gap-x-3 gap-y-2 border-b border-warning/25 bg-warning/[0.07] px-4 py-2 text-xs">
-          <span className="min-w-0 flex-1 basis-64 text-muted-foreground">
-            <span className="font-medium text-foreground">{nameOf(path)} changed while you were editing</span> — {agentName} may have rewritten it. Reload to
-            see the new version (your edits are discarded), or overwrite it with yours.
-          </span>
-          <span className="flex shrink-0 gap-1.5">
-            <Button variant="outline" size="xs" onClick={() => setDraft(null)}>
-              <RotateCcw /> Reload
-            </Button>
-            <Button size="xs" disabled={!!readOnly || save.isPending} onClick={() => save.mutate({ content: value, base: null })}>
-              {save.isPending ? <Spinner /> : <Save />} Overwrite
-            </Button>
-          </span>
-        </div>
-      )}
-
-      <div className="relative min-h-0 flex-1">
-        {file.isLoading ? (
-          <div className="space-y-2 p-4">
-            {Array.from({ length: 8 }, (_, i) => (
-              <Skeleton key={i} className="h-4" style={{ width: `${40 + ((i * 37) % 55)}%` }} />
-            ))}
-          </div>
-        ) : file.isError && !missing ? (
-          <div className="p-6 text-sm text-muted-foreground">Couldn't open this file: {errorMessage(file.error)}</div>
-        ) : view === "preview" && isMarkdown ? (
-          <div
-            ref={previewRef}
-            className="max-h-[70vh] overflow-y-auto p-5"
-            onClickCapture={(e) => {
-              const target = memoryLinkTarget((e.target as HTMLElement).closest("a")?.getAttribute("href") ?? null);
-              if (!target) return;
-              e.preventDefault();
-              e.stopPropagation();
-              onOpenFile(target);
-            }}
-          >
-            {value.trim() ? <Markdown>{value}</Markdown> : <p className="text-sm text-muted-foreground italic">Empty file.</p>}
-          </div>
-        ) : (
-          <textarea
-            ref={textareaRef}
-            value={value}
-            onChange={(e) => edit(e.target.value)}
-            onKeyDown={(e) => {
-              // Tab inserts two spaces instead of leaving the editor
-              if (e.key === "Tab" && !e.shiftKey && !readOnly) {
-                e.preventDefault();
-                const el = e.currentTarget;
-                const { selectionStart: s, selectionEnd: end } = el;
-                edit(`${value.slice(0, s)}  ${value.slice(end)}`);
-                requestAnimationFrame(() => el.setSelectionRange(s + 2, s + 2));
-              }
-            }}
-            readOnly={!!readOnly}
-            spellCheck={isMarkdown}
-            aria-label={`Contents of ${path}`}
-            placeholder={missing ? "This file doesn't exist yet — start typing to create it." : undefined}
-            className="block h-[60vh] w-full resize-none bg-transparent p-4 font-mono text-[13px] leading-relaxed outline-none placeholder:text-muted-foreground/70"
-          />
-        )}
-      </div>
-
-      <div className="flex items-center gap-3 overflow-hidden border-t px-4 py-2 text-[11px] whitespace-nowrap text-muted-foreground">
-        <span className="tabular-nums">{lines.toLocaleString()} lines</span>
-        <span className="tabular-nums">{formatSize(new Blob([value]).size)}</span>
-        {isMemory && memory.data && <MemoryBudget chars={value.length} memory={memory.data} />}
-        {isMemory && <BrokenLinks paths={broken} />}
-        {file.dataUpdatedAt > 0 && !dirty && (
-          <span className="ml-auto">loaded {formatDistanceToNowStrict(file.dataUpdatedAt, { addSuffix: true })}</span>
-        )}
-        {dirty && <span className="ml-auto text-warning">Unsaved changes</span>}
-      </div>
-    </>
-  );
-}
diff --git a/apps/desktop/src/components/files/bin-pane.tsx b/apps/desktop/src/components/files/bin-pane.tsx
new file mode 100644
index 00000000..1d9c4be9
--- /dev/null
+++ b/apps/desktop/src/components/files/bin-pane.tsx
@@ -0,0 +1,139 @@
+import { useState } from "react";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { formatDistanceToNowStrict } from "date-fns";
+import { Folder, RotateCcw, Trash, Trash2 } from "lucide-react";
+import { toast } from "sonner";
+import type { Agent } from "@godmode/shared";
+import { formatBytes } from "@godmode/shared";
+import { api, errorMessage } from "@/lib/api";
+import { qk } from "@/lib/queryKeys";
+import { Button } from "@/components/ui/button";
+import { Skeleton } from "@/components/ui/skeleton";
+import { Spinner } from "@/components/ui/spinner";
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { fileIcon, nameOf } from "./file-editor";
+import { plural, useRefreshFiles } from "./use-files";
+
+const KEEP_DAYS = 30;
+
+export function useBin(agentId: string) {
+  return useQuery({ queryKey: qk.agentBin(agentId), queryFn: () => api.agents.deletedFiles(agentId) });
+}
+
+export function BinPane({ agent, frozen }: { agent: Agent; frozen: boolean }) {
+  const bin = useBin(agent.id);
+  const refresh = useRefreshFiles(agent.id);
+  const [confirm, setConfirm] = useState<"empty" | { id: string; path: string } | null>(null);
+  const restore = useMutation({
+    mutationFn: (id: string) => api.agents.restoreDeleted(agent.id, id),
+    onSuccess: (r) => {
+      refresh();
+      toast.success(`Put back ${nameOf(r.path)}`, { description: r.path });
+    },
+    onError: (err) => toast.error("Couldn't put it back", { description: errorMessage(err) }),
+  });
+  const purge = useMutation({
+    mutationFn: (target: "empty" | { id: string }) => (target === "empty" ? api.agents.emptyBin(agent.id) : api.agents.purgeDeleted(agent.id, target.id)),
+    onSuccess: (r) => {
+      refresh();
+      toast.success(r.removed === 1 ? "Deleted for good" : `Emptied the bin`, { description: `${formatBytes(r.bytes)} freed.` });
+    },
+    onError: (err) => toast.error("Couldn't delete", { description: errorMessage(err) }),
+  });
+  const entries = bin.data ?? [];
+  const bytes = entries.reduce((n, e) => n + e.bytes, 0);
+
+  return (
+    <div className="flex h-full min-h-0 flex-col">
+      <div className="flex items-center gap-3 border-b px-4 py-3">
+        <div className="min-w-0">
+          <h2 className="text-sm font-medium tracking-[-0.01em]">Recently deleted</h2>
+          <p className="text-xs text-muted-foreground">
+            {entries.length ? `${plural(entries.length, "item")} · ${formatBytes(bytes)} · ` : ""}kept {KEEP_DAYS} days, then the daily cleanup removes them.
+          </p>
+        </div>
+        {entries.length > 0 && (
+          <Button size="sm" variant="outline" className="ml-auto" disabled={purge.isPending} onClick={() => setConfirm("empty")}>
+            <Trash /> Empty bin
+          </Button>
+        )}
+      </div>
+      <div className="min-h-0 flex-1 overflow-y-auto">
+        {bin.isLoading ? (
+          <div className="space-y-2 p-3">
+            <Skeleton className="h-11" />
+            <Skeleton className="h-11" />
+          </div>
+        ) : bin.isError ? (
+          <p className="p-4 text-sm text-destructive">{errorMessage(bin.error)}</p>
+        ) : !entries.length ? (
+          <div className="grid place-items-center px-6 py-16 text-center">
+            <div className="mb-3 grid size-11 place-items-center rounded-lg border bg-card shadow-card">
+              <Trash2 className="size-5 text-muted-foreground" />
+            </div>
+            <p className="text-sm font-medium">The bin is empty</p>
+            <p className="mt-1 max-w-xs text-xs text-muted-foreground">What you delete here waits {KEEP_DAYS} days, so you can put it back.</p>
+          </div>
+        ) : (
+          <ul className="divide-y">
+            {entries.map((e) => {
+              const left = Math.max(0, KEEP_DAYS - Math.floor((Date.now() - Date.parse(e.deletedAt)) / 86_400_000));
+              return (
+                <li key={e.id} className="flex items-center gap-3 px-4 py-2.5">
+                  {e.type === "dir" ? <Folder className="size-4 shrink-0 text-muted-foreground" /> : fileIcon(e.path)}
+                  <div className="min-w-0 flex-1">
+                    <p className="truncate font-mono text-xs" title={e.path}>
+                      {e.path}
+                    </p>
+                    <p className="text-[11px] text-muted-foreground">
+                      {formatBytes(e.bytes)}
+                      {e.type === "dir" && (e.files ? ` · ${plural(e.files, "file")}` : " · empty folder")} · deleted {formatDistanceToNowStrict(new Date(e.deletedAt), { addSuffix: true })} · {left ? `${left} days left` : "goes today"}
+                    </p>
+                  </div>
+                  <Button size="sm" variant="outline" disabled={frozen || restore.isPending} onClick={() => restore.mutate(e.id)}>
+                    {restore.isPending && restore.variables === e.id ? <Spinner /> : <RotateCcw />} Put back
+                  </Button>
+                  <Button size="icon-sm" variant="ghost" aria-label={`Delete ${nameOf(e.path)} for good`} onClick={() => setConfirm({ id: e.id, path: e.path })}>
+                    <Trash2 />
+                  </Button>
+                </li>
+              );
+            })}
+          </ul>
+        )}
+      </div>
+
+      <AlertDialog open={!!confirm} onOpenChange={(o) => !o && setConfirm(null)}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>{confirm === "empty" ? `Empty ${agent.name}'s bin?` : `Delete ${confirm ? nameOf(confirm.path) : ""} for good?`}</AlertDialogTitle>
+            <AlertDialogDescription>
+              {confirm === "empty" ? `${plural(entries.length, "item")} (${formatBytes(bytes)}) are removed for good.` : "It can't be put back afterwards."} Files the agent had committed stay in its version history.
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>Cancel</AlertDialogCancel>
+            <AlertDialogAction
+              variant="destructive"
+              onClick={() => {
+                if (confirm) purge.mutate(confirm === "empty" ? "empty" : { id: confirm.id });
+                setConfirm(null);
+              }}
+            >
+              Delete for good
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </div>
+  );
+}
diff --git a/apps/desktop/src/components/files/browse-pane.tsx b/apps/desktop/src/components/files/browse-pane.tsx
new file mode 100644
index 00000000..2e5ae4a8
--- /dev/null
+++ b/apps/desktop/src/components/files/browse-pane.tsx
@@ -0,0 +1,396 @@
+import { useEffect, useMemo, useState } from "react";
+import { keepPreviousData, useQuery } from "@tanstack/react-query";
+import { formatDistanceToNowStrict } from "date-fns";
+import { ArrowDownWideNarrow, ChevronRight, Copy, Folder, FolderInput, FolderOpen, FolderPlus, Lock, MoreHorizontal, PencilLine, Plus, Search, SquarePen, Trash2, X } from "lucide-react";
+import type { Agent, AgentFileEntry, AgentFileSize } from "@godmode/shared";
+import { formatBytes } from "@godmode/shared";
+import { api, errorMessage } from "@/lib/api";
+import { qk } from "@/lib/queryKeys";
+import { cn } from "@/lib/utils";
+import { Button } from "@/components/ui/button";
+import { Checkbox } from "@/components/ui/checkbox";
+import { Input } from "@/components/ui/input";
+import { Skeleton } from "@/components/ui/skeleton";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuLabel, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuTrigger } from "@/components/ui/dropdown-menu";
+import { fileIcon, nameOf, parentOf } from "./file-editor";
+import { placeable, plural, REVEAL_LABEL } from "./use-files";
+
+type Sort = "name" | "size" | "modified";
+
+const FIXED = new Set(["CLAUDE.md", "MEMORY.md", ".gitignore", "workspace", "memory", "workspace/tmp", "workspace/uploads", "conversations", "runs", "state"]);
+const ROOT_ORDER = ["workspace", "memory", "MEMORY.md", "CLAUDE.md"];
+
+/** Godmode's own files: they stay (the core refuses too; see agents/files.ts lockReason). */
+export function isLocked(path: string) {
+  return FIXED.has(path) || /^(conversations|runs|state)\//.test(path) || /^(memory|workspace|conversations|runs|state)\/\.gitkeep$/.test(path);
+}
+
+const FOLDER_NOTES: Record<string, string> = {
+  "workspace/tmp": "Scratch — goes by itself",
+  "workspace/uploads": "Your attachments",
+  conversations: "Chat transcripts",
+  runs: "Run logs",
+  state: "Settings snapshot",
+  memory: "Notes the agent reads",
+  workspace: "What the agent makes",
+};
+
+export interface BrowseActions {
+  onDelete: (paths: string[]) => void;
+  onMove: (paths: string[]) => void;
+  onRename: (path: string) => void;
+  onNew: (kind: "note" | "folder", dir: string) => void;
+  onReveal: (path: string) => void;
+}
+
+export function Breadcrumbs({ agent, dir, onDir }: { agent: Agent; dir: string; onDir: (dir: string) => void }) {
+  const parts = dir ? dir.split("/") : [];
+  return (
+    <nav aria-label="Folder" className="flex min-w-0 items-center gap-0.5 overflow-hidden text-[13px]">
+      <button type="button" onClick={() => onDir("")} className={cn("shrink-0 rounded px-1.5 py-0.5 hover:bg-accent", !parts.length && "font-medium")}>
+        {agent.name}
+      </button>
+      {parts.map((p, i) => {
+        const to = parts.slice(0, i + 1).join("/");
+        const last = i === parts.length - 1;
+        return (
+          <span key={to} className={cn("flex min-w-0 items-center gap-0.5", last ? "shrink" : "shrink-[2]")}>
+            <ChevronRight className="size-3.5 shrink-0 text-muted-foreground/60" />
+            <button type="button" onClick={() => onDir(to)} title={to} className={cn("truncate rounded px-1.5 py-0.5 hover:bg-accent", last && "font-medium")}>
+              {p}
+            </button>
+          </span>
+        );
+      })}
+    </nav>
+  );
+}
+
+function sortEntries(entries: AgentFileEntry[], sizes: Map<string, AgentFileSize>, sort: Sort, root: boolean) {
+  const bytes = (e: AgentFileEntry) => sizes.get(e.path)?.bytes ?? e.size;
+  const changed = (e: AgentFileEntry) => Date.parse(sizes.get(e.path)?.modifiedAt ?? e.modifiedAt) || 0;
+  return [...entries].sort((a, b) => {
+    if (root) {
+      const pa = ROOT_ORDER.indexOf(a.path);
+      const pb = ROOT_ORDER.indexOf(b.path);
+      if (pa !== -1 || pb !== -1) return (pa === -1 ? 99 : pa) - (pb === -1 ? 99 : pb);
+    }
+    if (sort === "size") return bytes(b) - bytes(a);
+    if (sort === "modified") return changed(b) - changed(a);
+    if (a.type !== b.type) return a.type === "dir" ? -1 : 1;
+    return nameOf(a.path).localeCompare(nameOf(b.path), undefined, { numeric: true, sensitivity: "base" });
+  });
+}
+
+export function BrowsePane({
+  agent,
+  dir,
+  onDir,
+  selected,
+  onSelect,
+  actions,
+  frozen,
+}: {
+  agent: Agent;
+  dir: string;
+  onDir: (dir: string) => void;
+  selected: string | null;
+  /** `dir`: the folder it lies in, when that isn't the one shown (a search hit). */
+  onSelect: (entry: { path: string; size: number }, dir?: string) => void;
+  actions: BrowseActions;
+  /** Moves and deletes wait (the agent dreams). */
+  frozen: boolean;
+}) {
+  const [sort, setSort] = useState<Sort>("name");
+  const [filter, setFilter] = useState("");
+  const [checked, setChecked] = useState<Set<string>>(() => new Set());
+  const listing = useQuery({ queryKey: qk.agentFiles(agent.id, dir), queryFn: () => api.agents.files(agent.id, dir), placeholderData: keepPreviousData });
+  const sizesQ = useQuery({ queryKey: qk.agentFileSizes(agent.id, dir), queryFn: () => api.agents.fileSizes(agent.id, dir), staleTime: 30_000 });
+  const sizes = useMemo(() => new Map((sizesQ.data ?? []).map((s) => [s.path, s])), [sizesQ.data]);
+  const needle = filter.trim().toLowerCase();
+  const search = useDebounced(needle, 250);
+  const found = useQuery({
+    queryKey: qk.agentFileSearch(agent.id, search),
+    queryFn: () => api.agents.searchFiles(agent.id, search),
+    enabled: search.length >= 2,
+    staleTime: 15_000,
+  });
+
+  useEffect(() => {
+    setChecked(new Set());
+    setFilter("");
+  }, [dir, agent.id]);
+
+  const entries = useMemo(() => {
+    const visible = (listing.data ?? []).filter((e) => nameOf(e.path) !== ".gitkeep" && parentOf(e.path) === dir);
+    const shown = needle ? visible.filter((e) => nameOf(e.path).toLowerCase().includes(needle)) : visible;
+    return sortEntries(shown, sizes, sort, !dir);
+  }, [listing.data, dir, needle, sizes, sort]);
+  const largest = Math.max(1, ...entries.map((e) => sizes.get(e.path)?.bytes ?? e.size));
+  const total = (sizesQ.data ?? []).reduce((n, s) => n + s.bytes, 0);
+  const pickable = entries.filter((e) => !isLocked(e.path));
+  const checkedList = [...checked].filter((p) => entries.some((e) => e.path === p));
+  const checkedBytes = checkedList.reduce((n, p) => n + (sizes.get(p)?.bytes ?? 0), 0);
+  const canCreate = placeable(dir);
+  const otherHits = (found.data ?? []).filter((h) => parentOf(h.path) !== dir || h.line !== null);
+
+  const toggle = (path: string, on: boolean) =>
+    setChecked((s) => {
+      const next = new Set(s);
+      if (on) next.add(path);
+      else next.delete(path);
+      return next;
+    });
+
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      const target = e.target as HTMLElement;
+      if (target.closest("input, textarea, [contenteditable], [role=dialog]")) return;
+      if ((e.key === "Delete" || e.key === "Backspace") && checkedList.length && !frozen) {
+        e.preventDefault();
+        actions.onDelete(checkedList);
+      }
+      if (e.key === "Escape" && checkedList.length) setChecked(new Set());
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [checkedList, actions, frozen]);
+
+  return (
+    <div className="flex h-full min-h-0 flex-col">
+      <div className="flex items-center gap-2 border-b px-3 py-2">
+        <Breadcrumbs agent={agent} dir={dir} onDir={onDir} />
+        <div className="ml-auto flex shrink-0 items-center gap-1">
+          <DropdownMenu>
+            <DropdownMenuTrigger asChild>
+              <Button variant="ghost" size="icon-sm" aria-label="Sort">
+                <ArrowDownWideNarrow />
+              </Button>
+            </DropdownMenuTrigger>
+            <DropdownMenuContent align="end">
+              <DropdownMenuLabel>Sort by</DropdownMenuLabel>
+              <DropdownMenuRadioGroup value={sort} onValueChange={(v) => setSort(v as Sort)}>
+                <DropdownMenuRadioItem value="name">Name</DropdownMenuRadioItem>
+                <DropdownMenuRadioItem value="size">Size</DropdownMenuRadioItem>
+                <DropdownMenuRadioItem value="modified">Last changed</DropdownMenuRadioItem>
+              </DropdownMenuRadioGroup>
+            </DropdownMenuContent>
+          </DropdownMenu>
+          {canCreate && (
+            <DropdownMenu>
+              <DropdownMenuTrigger asChild>
+                <Button variant="outline" size="sm" className="h-8">
+                  <Plus /> New
+                </Button>
+              </DropdownMenuTrigger>
+              <DropdownMenuContent align="end">
+                <DropdownMenuItem onSelect={() => actions.onNew("note", dir)}>
+                  <SquarePen /> Note
+                </DropdownMenuItem>
+                <DropdownMenuItem onSelect={() => actions.onNew("folder", dir)}>
+                  <FolderPlus /> Folder
+                </DropdownMenuItem>
+              </DropdownMenuContent>
+            </DropdownMenu>
+          )}
+        </div>
+      </div>
+
+      <div className="border-b px-3 py-2">
+        <div className="relative">
+          <Search className="pointer-events-none absolute top-1/2 left-2.5 size-3.5 -translate-y-1/2 text-muted-foreground" />
+          <Input value={filter} onChange={(e) => setFilter(e.target.value)} placeholder="Filter, or search every file and note" className="h-8 pl-8 text-[13px]" aria-label="Filter and search" />
+          {filter && (
+            <button type="button" aria-label="Clear" onClick={() => setFilter("")} className="absolute top-1/2 right-2 -translate-y-1/2 rounded p-0.5 text-muted-foreground hover:bg-accent">
+              <X className="size-3.5" />
+            </button>
+          )}
+        </div>
+      </div>
+
+      {checkedList.length > 0 && (
+        <div className="flex items-center gap-2 border-b bg-secondary/60 px-3 py-1.5 text-xs">
+          <span className="font-medium">{plural(checkedList.length, "item")} selected</span>
+          {checkedBytes > 0 && <span className="text-muted-foreground tabular-nums">{formatBytes(checkedBytes)}</span>}
+          <span className="ml-auto flex gap-1">
+            <Button size="xs" variant="ghost" disabled={frozen} onClick={() => actions.onMove(checkedList)}>
+              <FolderInput /> Move
+            </Button>
+            <Button size="xs" variant="ghost" className="text-destructive hover:text-destructive" disabled={frozen} onClick={() => actions.onDelete(checkedList)}>
+              <Trash2 /> Delete
+            </Button>
+            <Button size="icon-xs" variant="ghost" aria-label="Clear selection" onClick={() => setChecked(new Set())}>
+              <X />
+            </Button>
+          </span>
+        </div>
+      )}
+
+      <div className="min-h-0 flex-1 overflow-y-auto">
+        {pickable.length > 1 && (
+          <div className="flex items-center gap-2.5 px-3 pt-2 pb-1 text-[11px] font-medium tracking-wide text-muted-foreground uppercase">
+            <Checkbox
+              aria-label="Select all"
+              checked={checkedList.length === pickable.length ? true : checkedList.length ? "indeterminate" : false}
+              onCheckedChange={(v) => setChecked(v === true ? new Set(pickable.map((e) => e.path)) : new Set())}
+            />
+            <span className="flex-1">Name</span>
+            <span className="w-20 text-right">Size</span>
+            <span className="hidden w-20 text-right @5xl:block">Changed</span>
+            <span className="w-6" />
+          </div>
+        )}
+        {listing.isLoading ? (
+          <div className="space-y-1.5 p-3">
+            {Array.from({ length: 7 }, (_, i) => (
+              <Skeleton key={i} className="h-8" />
+            ))}
+          </div>
+        ) : listing.isError ? (
+          <p className="p-4 text-sm text-destructive">{errorMessage(listing.error)}</p>
+        ) : !entries.length ? (
+          <p className="px-4 py-8 text-center text-sm text-muted-foreground">{needle ? "Nothing here matches." : "This folder is empty."}</p>
+        ) : (
+          <ul className="px-1.5 pb-2" role="list">
+            {entries.map((e) => {
+              const isDir = e.type === "dir";
+              const size = sizes.get(e.path);
+              const bytes = size?.bytes ?? (isDir ? null : e.size);
+              const locked = isLocked(e.path);
+              const active = selected === e.path;
+              const on = checked.has(e.path);
+              const modified = size?.modifiedAt ?? e.modifiedAt;
+              return (
+                <li
+                  key={e.path}
+                  className={cn(
+                    "group/row relative flex items-center gap-2.5 rounded-md px-1.5 py-1.5 text-[13px] transition-colors hover:bg-accent/50",
+                    active && "bg-secondary",
+                    on && "bg-primary/[0.05]",
+                  )}
+                >
+                  <span className="grid w-4 place-items-center">
+                    {locked ? (
+                      <Lock className="size-3 text-muted-foreground/50" aria-label="Kept by Godmode" />
+                    ) : (
+                      <Checkbox aria-label={`Select ${nameOf(e.path)}`} checked={on} onCheckedChange={(v) => toggle(e.path, v === true)} className={cn(!on && !checkedList.length && "opacity-0 group-hover/row:opacity-100 focus-visible:opacity-100 pointer-coarse:opacity-100")} />
+                    )}
+                  </span>
+                  <button
+                    type="button"
+                    onClick={() => (isDir ? onDir(e.path) : onSelect({ path: e.path, size: e.size }))}
+                    className="flex min-w-0 flex-1 items-center gap-2 text-left outline-none focus-visible:underline"
+                  >
+                    {isDir ? <Folder className="size-4 shrink-0 text-muted-foreground" /> : <span className="shrink-0">{fileIcon(e.path)}</span>}
+                    <span className={cn("truncate", active && "font-medium")}>{nameOf(e.path)}</span>
+                    {FOLDER_NOTES[e.path] && <span className="hidden shrink-0 truncate text-xs text-muted-foreground @4xl:inline">· {FOLDER_NOTES[e.path]}</span>}
+                  </button>
+                  <span className="w-20 shrink-0 text-right">
+                    {bytes === null ? (
+                      <Skeleton className="ml-auto h-3 w-12" />
+                    ) : (
+                      <span className="block">
+                        <span className="text-xs text-muted-foreground tabular-nums" title={size?.files ? plural(size.files, "file") : undefined}>
+                          {size?.partial ? "≥ " : ""}
+                          {formatBytes(bytes)}
+                        </span>
+                        <span className="mt-1 ml-auto block h-[3px] w-14 overflow-hidden rounded-full bg-foreground/[0.06]">
+                          <span className="block h-full rounded-full bg-foreground/30" style={{ width: `${Math.max(2, (bytes / largest) * 100)}%` }} />
+                        </span>
+                      </span>
+                    )}
+                  </span>
+                  <span className="hidden w-20 shrink-0 text-right text-xs text-muted-foreground tabular-nums @5xl:block" title={modified ? new Date(modified).toLocaleString() : undefined}>
+                    {modified ? formatDistanceToNowStrict(new Date(modified)) : ""}
+                  </span>
+                  <RowMenu path={e.path} isDir={isDir} locked={locked} frozen={frozen} actions={actions} onOpen={() => (isDir ? onDir(e.path) : onSelect({ path: e.path, size: e.size }))} />
+                </li>
+              );
+            })}
+          </ul>
+        )}
+
+        {search.length >= 2 && (
+          <section className="border-t px-1.5 pt-2 pb-3" aria-label="Search results">
+            <p className="px-2 pb-1 text-[11px] font-medium tracking-wide text-muted-foreground uppercase">In all files</p>
+            {found.isLoading ? (
+              <Skeleton className="mx-2 h-8" />
+            ) : !otherHits.length ? (
+              <p className="px-2 py-2 text-xs text-muted-foreground">No other file or note mentions “{search}”.</p>
+            ) : (
+              <ul>
+                {otherHits.map((h) => (
+                  <li key={`${h.path}:${h.line}`}>
+                    <button
+                      type="button"
+                      onClick={() => {
+                        if (h.type === "dir") return onDir(h.path);
+                        onSelect({ path: h.path, size: 0 }, parentOf(h.path));
+                      }}
+                      className="w-full rounded-md px-2 py-1.5 text-left transition hover:bg-accent/50"
+                    >
+                      <span className="flex items-center gap-2 text-[13px]">
+                        {h.type === "dir" ? <FolderOpen className="size-4 shrink-0 text-muted-foreground" /> : fileIcon(h.path)}
+                        <span className="truncate font-mono text-xs">{h.path}</span>
+                        {h.line !== null && <span className="shrink-0 text-[11px] text-muted-foreground">line {h.line}</span>}
+                      </span>
+                      {h.snippet && <span className="mt-0.5 line-clamp-2 block pl-6 text-xs text-muted-foreground">{h.snippet}</span>}
+                    </button>
+                  </li>
+                ))}
+              </ul>
+            )}
+          </section>
+        )}
+      </div>
+
+      <div className="flex items-center gap-2 border-t px-3 py-1.5 text-[11px] text-muted-foreground">
+        <span>{needle ? `${entries.length} of ${plural(listing.data?.length ?? 0, "item")}` : plural(entries.length, "item")}</span>
+        {total > 0 && !needle && <span className="tabular-nums">· {formatBytes(total)}</span>}
+        {sizesQ.isFetching && <span className="ml-auto">counting…</span>}
+      </div>
+    </div>
+  );
+}
+
+function RowMenu({ path, isDir, locked, frozen, actions, onOpen }: { path: string; isDir: boolean; locked: boolean; frozen: boolean; actions: BrowseActions; onOpen: () => void }) {
+  return (
+    <DropdownMenu>
+      <DropdownMenuTrigger asChild>
+        <Button variant="ghost" size="icon-xs" aria-label={`Actions for ${nameOf(path)}`} className="opacity-0 group-hover/row:opacity-100 focus-visible:opacity-100 data-[state=open]:opacity-100 pointer-coarse:opacity-100">
+          <MoreHorizontal />
+        </Button>
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align="end" className="w-44">
+        <DropdownMenuItem onSelect={onOpen}>{isDir ? <FolderOpen /> : <SquarePen />} Open</DropdownMenuItem>
+        <DropdownMenuItem onSelect={() => actions.onReveal(path)}>
+          <Copy /> {REVEAL_LABEL}
+        </DropdownMenuItem>
+        {!locked && (
+          <>
+            <DropdownMenuSeparator />
+            <DropdownMenuItem disabled={frozen} onSelect={() => actions.onRename(path)}>
+              <PencilLine /> Rename
+            </DropdownMenuItem>
+            <DropdownMenuItem disabled={frozen} onSelect={() => actions.onMove([path])}>
+              <FolderInput /> Move to…
+            </DropdownMenuItem>
+            <DropdownMenuSeparator />
+            <DropdownMenuItem variant="destructive" disabled={frozen} onSelect={() => actions.onDelete([path])}>
+              <Trash2 /> Delete
+            </DropdownMenuItem>
+          </>
+        )}
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}
+
+function useDebounced<T>(value: T, ms: number): T {
+  const [v, setV] = useState(value);
+  useEffect(() => {
+    const t = setTimeout(() => setV(value), ms);
+    return () => clearTimeout(t);
+  }, [value, ms]);
+  return v;
+}
diff --git a/apps/desktop/src/components/files/detail-pane.tsx b/apps/desktop/src/components/files/detail-pane.tsx
new file mode 100644
index 00000000..354f0ccd
--- /dev/null
+++ b/apps/desktop/src/components/files/detail-pane.tsx
@@ -0,0 +1,130 @@
+import { useQuery } from "@tanstack/react-query";
+import { Copy, FileSearch, FolderInput, MoreHorizontal, PencilLine, Trash2 } from "lucide-react";
+import { chatImageUrl, formatBytes } from "@godmode/shared";
+import type { Agent } from "@godmode/shared";
+import { api } from "@/lib/api";
+import { Button } from "@/components/ui/button";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuTrigger } from "@/components/ui/dropdown-menu";
+import { useCoreFileUrl } from "@/components/chat/core-file";
+import { FileEditor, IMAGE_FILE, nameOf } from "./file-editor";
+import { isLocked } from "./browse-pane";
+import { REVEAL_LABEL } from "./use-files";
+
+export interface DetailActions {
+  onRename: (path: string) => void;
+  onMove: (paths: string[]) => void;
+  onDelete: (paths: string[]) => void;
+  onReveal: (path: string) => void;
+  onOpenFile: (path: string) => void;
+  onSaved: (path: string) => void;
+}
+
+function FileMenu({ path, frozen, actions }: { path: string; frozen: boolean; actions: DetailActions }) {
+  const locked = isLocked(path);
+  return (
+    <DropdownMenu>
+      <DropdownMenuTrigger asChild>
+        <Button variant="ghost" size="icon-sm" aria-label={`More for ${nameOf(path)}`}>
+          <MoreHorizontal />
+        </Button>
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align="end" className="w-44">
+        <DropdownMenuItem onSelect={() => actions.onReveal(path)}>
+          <Copy /> {REVEAL_LABEL}
+        </DropdownMenuItem>
+        {!locked && (
+          <>
+            <DropdownMenuSeparator />
+            <DropdownMenuItem disabled={frozen} onSelect={() => actions.onRename(path)}>
+              <PencilLine /> Rename
+            </DropdownMenuItem>
+            <DropdownMenuItem disabled={frozen} onSelect={() => actions.onMove([path])}>
+              <FolderInput /> Move to…
+            </DropdownMenuItem>
+            <DropdownMenuSeparator />
+            <DropdownMenuItem variant="destructive" disabled={frozen} onSelect={() => actions.onDelete([path])}>
+              <Trash2 /> Delete
+            </DropdownMenuItem>
+          </>
+        )}
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}
+
+function ImageView({ agent, path, frozen, actions }: { agent: Agent; path: string; frozen: boolean; actions: DetailActions }) {
+  const info = useQuery({ queryKey: ["files", agent.id, "inspect", [path]], queryFn: () => api.agents.inspectFiles(agent.id, [path]), staleTime: 30_000 });
+  const entry = info.data?.[0];
+  const version = entry?.modifiedAt ? Date.parse(entry.modifiedAt) : 0;
+  const image = useCoreFileUrl(entry ? chatImageUrl(`${agent.repoPath}/${path}`, version) : undefined, true);
+  return (
+    <div className="flex h-full min-h-0 flex-col">
+      <div className="flex items-center gap-2 border-b px-4 py-2.5">
+        <span className="min-w-0 truncate font-mono text-[13px]">{path}</span>
+        {entry && <span className="shrink-0 text-xs text-muted-foreground tabular-nums">{formatBytes(entry.bytes)}</span>}
+        <div className="ml-auto">
+          <FileMenu path={path} frozen={frozen} actions={actions} />
+        </div>
+      </div>
+      <div className="grid min-h-0 flex-1 place-items-center overflow-auto bg-[repeating-conic-gradient(var(--color-muted)_0%_25%,transparent_0%_50%)] bg-[length:16px_16px] p-6">
+        {image.src ? (
+          <img src={image.src} alt={nameOf(path)} className="max-h-full max-w-full rounded-md object-contain shadow-card" />
+        ) : image.failed ? (
+          <p className="text-sm text-muted-foreground">This picture can't be shown here (too large or not readable).</p>
+        ) : (
+          <div className="h-48 w-72 animate-pulse rounded-lg bg-muted" />
+        )}
+      </div>
+      {entry && entry.namedBy.length > 0 && <p className="border-t px-4 py-2 text-xs text-muted-foreground">Named in {entry.namedBy.join(", ")}</p>}
+    </div>
+  );
+}
+
+export function DetailPane({
+  agent,
+  file,
+  dreaming,
+  frozen,
+  defaultView,
+  onDirtyChange,
+  actions,
+}: {
+  agent: Agent;
+  file: { path: string; size: number } | null;
+  dreaming: boolean;
+  frozen: boolean;
+  defaultView?: "edit" | "split" | "preview";
+  onDirtyChange: (dirty: boolean) => void;
+  actions: DetailActions;
+}) {
+  if (!file) {
+    return (
+      <div className="grid h-full place-items-center p-10 text-center">
+        <div>
+          <div className="mx-auto mb-3 grid size-11 place-items-center rounded-lg border bg-card shadow-card">
+            <FileSearch className="size-5 text-muted-foreground" />
+          </div>
+          <p className="text-sm font-medium">Pick a file to read or edit it</p>
+          <p className="mx-auto mt-1 max-w-xs text-xs text-muted-foreground">Notes open with a preview; changes are saved into {agent.name}'s history, so they can be undone.</p>
+        </div>
+      </div>
+    );
+  }
+  if (IMAGE_FILE.test(file.path)) return <ImageView key={file.path} agent={agent} path={file.path} frozen={frozen} actions={actions} />;
+  return (
+    <FileEditor
+      key={file.path}
+      agentId={agent.id}
+      agentName={agent.name}
+      path={file.path}
+      size={file.size}
+      dreaming={dreaming}
+      onDirtyChange={onDirtyChange}
+      onOpenFile={actions.onOpenFile}
+      onSaved={actions.onSaved}
+      fill
+      defaultView={defaultView}
+      actions={<FileMenu path={file.path} frozen={frozen} actions={actions} />}
+    />
+  );
+}
diff --git a/apps/desktop/src/components/files/dialogs.tsx b/apps/desktop/src/components/files/dialogs.tsx
new file mode 100644
index 00000000..479c918d
--- /dev/null
+++ b/apps/desktop/src/components/files/dialogs.tsx
@@ -0,0 +1,436 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { AlertTriangle, ChevronRight, Folder, FolderOpen, Lock, Trash2 } from "lucide-react";
+import type { AgentFileEntry } from "@godmode/shared";
+import { formatBytes } from "@godmode/shared";
+import { api, errorMessage } from "@/lib/api";
+import { qk } from "@/lib/queryKeys";
+import { cn } from "@/lib/utils";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Skeleton } from "@/components/ui/skeleton";
+import { Spinner } from "@/components/ui/spinner";
+import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { fileIcon, nameOf, parentOf } from "./file-editor";
+import { joinPath, pinsAmong, plural, reservedPlace, useDeleteFiles, useMoveFiles } from "./use-files";
+
+/* ------------------------------------------------------------------ */
+/* Delete                                                               */
+/* ------------------------------------------------------------------ */
+
+/** Looks at what is about to go first: its size, whether the agent still names it, and what has to stay. */
+export function DeleteDialog({
+  agentId,
+  agentName,
+  paths,
+  onClose,
+  onDeleted,
+}: {
+  agentId: string;
+  agentName: string;
+  paths: string[] | null;
+  onClose: () => void;
+  onDeleted?: (paths: string[]) => void;
+}) {
+  const open = !!paths?.length;
+  const info = useQuery({
+    queryKey: ["files", agentId, "inspect", paths],
+    queryFn: () => api.agents.inspectFiles(agentId, paths!),
+    enabled: open,
+    staleTime: 0,
+    gcTime: 0,
+  });
+  const remove = useDeleteFiles(agentId, (r) => onDeleted?.(r.deleted.map((d) => d.path)));
+  const entries = info.data ?? [];
+  const going = entries.filter((e) => !e.locked);
+  const staying = entries.filter((e) => e.locked);
+  const named = going.filter((e) => e.namedBy.length);
+  const bytes = going.reduce((n, e) => n + e.bytes, 0);
+  const files = going.reduce((n, e) => n + e.files, 0);
+
+  return (
+    <Dialog open={open} onOpenChange={(o) => !o && onClose()}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle>{paths?.length === 1 ? `Delete ${nameOf(paths[0]!)}?` : `Delete ${plural(paths?.length ?? 0, "item")}?`}</DialogTitle>
+          <DialogDescription>It goes to {agentName}'s bin: you can put it back there for 30 days.</DialogDescription>
+        </DialogHeader>
+        {info.isLoading ? (
+          <div className="space-y-2">
+            <Skeleton className="h-9" />
+            <Skeleton className="h-9 w-4/5" />
+          </div>
+        ) : info.isError ? (
+          <p className="text-sm text-destructive">{errorMessage(info.error)}</p>
+        ) : (
+          <div className="space-y-3">
+            {going.length > 0 && (
+              <div className="rounded-lg border bg-paper-2/60">
+                <ul className="max-h-48 divide-y overflow-y-auto">
+                  {going.slice(0, 50).map((e) => (
+                    <li key={e.path} className="flex items-center gap-2.5 px-3 py-2 text-[13px]">
+                      {e.type === "dir" ? <Folder className="size-4 shrink-0 text-muted-foreground" /> : fileIcon(e.path)}
+                      <span className="min-w-0 flex-1 truncate font-mono text-xs" title={e.path}>
+                        {e.path}
+                      </span>
+                      <span className="shrink-0 text-xs text-muted-foreground tabular-nums">{formatBytes(e.bytes)}</span>
+                    </li>
+                  ))}
+                </ul>
+                <div className="border-t px-3 py-1.5 text-xs text-muted-foreground">
+                  {formatBytes(bytes)}
+                  {files > going.length && ` · ${plural(files, "file")}`}
+                </div>
+              </div>
+            )}
+            {named.length > 0 && (
+              <div className="flex gap-2.5 rounded-lg border border-warning/25 bg-warning/[0.07] px-3 py-2.5 text-xs">
+                <AlertTriangle className="mt-px size-3.5 shrink-0 text-warning" />
+                <div className="space-y-1">
+                  <p className="font-medium text-foreground">{agentName} still names {named.length === 1 ? "it" : `${named.length} of these`}</p>
+                  {named.slice(0, 4).map((e) => (
+                    <p key={e.path} className="text-muted-foreground">
+                      <span className="font-mono">{nameOf(e.path)}</span> — in {e.namedBy.slice(0, 2).join(", ")}
+                    </p>
+                  ))}
+                  <p className="text-muted-foreground">It may still need {named.length === 1 ? "it" : "them"}. Remove the mention too, or keep the file.</p>
+                </div>
+              </div>
+            )}
+            {staying.length > 0 && (
+              <div className="space-y-1 text-xs text-muted-foreground">
+                {staying.map((e) => (
+                  <p key={e.path} className="flex items-start gap-1.5">
+                    <Lock className="mt-px size-3.5 shrink-0" />
+                    <span>
+                      <span className="font-mono text-foreground">{nameOf(e.path) || e.path}</span> stays: {e.locked}
+                    </span>
+                  </p>
+                ))}
+              </div>
+            )}
+          </div>
+        )}
+        <DialogFooter>
+          <Button variant="ghost" onClick={onClose}>
+            Cancel
+          </Button>
+          <Button
+            variant="destructive"
+            disabled={!going.length || remove.isPending}
+            onClick={() =>
+              remove.mutate(
+                going.map((e) => e.path),
+                { onSuccess: onClose },
+              )
+            }
+          >
+            {remove.isPending ? <Spinner /> : <Trash2 />} Move to bin
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+/* ------------------------------------------------------------------ */
+/* Name: rename, new note, new folder                                   */
+/* ------------------------------------------------------------------ */
+
+export type NameDialogMode = { kind: "rename"; path: string } | { kind: "note"; dir: string } | { kind: "folder"; dir: string };
+
+/** The file a new note becomes: "plan" is plan.md. */
+function noteFile(name: string) {
+  const n = name.trim();
+  return /\.(md|markdown|txt)$/i.test(n) ? n : `${n}.md`;
+}
+
+function nameProblem(name: string, taken: Set<string>, kind: NameDialogMode["kind"], current?: string): string | null {
+  const n = name.trim();
+  if (!n) return "Give it a name.";
+  if (n.includes("/") || n.includes("\\")) return "A name can't contain a slash — use Move to put it elsewhere.";
+  if (n === "." || n === ".." || n.startsWith(".")) return "Names can't start with a dot here.";
+  if (n.length > 200) return "That name is too long.";
+  const final = kind === "note" ? noteFile(n) : n;
+  // A new spelling of its own name (Notes.md → notes.md) is fine.
+  if (current && final.toLowerCase() === current.toLowerCase()) return null;
+  if (taken.has(final.toLowerCase())) return `${final} is already there.`;
+  return null;
+}
+
+export function NameDialog({
+  agentId,
+  mode,
+  siblings,
+  onClose,
+  onCreated,
+  onRenamed,
+}: {
+  agentId: string;
+  mode: NameDialogMode | null;
+  /** Names already in the folder, so nothing is overwritten; null while they load. */
+  siblings: string[] | null;
+  onClose: () => void;
+  onCreated?: (path: string, kind: "note" | "folder") => void;
+  onRenamed?: (from: string, to: string) => void;
+}) {
+  const [name, setName] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const inputRef = useRef<HTMLInputElement>(null);
+  const move = useMoveFiles(agentId, (moves) => moves[0] && onRenamed?.(moves[0].from, moves[0].to));
+  const renaming = mode?.kind === "rename" ? mode.path : null;
+  const info = useQuery({
+    queryKey: ["files", agentId, "inspect", [renaming]],
+    queryFn: () => api.agents.inspectFiles(agentId, [renaming!]),
+    enabled: !!renaming,
+    staleTime: 0,
+    gcTime: 0,
+  });
+  const pins = pinsAmong(info.data?.[0]?.namedBy ?? []);
+  const current = mode?.kind === "rename" ? nameOf(mode.path) : undefined;
+  const taken = useMemo(() => new Set((siblings ?? []).map((s) => s.toLowerCase())), [siblings]);
+
+  useEffect(() => {
+    if (!mode) return;
+    setError(null);
+    setBusy(false);
+    setName(mode.kind === "rename" ? nameOf(mode.path) : mode.kind === "note" ? "untitled.md" : "new folder");
+    requestAnimationFrame(() => {
+      const el = inputRef.current;
+      if (!el) return;
+      el.focus();
+      const dot = el.value.lastIndexOf(".");
+      el.setSelectionRange(0, mode.kind !== "folder" && dot > 0 ? dot : el.value.length);
+    });
+  }, [mode]);
+
+  const problem = mode ? nameProblem(name, taken, mode.kind, current) : null;
+  const loading = siblings === null;
+  const dir = mode ? (mode.kind === "rename" ? parentOf(mode.path) : mode.dir) : "";
+
+  const submit = async () => {
+    if (!mode || problem || busy || loading) return;
+    const n = name.trim();
+    if (mode.kind === "rename") {
+      if (n === current) return onClose();
+      move.mutate([{ from: mode.path, to: joinPath(dir, n) }], { onSuccess: onClose });
+      return;
+    }
+    setBusy(true);
+    try {
+      if (mode.kind === "folder") {
+        const r = await api.agents.createFolder(agentId, joinPath(dir, n));
+        onCreated?.(r.path, "folder");
+      } else {
+        const file = noteFile(n);
+        const path = joinPath(dir, file);
+        const title = file.replace(/\.(md|markdown|txt)$/i, "").replace(/[-_]+/g, " ");
+        // Create-only: if something took the name meanwhile, the server says so instead of overwriting it.
+        await api.agents.writeFile(agentId, path, /\.txt$/i.test(file) ? "" : `# ${title.charAt(0).toUpperCase()}${title.slice(1)}\n\n`, true);
+        onCreated?.(path, "note");
+      }
+      onClose();
+    } catch (err) {
+      setError(errorMessage(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const title = mode?.kind === "rename" ? `Rename ${current}` : mode?.kind === "note" ? "New note" : "New folder";
+  return (
+    <Dialog open={!!mode} onOpenChange={(o) => !o && onClose()}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle>{title}</DialogTitle>
+          <DialogDescription>
+            In <span className="font-mono text-foreground">{dir || "the repository"}/</span>
+            {mode?.kind === "rename" && " — where the agent's memory names it, the new name is written in too."}
+          </DialogDescription>
+        </DialogHeader>
+        <form
+          onSubmit={(e) => {
+            e.preventDefault();
+            void submit();
+          }}
+          className="space-y-2"
+        >
+          <Input ref={inputRef} value={name} onChange={(e) => setName(e.target.value)} aria-label="Name" aria-invalid={!!problem && name !== current} className="font-mono text-[13px]" />
+          {(error || (problem && name)) && <p className="text-xs text-destructive">{error ?? problem}</p>}
+          {pins.length > 0 && (
+            <p className="flex items-start gap-1.5 text-xs text-muted-foreground">
+              <AlertTriangle className="mt-px size-3.5 shrink-0 text-warning" />
+              <span>
+                Named in {pins.slice(0, 2).join(", ")} — change the name there too, or the agent looks for the old one.
+              </span>
+            </p>
+          )}
+        </form>
+        <DialogFooter>
+          <Button variant="ghost" onClick={onClose}>
+            Cancel
+          </Button>
+          <Button disabled={!!problem || busy || loading || move.isPending} onClick={() => void submit()}>
+            {(busy || move.isPending) && <Spinner />}
+            {mode?.kind === "rename" ? "Rename" : "Create"}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+/* ------------------------------------------------------------------ */
+/* Move                                                                 */
+/* ------------------------------------------------------------------ */
+
+function FolderTree({
+  agentId,
+  dir,
+  depth,
+  picked,
+  onPick,
+  blocked,
+}: {
+  agentId: string;
+  dir: string;
+  depth: number;
+  picked: string;
+  onPick: (dir: string) => void;
+  /** Folders being moved: nothing goes into them. */
+  blocked: Set<string>;
+}) {
+  const [open, setOpen] = useState<Set<string>>(() => new Set());
+  const q = useQuery({ queryKey: qk.agentFiles(agentId, dir), queryFn: () => api.agents.files(agentId, dir) });
+  const dirs = (q.data ?? []).filter((e: AgentFileEntry) => e.type === "dir" && !nameOf(e.path).startsWith("."));
+  if (q.isLoading) return <Skeleton className="my-1 h-6 w-3/5" style={{ marginLeft: depth * 14 + 8 }} />;
+  if (!dirs.length) return null;
+  return (
+    <ul className="space-y-px">
+      {dirs.map((e) => {
+        const isOpen = open.has(e.path);
+        const disabled = reservedPlace(e.path) || [...blocked].some((b) => e.path === b || e.path.startsWith(`${b}/`));
+        return (
+          <li key={e.path}>
+            <div className="flex items-center" style={{ paddingLeft: depth * 14 }}>
+              <button
+                type="button"
+                aria-label={isOpen ? "Fold" : "Unfold"}
+                onClick={() =>
+                  setOpen((s) => {
+                    const next = new Set(s);
+                    if (next.has(e.path)) next.delete(e.path);
+                    else next.add(e.path);
+                    return next;
+                  })
+                }
+                className="grid size-6 shrink-0 place-items-center rounded text-muted-foreground hover:bg-accent"
+              >
+                <ChevronRight className={cn("size-3.5 transition-transform", isOpen && "rotate-90")} />
+              </button>
+              <button
+                type="button"
+                disabled={disabled}
+                onClick={() => onPick(e.path)}
+                className={cn(
+                  "flex min-w-0 flex-1 items-center gap-1.5 rounded-md px-1.5 py-1 text-left text-[13px] transition hover:bg-accent/60 disabled:opacity-40",
+                  picked === e.path && "bg-secondary font-medium",
+                )}
+              >
+                {isOpen ? <FolderOpen className="size-4 shrink-0 text-muted-foreground" /> : <Folder className="size-4 shrink-0 text-muted-foreground" />}
+                <span className="truncate">{nameOf(e.path)}</span>
+              </button>
+            </div>
+            {isOpen && <FolderTree agentId={agentId} dir={e.path} depth={depth + 1} picked={picked} onPick={onPick} blocked={blocked} />}
+          </li>
+        );
+      })}
+    </ul>
+  );
+}
+
+export function MoveDialog({
+  agentId,
+  paths,
+  onClose,
+  onMoved,
+}: {
+  agentId: string;
+  paths: string[] | null;
+  onClose: () => void;
+  onMoved?: (moves: { from: string; to: string }[]) => void;
+}) {
+  const [picked, setPicked] = useState("workspace");
+  const move = useMoveFiles(agentId, onMoved);
+  const info = useQuery({
+    queryKey: ["files", agentId, "inspect", paths],
+    queryFn: () => api.agents.inspectFiles(agentId, paths!),
+    enabled: !!paths?.length,
+    staleTime: 0,
+    gcTime: 0,
+  });
+  const pinned = (info.data ?? []).map((e) => ({ path: e.path, pins: pinsAmong(e.namedBy) })).filter((e) => e.pins.length);
+  useEffect(() => {
+    if (paths?.length) setPicked(parentOf(paths[0]!).startsWith("memory") ? "memory" : "workspace");
+  }, [paths]);
+  const blocked = useMemo(() => new Set(paths ?? []), [paths]);
+  const already = !!paths?.length && paths.every((p) => parentOf(p) === picked);
+  const roots = ["workspace", "memory"];
+
+  return (
+    <Dialog open={!!paths?.length} onOpenChange={(o) => !o && onClose()}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle>{paths?.length === 1 ? `Move ${nameOf(paths[0]!)}` : `Move ${plural(paths?.length ?? 0, "item")}`}</DialogTitle>
+          <DialogDescription>Pick a folder. Where the agent's memory names a moved file, the new place is written in.</DialogDescription>
+        </DialogHeader>
+        <div className="max-h-72 overflow-y-auto rounded-lg border p-1.5">
+          {roots.map((root) => (
+            <div key={root}>
+              <button
+                type="button"
+                onClick={() => setPicked(root)}
+                className={cn("flex w-full items-center gap-1.5 rounded-md px-2 py-1 text-left text-[13px] font-medium transition hover:bg-accent/60", picked === root && "bg-secondary")}
+              >
+                <FolderOpen className="size-4 text-muted-foreground" /> {root}/
+              </button>
+              <FolderTree agentId={agentId} dir={root} depth={1} picked={picked} onPick={setPicked} blocked={blocked} />
+            </div>
+          ))}
+        </div>
+        <p className="truncate font-mono text-xs text-muted-foreground">To {picked}/</p>
+        {pinned.length > 0 && (
+          <div className="flex gap-2.5 rounded-lg border border-warning/25 bg-warning/[0.07] px-3 py-2.5 text-xs">
+            <AlertTriangle className="mt-px size-3.5 shrink-0 text-warning" />
+            <div className="space-y-1">
+              <p className="font-medium text-foreground">Not updated by the move</p>
+              {pinned.slice(0, 4).map((e) => (
+                <p key={e.path} className="text-muted-foreground">
+                  <span className="font-mono">{nameOf(e.path)}</span> is named in {e.pins.slice(0, 2).join(", ")}
+                </p>
+              ))}
+              <p className="text-muted-foreground">Change the path there too, or the agent looks for it in the old place.</p>
+            </div>
+          </div>
+        )}
+        <DialogFooter>
+          <Button variant="ghost" onClick={onClose}>
+            Cancel
+          </Button>
+          <Button
+            disabled={already || move.isPending}
+            onClick={() =>
+              move.mutate(
+                (paths ?? []).map((from) => ({ from, to: joinPath(picked, nameOf(from)) })),
+                { onSettled: onClose },
+              )
+            }
+          >
+            {move.isPending && <Spinner />} {pinned.length ? "Move anyway" : "Move here"}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/apps/desktop/src/components/files/file-editor.tsx b/apps/desktop/src/components/files/file-editor.tsx
new file mode 100644
index 00000000..5db99de6
--- /dev/null
+++ b/apps/desktop/src/components/files/file-editor.tsx
@@ -0,0 +1,362 @@
+import { useEffect, useMemo, useRef, useState, type ReactNode } from "react";
+import { Link } from "react-router";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { toast } from "sonner";
+import { formatDistanceToNowStrict } from "date-fns";
+import { Brain, Columns2, Eye, FileArchive, FileAudio, FileCode2, FileImage, FileJson, FileSpreadsheet, FileText, FileVideo, Lock, Moon, PencilLine, RotateCcw, Save } from "lucide-react";
+import { formatBytes } from "@godmode/shared";
+import { api, ApiRequestError, errorMessage } from "@/lib/api";
+import { qk } from "@/lib/queryKeys";
+import { isMac, modKey } from "@/lib/desktop";
+import { cn } from "@/lib/utils";
+import { Kbd } from "@/components/common";
+import { Markdown } from "@/components/chat/markdown";
+import { Button } from "@/components/ui/button";
+import { Skeleton } from "@/components/ui/skeleton";
+import { Spinner } from "@/components/ui/spinner";
+import { ToggleGroup, ToggleGroupItem } from "@/components/ui/toggle-group";
+import { BrokenLinks, brokenMemoryLinks, MemoryBudget, memorySections, SectionMenu, type MemorySection } from "@/components/agents/detail/memory-editor-parts";
+
+const MAX_EDITABLE = 512 * 1024;
+
+export const IMAGE_FILE = /\.(png|jpe?g|gif|webp|avif|bmp)$/i;
+export const NOTE_FILE = /\.(md|markdown)$/i;
+
+export function parentOf(path: string) {
+  const i = path.lastIndexOf("/");
+  return i === -1 ? "" : path.slice(0, i);
+}
+
+export function nameOf(path: string) {
+  return path.slice(path.lastIndexOf("/") + 1);
+}
+
+/** Why a file can't be edited here (null = editable). */
+export function readOnlyReason(path: string, size: number): string | null {
+  if (path === "CLAUDE.md") return "Generated from the agent's settings — edit the instructions in Settings instead.";
+  if (path.startsWith("state/")) return "Snapshot written by Godmode — changes would be overwritten.";
+  if (path.startsWith("runs/")) return "Raw run log — read-only.";
+  if (path.startsWith("conversations/")) return "Conversation transcript — read-only.";
+  if (size > MAX_EDITABLE) return "This file is too large to edit here.";
+  return null;
+}
+
+/** MEMORY.md and memory/** — a running dream owns these (the core refuses edits meanwhile). */
+export function isMemoryPath(path: string) {
+  return path === "MEMORY.md" || path.startsWith("memory/");
+}
+
+export function fileIcon(path: string, className = "size-4 text-muted-foreground") {
+  if (path === "MEMORY.md") return <Brain className={cn(className, "text-foreground")} />;
+  if (path === "CLAUDE.md") return <Lock className={className} />;
+  if (IMAGE_FILE.test(path)) return <FileImage className={className} />;
+  if (/\.(json|jsonl)$/i.test(path)) return <FileJson className={className} />;
+  if (/\.(csv|tsv|xlsx?|numbers)$/i.test(path)) return <FileSpreadsheet className={className} />;
+  if (/\.(zip|tar|gz|tgz|7z|rar|dmg|apk|aab|ipa)$/i.test(path)) return <FileArchive className={className} />;
+  if (/\.(mp4|mov|webm|mkv)$/i.test(path)) return <FileVideo className={className} />;
+  if (/\.(mp3|wav|m4a|ogg|aac)$/i.test(path)) return <FileAudio className={className} />;
+  if (/\.(ts|tsx|js|mjs|cjs|py|sh|yaml|yml|toml|html|css|swift|kt|go|rs)$/i.test(path)) return <FileCode2 className={className} />;
+  return <FileText className={className} />;
+}
+
+function decodePath(path: string): string {
+  try {
+    return decodeURI(path);
+  } catch {
+    return path;
+  }
+}
+
+/** A file of the repository a clicked link points at (MEMORY.md, memory/…, workspace/…), or null for any other link. */
+export function repoLinkTarget(href: string | null): string | null {
+  if (!href || /^[a-z][a-z0-9+.-]*:/i.test(href) || href.startsWith("/")) return null;
+  const path = decodePath(href.replace(/^\.\//, "").split(/[#?]/)[0]!);
+  if (path.includes("..")) return null;
+  return path === "MEMORY.md" || path.startsWith("memory/") || path.startsWith("workspace/") ? path : null;
+}
+
+/** The file changed on the server since the draft started — saving would overwrite someone else's edit. */
+class StaleDraftError extends Error {}
+
+type View = "edit" | "split" | "preview";
+
+export function FileEditor({
+  agentId,
+  agentName,
+  path,
+  size,
+  dreaming,
+  onDirtyChange,
+  onOpenFile,
+  onSaved,
+  fill = false,
+  defaultView,
+  actions,
+}: {
+  agentId: string;
+  agentName: string;
+  path: string;
+  size: number;
+  /** A dream of the agent is running: memory files are locked until it ends. */
+  dreaming: boolean;
+  onDirtyChange: (dirty: boolean) => void;
+  /** A link in the preview points at another file in the repository. */
+  onOpenFile: (path: string) => void;
+  onSaved?: (path: string) => void;
+  /** Grow with the pane instead of a fixed height. */
+  fill?: boolean;
+  defaultView?: View;
+  /** More buttons for the file (rename, move, delete), at the end of the bar. */
+  actions?: ReactNode;
+}) {
+  const qc = useQueryClient();
+  const file = useQuery({ queryKey: qk.agentFile(agentId, path), queryFn: () => api.agents.readFile(agentId, path), retry: false });
+  const original = file.data?.content ?? "";
+  /** The edit and the file content it started from, so a rewrite underneath (e.g. by a dream) isn't silently overwritten. */
+  const [draft, setDraft] = useState<{ text: string; base: string } | null>(null);
+  const value = draft?.text ?? original;
+  const dirty = draft !== null && draft.text !== original;
+  const conflict = dirty && draft.base !== original;
+  const isMarkdown = NOTE_FILE.test(path);
+  const fixedReason = readOnlyReason(path, Math.max(size, original.length));
+  const dreamLock = dreaming && isMemoryPath(path);
+  const readOnly = fixedReason ?? (dreamLock ? `${agentName} is dreaming — editing is paused until the dream ends.` : null);
+  const [view, setView] = useState<View>(isMarkdown ? (fixedReason ? "preview" : (defaultView ?? "edit")) : "edit");
+  const edit = (text: string) => setDraft((d) => ({ text, base: d && d.text !== original ? d.base : original }));
+  const textareaRef = useRef<HTMLTextAreaElement>(null);
+  const previewRef = useRef<HTMLDivElement>(null);
+  const isMemory = path === "MEMORY.md";
+  const memory = useQuery({ queryKey: qk.agentMemory(agentId), queryFn: () => api.agents.memory(agentId), enabled: isMemory });
+  const sections = useMemo(() => (isMarkdown ? memorySections(value) : []), [isMarkdown, value]);
+  const broken = useMemo(() => (isMemory && memory.data ? brokenMemoryLinks(value, memory.data.topics) : []), [isMemory, memory.data, value]);
+  const showSource = view !== "preview" || !isMarkdown;
+  const showPreview = isMarkdown && view !== "edit";
+
+  const jumpTo = (section: MemorySection) => {
+    if (view === "preview") {
+      const headings = previewRef.current?.querySelectorAll("h1, h2, h3");
+      headings?.[sections.indexOf(section)]?.scrollIntoView({ block: "start", behavior: "smooth" });
+      return;
+    }
+    const el = textareaRef.current;
+    if (!el) return;
+    const offset = value.split("\n").slice(0, section.line).reduce((n, l) => n + l.length + 1, 0);
+    el.focus();
+    el.setSelectionRange(offset, offset);
+    const lineHeight = parseFloat(getComputedStyle(el).lineHeight) || 21;
+    el.scrollTop = Math.max(0, section.line * lineHeight - 12);
+  };
+
+  useEffect(() => onDirtyChange(dirty), [dirty, onDirtyChange]);
+  useEffect(() => () => onDirtyChange(false), [onDirtyChange]);
+
+  const save = useMutation({
+    mutationFn: async ({ content, base }: { content: string; base: string | null }) => {
+      // Not every writer announces itself (a chat run may rewrite MEMORY.md): check the file is still what the draft started from.
+      if (base !== null) {
+        const fresh = await api.agents.readFile(agentId, path).catch((err) => {
+          if (err instanceof ApiRequestError && err.status === 404) return { path, content: "" };
+          throw err;
+        });
+        if (fresh.content !== base) {
+          qc.setQueryData(qk.agentFile(agentId, path), fresh);
+          throw new StaleDraftError();
+        }
+      }
+      await api.agents.writeFile(agentId, path, content);
+      return content;
+    },
+    onSuccess: (content) => {
+      qc.setQueryData(qk.agentFile(agentId, path), { path, content });
+      qc.invalidateQueries({ queryKey: qk.agentCommits(agentId) });
+      qc.invalidateQueries({ queryKey: qk.agentFiles(agentId, parentOf(path)) });
+      if (isMemory) {
+        qc.invalidateQueries({ queryKey: qk.agentDreams(agentId) });
+        qc.invalidateQueries({ queryKey: qk.agentMemory(agentId) });
+      }
+      setDraft(null);
+      onSaved?.(path);
+      toast.success(`Saved ${nameOf(path)}`);
+    },
+    onError: (err) => {
+      if (err instanceof StaleDraftError) warnConflict();
+      else toast.error(`Couldn't save ${nameOf(path)}`, { description: errorMessage(err) });
+    },
+  });
+  const warnConflict = () =>
+    toast.warning(`${nameOf(path)} changed while you were editing`, { description: "Reload it, or overwrite it with your version." });
+
+  const saveRef = useRef<() => void>(() => {});
+  saveRef.current = () => {
+    if (!dirty || readOnly || save.isPending || !draft) return;
+    if (conflict) warnConflict();
+    else save.mutate({ content: value, base: draft.base });
+  };
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      const mod = isMac ? e.metaKey : e.ctrlKey;
+      if (mod && e.key.toLowerCase() === "s") {
+        e.preventDefault();
+        saveRef.current();
+      }
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, []);
+
+  const lines = value ? value.split("\n").length : 0;
+  const words = useMemo(() => (isMarkdown ? (value.match(/\S+/g)?.length ?? 0) : 0), [isMarkdown, value]);
+  const status = file.isError ? (file.error as { status?: number }).status : undefined;
+  const missing = status === 404;
+  const unreadable = status === 415 || status === 413;
+  const height = fill ? "h-full min-h-[18rem]" : "h-[60vh]";
+
+  const preview = (
+    <div
+      ref={previewRef}
+      className={cn("overflow-y-auto p-5", fill ? "h-full" : "max-h-[70vh]")}
+      onClickCapture={(e) => {
+        const target = repoLinkTarget((e.target as HTMLElement).closest("a")?.getAttribute("href") ?? null);
+        if (!target) return;
+        e.preventDefault();
+        e.stopPropagation();
+        onOpenFile(target);
+      }}
+    >
+      {value.trim() ? <Markdown>{value}</Markdown> : <p className="text-sm text-muted-foreground italic">Empty file.</p>}
+    </div>
+  );
+
+  const source = (
+    <textarea
+      ref={textareaRef}
+      value={value}
+      onChange={(e) => edit(e.target.value)}
+      onKeyDown={(e) => {
+        // Tab inserts two spaces instead of leaving the editor
+        if (e.key === "Tab" && !e.shiftKey && !readOnly) {
+          e.preventDefault();
+          const el = e.currentTarget;
+          const { selectionStart: s, selectionEnd: end } = el;
+          edit(`${value.slice(0, s)}  ${value.slice(end)}`);
+          requestAnimationFrame(() => el.setSelectionRange(s + 2, s + 2));
+        }
+      }}
+      readOnly={!!readOnly}
+      spellCheck={isMarkdown}
+      aria-label={`Contents of ${path}`}
+      placeholder={missing ? "This file doesn't exist yet — start typing to create it." : undefined}
+      className={cn("block w-full resize-none bg-transparent p-4 font-mono text-[13px] leading-relaxed outline-none placeholder:text-muted-foreground/70", height)}
+    />
+  );
+
+  return (
+    <div className={cn("flex min-h-0 flex-col", fill && "h-full")}>
+      <div className="flex flex-wrap items-center gap-2 border-b px-4 py-2.5">
+        <span className="shrink-0">{fileIcon(path)}</span>
+        <span className="min-w-0 truncate font-mono text-[13px]" title={path}>
+          {path}
+        </span>
+        {dirty && <span className="size-2 shrink-0 rounded-full bg-warning" aria-label="Unsaved changes" title="Unsaved changes" />}
+        <div className="ml-auto flex items-center gap-2">
+          <SectionMenu sections={sections} onPick={jumpTo} />
+          {isMarkdown && !unreadable && (
+            <ToggleGroup type="single" size="sm" variant="outline" value={view} onValueChange={(v) => v && setView(v as View)} aria-label="View mode">
+              <ToggleGroupItem value="edit" aria-label={readOnly ? "Source" : "Edit"} className="gap-1 px-2 text-xs">
+                <PencilLine className="size-3.5" /> {readOnly ? "Source" : "Edit"}
+              </ToggleGroupItem>
+              <ToggleGroupItem value="split" aria-label="Side by side" title="Side by side" className="gap-1 px-2 text-xs">
+                <Columns2 className="size-3.5" /> Split
+              </ToggleGroupItem>
+              <ToggleGroupItem value="preview" aria-label="Preview" className="gap-1 px-2 text-xs">
+                <Eye className="size-3.5" /> Preview
+              </ToggleGroupItem>
+            </ToggleGroup>
+          )}
+          {!fixedReason && !unreadable && (
+            <>
+              <Button variant="ghost" size="sm" disabled={!dirty} onClick={() => setDraft(null)}>
+                <RotateCcw /> Revert
+              </Button>
+              <Button size="sm" disabled={!dirty || !!readOnly || conflict || save.isPending} onClick={() => saveRef.current()}>
+                {save.isPending ? <Spinner /> : <Save />} Save
+                <Kbd>{modKey}S</Kbd>
+              </Button>
+            </>
+          )}
+          {actions}
+        </div>
+      </div>
+
+      {readOnly && !unreadable && (
+        <div className={cn("flex items-center gap-2 border-b px-4 py-2 text-xs text-muted-foreground", fixedReason ? "bg-paper-2" : "bg-dream-soft")} role={fixedReason ? undefined : "status"}>
+          {fixedReason ? <Lock className="size-3.5 shrink-0" /> : <Moon className="size-3.5 shrink-0 text-dream" aria-hidden />}
+          <span>{readOnly}</span>
+          {path === "CLAUDE.md" && (
+            <Link to={`/agents/${agentId}/settings`} className="ml-auto shrink-0 font-medium text-foreground underline decoration-foreground/25 underline-offset-[3px] hover:decoration-foreground">
+              Open settings
+            </Link>
+          )}
+        </div>
+      )}
+
+      {conflict && (
+        <div role="alert" className="flex flex-wrap items-center gap-x-3 gap-y-2 border-b border-warning/25 bg-warning/[0.07] px-4 py-2 text-xs">
+          <span className="min-w-0 flex-1 basis-64 text-muted-foreground">
+            <span className="font-medium text-foreground">{nameOf(path)} changed while you were editing</span> — {agentName} may have rewritten it. Reload to
+            see the new version (your edits are discarded), or overwrite it with yours.
+          </span>
+          <span className="flex shrink-0 gap-1.5">
+            <Button variant="outline" size="xs" onClick={() => setDraft(null)}>
+              <RotateCcw /> Reload
+            </Button>
+            <Button size="xs" disabled={!!readOnly || save.isPending} onClick={() => save.mutate({ content: value, base: null })}>
+              {save.isPending ? <Spinner /> : <Save />} Overwrite
+            </Button>
+          </span>
+        </div>
+      )}
+
+      <div className={cn("relative min-h-0", fill && "flex-1")}>
+        {file.isLoading ? (
+          <div className="space-y-2 p-4">
+            {Array.from({ length: 8 }, (_, i) => (
+              <Skeleton key={i} className="h-4" style={{ width: `${40 + ((i * 37) % 55)}%` }} />
+            ))}
+          </div>
+        ) : unreadable ? (
+          <div className="grid h-full min-h-[14rem] place-items-center p-8 text-center">
+            <div>
+              <div className="mx-auto mb-3 grid size-11 place-items-center rounded-lg border bg-card shadow-card">{fileIcon(path, "size-5 text-muted-foreground")}</div>
+              <p className="text-sm font-medium">{status === 413 ? "Too large to open here" : "Not a text file"}</p>
+              <p className="mt-1 text-xs text-muted-foreground">{size ? `${formatBytes(size)} · ` : ""}Move, rename or delete it from the list.</p>
+            </div>
+          </div>
+        ) : file.isError && !missing ? (
+          <div className="p-6 text-sm text-muted-foreground">Couldn't open this file: {errorMessage(file.error)}</div>
+        ) : showSource && showPreview ? (
+          <div className={cn("grid grid-cols-2 divide-x", fill ? "h-full" : "")}>
+            {source}
+            {preview}
+          </div>
+        ) : showPreview ? (
+          preview
+        ) : (
+          source
+        )}
+      </div>
+
+      {!unreadable && (
+        <div className="flex items-center gap-3 overflow-hidden border-t px-4 py-2 text-[11px] whitespace-nowrap text-muted-foreground">
+          <span className="tabular-nums">{lines.toLocaleString()} lines</span>
+          {isMarkdown && <span className="tabular-nums">{words.toLocaleString()} words</span>}
+          <span className="tabular-nums">{formatBytes(new Blob([value]).size)}</span>
+          {isMemory && memory.data && <MemoryBudget chars={value.length} memory={memory.data} />}
+          {isMemory && <BrokenLinks paths={broken} />}
+          {file.dataUpdatedAt > 0 && !dirty && <span className="ml-auto">loaded {formatDistanceToNowStrict(file.dataUpdatedAt, { addSuffix: true })}</span>}
+          {dirty && <span className="ml-auto text-warning">Unsaved changes</span>}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/apps/desktop/src/components/files/notes-pane.tsx b/apps/desktop/src/components/files/notes-pane.tsx
new file mode 100644
index 00000000..f4a37732
--- /dev/null
+++ b/apps/desktop/src/components/files/notes-pane.tsx
@@ -0,0 +1,131 @@
+import { useMemo, useState } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { formatDistanceToNowStrict } from "date-fns";
+import { ArrowDownWideNarrow, Brain, Search, Unplug, X } from "lucide-react";
+import type { Agent, AgentNote } from "@godmode/shared";
+import { formatBytes } from "@godmode/shared";
+import { api, errorMessage } from "@/lib/api";
+import { qk } from "@/lib/queryKeys";
+import { cn } from "@/lib/utils";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Skeleton } from "@/components/ui/skeleton";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuLabel, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuTrigger } from "@/components/ui/dropdown-menu";
+import { parentOf } from "./file-editor";
+import { plural } from "./use-files";
+
+type Sort = "folder" | "modified" | "size";
+
+export function NotesPane({ agent, selected, onSelect }: { agent: Agent; selected: string | null; onSelect: (note: AgentNote) => void }) {
+  const notes = useQuery({ queryKey: qk.agentNotes(agent.id), queryFn: () => api.agents.notes(agent.id), staleTime: 30_000 });
+  const [filter, setFilter] = useState("");
+  const [sort, setSort] = useState<Sort>("folder");
+  const [onlyUnlinked, setOnlyUnlinked] = useState(false);
+  const needle = filter.trim().toLowerCase();
+  const all = notes.data ?? [];
+  const unlinked = all.filter((n) => n.path.startsWith("memory/") && !n.linked).length;
+
+  const groups = useMemo(() => {
+    let list = all.filter((n) => !needle || n.title.toLowerCase().includes(needle) || n.path.toLowerCase().includes(needle));
+    if (onlyUnlinked) list = list.filter((n) => n.path.startsWith("memory/") && !n.linked);
+    if (sort === "modified") list = [...list].sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt));
+    if (sort === "size") list = [...list].sort((a, b) => b.bytes - a.bytes);
+    if (sort !== "folder") return [{ title: null as string | null, notes: list }];
+    const by = new Map<string, AgentNote[]>();
+    for (const n of list) {
+      const key = n.path === "MEMORY.md" ? "" : parentOf(n.path);
+      by.set(key, [...(by.get(key) ?? []), n]);
+    }
+    return [...by.entries()].map(([title, notes]) => ({ title: title || "Memory", notes }));
+  }, [all, needle, sort, onlyUnlinked]);
+  const shown = groups.reduce((n, g) => n + g.notes.length, 0);
+
+  return (
+    <div className="flex h-full min-h-0 flex-col">
+      <div className="flex items-center gap-2 border-b px-3 py-2">
+        <div className="relative flex-1">
+          <Search className="pointer-events-none absolute top-1/2 left-2.5 size-3.5 -translate-y-1/2 text-muted-foreground" />
+          <Input value={filter} onChange={(e) => setFilter(e.target.value)} placeholder="Filter notes" className="h-8 pl-8 text-[13px]" aria-label="Filter notes" />
+          {filter && (
+            <button type="button" aria-label="Clear" onClick={() => setFilter("")} className="absolute top-1/2 right-2 -translate-y-1/2 rounded p-0.5 text-muted-foreground hover:bg-accent">
+              <X className="size-3.5" />
+            </button>
+          )}
+        </div>
+        <DropdownMenu>
+          <DropdownMenuTrigger asChild>
+            <Button variant="ghost" size="icon-sm" aria-label="Sort notes">
+              <ArrowDownWideNarrow />
+            </Button>
+          </DropdownMenuTrigger>
+          <DropdownMenuContent align="end">
+            <DropdownMenuLabel>Sort by</DropdownMenuLabel>
+            <DropdownMenuRadioGroup value={sort} onValueChange={(v) => setSort(v as Sort)}>
+              <DropdownMenuRadioItem value="folder">Folder</DropdownMenuRadioItem>
+              <DropdownMenuRadioItem value="modified">Last changed</DropdownMenuRadioItem>
+              <DropdownMenuRadioItem value="size">Size</DropdownMenuRadioItem>
+            </DropdownMenuRadioGroup>
+          </DropdownMenuContent>
+        </DropdownMenu>
+      </div>
+      {unlinked > 0 && (
+        <button
+          type="button"
+          onClick={() => setOnlyUnlinked((v) => !v)}
+          aria-pressed={onlyUnlinked}
+          className={cn("flex items-center gap-2 border-b px-4 py-2 text-left text-xs transition hover:bg-accent/40", onlyUnlinked ? "bg-warning/[0.08]" : "bg-warning/[0.04]")}
+        >
+          <Unplug className="size-3.5 shrink-0 text-warning" />
+          <span className="flex-1">
+            <span className="font-medium">{plural(unlinked, "memory note")}</span> without a link from MEMORY.md
+          </span>
+          <span className="text-muted-foreground">{onlyUnlinked ? "Show all" : "Show only these"}</span>
+        </button>
+      )}
+
+      <div className="min-h-0 flex-1 overflow-y-auto">
+        {notes.isLoading ? (
+          <div className="space-y-2 p-3">
+            {Array.from({ length: 6 }, (_, i) => (
+              <Skeleton key={i} className="h-11" />
+            ))}
+          </div>
+        ) : notes.isError ? (
+          <p className="p-4 text-sm text-destructive">{errorMessage(notes.error)}</p>
+        ) : !shown ? (
+          <p className="px-4 py-8 text-center text-sm text-muted-foreground">{needle ? "No note matches." : "No notes yet."}</p>
+        ) : (
+          groups.map((g) => (
+            <section key={g.title ?? "all"} className="px-1.5 pt-2 pb-1">
+              {g.title && <p className="truncate px-2 pb-1 font-mono text-[11px] text-muted-foreground">{g.title === "Memory" ? "Memory" : `${g.title}/`}</p>}
+              <ul>
+                {g.notes.map((n) => (
+                  <li key={n.path}>
+                    <button
+                      type="button"
+                      onClick={() => onSelect(n)}
+                      className={cn("flex w-full items-start gap-2.5 rounded-md px-2 py-1.5 text-left transition hover:bg-accent/50", selected === n.path && "bg-secondary")}
+                    >
+                      {n.path === "MEMORY.md" ? <Brain className="mt-0.5 size-4 shrink-0" /> : <span className={cn("mt-1.5 size-1.5 shrink-0 rounded-full", n.path.startsWith("memory/") && !n.linked ? "bg-warning" : "bg-foreground/20")} />}
+                      <span className="min-w-0 flex-1">
+                        <span className={cn("block truncate text-[13px]", selected === n.path && "font-medium")}>{n.title}</span>
+                        <span className="block truncate font-mono text-[11px] text-muted-foreground">{sort === "folder" ? n.path.slice(n.path.lastIndexOf("/") + 1) : n.path}</span>
+                      </span>
+                      <span className="shrink-0 text-right text-[11px] text-muted-foreground tabular-nums">
+                        <span className="block">{formatBytes(n.bytes)}</span>
+                        <span className="block">{formatDistanceToNowStrict(new Date(n.modifiedAt))}</span>
+                      </span>
+                    </button>
+                  </li>
+                ))}
+              </ul>
+            </section>
+          ))
+        )}
+      </div>
+      <div className="border-t px-3 py-1.5 text-[11px] text-muted-foreground">
+        {plural(all.length, "note")} · {formatBytes(all.reduce((n, x) => n + x.bytes, 0))}
+      </div>
+    </div>
+  );
+}
diff --git a/apps/desktop/src/components/files/overview.tsx b/apps/desktop/src/components/files/overview.tsx
new file mode 100644
index 00000000..629dc213
--- /dev/null
+++ b/apps/desktop/src/components/files/overview.tsx
@@ -0,0 +1,136 @@
+import { useMemo, useState } from "react";
+import { Link } from "react-router";
+import { useQuery } from "@tanstack/react-query";
+import { motion } from "motion/react";
+import { ArrowUpRight, Brain, Clock3, NotebookText, Trash2 } from "lucide-react";
+import type { Agent, AgentFilesOverview } from "@godmode/shared";
+import { formatBytes, memoryBudget } from "@godmode/shared";
+import { api, errorMessage } from "@/lib/api";
+import { qk } from "@/lib/queryKeys";
+import { useBootstrap } from "@/lib/hooks";
+import { cn } from "@/lib/utils";
+import { AgentAvatar } from "@/components/common";
+import { Skeleton } from "@/components/ui/skeleton";
+import { ToggleGroup, ToggleGroupItem } from "@/components/ui/toggle-group";
+import { plural } from "./use-files";
+
+export function useFilesOverview() {
+  return useQuery({ queryKey: qk.filesOverview, queryFn: () => api.files.overview(), staleTime: 60_000 });
+}
+
+function compactChars(n: number) {
+  return n >= 1000 ? `${(n / 1000).toFixed(n >= 10_000 ? 0 : 1)}k` : String(n);
+}
+
+/** Every agent's files at a glance, the largest first: where tidying pays off. */
+export function FilesOverview({ agents }: { agents: Agent[] }) {
+  const overview = useFilesOverview();
+  const boot = useBootstrap();
+  const budget = memoryBudget(boot.data?.settings.memory.dreaming.maxMemoryChars);
+  const [sort, setSort] = useState<"size" | "name">("size");
+  const rows = useMemo(() => {
+    const by = new Map((overview.data ?? []).map((r) => [r.agentId, r]));
+    const list = agents.map((a) => ({ agent: a, row: by.get(a.id) ?? null }));
+    return sort === "size" ? list.sort((a, b) => (b.row?.bytes ?? 0) - (a.row?.bytes ?? 0)) : list.sort((a, b) => a.agent.name.localeCompare(b.agent.name));
+  }, [agents, overview.data, sort]);
+  const largest = Math.max(1, ...rows.map((r) => r.row?.bytes ?? 0));
+  const total = rows.reduce((n, r) => n + (r.row?.bytes ?? 0), 0);
+  const scratch = rows.reduce((n, r) => n + (r.row?.scratchBytes ?? 0), 0);
+
+  return (
+    <div className="space-y-4">
+      <div className="flex flex-wrap items-end justify-between gap-3">
+        <div>
+          <p className="text-[13px] text-muted-foreground">
+            {overview.data ? (
+              <>
+                <span className="font-medium text-foreground tabular-nums">{formatBytes(total)}</span> across {plural(rows.length, "agent")}
+                {scratch > 0 && <> · {formatBytes(scratch)} of it scratch in tmp/, which goes by itself</>}
+              </>
+            ) : (
+              "Counting what every agent keeps…"
+            )}
+          </p>
+        </div>
+        <ToggleGroup type="single" size="sm" variant="outline" value={sort} onValueChange={(v) => v && setSort(v as "size" | "name")} aria-label="Sort agents">
+          <ToggleGroupItem value="size" className="px-2.5 text-xs">
+            Largest first
+          </ToggleGroupItem>
+          <ToggleGroupItem value="name" className="px-2.5 text-xs">
+            A–Z
+          </ToggleGroupItem>
+        </ToggleGroup>
+      </div>
+      {overview.isError && <p className="text-sm text-destructive">{errorMessage(overview.error)}</p>}
+      <ul className="grid grid-cols-1 gap-3 @2xl:grid-cols-2 @5xl:grid-cols-3">
+        {rows.map(({ agent, row }, i) => (
+          <motion.li key={agent.id} initial={{ opacity: 0, y: 6 }} animate={{ opacity: 1, y: 0 }} transition={{ delay: Math.min(i, 12) * 0.02 }}>
+            <AgentCard agent={agent} row={row} largest={largest} memoryLimit={budget.target} />
+          </motion.li>
+        ))}
+      </ul>
+    </div>
+  );
+}
+
+function AgentCard({ agent, row, largest, memoryLimit }: { agent: Agent; row: AgentFilesOverview | null; largest: number; memoryLimit: number }) {
+  const over = row ? row.memoryChars > memoryLimit : false;
+  return (
+    <Link
+      to={`/files/${agent.id}`}
+      className="group/card block rounded-xl border bg-card p-4 shadow-card transition hover:border-foreground/15 hover:shadow-float focus-visible:ring-[3px] focus-visible:ring-ring/50 focus-visible:outline-none"
+    >
+      <div className="flex items-start gap-3">
+        <AgentAvatar agent={agent} size="md" still />
+        <div className="min-w-0 flex-1">
+          <p className="truncate text-sm font-medium tracking-[-0.01em]">{agent.name}</p>
+          <p className="truncate text-xs text-muted-foreground">{agent.role || "Agent"}</p>
+        </div>
+        <ArrowUpRight className="size-4 text-muted-foreground/0 transition group-hover/card:text-muted-foreground" />
+      </div>
+      <div className="mt-4">
+        {row ? (
+          <>
+            <p className="text-[22px] leading-none font-medium tracking-[-0.03em] tabular-nums">
+              {row.partial && <span className="text-base text-muted-foreground">≥ </span>}
+              {formatBytes(row.bytes)}
+            </p>
+            <div className="mt-2.5 h-1 overflow-hidden rounded-full bg-foreground/[0.06]">
+              <div className="flex h-full" style={{ width: `${Math.max(1.5, (row.bytes / largest) * 100)}%` }}>
+                <span className="h-full bg-foreground/45" style={{ flexGrow: Math.max(row.bytes - row.scratchBytes, 0) }} />
+                <span className="h-full bg-foreground/15" style={{ flexGrow: row.scratchBytes }} />
+              </div>
+            </div>
+          </>
+        ) : (
+          <>
+            <Skeleton className="h-6 w-24" />
+            <Skeleton className="mt-2.5 h-1 w-full" />
+          </>
+        )}
+      </div>
+      <div className="mt-3 flex flex-wrap gap-x-3 gap-y-1 text-[11px] text-muted-foreground">
+        {row && (
+          <>
+            <span className="inline-flex items-center gap-1">
+              <NotebookText className="size-3" /> {plural(row.notes, "note")}
+            </span>
+            <span className={cn("inline-flex items-center gap-1", over && "text-warning")} title={`MEMORY.md: ${row.memoryChars.toLocaleString()} of ${memoryLimit.toLocaleString()} characters`}>
+              <Brain className="size-3" /> {compactChars(row.memoryChars)} / {compactChars(memoryLimit)}
+            </span>
+            {row.scratchBytes > 0 && (
+              <span className="inline-flex items-center gap-1" title="Scratch in workspace/tmp — goes by itself a week after its last change">
+                <Clock3 className="size-3" /> tmp {formatBytes(row.scratchBytes)}
+              </span>
+            )}
+            {row.deleted > 0 && (
+              <span className="inline-flex items-center gap-1">
+                <Trash2 className="size-3" /> {row.deleted} in bin
+              </span>
+            )}
+          </>
+        )}
+      </div>
+    </Link>
+  );
+}
diff --git a/apps/desktop/src/components/files/review-pane.tsx b/apps/desktop/src/components/files/review-pane.tsx
new file mode 100644
index 00000000..eb1bbcea
--- /dev/null
+++ b/apps/desktop/src/components/files/review-pane.tsx
@@ -0,0 +1,232 @@
+import { useMemo, useState, type ComponentType } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { formatDistanceToNowStrict } from "date-fns";
+import { Boxes, CircleCheck, Clock3, Copy, FileWarning, Folder, FolderInput, FolderX, HardDrive, RefreshCw, Sparkles, Trash2, Unlink, Unplug, Wind } from "lucide-react";
+import type { Agent, FileReviewItem, FileReviewKind } from "@godmode/shared";
+import { formatBytes } from "@godmode/shared";
+import { api, errorMessage } from "@/lib/api";
+import { qk } from "@/lib/queryKeys";
+import { cn } from "@/lib/utils";
+import { Button } from "@/components/ui/button";
+import { Checkbox } from "@/components/ui/checkbox";
+import { Skeleton } from "@/components/ui/skeleton";
+import { Spinner } from "@/components/ui/spinner";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
+import { fileIcon, nameOf } from "./file-editor";
+import { plural } from "./use-files";
+
+const KINDS: Record<FileReviewKind, { title: string; hint: string; icon: ComponentType<{ className?: string }>; safe: boolean }> = {
+  build: { title: "Installed packages and build output", hint: "Installing or building again brings them back.", icon: Boxes, safe: true },
+  junk: { title: "Junk files", hint: "Logs, temporary files and Finder leftovers.", icon: Wind, safe: true },
+  empty: { title: "Empty files and folders", hint: "Nothing in them.", icon: FolderX, safe: true },
+  duplicate: { title: "Copies", hint: "The same content lies somewhere else too — the other copy stays.", icon: Copy, safe: true },
+  large: { title: "Large files", hint: "Check whether they are still needed.", icon: HardDrive, safe: false },
+  scratch: { title: "Large scratch in tmp/", hint: "Goes by itself a week after its last change — delete now to free the space today.", icon: Clock3, safe: false },
+  stale: { title: "Untouched for 30 days", hint: "Old reports, exports and experiments: keep what still matters.", icon: Clock3, safe: false },
+  loose: { title: "Unsorted", hint: "Loose files at the top: sort them into a folder.", icon: FolderInput, safe: false },
+  "unlinked-note": { title: "Notes nothing links to", hint: "Memory notes without a link from MEMORY.md are rarely read: link, merge or delete them.", icon: Unplug, safe: false },
+  "broken-link": { title: "Broken links in memory", hint: "The memory points at notes that don't exist: fix the link in the note.", icon: Unlink, safe: false },
+};
+const ORDER = Object.keys(KINDS) as FileReviewKind[];
+
+/** What a review item does when clicked: open it, the note that links (broken link), or the folder. */
+export interface ReviewActions {
+  onOpen: (item: FileReviewItem) => void;
+  onDelete: (paths: string[]) => void;
+  onMove: (paths: string[]) => void;
+}
+
+export function useFileReview(agentId: string) {
+  return useQuery({ queryKey: qk.agentFileReview(agentId), queryFn: () => api.agents.fileReview(agentId), staleTime: 60_000 });
+}
+
+export function ReviewPane({ agent, selected, actions, frozen }: { agent: Agent; selected: string | null; actions: ReviewActions; frozen: boolean }) {
+  const qc = useQueryClient();
+  const review = useFileReview(agent.id);
+  const recheck = useMutation({
+    mutationFn: () => api.agents.fileReview(agent.id, true),
+    onSuccess: (data) => qc.setQueryData(qk.agentFileReview(agent.id), data),
+  });
+  /** What the human ticked or unticked; everything else follows the defaults (kept across refreshes). */
+  const [picked, setPicked] = useState<Map<string, boolean>>(() => new Map());
+  const items = review.data?.items ?? [];
+  const deletable = (i: FileReviewItem) => i.kind !== "broken-link";
+  // Safe kinds start ticked, unless the agent still names the item or it is a backup copy.
+  const defaults = useMemo(() => new Set(items.filter((i) => KINDS[i.kind].safe && !i.namedBy && !/\.bak$/i.test(i.path)).map((i) => i.path)), [items]);
+  const chosen = useMemo(() => new Set(items.map((i) => i.path).filter((p) => picked.get(p) ?? defaults.has(p))), [items, picked, defaults]);
+  const groups = useMemo(() => ORDER.map((kind) => ({ kind, items: items.filter((i) => i.kind === kind) })).filter((g) => g.items.length), [items]);
+  const chosenItems = items.filter((i) => chosen.has(i.path) && deletable(i));
+  const chosenBytes = chosenItems.reduce((n, i) => n + i.bytes, 0);
+  const totalBytes = items.filter(deletable).reduce((n, i) => n + i.bytes, 0);
+
+  const toggle = (paths: string[], on: boolean) =>
+    setPicked((prev) => {
+      const next = new Map(prev);
+      for (const p of paths) next.set(p, on);
+      return next;
+    });
+
+  return (
+    <div className="flex h-full min-h-0 flex-col">
+      <div className="flex items-center gap-3 border-b px-4 py-3">
+        <div className="min-w-0">
+          <h2 className="text-sm font-medium tracking-[-0.01em]">{review.data ? (items.length ? `${plural(items.length, "thing")} to look at` : "Nothing to tidy") : "Looking through the files…"}</h2>
+          <p className="text-xs text-muted-foreground">
+            {review.data
+              ? `${totalBytes ? `${formatBytes(totalBytes)} could go · ` : ""}checked ${formatDistanceToNowStrict(new Date(review.data.checkedAt), { addSuffix: true })}${review.data.partial ? " · very large, not everything was looked at" : ""}`
+              : "Sizes, copies, junk and notes nothing links to."}
+          </p>
+        </div>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Button variant="ghost" size="icon-sm" className="ml-auto" aria-label="Check again" disabled={review.isFetching || recheck.isPending} onClick={() => recheck.mutate()}>
+              {review.isFetching || recheck.isPending ? <Spinner /> : <RefreshCw />}
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent>Check again</TooltipContent>
+        </Tooltip>
+      </div>
+
+      <div className="min-h-0 flex-1 overflow-y-auto">
+        {review.isLoading ? (
+          <div className="space-y-4 p-4">
+            {Array.from({ length: 3 }, (_, i) => (
+              <div key={i} className="space-y-2">
+                <Skeleton className="h-5 w-1/2" />
+                <Skeleton className="h-9" />
+                <Skeleton className="h-9 w-11/12" />
+              </div>
+            ))}
+          </div>
+        ) : review.isError ? (
+          <p className="p-4 text-sm text-destructive">{errorMessage(review.error)}</p>
+        ) : !groups.length ? (
+          <div className="grid place-items-center px-6 py-16 text-center">
+            <div className="mb-3 grid size-11 place-items-center rounded-full bg-brand-soft text-brand-strong">
+              <CircleCheck className="size-5" />
+            </div>
+            <p className="text-sm font-medium">{agent.name}'s files look tidy</p>
+            <p className="mt-1 max-w-xs text-xs text-muted-foreground">No build output, junk, copies or forgotten notes. The nightly dream keeps sorting the workspace too.</p>
+          </div>
+        ) : (
+          <div className="divide-y">
+            {groups.map((g) => {
+              const meta = KINDS[g.kind];
+              const Icon = meta.icon;
+              const paths = g.items.filter(deletable).map((i) => i.path);
+              const on = paths.filter((p) => chosen.has(p)).length;
+              const bytes = g.items.reduce((n, i) => n + i.bytes, 0);
+              return (
+                <section key={g.kind} aria-label={meta.title} className="py-2">
+                  <div className="flex items-start gap-2.5 px-4 pt-1 pb-1.5">
+                    {paths.length > 0 ? (
+                      <Checkbox
+                        className="mt-0.5"
+                        aria-label={`Select all ${meta.title.toLowerCase()}`}
+                        checked={on === paths.length ? true : on ? "indeterminate" : false}
+                        onCheckedChange={(v) => toggle(paths, v === true)}
+                      />
+                    ) : (
+                      <span className="w-4" />
+                    )}
+                    <Icon className="mt-0.5 size-4 shrink-0 text-muted-foreground" />
+                    <div className="min-w-0 flex-1">
+                      <p className="text-[13px] font-medium">
+                        {meta.title} <span className="font-normal text-muted-foreground tabular-nums">· {g.items.length}{bytes ? ` · ${formatBytes(bytes)}` : ""}</span>
+                      </p>
+                      <p className="text-xs text-muted-foreground">{meta.hint}</p>
+                    </div>
+                  </div>
+                  <ul className="px-1.5">
+                    {g.items.map((item) => (
+                      <ReviewRow
+                        key={`${item.kind}:${item.path}`}
+                        item={item}
+                        active={!!selected && (selected === item.path || selected === item.related)}
+                        checked={chosen.has(item.path)}
+                        onCheck={deletable(item) ? (v) => toggle([item.path], v) : undefined}
+                        actions={actions}
+                        frozen={frozen}
+                      />
+                    ))}
+                  </ul>
+                </section>
+              );
+            })}
+          </div>
+        )}
+      </div>
+
+      {groups.length > 0 && (
+        <div className="flex items-center gap-3 border-t bg-card px-4 py-2.5">
+          <Sparkles className="size-4 shrink-0 text-muted-foreground" />
+          <p className="min-w-0 flex-1 text-xs text-muted-foreground">
+            {chosenItems.length ? (
+              <>
+                <span className="font-medium text-foreground">{plural(chosenItems.length, "item")}</span> selected · {formatBytes(chosenBytes)} · everything goes to the bin first
+              </>
+            ) : (
+              "Tick what can go — it waits in the bin for 30 days."
+            )}
+          </p>
+          <Button size="sm" variant="destructive" disabled={!chosenItems.length || frozen} onClick={() => actions.onDelete(chosenItems.map((i) => i.path))}>
+            <Trash2 /> Delete {chosenItems.length || ""}
+          </Button>
+        </div>
+      )}
+    </div>
+  );
+}
+
+function ReviewRow({
+  item,
+  active,
+  checked,
+  onCheck,
+  actions,
+  frozen,
+}: {
+  item: FileReviewItem;
+  active: boolean;
+  checked: boolean;
+  onCheck?: (on: boolean) => void;
+  actions: ReviewActions;
+  frozen: boolean;
+}) {
+  const isDir = item.type === "dir";
+  return (
+    <li className={cn("group/row flex items-start gap-2.5 rounded-md px-2.5 py-1.5 transition-colors hover:bg-accent/50", active && "bg-secondary")}>
+      <span className="mt-0.5 grid w-4 place-items-center">{onCheck ? <Checkbox aria-label={`Select ${item.path}`} checked={checked} onCheckedChange={(v) => onCheck(v === true)} /> : <FileWarning className="size-3.5 text-warning" />}</span>
+      <button type="button" onClick={() => actions.onOpen(item)} className="min-w-0 flex-1 text-left">
+        <span className="flex items-center gap-1.5">
+          <span className="shrink-0">{isDir ? <Folder className="size-4 text-muted-foreground" /> : fileIcon(item.path)}</span>
+          <span className="truncate font-mono text-xs" title={item.path}>
+            {item.path}
+          </span>
+        </span>
+        <span className="mt-0.5 block text-xs text-muted-foreground">
+          {item.detail}
+          {item.namedBy && <span className="ml-1 rounded-[4px] bg-warning/12 px-1 py-px text-[10px] font-medium text-warning">named in {item.namedBy}</span>}
+        </span>
+      </button>
+      <span className="flex shrink-0 flex-col items-end gap-1">
+        {item.bytes > 0 && (
+          <span className="text-xs text-muted-foreground tabular-nums">
+            {formatBytes(item.bytes)}
+            {isDir && item.files > 1 && <span className="text-muted-foreground/70"> · {item.files.toLocaleString()}</span>}
+          </span>
+        )}
+        {item.kind === "loose" && (
+          <Button size="xs" variant="ghost" className="h-5 opacity-0 group-hover/row:opacity-100 focus-visible:opacity-100 pointer-coarse:opacity-100" disabled={frozen} onClick={() => actions.onMove([item.path])}>
+            <FolderInput /> Move
+          </Button>
+        )}
+        {item.kind === "broken-link" && item.related && (
+          <Button size="xs" variant="ghost" className="h-5" onClick={() => actions.onOpen(item)}>
+            Open {nameOf(item.related)}
+          </Button>
+        )}
+      </span>
+    </li>
+  );
+}
diff --git a/apps/desktop/src/components/files/use-files.ts b/apps/desktop/src/components/files/use-files.ts
new file mode 100644
index 00000000..966d6862
--- /dev/null
+++ b/apps/desktop/src/components/files/use-files.ts
@@ -0,0 +1,137 @@
+import { useCallback } from "react";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { toast } from "sonner";
+import type { AgentFilesDeleteResult } from "@godmode/shared";
+import { formatBytes } from "@godmode/shared";
+import { api, errorMessage } from "@/lib/api";
+import { qk } from "@/lib/queryKeys";
+import { cloudContext, isTauri } from "@/lib/core";
+import { isMac } from "@/lib/desktop";
+import { copyText } from "@/components/chat/copy-button";
+import { nameOf } from "./file-editor";
+
+/** The core runs on this machine: its file manager can show a path. */
+export const canReveal = isTauri && !cloudContext;
+export const REVEAL_LABEL = canReveal ? (isMac ? "Show in Finder" : "Show in folder") : "Copy path";
+
+export function joinPath(dir: string, name: string) {
+  return dir ? `${dir}/${name}` : name;
+}
+
+/** tmp/ is cleared without the bin, uploads/ holds the human's attachments: nothing is made or moved there. */
+export function reservedPlace(path: string) {
+  const lower = path.toLowerCase();
+  return ["workspace/tmp", "workspace/uploads"].some((r) => lower === r || lower.startsWith(`${r}/`));
+}
+
+/** Where new entries may go and entries may be moved: inside workspace/ or memory/, not tmp/ or uploads/. */
+export function placeable(path: string) {
+  return (path.startsWith("workspace/") || path.startsWith("memory/") || path === "workspace" || path === "memory") && !reservedPlace(path);
+}
+
+/** Of what names a path, what Godmode can't rewrite on a move: the agent's instructions, automations and follow-ups. */
+export function pinsAmong(names: string[]) {
+  return names.filter((n) => /^(the instructions|the automation |a follow-up)/.test(n));
+}
+
+export function plural(n: number, one: string, many = `${one}s`) {
+  return `${n.toLocaleString()} ${n === 1 ? one : many}`;
+}
+
+/** Everything the Files page shows about an agent goes stale after a change. */
+export function useRefreshFiles(agentId: string) {
+  const qc = useQueryClient();
+  return useCallback(() => {
+    qc.invalidateQueries({ queryKey: qk.agentFilesPage(agentId) });
+    qc.invalidateQueries({ queryKey: ["agents", "files", agentId] });
+    qc.invalidateQueries({ queryKey: ["agents", "file", agentId] });
+    qc.invalidateQueries({ queryKey: qk.agentCommits(agentId) });
+    qc.invalidateQueries({ queryKey: qk.agentMemory(agentId) });
+    qc.invalidateQueries({ queryKey: qk.filesOverview });
+  }, [qc, agentId]);
+}
+
+export function useReveal(repoPath: string) {
+  return useCallback(
+    (rel: string) => {
+      const abs = rel ? `${repoPath}/${rel}` : repoPath;
+      if (!canReveal) {
+        void copyText(abs).then((ok) => ok && toast.success("Path copied"));
+        return;
+      }
+      api.files.reveal(abs).catch((err) => toast.error(`Couldn't open ${isMac ? "Finder" : "the file manager"}`, { description: errorMessage(err) }));
+    },
+    [repoPath],
+  );
+}
+
+/** Delete into the bin, with an Undo on the toast that puts everything back. */
+export function useDeleteFiles(agentId: string, onDone?: (result: AgentFilesDeleteResult) => void) {
+  const refresh = useRefreshFiles(agentId);
+  const restore = useMutation({
+    mutationFn: async (ids: string[]) => {
+      for (const id of ids) await api.agents.restoreDeleted(agentId, id);
+    },
+    onSuccess: (_, ids) => {
+      refresh();
+      toast.success(ids.length === 1 ? "Put back" : `Put ${ids.length} back`);
+    },
+    onError: (err) => {
+      refresh();
+      toast.error("Couldn't put everything back", { description: `${errorMessage(err)} — the rest is in the bin.` });
+    },
+  });
+  return useMutation({
+    mutationFn: (paths: string[]) => api.agents.deleteFiles(agentId, paths),
+    onSuccess: (result) => {
+      refresh();
+      onDone?.(result);
+      const { deleted, refused } = result;
+      if (deleted.length) {
+        const bytes = deleted.reduce((n, d) => n + d.bytes, 0);
+        toast.success(deleted.length === 1 ? `Deleted ${nameOf(deleted[0]!.path)}` : `Deleted ${deleted.length} items`, {
+          description: `${formatBytes(bytes)} moved to the bin.${refused.length ? ` ${plural(refused.length, "item")} stayed.` : ""}`,
+          action: { label: "Undo", onClick: () => restore.mutate(deleted.map((d) => d.id)) },
+        });
+      } else if (refused.length) {
+        toast.error(refused.length === 1 ? `${nameOf(refused[0]!.path)} stays` : "Nothing was deleted", { description: refused[0]!.reason });
+      }
+    },
+    onError: (err) => toast.error("Couldn't delete", { description: errorMessage(err) }),
+  });
+}
+
+/** Move or rename one entry or several, one after the other. */
+export function useMoveFiles(agentId: string, onMoved?: (moves: { from: string; to: string }[]) => void) {
+  const refresh = useRefreshFiles(agentId);
+  return useMutation({
+    mutationFn: async (moves: { from: string; to: string }[]) => {
+      const done: { from: string; to: string }[] = [];
+      const rewritten = new Set<string>();
+      try {
+        for (const m of moves) {
+          const r = await api.agents.moveFile(agentId, m.from, m.to);
+          done.push({ from: m.from, to: r.path });
+          r.rewritten.forEach((p) => rewritten.add(p));
+        }
+      } catch (err) {
+        if (done.length) onMoved?.(done);
+        throw err;
+      }
+      return { done, rewritten: [...rewritten] };
+    },
+    onSuccess: ({ done, rewritten }) => {
+      refresh();
+      onMoved?.(done);
+      const one = done.length === 1 ? done[0]! : null;
+      const renamed = one && one.from.slice(0, one.from.lastIndexOf("/")) === one.to.slice(0, one.to.lastIndexOf("/"));
+      toast.success(one ? (renamed ? `Renamed to ${nameOf(one.to)}` : `Moved ${nameOf(one.to)}`) : `Moved ${done.length} items`, {
+        description: rewritten.length ? `Updated the path in ${rewritten.join(", ")}.` : undefined,
+      });
+    },
+    onError: (err) => {
+      refresh();
+      toast.error("Couldn't move", { description: errorMessage(err) });
+    },
+  });
+}
diff --git a/apps/desktop/src/components/layout/app-shell.tsx b/apps/desktop/src/components/layout/app-shell.tsx
index 820eaead..012a5e91 100644
--- a/apps/desktop/src/components/layout/app-shell.tsx
+++ b/apps/desktop/src/components/layout/app-shell.tsx
@@ -10,6 +10,7 @@ import {
   ChevronRight,
   CreditCard,
   Fingerprint,
+  FolderOpen,
   Globe,
   MonitorUp,
   Inbox,
@@ -191,6 +192,7 @@ export function AppShell({ children }: { children: ReactNode }) {
     { to: "/my-tasks", label: "My tasks", icon: <ListTodo />, badge: myTasks || undefined },
     { to: "/tasks", label: "Tasks", icon: <SquareKanban />, badge: (attention?.review ?? 0) + (attention?.blocked ?? 0) || undefined },
     { to: "/agents", label: "Agents", icon: <Bot />, badge: runningCount || undefined },
+    { to: "/files", label: "Files", icon: <FolderOpen /> },
     { to: "/automations", label: "Automations", icon: <Workflow />, badge: attention?.automation || undefined },
     { to: "/activity", label: "Activity", icon: <Activity /> },
     { to: "/calls", label: "Calls", icon: <Phone /> },
@@ -225,6 +227,7 @@ export function AppShell({ children }: { children: ReactNode }) {
     easyItem("/integrations", "Connected apps"),
   ];
   const easyMore: NavItem[] = [
+    easyItem("/files", "Files"),
     easyItem("/activity", "History"),
     easyItem("/calls", "Phone calls"),
     easyItem("/messaging", "Chat apps"),
diff --git a/apps/desktop/src/components/layout/command-palette.tsx b/apps/desktop/src/components/layout/command-palette.tsx
index 38f987a5..32f1763b 100644
--- a/apps/desktop/src/components/layout/command-palette.tsx
+++ b/apps/desktop/src/components/layout/command-palette.tsx
@@ -12,6 +12,7 @@ import {
   BrainCircuit,
   Cloud,
   CreditCard,
+  FolderOpen,
   DatabaseBackup,
   Gauge,
   Globe,
@@ -350,6 +351,9 @@ export function CommandPalette() {
           <CommandItem value="plugins claude code mods skills hooks guardrails github install" keywords={alias("/plugins", "Plugins")} onSelect={() => go("/plugins")}>
             <Puzzle /> {named("/plugins", "Plugins")}
           </CommandItem>
+          <CommandItem value="files workspace notes memory cleanup tidy delete" keywords={alias("/files", "Files")} onSelect={() => go("/files")}>
+            <FolderOpen /> {named("/files", "Files")}
+          </CommandItem>
           <CommandItem keywords={alias("/activity", "Activity")} onSelect={() => go("/activity")}>
             <Activity /> {named("/activity", "Activity")}
           </CommandItem>
diff --git a/apps/desktop/src/components/settings/cleanup-items.tsx b/apps/desktop/src/components/settings/cleanup-items.tsx
index 6bafb24f..ad94edaa 100644
--- a/apps/desktop/src/components/settings/cleanup-items.tsx
+++ b/apps/desktop/src/components/settings/cleanup-items.tsx
@@ -19,6 +19,7 @@ import {
   Lock,
   Logs,
   ScrollText,
+  FolderX,
   Trash2,
 } from "lucide-react";
 import { toast } from "sonner";
@@ -57,6 +58,7 @@ const ICONS: Record<CleanupId, ComponentType<{ className?: string }>> = {
   "agent-scratch": FolderClock,
   "agent-run-logs": Logs,
   "agent-history": Archive,
+  "deleted-files": FolderX,
 };
 
 const cleanable = (i: CleanupItem) => i.count > 0 && !i.blocked;
diff --git a/apps/desktop/src/components/settings/cleanup-section.tsx b/apps/desktop/src/components/settings/cleanup-section.tsx
index 990029ca..7b39c209 100644
--- a/apps/desktop/src/components/settings/cleanup-section.tsx
+++ b/apps/desktop/src/components/settings/cleanup-section.tsx
@@ -2,7 +2,7 @@ import type { ReactNode } from "react";
 import { useMutation, useQuery, useQueryClient, type UseMutationResult } from "@tanstack/react-query";
 import { formatDistanceToNow } from "date-fns";
 import { motion } from "motion/react";
-import { ArrowDown, ArrowUpRight, BroomSparkles, CalendarClock, CircleAlert, CircleArrowDown, CircleCheck, CircleX, HardDrive, RefreshCw, Stethoscope } from "lucide-react";
+import { ArrowDown, ArrowUpRight, BroomSparkles, CalendarClock, CircleAlert, CircleArrowDown, CircleCheck, CircleX, FolderOpen, HardDrive, RefreshCw, Stethoscope } from "lucide-react";
 import { Link } from "react-router";
 import { toast } from "sonner";
 import type { CleanupReport, HealthCheck, Settings, StorageArea } from "@godmode/shared";
@@ -62,6 +62,15 @@ export function CleanupSection({ settings }: { settings: Settings | undefined })
       )}
       <SelfCheck report={report.data} failed={report.isError} rescan={rescan} />
       {report.data ? <CleanupItems report={report.data} refreshing={scanning} /> : !report.isError && <ItemsSkeleton />}
+      <SettingsGroup title="Agents' files" description="Look through each agent's workspace, notes and memory yourself: what takes space, copies, junk and notes nothing links to." icon={<FolderOpen />}>
+        <SettingRow label="Files" description="Rename, move and delete by hand. Deleted files wait 30 days in the agent's bin.">
+          <Button asChild size="sm" variant="outline">
+            <Link to="/files">
+              Open Files <ArrowUpRight />
+            </Link>
+          </Button>
+        </SettingRow>
+      </SettingsGroup>
       {settings && <AutoCleanup settings={settings} />}
     </div>
   );
diff --git a/apps/desktop/src/lib/api.ts b/apps/desktop/src/lib/api.ts
index 2d00fa5e..035af15d 100644
--- a/apps/desktop/src/lib/api.ts
+++ b/apps/desktop/src/lib/api.ts
@@ -22,6 +22,16 @@ import type { DeviceGroup, DeviceGroupPatch, DeviceInvite, HandoffInput, Handoff
   SpendReport,
   Agent,
   AgentFileEntry,
+  AgentFileInfo,
+  AgentFileMoveResult,
+  AgentFileRestoreResult,
+  AgentFileSearchHit,
+  AgentFileSize,
+  AgentFilesDeleteResult,
+  AgentFilesOverview,
+  AgentNote,
+  DeletedAgentFile,
+  FileReview,
   AgentMemory,
   AgentHeartbeatState,
   AgentInput,
@@ -561,7 +571,24 @@ export const api = {
     run: (id: string, prompt?: string, workspaceId?: string) => post<StartChatResult>(`/api/agents/${id}/run`, { prompt, workspaceId }),
     files: (id: string, path = "") => get<AgentFileEntry[]>(`/api/agents/${id}/files`, { path }),
     readFile: (id: string, path: string) => get<{ path: string; content: string }>(`/api/agents/${id}/file`, { path }),
-    writeFile: (id: string, path: string, content: string) => put<{ ok: true }>(`/api/agents/${id}/file`, { path, content }),
+    /** `create`: only a new file (409 when one is there). */
+    writeFile: (id: string, path: string, content: string, create?: boolean) => put<{ ok: true }>(`/api/agents/${id}/file`, { path, content, ...(create ? { create } : {}) }),
+    /** Sizes of what lies directly in a folder (every file below counted). */
+    fileSizes: (id: string, path = "") => get<AgentFileSize[]>(`/api/agents/${id}/files/sizes`, { path }),
+    /** Size, what names them and whether they may go, before a move or delete. */
+    inspectFiles: (id: string, paths: string[]) => post<AgentFileInfo[]>(`/api/agents/${id}/files/inspect`, { paths }),
+    fileReview: (id: string, fresh = false) => get<FileReview>(`/api/agents/${id}/files/review`, fresh ? { fresh: "1" } : undefined),
+    notes: (id: string) => get<AgentNote[]>(`/api/agents/${id}/files/notes`),
+    searchFiles: (id: string, q: string) => get<AgentFileSearchHit[]>(`/api/agents/${id}/files/search`, { q }),
+    createFolder: (id: string, path: string) => post<{ path: string }>(`/api/agents/${id}/files/folder`, { path }),
+    /** Rename or move inside workspace/ or memory/; mentions in the memory follow. */
+    moveFile: (id: string, from: string, to: string) => post<AgentFileMoveResult>(`/api/agents/${id}/files/move`, { from, to }),
+    /** Into the agent's bin, from where they can be put back. */
+    deleteFiles: (id: string, paths: string[]) => post<AgentFilesDeleteResult>(`/api/agents/${id}/files/delete`, { paths }),
+    deletedFiles: (id: string) => get<DeletedAgentFile[]>(`/api/agents/${id}/files/deleted`),
+    restoreDeleted: (id: string, entryId: string) => post<AgentFileRestoreResult>(`/api/agents/${id}/files/deleted/${entryId}/restore`),
+    purgeDeleted: (id: string, entryId: string) => del<{ removed: number; bytes: number }>(`/api/agents/${id}/files/deleted/${entryId}`),
+    emptyBin: (id: string) => del<{ removed: number; bytes: number }>(`/api/agents/${id}/files/deleted`),
     commits: (id: string) => get<GitCommit[]>(`/api/agents/${id}/commits`),
     /** MEMORY.md with its size budget and the notes under memory/ it can link to. */
     memory: (id: string) => get<AgentMemory>(`/api/agents/${id}/memory`),
@@ -861,6 +888,8 @@ export const api = {
     resolve: (conversationId: string, messages: string[][]) => post<ChatFiles>(`/api/conversations/${conversationId}/files`, { messages }),
     /** Show a file or folder in the file manager; refused unless the app runs on the core's machine. */
     reveal: (path: string) => post<{ ok: true }>("/api/files/reveal", { path }),
+    /** Per agent: what its files take, its notes and memory length (Files page). */
+    overview: () => get<AgentFilesOverview[]>("/api/files/overview"),
   },
 
   runs: {
diff --git a/apps/desktop/src/lib/mode.ts b/apps/desktop/src/lib/mode.ts
index 5a497bcc..ffd8c798 100644
--- a/apps/desktop/src/lib/mode.ts
+++ b/apps/desktop/src/lib/mode.ts
@@ -23,6 +23,7 @@ export const EASY_PAGES: Record<string, { title?: string; description?: string }
   "/my-tasks": { title: "My to-dos" },
   "/tasks": { title: "Task board" },
   "/automations": { description: "Let your agents start work by themselves: on a schedule, or when something happens in your apps." },
+  "/files": { description: "What your agents keep: their files, notes and memory. Look through it, tidy it up, and put back what you deleted." },
   "/activity": { title: "History", description: "Everything your agents did." },
   "/calls": { title: "Phone calls" },
   "/plugins": { title: "Add-ons", description: "Extra skills for your agents. Add one, switch it off or remove it any time." },
diff --git a/apps/desktop/src/lib/queryKeys.ts b/apps/desktop/src/lib/queryKeys.ts
index a78dbe55..093ef777 100644
--- a/apps/desktop/src/lib/queryKeys.ts
+++ b/apps/desktop/src/lib/queryKeys.ts
@@ -48,6 +48,13 @@ export const qk = {
   agentMemory: (id: string) => ["agents", "memory", id],
   agentCommitsAll: ["agents", "commits"] as unknown[],
   agentCommits: (id: string) => ["agents", "commits", id],
+  filesOverview: ["files", "overview"] as unknown[],
+  agentFilesPage: (id: string) => ["files", id],
+  agentFileSizes: (id: string, path: string) => ["files", id, "sizes", path],
+  agentFileReview: (id: string) => ["files", id, "review"],
+  agentNotes: (id: string) => ["files", id, "notes"],
+  agentFileSearch: (id: string, q: string) => ["files", id, "search", q],
+  agentBin: (id: string) => ["files", id, "bin"],
   agentCommands: (id: string) => ["agents", "commands", id],
   agentTemplates: ["agent-templates"] as unknown[],
   teamTemplates: ["team-templates"] as unknown[],
diff --git a/apps/desktop/src/pages/files/files-page.tsx b/apps/desktop/src/pages/files/files-page.tsx
new file mode 100644
index 00000000..7417dba7
--- /dev/null
+++ b/apps/desktop/src/pages/files/files-page.tsx
@@ -0,0 +1,337 @@
+import { useCallback, useMemo, useState } from "react";
+import { Link, useNavigate, useParams, useSearchParams } from "react-router";
+import { useQuery } from "@tanstack/react-query";
+import { ArrowLeft, FolderOpen, HardDriveDownload, Moon } from "lucide-react";
+import type { Agent, FileReviewItem } from "@godmode/shared";
+import { api } from "@/lib/api";
+import { useAgents, useAllAgents } from "@/lib/hooks";
+import { qk } from "@/lib/queryKeys";
+import { useAgentRunning } from "@/stores/live";
+import { cn } from "@/lib/utils";
+import { AgentAvatar, EmptyState, PageBody, PageHeader } from "@/components/common";
+import { Button } from "@/components/ui/button";
+import { Skeleton } from "@/components/ui/skeleton";
+import { Tabs, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { useDreamingNow } from "@/components/agents/detail/dreams-panel";
+import { BrowsePane } from "@/components/files/browse-pane";
+import { BinPane, useBin } from "@/components/files/bin-pane";
+import { DetailPane } from "@/components/files/detail-pane";
+import { DeleteDialog, MoveDialog, NameDialog, type NameDialogMode } from "@/components/files/dialogs";
+import { NOTE_FILE, parentOf } from "@/components/files/file-editor";
+import { NotesPane } from "@/components/files/notes-pane";
+import { FilesOverview } from "@/components/files/overview";
+import { ReviewPane, useFileReview } from "@/components/files/review-pane";
+import { useRefreshFiles, useReveal } from "@/components/files/use-files";
+
+type Tab = "browse" | "notes" | "review" | "bin";
+const TABS: Tab[] = ["browse", "notes", "review", "bin"];
+
+const DESCRIPTION = "Look through what your agents keep — their workspace, notes and memory — and clean it up. Deleted files wait 30 days in a bin.";
+
+export default function FilesPage() {
+  const { agentId } = useParams();
+  const scoped = useAgents();
+  const everyone = useAllAgents();
+  const agent = everyone.data?.find((a) => a.id === agentId) ?? scoped.data?.find((a) => a.id === agentId);
+
+  if (!agentId) {
+    return (
+      <>
+        <PageHeader title="Files" description={DESCRIPTION} icon={<FolderOpen />} actions={<CleanupLink />} />
+        <PageBody>{scoped.isLoading ? <OverviewSkeleton /> : <FilesOverview agents={scoped.data ?? []} />}</PageBody>
+      </>
+    );
+  }
+  if (everyone.isLoading) {
+    return (
+      <>
+        <PageHeader title="Files" icon={<FolderOpen />} />
+        <PageBody>
+          <Skeleton className="h-[28rem] rounded-xl" />
+        </PageBody>
+      </>
+    );
+  }
+  if (!agent) {
+    return (
+      <>
+        <PageHeader title="Files" icon={<FolderOpen />} />
+        <PageBody>
+          <EmptyState icon={<FolderOpen />} title="This agent doesn't exist anymore" action={<Button asChild variant="outline"><Link to="/files">All agents</Link></Button>} />
+        </PageBody>
+      </>
+    );
+  }
+  return <AgentFiles key={agent.id} agent={agent} agents={everyone.data ?? []} />;
+}
+
+function CleanupLink() {
+  return (
+    <Button asChild variant="outline" size="sm">
+      <Link to="/settings/cleanup">
+        <HardDriveDownload /> Cleanup settings
+      </Link>
+    </Button>
+  );
+}
+
+function OverviewSkeleton() {
+  return (
+    <div className="grid grid-cols-1 gap-3 @2xl:grid-cols-2 @5xl:grid-cols-3">
+      {Array.from({ length: 6 }, (_, i) => (
+        <Skeleton key={i} className="h-36 rounded-xl" />
+      ))}
+    </div>
+  );
+}
+
+function AgentPicker({ agent, agents, onPick }: { agent: Agent; agents: Agent[]; onPick: (id: string) => void }) {
+  const sorted = useMemo(() => [...agents].sort((a, b) => Number(b.isDefault) - Number(a.isDefault) || a.name.localeCompare(b.name)), [agents]);
+  return (
+    <Select value={agent.id} onValueChange={onPick}>
+      <SelectTrigger className="h-9 w-64 bg-card" aria-label="Agent">
+        <SelectValue />
+      </SelectTrigger>
+      <SelectContent className="max-h-80">
+        {sorted.map((a) => (
+          <SelectItem key={a.id} value={a.id}>
+            <span className="flex items-center gap-2">
+              <AgentAvatar agent={a} size="sm" still />
+              <span className="truncate">{a.name}</span>
+            </span>
+          </SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  );
+}
+
+function AgentFiles({ agent, agents }: { agent: Agent; agents: Agent[] }) {
+  const navigate = useNavigate();
+  const [params, setParams] = useSearchParams();
+  const tab = (TABS.find((t) => t === params.get("tab")) ?? "browse") as Tab;
+  const dir = params.get("dir") ?? "workspace";
+  const filePath = params.get("file");
+  const [fileSize, setFileSize] = useState(0);
+  const file = filePath ? { path: filePath, size: fileSize } : null;
+  const [dirty, setDirty] = useState(false);
+  const [pending, setPending] = useState<(() => void) | null>(null);
+  const [deleting, setDeleting] = useState<string[] | null>(null);
+  const [moving, setMoving] = useState<string[] | null>(null);
+  const [naming, setNaming] = useState<NameDialogMode | null>(null);
+  const dreaming = useDreamingNow(agent.id);
+  const working = useAgentRunning(agent.id);
+  const refresh = useRefreshFiles(agent.id);
+  const reveal = useReveal(agent.repoPath);
+  const review = useFileReview(agent.id);
+  const bin = useBin(agent.id);
+  const namingDir = naming ? (naming.kind === "rename" ? parentOf(naming.path) : naming.dir) : dir;
+  const listing = useQuery({ queryKey: qk.agentFiles(agent.id, namingDir), queryFn: () => api.agents.files(agent.id, namingDir), enabled: !!naming });
+  const siblings = listing.data ? listing.data.map((e) => e.path.slice(e.path.lastIndexOf("/") + 1)) : null;
+  const reviewCount = review.data?.items.length ?? 0;
+  const binCount = bin.data?.length ?? 0;
+
+  const update = useCallback(
+    (next: Partial<Record<"tab" | "dir" | "file", string | null>>, replace = true) =>
+      setParams(
+        (p) => {
+          const q = new URLSearchParams(p);
+          for (const [k, v] of Object.entries(next)) {
+            if (v === null || v === undefined || (k === "tab" && v === "browse") || (k === "dir" && v === "workspace")) q.delete(k);
+            else q.set(k, v);
+          }
+          return q;
+        },
+        { replace },
+      ),
+    [setParams],
+  );
+
+  /** Leave unsaved edits only after asking. */
+  const guard = (go: () => void) => (dirty ? setPending(() => go) : go());
+  /** Open a file (and the folder it lies in, in the same URL change: two changes in one tick would undo each other). */
+  const openFile = (path: string, size = 0, inDir?: string) =>
+    guard(() => {
+      setFileSize(size);
+      update(inDir === undefined ? { file: path } : { file: path, dir: inDir });
+    });
+  const affectsOpenFile = (paths: string[]) => !!filePath && paths.some((p) => filePath === p || filePath.startsWith(`${p}/`));
+  /** Rename, move or delete of the open file: its unsaved edits would be lost, so ask first. */
+  const guardOpen = (paths: string[], go: () => void) => (affectsOpenFile(paths) ? guard(go) : go());
+  const setTab = (t: Tab) => update({ tab: t }, false);
+  const setDir = (d: string) => update({ dir: d }, false);
+
+  const afterDelete = (paths: string[]) => {
+    const patch: Partial<Record<"dir" | "file", string | null>> = {};
+    if (affectsOpenFile(paths)) {
+      setDirty(false);
+      patch.file = null;
+    }
+    const gone = paths.find((p) => dir === p || dir.startsWith(`${p}/`));
+    if (gone !== undefined) patch.dir = parentOf(gone) || "workspace";
+    if (Object.keys(patch).length) update(patch);
+  };
+  const afterMove = (moves: { from: string; to: string }[]) => {
+    const patch: Partial<Record<"dir" | "file", string | null>> = {};
+    for (const m of moves) {
+      if (filePath === m.from) patch.file = m.to;
+      else if (filePath?.startsWith(`${m.from}/`)) patch.file = `${m.to}${filePath.slice(m.from.length)}`;
+      if (dir === m.from || dir.startsWith(`${m.from}/`)) patch.dir = `${m.to}${dir.slice(m.from.length)}`;
+    }
+    if (Object.keys(patch).length) {
+      if (patch.file !== undefined) setDirty(false);
+      update(patch);
+    }
+  };
+
+  const fileActions = {
+    onRename: (path: string) => guardOpen([path], () => setNaming({ kind: "rename", path })),
+    onMove: (paths: string[]) => guardOpen(paths, () => setMoving(paths)),
+    onDelete: (paths: string[]) => guardOpen(paths, () => setDeleting(paths)),
+    onReveal: reveal,
+    onOpenFile: (path: string) => openFile(path),
+    onSaved: () => refresh(),
+  };
+  const openReviewItem = (item: FileReviewItem) => {
+    if (item.kind === "broken-link" && item.related) return openFile(item.related);
+    if (item.type === "dir") {
+      guard(() => update({ tab: null, dir: item.path, file: null }));
+      return;
+    }
+    openFile(item.path, item.bytes);
+  };
+
+  return (
+    <>
+      <PageHeader
+        title="Files"
+        description={DESCRIPTION}
+        icon={<FolderOpen />}
+        actions={
+          <>
+            <Button variant="ghost" size="sm" onClick={() => guard(() => navigate("/files"))}>
+              <ArrowLeft /> All agents
+            </Button>
+            <AgentPicker agent={agent} agents={agents} onPick={(id) => guard(() => navigate(`/files/${id}`))} />
+          </>
+        }
+      />
+      <PageBody className="space-y-3">
+        <div className="flex flex-wrap items-center gap-3">
+          <Tabs value={tab} onValueChange={(v) => guard(() => setTab(v as Tab))}>
+            <TabsList>
+              <TabsTrigger value="browse" className="px-3">
+                Browse
+              </TabsTrigger>
+              <TabsTrigger value="notes" className="px-3">
+                Notes
+              </TabsTrigger>
+              <TabsTrigger value="review" className="gap-1.5 px-3">
+                Review
+                {reviewCount > 0 && <span className="rounded-[4px] bg-warning/12 px-1.5 font-mono text-[10px] font-medium text-warning tabular-nums">{reviewCount}</span>}
+              </TabsTrigger>
+              <TabsTrigger value="bin" className="gap-1.5 px-3">
+                Bin
+                {binCount > 0 && <span className="rounded-[4px] bg-foreground/[0.06] px-1.5 font-mono text-[10px] text-muted-foreground tabular-nums">{binCount}</span>}
+              </TabsTrigger>
+            </TabsList>
+          </Tabs>
+          {dreaming ? (
+            <p className="flex items-center gap-1.5 rounded-md bg-dream-soft px-2.5 py-1 text-xs text-muted-foreground" role="status">
+              <Moon className="size-3.5 text-dream" /> {agent.name} is dreaming — moves and deletes wait until the dream has ended.
+            </p>
+          ) : working ? (
+            <p className="flex items-center gap-1.5 rounded-md bg-warning/[0.08] px-2.5 py-1 text-xs text-muted-foreground" role="status">
+              <span className="size-1.5 animate-pulse rounded-full bg-warning" /> {agent.name} is working right now and may still use files here.
+            </p>
+          ) : null}
+        </div>
+
+        <div className={cn("grid h-[calc(100svh-15rem)] min-h-[30rem] gap-4", tab === "bin" ? "grid-cols-1" : "grid-cols-1 @4xl:grid-cols-[minmax(340px,5fr)_minmax(0,7fr)]")}>
+          <section className={cn("min-h-0 overflow-hidden rounded-xl border bg-card shadow-card", file && tab !== "bin" && "@max-4xl:hidden")}>
+            {tab === "browse" && (
+              <BrowsePane
+                agent={agent}
+                dir={dir}
+                onDir={(d) => setDir(d)}
+                selected={filePath}
+                onSelect={(e, inDir) => openFile(e.path, e.size, inDir)}
+                frozen={dreaming}
+                actions={{ ...fileActions, onNew: (kind, d) => setNaming({ kind, dir: d }) }}
+              />
+            )}
+            {tab === "notes" && <NotesPane agent={agent} selected={filePath} onSelect={(n) => openFile(n.path, n.bytes)} />}
+            {tab === "review" && <ReviewPane agent={agent} selected={filePath} frozen={dreaming} actions={{ onOpen: openReviewItem, onDelete: fileActions.onDelete, onMove: fileActions.onMove }} />}
+            {tab === "bin" && <BinPane agent={agent} frozen={dreaming} />}
+          </section>
+          {tab !== "bin" && (
+            <section className={cn("flex min-h-0 min-w-0 flex-col overflow-hidden rounded-xl border bg-card shadow-card", !file && "@max-4xl:hidden")}>
+              {file && (
+                <button type="button" onClick={() => guard(() => update({ file: null }))} className="flex items-center gap-1.5 border-b px-3 py-2 text-xs text-muted-foreground hover:text-foreground @4xl:hidden">
+                  <ArrowLeft className="size-3.5" /> Back to the list
+                </button>
+              )}
+              <div className="min-h-0 flex-1">
+                <DetailPane
+                  agent={agent}
+                  file={file}
+                  dreaming={dreaming}
+                  frozen={dreaming}
+                  defaultView={tab === "notes" || (file && NOTE_FILE.test(file.path) && tab === "review") ? "preview" : "edit"}
+                  onDirtyChange={setDirty}
+                  actions={fileActions}
+                />
+              </div>
+            </section>
+          )}
+        </div>
+      </PageBody>
+
+      <DeleteDialog agentId={agent.id} agentName={agent.name} paths={deleting} onClose={() => setDeleting(null)} onDeleted={afterDelete} />
+      <MoveDialog agentId={agent.id} paths={moving} onClose={() => setMoving(null)} onMoved={afterMove} />
+      <NameDialog
+        agentId={agent.id}
+        mode={naming}
+        siblings={siblings}
+        onClose={() => setNaming(null)}
+        onRenamed={(from, to) => afterMove([{ from, to }])}
+        onCreated={(path, kind) => {
+          refresh();
+          if (kind === "note") openFile(path);
+        }}
+      />
+      <AlertDialog open={!!pending} onOpenChange={(o) => !o && setPending(null)}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>Discard unsaved changes?</AlertDialogTitle>
+            <AlertDialogDescription>Your edits to {filePath} haven't been saved.</AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>Keep editing</AlertDialogCancel>
+            <AlertDialogAction
+              variant="destructive"
+              onClick={() => {
+                setDirty(false);
+                pending?.();
+                setPending(null);
+              }}
+            >
+              Discard
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </>
+  );
+}
diff --git a/docs/screenshots/files-page/bin.png b/docs/screenshots/files-page/bin.png
new file mode 100644
index 00000000..c9dea6f1
Binary files /dev/null and b/docs/screenshots/files-page/bin.png differ
diff --git a/docs/screenshots/files-page/browse.png b/docs/screenshots/files-page/browse.png
new file mode 100644
index 00000000..524f69a5
Binary files /dev/null and b/docs/screenshots/files-page/browse.png differ
diff --git a/docs/screenshots/files-page/delete.png b/docs/screenshots/files-page/delete.png
new file mode 100644
index 00000000..75a00250
Binary files /dev/null and b/docs/screenshots/files-page/delete.png differ
diff --git a/docs/screenshots/files-page/notes.png b/docs/screenshots/files-page/notes.png
new file mode 100644
index 00000000..9d3256b5
Binary files /dev/null and b/docs/screenshots/files-page/notes.png differ
diff --git a/docs/screenshots/files-page/overview.png b/docs/screenshots/files-page/overview.png
new file mode 100644
index 00000000..a4505877
Binary files /dev/null and b/docs/screenshots/files-page/overview.png differ
diff --git a/docs/screenshots/files-page/review-dark.png b/docs/screenshots/files-page/review-dark.png
new file mode 100644
index 00000000..751c2ae0
Binary files /dev/null and b/docs/screenshots/files-page/review-dark.png differ
diff --git a/docs/screenshots/files-page/review.png b/docs/screenshots/files-page/review.png
new file mode 100644
index 00000000..0593877f
Binary files /dev/null and b/docs/screenshots/files-page/review.png differ
diff --git a/docs/screenshots/files-page/split-editor.png b/docs/screenshots/files-page/split-editor.png
new file mode 100644
index 00000000..7112632f
Binary files /dev/null and b/docs/screenshots/files-page/split-editor.png differ
diff --git a/packages/core/src/agents/files.ts b/packages/core/src/agents/files.ts
new file mode 100644
index 00000000..fd924cc5
--- /dev/null
+++ b/packages/core/src/agents/files.ts
@@ -0,0 +1,1064 @@
+/**
+ * The Files page: the human looks through an agent's repository and tidies it by hand — folder sizes, the agent's
+ * notes, a search, a review of what clutters it (build output, junk, empty entries, copies, large files, stale and
+ * unsorted entries, memory notes nothing links to), new folders, moves and deletes.
+ *
+ * A delete goes into the agent's bin (`<agents>/.deleted-files/<agent>/<entry>/`), where it waits to be put back until
+ * the automatic cleanup removes what is older than DELETED_DAYS (services/cleanup.ts). A move points the agent's memory
+ * at the new place. Godmode's own files stay where they are (lockReason), nothing moves while the agent dreams (the
+ * dream's rollback and undo would lose track of it), symlinks are never followed, and every change is committed.
+ */
+import { createHash, randomBytes } from "node:crypto";
+import { createReadStream, existsSync, lstatSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { cp, lstat, mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, relative } from "node:path";
+import type {
+  Agent,
+  AgentFileInfo,
+  AgentFileMoveResult,
+  AgentFileRestoreResult,
+  AgentFileSearchHit,
+  AgentFileSize,
+  AgentFilesDeleteResult,
+  AgentFilesOverview,
+  AgentNote,
+  DeletedAgentFile,
+  FileReview,
+  FileReviewItem,
+  FileReviewKind,
+} from "@godmode/shared";
+import { formatBytes } from "@godmode/shared";
+import { config } from "../config";
+import { all } from "../db";
+import { isDreaming } from "../memory/dreaming";
+import { memoryTopics } from "../memory/editor";
+import { MEMORY_DIR, MEMORY_FILE, canRestore, memoryChars, snapshotMemory } from "../memory/files";
+import { listNotes, namesOf, noteTitle, WORKSPACE_DIR } from "../memory/workspace";
+import { HttpError, badRequest, conflict, notFound, now } from "../util";
+import { AGENT_REPO_DIRS } from "./claudeMd";
+import { commitAllInLock, resolveRepoPath, withRepoLock } from "./repo";
+import { withRepo } from "./service";
+
+const BIN = ".deleted-files";
+/** What the human deleted waits this long in the agent's bin, then the automatic cleanup removes it. */
+export const DELETED_DAYS = 30;
+const DAY = 86_400_000;
+/** Entries one size count visits at most (a folder with more counts as "at least"). */
+const COUNT_BUDGET = 400_000;
+const REVIEW_BUDGET = 250_000;
+/** Entries one item of the review counts at most (its own budget, so one huge folder doesn't starve the rest). */
+const ITEM_BUDGET = 200_000;
+/** A fresh review (it hashes files) at most this often per agent. */
+const FRESH_MS = 10_000;
+const SEARCH_BUDGET = 80_000;
+const SEARCH_LIMIT = 100;
+const SEARCH_READ_MAX = 512 * 1024;
+const LARGE = 25 * 1024 * 1024;
+const LARGE_SCRATCH = 50 * 1024 * 1024;
+const STALE_DAYS = 30;
+const RECENT_DAYS = 3;
+const HASH_MIN = 1024;
+const HASH_MAX_FILE = 1024 * 1024 * 1024;
+const HASH_BUDGET = 2 * 1024 * 1024 * 1024;
+const KIND_LIMIT = 200;
+const MAX_PATHS = 500;
+const CACHE_MS = 30_000;
+
+const SCRATCH = `${WORKSPACE_DIR}/tmp`;
+const UPLOADS = `${WORKSPACE_DIR}/uploads`;
+
+/** Installed packages and caches: installing or building again brings them back. */
+const BUILD = new Set([
+  "node_modules",
+  ".venv",
+  "venv",
+  "__pycache__",
+  "Pods",
+  "DerivedData",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  ".gradle",
+  ".pytest_cache",
+  ".parcel-cache",
+  ".svelte-kit",
+  ".dart_tool",
+  ".expo",
+]);
+/** Build output, when it lies next to a project file. */
+const OUTPUT = new Set(["build", "dist", "out", "target", ".build"]);
+const PROJECT_FILES = ["package.json", "build.gradle", "build.gradle.kts", "pubspec.yaml", "Cargo.toml", "pyproject.toml", "setup.py", "Package.swift", "pom.xml", "Podfile"];
+const JUNK = /^(\.DS_Store|Thumbs\.db|desktop\.ini|npm-debug\.log.*|yarn-error\.log|~\$.*|\.~lock\..*#)$|\.(log|tmp|temp|bak|swp|crdownload|part)$/i;
+/** Downloads and temporary files that may still be written to. */
+const IN_PROGRESS = /\.(crdownload|part|tmp|temp|swp)$/i;
+const IN_PROGRESS_MS = 6 * 60 * 60_000;
+const TEXT = /\.(md|markdown|txt|json|jsonl|csv|tsv|ya?ml|toml|html?|css|xml|sh|py|m?js|ts|tsx|jsx|sql|env\.example)$/i;
+const NOTE = /\.(md|markdown)$/i;
+const ROOT_KNOWN = new Set([MEMORY_FILE, "CLAUDE.md", ".gitignore", ...AGENT_REPO_DIRS]);
+
+/* ------------------------------------------------------------------ */
+/* What stays put                                                       */
+/* ------------------------------------------------------------------ */
+
+const FIXED: Record<string, string> = {
+  "": "The agent's repository itself.",
+  [MEMORY_FILE]: "The agent's memory: edit it here, but it stays.",
+  "CLAUDE.md": "Written from the agent's settings — change them in its Settings tab.",
+  ".gitignore": "Keeps scratch files and run logs out of the agent's history.",
+  [WORKSPACE_DIR]: "Every agent has this folder.",
+  [MEMORY_DIR]: "Every agent has this folder.",
+  [SCRATCH]: "Godmode's scratch folder: what lies in it goes by itself a week after its last change.",
+  [UPLOADS]: "Where the files you attach in chats land.",
+};
+const GODMODE_DIRS: Record<string, string> = {
+  conversations: "Chat transcripts are written by Godmode.",
+  runs: "Run logs are written by Godmode — Settings → Cleanup removes the old ones.",
+  state: "A snapshot of the agent's settings, written by Godmode.",
+};
+
+const FIXED_LOWER = new Map(Object.entries(FIXED).map(([k, v]) => [k.toLowerCase(), v]));
+
+/**
+ * Why `rel` can't be moved or deleted on the Files page (null = it can). Compared without case: on macOS `memory.md`
+ * is MEMORY.md.
+ */
+export function lockReason(rel: string): string | null {
+  const lower = rel.toLowerCase();
+  const fixed = FIXED_LOWER.get(lower);
+  if (fixed) return fixed;
+  const parts = lower.split("/");
+  if (parts.length === 2 && parts[1] === ".gitkeep" && (AGENT_REPO_DIRS as readonly string[]).includes(parts[0]!)) return "Keeps the folder in the agent's history.";
+  return GODMODE_DIRS[parts[0]!] ?? null;
+}
+
+/** tmp/ is cleared without the bin, uploads/ holds the human's attachments: nothing is moved or made there. */
+function reservedPlace(rel: string): boolean {
+  const lower = rel.toLowerCase();
+  return [SCRATCH, UPLOADS].some((r) => lower === r || lower.startsWith(`${r}/`));
+}
+
+/** Where moved entries and new folders may go: inside workspace/ or memory/, not into tmp/ or uploads/. */
+function placeable(rel: string): boolean {
+  return (rel.startsWith(`${WORKSPACE_DIR}/`) || rel.startsWith(`${MEMORY_DIR}/`)) && !reservedPlace(rel);
+}
+
+/** A top folder of the repository that is a real folder (not a link to somewhere else). */
+function realDir(root: string, rel: string): boolean {
+  return entryOf(root, rel)?.isDirectory() ?? false;
+}
+
+/** No symlink on the way from the repository down to `rel` (with `self`, the entry itself neither). */
+function noLink(root: string, rel: string, self = true): boolean {
+  const parts = rel ? rel.split("/") : [];
+  let probe = root;
+  for (let i = 0; i < parts.length; i++) {
+    probe = join(probe, parts[i]!);
+    if (i === parts.length - 1 && !self) break;
+    try {
+      if (lstatSync(probe).isSymbolicLink()) return false;
+    } catch {
+      return true;
+    }
+  }
+  return true;
+}
+
+function entryOf(root: string, rel: string) {
+  try {
+    return lstatSync(join(root, rel));
+  } catch {
+    return null;
+  }
+}
+
+/** A path of the repository as the human sent it, confined to it ("" = the repository itself). */
+function repoPath(agent: Agent, input: string): string {
+  return resolveRepoPath(agent.repoPath, input).rel;
+}
+
+/** Checked before waiting for the repository and again once it is ours: a dream may have started meanwhile. */
+function refuseWhileDreaming(agent: Agent) {
+  if (isDreaming(agent.id)) {
+    throw conflict(`${agent.name} is dreaming (tidying its memory and workspace) right now — try again when the dream has ended.`);
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/* Sizes                                                                */
+/* ------------------------------------------------------------------ */
+
+interface Tally {
+  bytes: number;
+  files: number;
+  modified: number;
+  partial: boolean;
+}
+
+const NONE: Tally = { bytes: 0, files: 0, modified: 0, partial: false };
+
+function add(a: Tally, b: Tally): Tally {
+  return { bytes: a.bytes + b.bytes, files: a.files + b.files, modified: Math.max(a.modified, b.modified), partial: a.partial || b.partial };
+}
+
+function limiter(max: number) {
+  let active = 0;
+  const waiting: (() => void)[] = [];
+  return async <T>(fn: () => Promise<T>): Promise<T> => {
+    if (active >= max) await new Promise<void>((resolve) => waiting.push(resolve));
+    active++;
+    try {
+      return await fn();
+    } finally {
+      active--;
+      waiting.shift()?.();
+    }
+  };
+}
+
+const io = limiter(48);
+
+/** Counts what lies below a path (symlinks counted, never followed) within one budget of entries. */
+class Counter {
+  constructor(private left = COUNT_BUDGET) {}
+
+  async of(abs: string): Promise<Tally> {
+    if (this.left-- <= 0) return { ...NONE, partial: true };
+    const st = await io(() => lstat(abs)).catch(() => null);
+    if (!st) return NONE;
+    if (!st.isDirectory()) return { bytes: st.size, files: 1, modified: st.mtimeMs, partial: false };
+    const names = await io(() => readdir(abs)).catch(() => [] as string[]);
+    const total = (await Promise.all(names.map((n) => this.of(join(abs, n))))).reduce(add, NONE);
+    return total.files ? total : { ...total, modified: st.mtimeMs };
+  }
+}
+
+const sizeCache = new Map<string, { at: number; tally: Promise<Tally> }>();
+
+function cachedTally(abs: string): Promise<Tally> {
+  const hit = sizeCache.get(abs);
+  if (hit && Date.now() - hit.at < CACHE_MS) return hit.tally;
+  const tally = new Counter().of(abs);
+  sizeCache.set(abs, { at: Date.now(), tally });
+  return tally;
+}
+
+const reviewCache = new Map<string, { at: number; review: Promise<FileReview> }>();
+let overviewCache: { at: number; rows: Promise<AgentFilesOverview[]> } | null = null;
+
+/** Something in the agent's repository changed here: sizes and the review are looked at again. */
+function forget(agent: Agent) {
+  for (const key of sizeCache.keys()) if (key === agent.repoPath || key.startsWith(`${agent.repoPath}/`)) sizeCache.delete(key);
+  reviewCache.delete(agent.id);
+  overviewCache = null;
+}
+
+function sizeOf(path: string, t: Tally): AgentFileSize {
+  return { path, bytes: t.bytes, files: t.files, modifiedAt: t.modified ? new Date(t.modified).toISOString() : null, partial: t.partial };
+}
+
+/** Sizes of what lies directly in a folder of the repository. */
+export async function folderSizes(agentId: string, dir: string): Promise<AgentFileSize[]> {
+  const agent = await withRepo(agentId);
+  const rel = repoPath(agent, dir);
+  const st = entryOf(agent.repoPath, rel);
+  if (!st || !noLink(agent.repoPath, rel)) throw notFound("Folder");
+  if (!st.isDirectory()) throw badRequest("Path is not a folder");
+  const names = readdirSync(join(agent.repoPath, rel)).filter((n) => n.toLowerCase() !== ".git");
+  return Promise.all(
+    names.map(async (name) => {
+      const child = rel ? `${rel}/${name}` : name;
+      return sizeOf(child, await cachedTally(join(agent.repoPath, child)));
+    }),
+  );
+}
+
+/** memory/ notes, only when memory/ is a real folder of the repository. */
+function memoryNotes(repoPath: string): string[] {
+  return realDir(repoPath, MEMORY_DIR) ? memoryTopics(repoPath).filter((p) => NOTE.test(p)) : [];
+}
+
+function binDir(agentId: string): string {
+  return join(config().agentsDir, BIN, agentId);
+}
+
+/** One row per agent: what its files take, how many notes it keeps, how long its memory is. */
+export function filesOverview(): Promise<AgentFilesOverview[]> {
+  if (overviewCache && Date.now() - overviewCache.at < CACHE_MS * 4) return overviewCache.rows;
+  const rows = Promise.all(
+    all<{ id: string; repo_path: string }>("SELECT id, repo_path FROM agents ORDER BY name").map(async (a) => {
+      const workspace = join(a.repo_path, WORKSPACE_DIR);
+      const [ws, scratch, memory, memoryFile] = await Promise.all([
+        cachedTally(workspace),
+        cachedTally(join(workspace, "tmp")),
+        cachedTally(join(a.repo_path, MEMORY_DIR)),
+        cachedTally(join(a.repo_path, MEMORY_FILE)),
+      ]);
+      let notes = memoryNotes(a.repo_path).length;
+      if (realDir(a.repo_path, WORKSPACE_DIR)) notes += listNotes(workspace).length;
+      return {
+        agentId: a.id,
+        bytes: ws.bytes + memory.bytes + memoryFile.bytes,
+        workspaceBytes: ws.bytes,
+        scratchBytes: scratch.bytes,
+        notes,
+        memoryChars: memoryChars(a.repo_path),
+        deleted: deletedEntries(a.id).length,
+        partial: ws.partial || memory.partial,
+      };
+    }),
+  );
+  overviewCache = { at: Date.now(), rows };
+  rows.catch(() => (overviewCache = null));
+  return rows;
+}
+
+/* ------------------------------------------------------------------ */
+/* Who names what                                                       */
+/* ------------------------------------------------------------------ */
+
+const escape = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+/** `rel` as a path of its own in a text (not the start of a longer name). */
+function mention(rel: string, flags = ""): RegExp {
+  return new RegExp(`(?<![A-Za-z0-9._-])${escape(rel)}(?![A-Za-z0-9_-]|\\.[A-Za-z0-9_-])`, flags);
+}
+
+/** Memory files that link to the memory note `rel`: by its path, by a link next to it, or as [[its-name]]. */
+function memoryLinks(repoPath: string): (rel: string) => string[] {
+  const files = Object.entries(snapshotMemory(repoPath).files);
+  return (rel) => {
+    const full = mention(rel);
+    const name = basename(rel);
+    const stem = name.replace(/\.(md|markdown|txt)$/i, "");
+    const near = new RegExp(`\\]\\((?:\\./)?${escape(name)}(?:#[^)]*)?\\)`);
+    const wiki = new RegExp(`\\[\\[${escape(stem)}(?:\\|[^\\]]*)?\\]\\]`);
+    return files
+      .filter(([path, text]) => path !== rel && (full.test(text) || wiki.test(text) || (dirname(path) === dirname(rel) && near.test(text))))
+      .map(([path]) => path);
+  };
+}
+
+/** The agent's instructions, automations and follow-ups (label → text): what names a path there keeps it in place. */
+function pinTexts(agent: Agent): [string, string][] {
+  const out: [string, string][] = [["the instructions", agent.instructions]];
+  for (const r of all<{ name: string; prompt: string }>("SELECT name, prompt FROM routines WHERE agent_id = ?", agent.id)) out.push([`the automation "${r.name}"`, r.prompt]);
+  for (const f of all<{ note: string }>("SELECT note FROM followups WHERE agent_id = ?", agent.id)) out.push(["a follow-up", f.note]);
+  return out;
+}
+
+/** Where the agent names a path of its repository (read once for many paths). */
+function namer(agent: Agent): (rel: string) => string[] {
+  const workspace = namesOf(agent);
+  const memory = memoryLinks(agent.repoPath);
+  const pins = pinTexts(agent);
+  return (rel) => {
+    if (rel.startsWith(`${WORKSPACE_DIR}/`)) return workspace(rel.slice(WORKSPACE_DIR.length + 1));
+    if (rel.startsWith(`${MEMORY_DIR}/`)) {
+      const pattern = mention(rel);
+      return [...pins.filter(([, text]) => pattern.test(text)).map(([label]) => label), ...memory(rel)];
+    }
+    return [];
+  };
+}
+
+
+/** Size, what names them and whether they may go, for the paths the human is about to move or delete. */
+export async function inspectFiles(agentId: string, paths: string[]): Promise<AgentFileInfo[]> {
+  const agent = await withRepo(agentId);
+  const named = namer(agent);
+  const out: AgentFileInfo[] = [];
+  for (const input of paths.slice(0, MAX_PATHS)) {
+    const rel = repoPath(agent, input);
+    const st = entryOf(agent.repoPath, rel);
+    if (!st || !noLink(agent.repoPath, rel, false)) continue;
+    const tally = st.isSymbolicLink() ? { bytes: st.size, files: 1, modified: st.mtimeMs, partial: false } : await cachedTally(join(agent.repoPath, rel));
+    out.push({ ...sizeOf(rel, tally), type: st.isDirectory() ? "dir" : "file", namedBy: named(rel), locked: lockReason(rel) });
+  }
+  return out;
+}
+
+/* ------------------------------------------------------------------ */
+/* Review                                                               */
+/* ------------------------------------------------------------------ */
+
+/** Which kind wins when one path fits several. */
+const PRIORITY: FileReviewKind[] = ["build", "junk", "empty", "duplicate", "large", "scratch", "stale", "loose", "unlinked-note", "broken-link"];
+
+interface Candidate {
+  kind: FileReviewKind;
+  rel: string;
+  dir: boolean;
+  tally: Tally;
+  detail: string;
+  related?: string;
+}
+
+function day(ms: number): string {
+  return new Date(ms).toISOString().slice(0, 10);
+}
+
+function isProjectFolder(abs: string): boolean {
+  return PROJECT_FILES.some((f) => existsSync(join(abs, f)));
+}
+
+async function sha(abs: string): Promise<string | null> {
+  return new Promise((resolve) => {
+    const hash = createHash("sha256");
+    createReadStream(abs)
+      .on("data", (chunk) => hash.update(chunk))
+      .on("error", () => resolve(null))
+      .on("end", () => resolve(hash.digest("hex")));
+  });
+}
+
+class Reviewer {
+  readonly found: Candidate[] = [];
+  readonly copies = new Map<number, { rel: string; modified: number }[]>();
+  partial = false;
+  private left = REVIEW_BUDGET;
+
+  constructor(
+    private root: string,
+    private at: number,
+  ) {}
+
+  private add(kind: FileReviewKind, rel: string, dir: boolean, tally: Tally, detail: string, related?: string) {
+    if (tally.partial) this.partial = true;
+    this.found.push({ kind, rel, dir, tally, detail, related });
+  }
+
+  /** What lies below `abs`, counted with a budget of its own. */
+  private count(abs: string): Promise<Tally> {
+    return new Counter(ITEM_BUDGET).of(abs);
+  }
+
+  /**
+   * Walk a folder of the repository: what clutters it, and the files that may be copies of each other. "unknown" when
+   * the walk couldn't look inside (too deep, out of budget, unreadable): such a folder is never called empty.
+   */
+  async walk(rel: string, depth: number): Promise<"filled" | "empty" | "unknown"> {
+    if (this.left <= 0 || depth > 14) {
+      this.partial = true;
+      return "unknown";
+    }
+    const abs = join(this.root, rel);
+    const entries = await io(() => readdir(abs, { withFileTypes: true })).catch(() => null);
+    if (!entries) return "unknown";
+    this.left -= entries.length;
+    let kept = 0;
+    for (const entry of entries) {
+      const name = entry.name;
+      const child = `${rel}/${name}`;
+      const childAbs = join(abs, name);
+      if (name.toLowerCase() === ".git") {
+        kept++;
+        continue;
+      }
+      if (entry.isSymbolicLink()) {
+        kept++;
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (child === SCRATCH) {
+          kept++;
+          await this.scratch();
+          continue;
+        }
+        if (BUILD.has(name) || (OUTPUT.has(name) && isProjectFolder(abs))) {
+          const tally = await this.count(childAbs);
+          this.add("build", child, true, tally, BUILD.has(name) ? `Installed packages or a cache (${name}) — installing or building again brings it back.` : `Build output (${name}) — building the project again brings it back.`);
+          kept++;
+          continue;
+        }
+        // A project of its own (a clone): its files are its business, not clutter of the agent.
+        if (existsSync(join(childAbs, ".git"))) {
+          kept++;
+          continue;
+        }
+        if (name.startsWith(".")) {
+          kept++;
+          continue;
+        }
+        const inside = await this.walk(child, depth + 1);
+        if (inside !== "empty") kept++;
+        else {
+          const st = await lstat(childAbs).catch(() => null);
+          this.add("empty", child, true, { ...NONE, modified: st?.mtimeMs ?? 0 }, "An empty folder.");
+        }
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const st = await io(() => lstat(childAbs)).catch(() => null);
+      if (!st) continue;
+      const tally: Tally = { bytes: st.size, files: 1, modified: st.mtimeMs, partial: false };
+      // Junk still counts as content: the folder isn't empty, the junk is listed on its own.
+      kept++;
+      if (JUNK.test(name)) {
+        if (IN_PROGRESS.test(name) && this.at - st.mtimeMs < IN_PROGRESS_MS) continue;
+        this.add("junk", child, false, tally, name === ".DS_Store" ? "Finder's folder settings — macOS writes them again when needed." : /\.log$/i.test(name) ? "A log file." : /\.bak$/i.test(name) ? "A backup copy." : "A temporary file.");
+        continue;
+      }
+      if (name === ".gitkeep") continue;
+      if (st.size === 0) {
+        this.add("empty", child, false, tally, "An empty file.");
+        continue;
+      }
+      if (st.size >= LARGE) this.add("large", child, false, tally, `${formatBytes(st.size)} — one of the largest files here.`);
+      if (st.size >= HASH_MIN && st.size <= HASH_MAX_FILE) {
+        const list = this.copies.get(st.size) ?? [];
+        list.push({ rel: child, modified: st.mtimeMs });
+        this.copies.set(st.size, list);
+      }
+    }
+    return kept > 0 ? "filled" : "empty";
+  }
+
+  /** tmp/ goes by itself: only what is large is worth a look now. */
+  private async scratch() {
+    const abs = join(this.root, SCRATCH);
+    for (const name of await readdir(abs).catch(() => [] as string[])) {
+      if (name.startsWith(".")) continue;
+      const rel = `${SCRATCH}/${name}`;
+      const st = await lstat(join(abs, name)).catch(() => null);
+      if (!st || st.isSymbolicLink()) continue;
+      const tally = await this.count(join(abs, name));
+      const discarded = /^discarded-(\d{4}-\d{2}-\d{2})/.exec(name);
+      if (discarded) {
+        this.add("scratch", rel, st.isDirectory(), tally, `A dream sorted these out on ${discarded[1]} — the daily cleanup removes them a week after their last change.`);
+      } else if (tally.bytes >= LARGE_SCRATCH) {
+        const left = Math.max(0, Math.ceil((tally.modified + 7 * DAY - this.at) / DAY));
+        this.add("scratch", rel, st.isDirectory(), tally, `Scratch in tmp/ — goes by itself ${left ? `in about ${left} day${left === 1 ? "" : "s"}` : "with the next daily cleanup"}, unless a note names it.`);
+      }
+    }
+  }
+
+  /** Top of the repository and of workspace/: stray files, and entries nobody touched for long. */
+  async tops() {
+    for (const name of await readdir(this.root).catch(() => [] as string[])) {
+      if (name.startsWith(".") || ROOT_KNOWN.has(name)) continue;
+      const st = await lstat(join(this.root, name)).catch(() => null);
+      if (!st || st.isSymbolicLink()) continue;
+      const tally = await this.count(join(this.root, name));
+      if (JUNK.test(name)) this.add("junk", name, st.isDirectory(), tally, /\.log$/i.test(name) ? "A log file at the top of the repository." : "A temporary file at the top of the repository.");
+      else this.add("loose", name, st.isDirectory(), tally, "Lies at the top of the repository, outside workspace/ — move it into workspace/ or delete it.");
+    }
+    const ws = join(this.root, WORKSPACE_DIR);
+    for (const name of await readdir(ws).catch(() => [] as string[])) {
+      const rel = `${WORKSPACE_DIR}/${name}`;
+      if (name.startsWith(".") || rel === SCRATCH || rel === UPLOADS) continue;
+      const st = await lstat(join(ws, name)).catch(() => null);
+      if (!st || st.isSymbolicLink()) continue;
+      const tally = await this.count(join(ws, name));
+      // A count that stopped early doesn't know the newest change: no guess about age.
+      if (!tally.modified || tally.partial) continue;
+      const idle = Math.floor((this.at - tally.modified) / DAY);
+      if (idle >= STALE_DAYS) {
+        this.add("stale", rel, st.isDirectory(), tally, `Nothing in it changed for ${idle} days (last ${day(tally.modified)}).`);
+      } else if (!st.isDirectory() && idle >= RECENT_DAYS) {
+        this.add("loose", rel, false, tally, "Lies loose at the top of workspace/ — sort it into a folder.");
+      }
+    }
+  }
+
+  /** Files with the same content: the copy the agent names (or the oldest) stays. */
+  async duplicates(named: (rel: string) => string[]) {
+    let budget = HASH_BUDGET;
+    for (const [size, list] of this.copies) {
+      if (list.length < 2) continue;
+      const byHash = new Map<string, { rel: string; modified: number }[]>();
+      for (const file of list) {
+        if (budget < size) {
+          this.partial = true;
+          break;
+        }
+        budget -= size;
+        const hash = await sha(join(this.root, file.rel));
+        if (!hash) continue;
+        byHash.set(hash, [...(byHash.get(hash) ?? []), file]);
+      }
+      for (const group of byHash.values()) {
+        if (group.length < 2) continue;
+        const keep = [...group].sort(
+          (a, b) =>
+            Number(named(b.rel).length > 0) - Number(named(a.rel).length > 0) ||
+            Number(b.rel.startsWith(`${MEMORY_DIR}/`)) - Number(a.rel.startsWith(`${MEMORY_DIR}/`)) ||
+            Number(a.rel.startsWith(`${SCRATCH}/`)) - Number(b.rel.startsWith(`${SCRATCH}/`)) ||
+            a.modified - b.modified ||
+            a.rel.length - b.rel.length,
+        )[0]!;
+        for (const copy of group) {
+          if (copy === keep) continue;
+          this.add("duplicate", copy.rel, false, { bytes: size, files: 1, modified: copy.modified, partial: false }, `Same content as ${keep.rel}.`, keep.rel);
+        }
+      }
+    }
+  }
+
+  /** Memory notes nothing links to or names, and links to notes that don't exist. */
+  memory(named: (rel: string) => string[]) {
+    for (const rel of memoryNotes(this.root)) {
+      if (named(rel).length) continue;
+      const st = entryOf(this.root, rel);
+      if (!st) continue;
+      this.add("unlinked-note", rel, false, { bytes: st.size, files: 1, modified: st.mtimeMs, partial: false }, "No link from MEMORY.md or another note — the agent may never read it. Link it, merge it, or delete it.");
+    }
+    const pattern = /(?<![A-Za-z0-9._/-])memory\/[A-Za-z0-9._/-]+?\.(?:md|markdown|txt)(?![A-Za-z0-9_-]|\.[A-Za-z0-9_-])/g;
+    const seen = new Set<string>();
+    for (const [file, text] of Object.entries(snapshotMemory(this.root).files)) {
+      for (const m of text.matchAll(pattern)) {
+        const target = m[0];
+        if (seen.has(target) || target.split("/").some((p) => p === ".." || p === "") || entryOf(this.root, target)) continue;
+        seen.add(target);
+        this.add("broken-link", target, false, NONE, `${file} links to it, but it doesn't exist.`, file);
+      }
+    }
+  }
+}
+
+/** What clutters the agent's repository, by kind; what the agent still names is marked, never hidden. */
+export async function reviewFiles(agentId: string, fresh = false): Promise<FileReview> {
+  const agent = await withRepo(agentId);
+  const hit = reviewCache.get(agent.id);
+  if (hit && Date.now() - hit.at < (fresh ? FRESH_MS : CACHE_MS * 2)) return hit.review;
+  const review = buildReview(agent);
+  reviewCache.set(agent.id, { at: Date.now(), review });
+  review.catch(() => reviewCache.delete(agent.id));
+  return review;
+}
+
+async function buildReview(agent: Agent): Promise<FileReview> {
+  const at = Date.now();
+  const r = new Reviewer(agent.repoPath, at);
+  const named = namer(agent);
+  if (realDir(agent.repoPath, WORKSPACE_DIR)) await r.walk(WORKSPACE_DIR, 0);
+  if (realDir(agent.repoPath, MEMORY_DIR)) await r.walk(MEMORY_DIR, 0);
+  await r.tops();
+  await r.duplicates(named);
+  r.memory(named);
+
+  const byPath = new Map<string, Candidate>();
+  for (const c of r.found) {
+    const prev = byPath.get(c.rel);
+    if (!prev || PRIORITY.indexOf(c.kind) < PRIORITY.indexOf(prev.kind)) byPath.set(c.rel, c);
+  }
+  // A folder already on the list covers what lies in it.
+  const folders = [...byPath.values()].filter((c) => c.dir).map((c) => `${c.rel}/`);
+  const covered = (rel: string) => folders.some((f) => rel.startsWith(f));
+  const items: FileReviewItem[] = [];
+  const perKind = new Map<FileReviewKind, number>();
+  const sorted = [...byPath.values()]
+    .filter((c) => !lockReason(c.rel) && !covered(c.rel))
+    // The copy that stays may itself be on the list (in an old folder, as a large file): ticking both would lose both.
+    .filter((c) => c.kind !== "duplicate" || !c.related || (!covered(c.related) && !byPath.has(c.related)))
+    .sort((a, b) => PRIORITY.indexOf(a.kind) - PRIORITY.indexOf(b.kind) || b.tally.bytes - a.tally.bytes || a.rel.localeCompare(b.rel));
+  for (const c of sorted) {
+    const n = perKind.get(c.kind) ?? 0;
+    if (n >= KIND_LIMIT) {
+      r.partial = true;
+      continue;
+    }
+    perKind.set(c.kind, n + 1);
+    const names = c.kind === "broken-link" ? [] : named(c.rel);
+    items.push({
+      kind: c.kind,
+      path: c.rel,
+      type: c.dir ? "dir" : "file",
+      bytes: c.tally.bytes,
+      files: c.tally.files,
+      modifiedAt: c.tally.modified ? new Date(c.tally.modified).toISOString() : null,
+      detail: c.detail,
+      namedBy: names[0] ?? null,
+      related: c.related ?? null,
+    });
+  }
+  return { agentId: agent.id, checkedAt: new Date(at).toISOString(), items, partial: r.partial };
+}
+
+/* ------------------------------------------------------------------ */
+/* Notes and search                                                     */
+/* ------------------------------------------------------------------ */
+
+/** The agent's Markdown notes: MEMORY.md, memory/ and the workspace (tmp/, uploads/ and clones left out). */
+export async function listAgentNotes(agentId: string): Promise<AgentNote[]> {
+  const agent = await withRepo(agentId);
+  const links = memoryLinks(agent.repoPath);
+  const named = namer(agent);
+  const notes: AgentNote[] = [];
+  const push = (rel: string, linked: boolean) => {
+    const st = entryOf(agent.repoPath, rel);
+    if (!st?.isFile()) return;
+    const names = named(rel);
+    notes.push({
+      path: rel,
+      title: noteTitle(join(agent.repoPath, rel)) || basename(rel),
+      bytes: st.size,
+      modifiedAt: st.mtime.toISOString(),
+      linked,
+      namedBy: names[0] ?? null,
+    });
+  };
+  push(MEMORY_FILE, true);
+  for (const rel of memoryNotes(agent.repoPath)) push(rel, links(rel).length > 0);
+  const ws = join(agent.repoPath, WORKSPACE_DIR);
+  if (realDir(agent.repoPath, WORKSPACE_DIR)) {
+    for (const note of listNotes(ws)) {
+      const rel = `${WORKSPACE_DIR}/${note.rel}`;
+      push(rel, named(rel).length > 0);
+    }
+  }
+  return notes;
+}
+
+function snippetOf(line: string, at: number, length: number): string {
+  const start = Math.max(0, at - 60);
+  const end = Math.min(line.length, at + length + 100);
+  return `${start > 0 ? "…" : ""}${line.slice(start, end).trim()}${end < line.length ? "…" : ""}`;
+}
+
+/** Files and folders whose name holds `query`, and text files that contain it (first match per file). */
+export async function searchAgentFiles(agentId: string, query: string): Promise<AgentFileSearchHit[]> {
+  const agent = await withRepo(agentId);
+  const needle = query.trim().toLowerCase();
+  if (needle.length < 2) return [];
+  const hits: AgentFileSearchHit[] = [];
+  let left = SEARCH_BUDGET;
+  const visit = async (rel: string, depth: number): Promise<void> => {
+    if (hits.length >= SEARCH_LIMIT || left <= 0 || depth > 12) return;
+    const entries = await readdir(join(agent.repoPath, rel), { withFileTypes: true }).catch(() => []);
+    left -= entries.length;
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      if (hits.length >= SEARCH_LIMIT) return;
+      const name = entry.name;
+      if (name.startsWith(".") || BUILD.has(name) || entry.isSymbolicLink()) continue;
+      const child = `${rel}/${name}`;
+      const nameHit = name.toLowerCase().includes(needle);
+      if (entry.isDirectory()) {
+        if (nameHit) hits.push({ path: child, type: "dir", line: null, snippet: null });
+        if (!existsSync(join(agent.repoPath, child, ".git"))) await visit(child, depth + 1);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (nameHit) {
+        hits.push({ path: child, type: "file", line: null, snippet: null });
+        continue;
+      }
+      if (!TEXT.test(name)) continue;
+      const st = await lstat(join(agent.repoPath, child)).catch(() => null);
+      if (!st || st.size > SEARCH_READ_MAX) continue;
+      const text = await readFile(join(agent.repoPath, child), "utf8").catch(() => "");
+      const lower = text.toLowerCase();
+      const at = lower.indexOf(needle);
+      if (at < 0) continue;
+      const lineStart = lower.lastIndexOf("\n", at) + 1;
+      const lineEnd = lower.indexOf("\n", at);
+      const line = text.slice(lineStart, lineEnd < 0 ? undefined : lineEnd);
+      hits.push({ path: child, type: "file", line: text.slice(0, at).split("\n").length, snippet: snippetOf(line, at - lineStart, needle.length) });
+    }
+  };
+  const memoryFile = entryOf(agent.repoPath, MEMORY_FILE);
+  if (memoryFile?.isFile() && memoryFile.size <= SEARCH_READ_MAX) {
+    const text = await readFile(join(agent.repoPath, MEMORY_FILE), "utf8").catch(() => "");
+    const at = text.toLowerCase().indexOf(needle);
+    if (at >= 0) {
+      const lineStart = text.lastIndexOf("\n", at) + 1;
+      const lineEnd = text.indexOf("\n", at);
+      hits.push({ path: MEMORY_FILE, type: "file", line: text.slice(0, at).split("\n").length, snippet: snippetOf(text.slice(lineStart, lineEnd < 0 ? undefined : lineEnd), at - lineStart, needle.length) });
+    }
+  }
+  if (realDir(agent.repoPath, MEMORY_DIR)) await visit(MEMORY_DIR, 1);
+  if (realDir(agent.repoPath, WORKSPACE_DIR)) await visit(WORKSPACE_DIR, 1);
+  return hits.sort((a, b) => Number(a.line !== null) - Number(b.line !== null));
+}
+
+/* ------------------------------------------------------------------ */
+/* Changes                                                              */
+/* ------------------------------------------------------------------ */
+
+/** A new, empty folder inside workspace/ or memory/. */
+export async function createFolder(agentId: string, input: string): Promise<{ path: string }> {
+  const agent = await withRepo(agentId);
+  const rel = repoPath(agent, input);
+  if (!placeable(rel)) throw badRequest("New folders go inside workspace/ or memory/ (not into tmp/ or uploads/).");
+  if (!noLink(agent.repoPath, rel)) throw badRequest("The folder would lie behind a link.");
+  if (entryOf(agent.repoPath, rel)) throw conflict(`${rel} already exists.`);
+  await withRepoLock(agent.repoPath, () => mkdir(join(agent.repoPath, rel), { recursive: true }));
+  forget(agent);
+  return { path: rel };
+}
+
+/**
+ * Point the agent's memory at `to` wherever it named `from`: repository paths and this agent's own absolute paths
+ * (never another agent's). A name at the top of the repository is only a path of its own when it is absolute — a bare
+ * "todo.txt" in a note may mean a file next to that note. A memory note moved also keeps its links next to it
+ * (`](note.md)`, written relative to the linking note) and its [[name]] when it is renamed.
+ */
+function repointMemory(repoPath: string, from: string, to: string): string[] {
+  const pattern = mention(from, "g");
+  const top = !from.includes("/");
+  const absolute = (text: string, at: number) => text[at - 1] === "/" && text.slice(0, at - 1).endsWith(repoPath);
+  const own = (text: string, at: number) => (top ? absolute(text, at) : at === 0 || text[at - 1] !== "/" || absolute(text, at) || text.slice(Math.max(0, at - 2), at) === "./");
+  const memoryNote = from.startsWith(`${MEMORY_DIR}/`) && NOTE.test(from);
+  const stem = (p: string) => basename(p).replace(/\.(md|markdown|txt)$/i, "");
+  const files = snapshotMemory(repoPath).files;
+  const sameStem = Object.keys(files).filter((p) => p !== from && stem(p).toLowerCase() === stem(from).toLowerCase()).length > 0;
+  const changed: string[] = [];
+  for (const [path, text] of Object.entries(files)) {
+    let next = text.replace(pattern, (match: string, at: number) => (own(text, at) ? to : match));
+    if (memoryNote) {
+      if (dirname(path) === dirname(from)) {
+        const near = new RegExp(`\\]\\((?:\\./)?${escape(basename(from))}((?:#[^)]*)?)\\)`, "g");
+        const target = relative(dirname(path), to).split("\\").join("/");
+        next = next.replace(near, (_m: string, hash: string) => `](${target}${hash})`);
+      }
+      if (stem(from) !== stem(to) && !sameStem) {
+        const wiki = new RegExp(`\\[\\[${escape(stem(from))}((?:\\|[^\\]]*)?)\\]\\]`, "g");
+        next = next.replace(wiki, (_m: string, label: string) => `[[${stem(to)}${label}]]`);
+      }
+    }
+    if (next === text || !canRestore(repoPath, path) || !noLink(repoPath, path)) continue;
+    writeFileSync(join(repoPath, path), next);
+    changed.push(path);
+  }
+  return changed;
+}
+
+/** Rename or move an entry inside workspace/ or memory/ (never over another one); the memory follows it. */
+export async function moveFile(agentId: string, fromInput: string, toInput: string): Promise<AgentFileMoveResult> {
+  const agent = await withRepo(agentId);
+  const from = repoPath(agent, fromInput);
+  const to = repoPath(agent, toInput);
+  const locked = lockReason(from);
+  if (locked) throw new HttpError(403, locked, "locked");
+  if (!placeable(to) || lockReason(to)) throw badRequest(reservedPlace(to) ? "Nothing moves into tmp/ (cleared without the bin) or uploads/." : "Entries move inside workspace/ or memory/.");
+  if (to === from) return { path: to, rewritten: [] };
+  if (to.startsWith(`${from}/`)) throw badRequest("A folder can't move into itself.");
+  refuseWhileDreaming(agent);
+  return withRepoLock(agent.repoPath, async () => {
+    refuseWhileDreaming(agent);
+    const source = entryOf(agent.repoPath, from);
+    if (!source) throw notFound(from);
+    if (!noLink(agent.repoPath, from, false) || !noLink(agent.repoPath, to, false)) throw badRequest("The way there goes through a link.");
+    const target = entryOf(agent.repoPath, to);
+    // Only a new spelling of the same name (on a case-insensitive disk) may find "itself" there.
+    if (target && !(target.ino === source.ino && target.dev === source.dev && from.toLowerCase() === to.toLowerCase())) {
+      throw conflict(`${to} already exists — pick another name.`);
+    }
+    await mkdir(dirname(join(agent.repoPath, to)), { recursive: true });
+    await rename(join(agent.repoPath, from), join(agent.repoPath, to));
+    const rewritten = repointMemory(agent.repoPath, from, to);
+    await commitAllInLock(agent.repoPath, `Move ${from} to ${to}`);
+    forget(agent);
+    return { path: to, rewritten };
+  });
+}
+
+/* ------------------------------------------------------------------ */
+/* The bin                                                              */
+/* ------------------------------------------------------------------ */
+
+const ENTRY_ID = /^[a-z0-9]{8,40}$/;
+
+interface Stored extends DeletedAgentFile {
+  dir: string;
+}
+
+function readEntry(dir: string, id: string): Stored | null {
+  try {
+    const meta = JSON.parse(readFileSync(join(dir, id, "entry.json"), "utf8")) as DeletedAgentFile;
+    if (typeof meta.path !== "string" || typeof meta.deletedAt !== "string" || !Number.isFinite(Date.parse(meta.deletedAt))) return null;
+    // lstat: a link moved into the bin may point nowhere from there, it is still the entry.
+    lstatSync(join(dir, id, "item"));
+    return { ...meta, id, dir: join(dir, id) };
+  } catch {
+    return null;
+  }
+}
+
+function deletedEntries(agentId: string): Stored[] {
+  const dir = binDir(agentId);
+  let ids: string[];
+  try {
+    ids = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return ids
+    .filter((id) => ENTRY_ID.test(id))
+    .map((id) => readEntry(dir, id))
+    .filter((e): e is Stored => !!e)
+    .sort((a, b) => b.deletedAt.localeCompare(a.deletedAt));
+}
+
+const strip = ({ dir: _dir, ...entry }: Stored): DeletedAgentFile => entry;
+
+export async function listDeletedFiles(agentId: string): Promise<DeletedAgentFile[]> {
+  const agent = await withRepo(agentId);
+  return deletedEntries(agent.id).map(strip);
+}
+
+/**
+ * Entries of every agent's bin deleted more than `days` ago (agents removed since included), and leftovers of a delete
+ * that broke off (no item or no readable entry.json) older than a day: for the cleanup.
+ */
+export function expiredDeletedFiles(at = Date.now(), days = DELETED_DAYS): { agentId: string; path: string; dir: string; deletedAt: string }[] {
+  const root = join(config().agentsDir, BIN);
+  let agents: string[];
+  try {
+    agents = readdirSync(root);
+  } catch {
+    return [];
+  }
+  return agents.flatMap((agentId) => {
+    const dir = binDir(agentId);
+    const expired = deletedEntries(agentId)
+      .filter((e) => at - Date.parse(e.deletedAt) >= days * DAY)
+      .map((e) => ({ agentId, path: e.path, dir: e.dir, deletedAt: e.deletedAt }));
+    const broken = readdirSafe(dir)
+      .filter((id) => ENTRY_ID.test(id) && !readEntry(dir, id))
+      .flatMap((id) => {
+        const st = entryOf(dir, id);
+        return st && at - st.mtimeMs >= DAY ? [{ agentId, path: "(an unfinished delete)", dir: join(dir, id), deletedAt: st.mtime.toISOString() }] : [];
+      });
+    return [...expired, ...broken];
+  });
+}
+
+function readdirSafe(dir: string): string[] {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+
+/** The move into or out of the bin copied everything, but the source couldn't be removed completely. */
+class PartlyMoved extends Error {}
+
+/** Rename, or across disks copy and remove. Once the copy is complete it is never the part that goes. */
+async function moveAside(from: string, to: string) {
+  try {
+    await rename(from, to);
+    return;
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== "EXDEV") throw err;
+  }
+  try {
+    await cp(from, to, { recursive: true, verbatimSymlinks: true, preserveTimestamps: true, errorOnExist: true, force: false });
+  } catch (err) {
+    await rm(to, { recursive: true, force: true }).catch(() => {});
+    throw err;
+  }
+  try {
+    await rm(from, { recursive: true, force: true });
+  } catch (err) {
+    throw new PartlyMoved(err instanceof Error ? err.message : String(err));
+  }
+}
+
+/** Move entries into the agent's bin, in one commit. What must stay is refused, the rest goes. */
+export async function deleteFiles(agentId: string, inputs: string[]): Promise<AgentFilesDeleteResult> {
+  const agent = await withRepo(agentId);
+  refuseWhileDreaming(agent);
+  const paths = [...new Set(inputs.slice(0, MAX_PATHS).map((p) => repoPath(agent, p)))];
+  // A folder that goes takes what lies in it along.
+  const top = paths.filter((p) => !paths.some((q) => q !== p && p.startsWith(`${q}/`)));
+  const result: AgentFilesDeleteResult = { deleted: [], refused: [] };
+  await withRepoLock(agent.repoPath, async () => {
+    refuseWhileDreaming(agent);
+    const bin = binDir(agent.id);
+    for (const rel of top) {
+      const locked = lockReason(rel);
+      if (locked) {
+        result.refused.push({ path: rel, reason: locked });
+        continue;
+      }
+      const st = entryOf(agent.repoPath, rel);
+      if (!st) {
+        result.refused.push({ path: rel, reason: "It isn't there anymore." });
+        continue;
+      }
+      if (!noLink(agent.repoPath, rel, false)) {
+        result.refused.push({ path: rel, reason: "It lies behind a link." });
+        continue;
+      }
+      const tally = st.isDirectory() ? await new Counter().of(join(agent.repoPath, rel)) : { bytes: st.size, files: 1, modified: st.mtimeMs, partial: false };
+      const id = `${Date.now().toString(36)}${randomBytes(5).toString("hex")}`;
+      const dir = join(bin, id);
+      const entry: DeletedAgentFile = { id, path: rel, type: st.isDirectory() ? "dir" : "file", bytes: tally.bytes, files: tally.files, deletedAt: now() };
+      try {
+        await mkdir(dir, { recursive: true, mode: 0o700 });
+        await writeFile(join(dir, "entry.json"), JSON.stringify(entry));
+        await moveAside(join(agent.repoPath, rel), join(dir, "item"));
+        result.deleted.push(entry);
+      } catch (err) {
+        if (err instanceof PartlyMoved) {
+          // The bin holds a full copy: it stays there; what couldn't be removed stays in place too.
+          result.deleted.push(entry);
+          result.refused.push({ path: rel, reason: `A full copy is in the bin, but some of it couldn't be removed here (${err.message}).` });
+          continue;
+        }
+        await rm(dir, { recursive: true, force: true }).catch(() => {});
+        result.refused.push({ path: rel, reason: `It couldn't be moved to the bin (${err instanceof Error ? err.message : String(err)}).` });
+      }
+    }
+    if (result.deleted.length) {
+      const first = result.deleted[0]!.path;
+      await commitAllInLock(agent.repoPath, result.deleted.length === 1 ? `Delete ${first}` : `Delete ${first} and ${result.deleted.length - 1} more`);
+    }
+  });
+  for (const rel of paths) if (!top.includes(rel)) result.refused.push({ path: rel, reason: "Goes with the folder it lies in." });
+  forget(agent);
+  return result;
+}
+
+/** A free place next to `rel`: "notes (restored).md", "notes (restored 2).md", … */
+function freePlace(root: string, rel: string): string {
+  if (!entryOf(root, rel)) return rel;
+  const ext = extname(rel);
+  const base = ext ? rel.slice(0, -ext.length) : rel;
+  for (let i = 1; ; i++) {
+    const next = `${base} (restored${i > 1 ? ` ${i}` : ""})${ext}`;
+    if (!entryOf(root, next)) return next;
+  }
+}
+
+/** Put a deleted entry back where it was (next to it, when something new took its place). */
+export async function restoreDeletedFile(agentId: string, id: string): Promise<AgentFileRestoreResult> {
+  const agent = await withRepo(agentId);
+  if (!ENTRY_ID.test(id)) throw notFound("Deleted entry");
+  refuseWhileDreaming(agent);
+  return withRepoLock(agent.repoPath, async () => {
+    refuseWhileDreaming(agent);
+    const entry = readEntry(binDir(agent.id), id);
+    if (!entry) throw notFound("Deleted entry");
+    const original = repoPath(agent, entry.path);
+    // Only where the Files page deletes from: workspace/, memory/ or a plain name at the top — never a hidden file.
+    const fits = original.startsWith(`${WORKSPACE_DIR}/`) || original.startsWith(`${MEMORY_DIR}/`) || (!original.includes("/") && !original.startsWith("."));
+    if (!fits || lockReason(original)) throw badRequest("It can't go back there.");
+    if (!noLink(agent.repoPath, original, false)) throw badRequest("The way back goes through a link.");
+    const rel = freePlace(agent.repoPath, original);
+    await mkdir(dirname(join(agent.repoPath, rel)), { recursive: true });
+    await moveAside(join(entry.dir, "item"), join(agent.repoPath, rel)).catch((err) => {
+      if (!(err instanceof PartlyMoved)) throw err;
+    });
+    await rm(entry.dir, { recursive: true, force: true });
+    await commitAllInLock(agent.repoPath, `Restore ${rel}`);
+    forget(agent);
+    return { path: rel };
+  });
+}
+
+/** Remove deleted entries for good: one (`id`), or the whole bin. */
+export async function purgeDeletedFiles(agentId: string, id?: string): Promise<{ removed: number; bytes: number }> {
+  const agent = await withRepo(agentId);
+  if (id !== undefined && !ENTRY_ID.test(id)) throw notFound("Deleted entry");
+  const entries = deletedEntries(agent.id).filter((e) => id === undefined || e.id === id);
+  if (id !== undefined && !entries.length) throw notFound("Deleted entry");
+  let bytes = 0;
+  for (const e of entries) {
+    await rm(e.dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 200 });
+    bytes += e.bytes;
+  }
+  overviewCache = null;
+  return { removed: entries.length, bytes };
+}
diff --git a/packages/core/src/agents/repo.ts b/packages/core/src/agents/repo.ts
index b27525c7..23d640ce 100644
--- a/packages/core/src/agents/repo.ts
+++ b/packages/core/src/agents/repo.ts
@@ -354,8 +354,11 @@ export async function readRepoFile(dir: string, relPath: string): Promise<{ path
   return { path: rel, content };
 }
 
-/** Write a UTF-8 text file inside the repository (creates parent directories). Returns the relative path. */
-export async function writeRepoFile(dir: string, relPath: string, content: string): Promise<string> {
+/**
+ * Write a UTF-8 text file inside the repository (creates parent directories). Returns the relative path. `create`: only
+ * a new file — 409 when one is there already.
+ */
+export async function writeRepoFile(dir: string, relPath: string, content: string, opts: { create?: boolean } = {}): Promise<string> {
   ensureRepoExists(dir);
   const { abs, rel } = resolveRepoPath(dir, relPath);
   if (!rel) throw badRequest("A file path is required");
@@ -366,8 +369,12 @@ export async function writeRepoFile(dir: string, relPath: string, content: strin
     await assertRealInside(dir, abs);
     const existing = await stat(abs).catch(() => null);
     if (existing?.isDirectory()) throw badRequest("Path is a directory");
+    if (opts.create && (existing || (await lstat(abs).catch(() => null)))) throw new HttpError(409, "A file with this name is already there", "exists");
     await mkdir(dirname(abs), { recursive: true });
-    await writeFile(abs, content, "utf8");
+    await writeFile(abs, content, { encoding: "utf8", flag: opts.create ? "wx" : "w" }).catch((err) => {
+      if ((err as NodeJS.ErrnoException).code === "EEXIST") throw new HttpError(409, "A file with this name is already there", "exists");
+      throw err;
+    });
     return rel;
   });
 }
diff --git a/packages/core/src/agents/service.ts b/packages/core/src/agents/service.ts
index cda27cf0..a21658b3 100644
--- a/packages/core/src/agents/service.ts
+++ b/packages/core/src/agents/service.ts
@@ -1087,9 +1087,9 @@ export async function readAgentFile(id: string, path: string): Promise<{ path: s
 }
 
 /** Write a file as the user and commit it ("Edit <path>"). CLAUDE.md edits last until the next settings update. */
-export async function writeAgentFile(id: string, path: string, content: string): Promise<void> {
+export async function writeAgentFile(id: string, path: string, content: string, opts: { create?: boolean } = {}): Promise<void> {
   const agent = await withRepo(id);
-  const rel = await repo.writeRepoFile(agent.repoPath, path, content);
+  const rel = await repo.writeRepoFile(agent.repoPath, path, content, opts);
   await repo.commitAll(agent.repoPath, `Edit ${rel}`);
 }
 
diff --git a/packages/core/src/cloud/scope.ts b/packages/core/src/cloud/scope.ts
index ac845183..d7152662 100644
--- a/packages/core/src/cloud/scope.ts
+++ b/packages/core/src/cloud/scope.ts
@@ -142,6 +142,18 @@ const RULES: [methods: string, path: string, rule: Rule][] = [
   ["GET", "/api/agents/:id/commands", A],
   ["GET", "/api/agents/:id/files", A],
   ["GET|PUT", "/api/agents/:id/file", A],
+  ["GET", "/api/files/overview", A],
+  ["GET", "/api/agents/:id/files/sizes", A],
+  ["POST", "/api/agents/:id/files/inspect", A],
+  ["GET", "/api/agents/:id/files/review", A],
+  ["GET", "/api/agents/:id/files/notes", A],
+  ["GET", "/api/agents/:id/files/search", A],
+  ["POST", "/api/agents/:id/files/folder", A],
+  ["POST", "/api/agents/:id/files/move", A],
+  ["POST", "/api/agents/:id/files/delete", A],
+  ["GET|DELETE", "/api/agents/:id/files/deleted", A],
+  ["POST", "/api/agents/:id/files/deleted/:entryId/restore", A],
+  ["DELETE", "/api/agents/:id/files/deleted/:entryId", A],
   ["GET|PUT", "/api/agents/:id/memory", A],
   ["GET", "/api/agents/:id/commits", A],
   ["GET", "/api/agents/:id/heartbeat", A],
@@ -408,8 +420,11 @@ const RULES: [methods: string, path: string, rule: Rule][] = [
   ["POST", "/api/budgets/release", A],
 ];
 
-/** Writes a viewer may make: resolving a chat's files changes nothing. */
-const VIEWER_WRITES: [string, string][] = [["POST", "/api/conversations/:id/files"]];
+/** Writes a viewer may make: resolving a chat's files and looking at an agent's before a delete change nothing. */
+const VIEWER_WRITES: [string, string][] = [
+  ["POST", "/api/conversations/:id/files"],
+  ["POST", "/api/agents/:id/files/inspect"],
+];
 /** Reads a viewer may not make: pictures of the screen, codes and keys. */
 const VIEWER_HIDDEN_READS = ["/api/computer/thumbnail", "/api/computer/sources", "/api/vms/:id/screenshot", "/api/android/devices/:id/screenshot", "/api/totp/codes", "/api/ssh/local-keys"];
 
diff --git a/packages/core/src/memory/editor.ts b/packages/core/src/memory/editor.ts
index 94fb26bd..275ccefa 100644
--- a/packages/core/src/memory/editor.ts
+++ b/packages/core/src/memory/editor.ts
@@ -22,7 +22,7 @@ export function memoryDigestOf(text: string): string {
 }
 
 /** Markdown notes under memory/, sorted; hidden entries and symlinks are skipped. */
-function memoryTopics(repoPath: string): string[] {
+export function memoryTopics(repoPath: string): string[] {
   const out: string[] = [];
   const walk = (rel: string, depth: number) => {
     if (depth > 6 || out.length >= MAX_TOPICS) return;
diff --git a/packages/core/src/memory/workspace.ts b/packages/core/src/memory/workspace.ts
index 485727ee..8d98abd5 100644
--- a/packages/core/src/memory/workspace.ts
+++ b/packages/core/src/memory/workspace.ts
@@ -226,6 +226,15 @@ export function namedBy(agent: Owner): (rel: string) => string | null {
   return (rel) => pinnedBy(agent, refs, rel) ?? memoryMentions(refs, rel)[0] ?? null;
 }
 
+/** Every place that names `workspace/<rel>` or something in it, read once for many entries: what keeps it, then the memory files. */
+export function namesOf(agent: Owner): (rel: string) => string[] {
+  const refs = references(agent);
+  return (rel) => {
+    const pin = pinnedBy(agent, refs, rel);
+    return [...(pin ? [pin] : []), ...memoryMentions(refs, rel)];
+  };
+}
+
 /** Paths in tmp/ the agent's notes name (`tmp/...`, existing ones only) → where they are named. */
 function namedScratch(root: string, refs: References): Map<string, string[]> {
   const found = new Map<string, string[]>();
@@ -256,14 +265,14 @@ function inProject(root: string, rel: string): boolean {
   return false;
 }
 
-interface Note {
+export interface Note {
   rel: string;
   bytes: number;
   modified: number;
 }
 
 /** The agent's notes: Markdown files in the workspace, outside tmp/, uploads/, hidden folders, packages and projects. */
-function listNotes(root: string): Note[] {
+export function listNotes(root: string): Note[] {
   const notes: Note[] = [];
   const walk = (dir: string, depth: number) => {
     let names: string[];
@@ -292,7 +301,7 @@ function listNotes(root: string): Note[] {
 }
 
 /** The note's first line as a title. */
-function noteTitle(abs: string): string {
+export function noteTitle(abs: string): string {
   try {
     const head = readFileSync(abs, "utf8").slice(0, 2_000);
     const line = head.split("\n").find((l) => l.trim()) ?? "";
diff --git a/packages/core/src/server/routes/agents.ts b/packages/core/src/server/routes/agents.ts
index b4d7bfdb..756fd69d 100644
--- a/packages/core/src/server/routes/agents.ts
+++ b/packages/core/src/server/routes/agents.ts
@@ -39,6 +39,20 @@ import { dreamOverview, getDream, isDreaming, revertDream, startDream } from "..
 import { isMemoryPath } from "../../memory/files";
 import { MAX_MEMORY_EDIT_BYTES, readAgentMemory, writeAgentMemory } from "../../memory/editor";
 import { resolveRepoPath } from "../../agents/repo";
+import {
+  createFolder,
+  deleteFiles,
+  filesOverview,
+  folderSizes,
+  inspectFiles,
+  listAgentNotes,
+  listDeletedFiles,
+  moveFile,
+  purgeDeletedFiles,
+  restoreDeletedFile,
+  reviewFiles,
+  searchAgentFiles,
+} from "../../agents/files";
 import { getSettings } from "../../services/settings";
 import { conflict } from "../../util";
 import { requestDevice } from "../auth";
@@ -283,16 +297,59 @@ export function registerAgentRoutes(app: Hono): void {
   app.get("/api/agents/:id/file", async (c) => c.json(await readAgentFile(c.req.param("id"), c.req.query("path") ?? "")));
 
   app.put("/api/agents/:id/file", async (c) => {
-    const { path, content } = await body(c, z.object({ path: z.string().trim().min(1).max(1024), content: z.string() }));
+    const { path, content, create } = await body(c, z.object({ path: z.string().trim().min(1).max(1024), content: z.string(), create: z.boolean().optional() }));
     const agent = getAgent(c.req.param("id"));
     // A dream owns the memory files while it runs (its rollback or undo would take the edit with it).
     if (isMemoryPath(resolveRepoPath(agent.repoPath, path).rel) && isDreaming(agent.id)) {
       throw conflict(`${agent.name} is dreaming (consolidating its memory) — edit it when the dream has ended, or cancel the dream.`);
     }
-    await writeAgentFile(agent.id, path, content);
+    await writeAgentFile(agent.id, path, content, { create });
     return c.json({ ok: true });
   });
 
+  /* Files page: sizes, review, notes, search, moves and the bin -------- */
+
+  const repoPathInput = z.string().trim().max(1024);
+  const pathList = z.array(repoPathInput.min(1)).min(1).max(500);
+
+  app.get("/api/files/overview", async (c) => c.json(await filesOverview()));
+
+  app.get("/api/agents/:id/files/sizes", async (c) => c.json(await folderSizes(c.req.param("id"), c.req.query("path") ?? "")));
+
+  app.post("/api/agents/:id/files/inspect", async (c) => {
+    const { paths } = await body(c, z.object({ paths: pathList }));
+    return c.json(await inspectFiles(c.req.param("id"), paths));
+  });
+
+  app.get("/api/agents/:id/files/review", async (c) => c.json(await reviewFiles(c.req.param("id"), c.req.query("fresh") === "1")));
+
+  app.get("/api/agents/:id/files/notes", async (c) => c.json(await listAgentNotes(c.req.param("id"))));
+
+  app.get("/api/agents/:id/files/search", async (c) => c.json(await searchAgentFiles(c.req.param("id"), (c.req.query("q") ?? "").slice(0, 200))));
+
+  app.post("/api/agents/:id/files/folder", async (c) => {
+    const { path } = await body(c, z.object({ path: repoPathInput.min(1) }));
+    return c.json(await createFolder(c.req.param("id"), path));
+  });
+
+  app.post("/api/agents/:id/files/move", async (c) => {
+    const { from, to } = await body(c, z.object({ from: repoPathInput.min(1), to: repoPathInput.min(1) }));
+    return c.json(await moveFile(c.req.param("id"), from, to));
+  });
+
+  app.post("/api/agents/:id/files/delete", async (c) => {
+    const { paths } = await body(c, z.object({ paths: pathList }));
+    return c.json(await deleteFiles(c.req.param("id"), paths));
+  });
+
+  app.get("/api/agents/:id/files/deleted", async (c) => c.json(await listDeletedFiles(c.req.param("id"))));
+
+  app.delete("/api/agents/:id/files/deleted", async (c) => c.json(await purgeDeletedFiles(c.req.param("id"))));
+
+  app.post("/api/agents/:id/files/deleted/:entryId/restore", async (c) => c.json(await restoreDeletedFile(c.req.param("id"), c.req.param("entryId"))));
+
+  app.delete("/api/agents/:id/files/deleted/:entryId", async (c) => c.json(await purgeDeletedFiles(c.req.param("id"), c.req.param("entryId"))));
+
   /* Memory editor (MEMORY.md only; phones reach this, never the other files) */
 
   app.get("/api/agents/:id/memory", async (c) => c.json(await readAgentMemory(c.req.param("id"))));
diff --git a/packages/core/src/services/cleanup.ts b/packages/core/src/services/cleanup.ts
index 306a4eb2..e791d373 100644
--- a/packages/core/src/services/cleanup.ts
+++ b/packages/core/src/services/cleanup.ts
@@ -14,6 +14,7 @@ import { tmpdir } from "node:os";
 import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
 import type { CleanupEntry, CleanupId, CleanupItem, CleanupReport, CleanupResult, CleanupRun, HealthCheck, StorageArea, StorageUsage } from "@godmode/shared";
 import { formatBytes } from "@godmode/shared";
+import { DELETED_DAYS, expiredDeletedFiles } from "../agents/files";
 import { withRepoLock } from "../agents/repo";
 import { namedBy } from "../memory/workspace";
 import { backupInProgress } from "../backup/backup";
@@ -39,6 +40,7 @@ const NAMES = {
   "agent-scratch": "Agents' scratch files",
   "agent-run-logs": "Old run logs",
   "agent-history": "Agent file history",
+  "deleted-files": "Deleted files",
   database: "Database",
   "old-logs": "Old logs",
   "vm-downloads": "Unfinished VM downloads",
@@ -57,6 +59,7 @@ export const RECOMMENDED: CleanupId[] = [
   "agent-scratch",
   "agent-run-logs",
   "agent-history",
+  "deleted-files",
   "database",
   "old-logs",
 ];
@@ -758,6 +761,24 @@ async function vmDownloads(scan: Scan): Promise<Category | null> {
   };
 }
 
+async function deletedFiles(scan: Scan): Promise<Category> {
+  const agents = new Map(all<{ id: string; name: string; repo_path: string }>("SELECT id, name, repo_path FROM agents").map((a) => [a.id, a]));
+  const targets: Target[] = [];
+  for (const entry of expiredDeletedFiles(scan.at)) {
+    const repo = agents.get(entry.agentId)?.repo_path;
+    // Under the agent's repository lock: a "Put back" at the same moment either finishes first or finds nothing.
+    const clean = () => (repo && inside(config().agentsDir, repo) ? withRepoLock(repo, () => remove(entry.dir)) : remove(entry.dir));
+    const t = await target(scan, entry.dir, `${agents.get(entry.agentId)?.name ?? "A removed agent"} · ${entry.path}`, { clean });
+    t.entry.modifiedAt = entry.deletedAt;
+    targets.push(t);
+  }
+  return {
+    id: "deleted-files",
+    detail: `What you deleted on the Files page more than ${DELETED_DAYS} days ago. Until then it waits in the agent's bin, to be put back.`,
+    targets,
+  };
+}
+
 const TRASH_STAMP = /-(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})(?:-(\d{3}))?Z(?:-\d+)?$/;
 
 function trashedAt(name: string): number {
@@ -809,6 +830,7 @@ const SCANNERS: Record<CleanupId, (scan: Scan) => Promise<Category | null> | Cat
   "agent-scratch": agentScratch,
   "agent-run-logs": agentRunLogs,
   "agent-history": agentHistory,
+  "deleted-files": deletedFiles,
   database,
   "old-logs": oldLogs,
   "vm-downloads": vmDownloads,
diff --git a/packages/core/test/agent-files.test.ts b/packages/core/test/agent-files.test.ts
new file mode 100644
index 00000000..c13f2866
--- /dev/null
+++ b/packages/core/test/agent-files.test.ts
@@ -0,0 +1,343 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, utimesSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Agent, AgentFileInfo, AgentFileMoveResult, AgentFileSearchHit, AgentFileSize, AgentFilesDeleteResult, AgentNote, DeletedAgentFile, FileReview, GitCommit } from "@godmode/shared";
+import { loadConfig } from "../src/config";
+import { closeDb, openDb, run } from "../src/db";
+import { setLogLevel } from "../src/log";
+import { resetSettingsCache } from "../src/services/settings";
+import { createApp } from "../src/server/app";
+import { getAccessToken } from "../src/server/auth";
+import { expiredDeletedFiles } from "../src/agents/files";
+import { runCleanup, scanCleanup } from "../src/services/cleanup";
+
+let dataDir: string;
+let app: ReturnType<typeof createApp>;
+let token: string;
+let agent: Agent;
+
+async function call<T = unknown>(method: string, path: string, body?: unknown): Promise<{ status: number; data: T }> {
+  const headers: Record<string, string> = { authorization: `Bearer ${token}` };
+  if (body !== undefined) headers["content-type"] = "application/json";
+  const res = await app.request(`http://127.0.0.1${path}`, { method, headers, body: body === undefined ? undefined : JSON.stringify(body) });
+  return { status: res.status, data: (await res.json()) as T };
+}
+
+const at = (rel: string) => join(agent.repoPath, rel);
+
+function put(rel: string, content: string | Buffer, daysAgo = 0) {
+  mkdirSync(join(at(rel), ".."), { recursive: true });
+  writeFileSync(at(rel), content);
+  if (daysAgo) {
+    const t = new Date(Date.now() - daysAgo * 86_400_000);
+    utimesSync(at(rel), t, t);
+  }
+}
+
+beforeAll(async () => {
+  setLogLevel("error");
+  dataDir = mkdtempSync(join(tmpdir(), "godmode-agent-files-"));
+  loadConfig({ dataDir });
+  openDb(join(dataDir, "test.db"));
+  resetSettingsCache();
+  app = createApp();
+  token = getAccessToken();
+  agent = (await call<Agent>("POST", "/api/agents", { name: "Tidy Bot" })).data;
+  await call("GET", `/api/agents/${agent.id}/files?path=`);
+});
+
+afterAll(() => {
+  closeDb();
+  resetSettingsCache();
+  rmSync(dataDir, { recursive: true, force: true });
+});
+
+describe("files page", () => {
+  test("folder sizes count every file below, without following links", async () => {
+    put("workspace/reports/a.md", "x".repeat(1000));
+    put("workspace/reports/deep/b.txt", "y".repeat(500));
+    symlinkSync("/etc", at("workspace/reports/outside"));
+    const sizes = (await call<AgentFileSize[]>("GET", `/api/agents/${agent.id}/files/sizes?path=workspace`)).data;
+    const reports = sizes.find((s) => s.path === "workspace/reports")!;
+    expect(reports.files).toBe(3);
+    expect(reports.bytes).toBeGreaterThanOrEqual(1500);
+    expect(reports.bytes).toBeLessThan(1600);
+    expect((await call("GET", `/api/agents/${agent.id}/files/sizes?path=..`)).status).toBe(403);
+    rmSync(at("workspace/reports/outside"));
+  });
+
+  test("delete goes to the bin and comes back; Godmode's own files stay", async () => {
+    put("workspace/old/report.md", "# Old report\n");
+    put("memory/old-note.md", "# Old\n");
+    const res = await call<AgentFilesDeleteResult>("POST", `/api/agents/${agent.id}/files/delete`, {
+      paths: ["workspace/old", "workspace/old/report.md", "memory/old-note.md", "MEMORY.md", "CLAUDE.md", "runs", "workspace/tmp", "workspace/missing.md"],
+    });
+    expect(res.status).toBe(200);
+    expect(res.data.deleted.map((d) => d.path).sort()).toEqual(["memory/old-note.md", "workspace/old"]);
+    const refused = Object.fromEntries(res.data.refused.map((r) => [r.path, r.reason]));
+    expect(Object.keys(refused).sort()).toEqual(["CLAUDE.md", "MEMORY.md", "runs", "workspace/missing.md", "workspace/old/report.md", "workspace/tmp"]);
+    expect(existsSync(at("workspace/old"))).toBe(false);
+    expect(existsSync(at("MEMORY.md"))).toBe(true);
+
+    const commits = (await call<GitCommit[]>("GET", `/api/agents/${agent.id}/commits`)).data;
+    expect(commits[0]!.message).toMatch(/^Delete (memory\/old-note\.md|workspace\/old) and 1 more$/);
+
+    const bin = (await call<DeletedAgentFile[]>("GET", `/api/agents/${agent.id}/files/deleted`)).data;
+    expect(bin).toHaveLength(2);
+    const folder = bin.find((b) => b.path === "workspace/old")!;
+    expect(folder.type).toBe("dir");
+    expect(folder.files).toBe(1);
+
+    // Something new took its place meanwhile: it comes back next to it.
+    put("workspace/old", "new file");
+    const restored = await call<{ path: string }>("POST", `/api/agents/${agent.id}/files/deleted/${folder.id}/restore`);
+    expect(restored.data.path).toBe("workspace/old (restored)");
+    expect(readFileSync(at("workspace/old (restored)/report.md"), "utf8")).toBe("# Old report\n");
+
+    const note = bin.find((b) => b.path === "memory/old-note.md")!;
+    expect((await call("DELETE", `/api/agents/${agent.id}/files/deleted/${note.id}`)).status).toBe(200);
+    expect((await call<DeletedAgentFile[]>("GET", `/api/agents/${agent.id}/files/deleted`)).data).toHaveLength(0);
+    expect((await call("POST", `/api/agents/${agent.id}/files/deleted/${note.id}/restore`)).status).toBe(404);
+    expect((await call("POST", `/api/agents/${agent.id}/files/delete`, { paths: [".git/config"] })).status).toBe(403);
+  });
+
+  test("a move points the memory at the new place, never over another entry", async () => {
+    put("workspace/drafts/plan.md", "# Plan\n");
+    put("memory/topic.md", "# Topic\nSee workspace/drafts/plan.md.\n");
+    writeFileSync(at("MEMORY.md"), "# Memory\n- [Topic](memory/topic.md)\n- Plan: workspace/drafts/plan.md\n- Other agent: /x/other/workspace/drafts/plan.md\n");
+    const moved = await call<AgentFileMoveResult>("POST", `/api/agents/${agent.id}/files/move`, { from: "workspace/drafts/plan.md", to: "workspace/plans/q4.md" });
+    expect(moved.status).toBe(200);
+    expect(moved.data.rewritten.sort()).toEqual(["MEMORY.md", "memory/topic.md"]);
+    const memory = readFileSync(at("MEMORY.md"), "utf8");
+    expect(memory).toContain("- Plan: workspace/plans/q4.md");
+    expect(memory).toContain("/x/other/workspace/drafts/plan.md");
+
+    const renamed = await call<AgentFileMoveResult>("POST", `/api/agents/${agent.id}/files/move`, { from: "memory/topic.md", to: "memory/topics/main.md" });
+    expect(renamed.data.rewritten).toEqual(["MEMORY.md"]);
+    expect(readFileSync(at("MEMORY.md"), "utf8")).toContain("(memory/topics/main.md)");
+
+    put("workspace/plans/other.md", "x");
+    expect((await call("POST", `/api/agents/${agent.id}/files/move`, { from: "workspace/plans/other.md", to: "workspace/plans/q4.md" })).status).toBe(409);
+    expect((await call("POST", `/api/agents/${agent.id}/files/move`, { from: "workspace/plans", to: "workspace/plans/inner" })).status).toBe(400);
+    expect((await call("POST", `/api/agents/${agent.id}/files/move`, { from: "workspace/plans/other.md", to: "state/other.md" })).status).toBe(400);
+    expect((await call("POST", `/api/agents/${agent.id}/files/move`, { from: "MEMORY.md", to: "workspace/m.md" })).status).toBe(403);
+    expect((await call<GitCommit[]>("GET", `/api/agents/${agent.id}/commits`)).data[0]!.message).toBe("Move memory/topic.md to memory/topics/main.md");
+  });
+
+  test("inspect says what names a path and whether it may go", async () => {
+    const info = (await call<AgentFileInfo[]>("POST", `/api/agents/${agent.id}/files/inspect`, { paths: ["workspace/plans/q4.md", "memory/topics/main.md", "CLAUDE.md"] })).data;
+    const by = Object.fromEntries(info.map((i) => [i.path, i]));
+    expect(by["workspace/plans/q4.md"]!.namedBy).toContain("MEMORY.md");
+    expect(by["memory/topics/main.md"]!.namedBy).toEqual(["MEMORY.md"]);
+    expect(by["CLAUDE.md"]!.locked).toContain("settings");
+  });
+
+  test("new folders only inside workspace/ or memory/", async () => {
+    expect((await call("POST", `/api/agents/${agent.id}/files/folder`, { path: "workspace/clients/acme" })).status).toBe(200);
+    expect(existsSync(at("workspace/clients/acme"))).toBe(true);
+    expect((await call("POST", `/api/agents/${agent.id}/files/folder`, { path: "workspace/clients/acme" })).status).toBe(409);
+    expect((await call("POST", `/api/agents/${agent.id}/files/folder`, { path: "runs/x" })).status).toBe(400);
+  });
+
+  test("the review finds clutter and marks what the agent still names", async () => {
+    const big = Buffer.alloc(4096, 7);
+    put("workspace/app/package.json", "{}");
+    put("workspace/app/node_modules/left-pad/index.js", "module.exports = 1;");
+    put("workspace/app/dist/bundle.js", "x");
+    put("workspace/shots/one.png", big, 5);
+    put("workspace/shots/copy-of-one.png", big, 1);
+    put("workspace/.DS_Store", "x");
+    put("workspace/empty.txt", "");
+    mkdirSync(at("workspace/nothing-here"), { recursive: true });
+    put("workspace/archive/2026-08/notes.md", "# August\n", 60);
+    put("workspace/loose-report.md", "# Loose\n", 10);
+    put("firebase-debug.log", "debug");
+    put("memory/forgotten.md", "# Nobody links here\n");
+    writeFileSync(at("MEMORY.md"), `${readFileSync(at("MEMORY.md"), "utf8")}- [Gone](memory/gone.md)\n- Shots: workspace/shots/one.png\n`);
+
+    const review = (await call<FileReview>("GET", `/api/agents/${agent.id}/files/review?fresh=1`)).data;
+    const kind = (path: string) => review.items.find((i) => i.path === path)?.kind;
+    expect(kind("workspace/app/node_modules")).toBe("build");
+    expect(kind("workspace/app/dist")).toBe("build");
+    expect(kind("workspace/app/node_modules/left-pad/index.js")).toBeUndefined();
+    expect(kind("workspace/.DS_Store")).toBe("junk");
+    expect(kind("firebase-debug.log")).toBe("junk");
+    expect(kind("workspace/empty.txt")).toBe("empty");
+    expect(kind("workspace/nothing-here")).toBe("empty");
+    const copy = review.items.find((i) => i.path === "workspace/shots/copy-of-one.png")!;
+    expect(copy.kind).toBe("duplicate");
+    expect(copy.related).toBe("workspace/shots/one.png");
+    expect(kind("workspace/archive")).toBe("stale");
+    expect(kind("workspace/loose-report.md")).toBe("loose");
+    expect(kind("memory/forgotten.md")).toBe("unlinked-note");
+    expect(kind("memory/topics/main.md")).toBeUndefined();
+    const broken = review.items.find((i) => i.kind === "broken-link")!;
+    expect(broken.path).toBe("memory/gone.md");
+    expect(broken.related).toBe("MEMORY.md");
+    expect(review.items.some((i) => i.path === "workspace/uploads" || i.path === "workspace/tmp")).toBe(false);
+  });
+
+  test("notes list and search", async () => {
+    const notes = (await call<AgentNote[]>("GET", `/api/agents/${agent.id}/files/notes`)).data;
+    const by = Object.fromEntries(notes.map((n) => [n.path, n]));
+    expect(by["MEMORY.md"]!.linked).toBe(true);
+    expect(by["memory/topics/main.md"]!.linked).toBe(true);
+    expect(by["memory/forgotten.md"]!.linked).toBe(false);
+    expect(by["workspace/plans/q4.md"]!.title).toBe("Plan");
+    expect(by["workspace/plans/q4.md"]!.namedBy).toBe("MEMORY.md");
+
+    const hits = (await call<AgentFileSearchHit[]>("GET", `/api/agents/${agent.id}/files/search?q=nobody%20links`)).data;
+    expect(hits).toEqual([{ path: "memory/forgotten.md", type: "file", line: 1, snippet: "# Nobody links here" }]);
+    const byName = (await call<AgentFileSearchHit[]>("GET", `/api/agents/${agent.id}/files/search?q=q4`)).data;
+    expect(byName.map((h) => h.path)).toContain("workspace/plans/q4.md");
+    expect((await call<AgentFileSearchHit[]>("GET", `/api/agents/${agent.id}/files/search?q=left-pad`)).data).toEqual([]);
+  });
+
+  test("nothing moves while the agent dreams", async () => {
+    run("INSERT INTO runs (id, agent_id, conversation_id, trigger, status, prompt, created_at) VALUES ('run_dream', ?, 'cnv_dream', 'dream', 'running', '', datetime('now'))", agent.id);
+    run("INSERT INTO dreams (id, agent_id, run_id, status, reason, created_at) VALUES ('drm_x', ?, 'run_dream', 'running', 'manual', datetime('now'))", agent.id);
+    try {
+      expect((await call("POST", `/api/agents/${agent.id}/files/delete`, { paths: ["workspace/loose-report.md"] })).status).toBe(409);
+      expect((await call("POST", `/api/agents/${agent.id}/files/move`, { from: "workspace/loose-report.md", to: "workspace/r.md" })).status).toBe(409);
+    } finally {
+      run("DELETE FROM dreams WHERE id = 'drm_x'");
+      run("DELETE FROM runs WHERE id = 'run_dream'");
+    }
+  });
+
+  test("the cleanup empties what waited in the bin for 30 days", async () => {
+    put("workspace/expired.md", "bye");
+    const del = (await call<AgentFilesDeleteResult>("POST", `/api/agents/${agent.id}/files/delete`, { paths: ["workspace/expired.md"] })).data;
+    const entry = del.deleted[0]!;
+    const binEntry = join(dataDir, "agents", ".deleted-files", agent.id, entry.id);
+    writeFileSync(join(binEntry, "entry.json"), JSON.stringify({ ...entry, deletedAt: new Date(Date.now() - 31 * 86_400_000).toISOString() }));
+    expect(expiredDeletedFiles().map((e) => e.path)).toEqual(["workspace/expired.md"]);
+    const item = (await scanCleanup()).items.find((i) => i.id === "deleted-files")!;
+    expect(item.count).toBe(1);
+    expect(item.recommended).toBe(true);
+    await runCleanup(["deleted-files"]);
+    expect(existsSync(binEntry)).toBe(false);
+    expect(readdirSync(join(dataDir, "agents", ".deleted-files", agent.id))).toEqual([]);
+  });
+
+  test("overview row per agent", async () => {
+    const rows = (await call<{ agentId: string; notes: number; bytes: number }[]>("GET", "/api/files/overview")).data;
+    const row = rows.find((r) => r.agentId === agent.id)!;
+    expect(row.notes).toBeGreaterThanOrEqual(4);
+    expect(row.bytes).toBeGreaterThan(0);
+  });
+
+  test("review: a folder it couldn't look all through, or one with only junk, is never called empty", async () => {
+    let deep = "workspace/deep";
+    for (let i = 0; i < 16; i++) deep += `/d${i}`;
+    put(`${deep}/big.bin`, Buffer.alloc(5000, 1));
+    put("workspace/logs/a.bak", "backup");
+    put("workspace/downloads/video.part", "still loading");
+    const review = (await call<FileReview>("GET", `/api/agents/${agent.id}/files/review?fresh=1`)).data;
+    const kinds = Object.fromEntries(review.items.map((i) => [i.path, i.kind]));
+    expect(Object.entries(kinds).filter(([p, k]) => p.startsWith("workspace/deep") && k === "empty")).toEqual([]);
+    expect(review.partial).toBe(true);
+    expect(kinds["workspace/logs"]).toBeUndefined();
+    expect(kinds["workspace/logs/a.bak"]).toBe("junk");
+    expect(kinds["workspace/downloads/video.part"]).toBeUndefined();
+    rmSync(at("workspace/deep"), { recursive: true });
+  });
+
+  test("a new note never overwrites a file that is there", async () => {
+    put("workspace/plans/existing.md", "# Keep me\n");
+    const res = await call("PUT", `/api/agents/${agent.id}/file`, { path: "workspace/plans/existing.md", content: "# New\n", create: true });
+    expect(res.status).toBe(409);
+    expect(readFileSync(at("workspace/plans/existing.md"), "utf8")).toBe("# Keep me\n");
+    expect((await call("PUT", `/api/agents/${agent.id}/file`, { path: "workspace/plans/brand-new.md", content: "# New\n", create: true })).status).toBe(200);
+  });
+
+  test("search and notes don't follow a linked MEMORY.md or memory/ out of the repository", async () => {
+    const outside = mkdtempSync(join(tmpdir(), "godmode-outside-"));
+    writeFileSync(join(outside, "secret.txt"), "TOPSECRET line here\n");
+    mkdirSync(join(outside, "notes"));
+    writeFileSync(join(outside, "notes", "x.md"), "# Outside note TOPSECRET\n");
+    const memory = readFileSync(at("MEMORY.md"), "utf8");
+    rmSync(at("MEMORY.md"));
+    symlinkSync(join(outside, "secret.txt"), at("MEMORY.md"));
+    try {
+      expect((await call<AgentFileSearchHit[]>("GET", `/api/agents/${agent.id}/files/search?q=topsecret`)).data).toEqual([]);
+    } finally {
+      rmSync(at("MEMORY.md"));
+      writeFileSync(at("MEMORY.md"), memory);
+    }
+    const other = (await call<Agent>("POST", "/api/agents", { name: "Linked Bot" })).data;
+    await call("GET", `/api/agents/${other.id}/files?path=`);
+    rmSync(join(other.repoPath, "memory"), { recursive: true });
+    symlinkSync(join(outside, "notes"), join(other.repoPath, "memory"));
+    const notes = (await call<AgentNote[]>("GET", `/api/agents/${other.id}/files/notes`)).data;
+    expect(notes.some((n) => n.title.includes("Outside"))).toBe(false);
+    expect((await call<AgentFileSearchHit[]>("GET", `/api/agents/${other.id}/files/search?q=topsecret`)).data).toEqual([]);
+    rmSync(outside, { recursive: true, force: true });
+  });
+
+  test("a deleted link that points nowhere from the bin can still be put back", async () => {
+    put("workspace/links/target.txt", "t");
+    symlinkSync("target.txt", at("workspace/links/rel-link"));
+    const del = (await call<AgentFilesDeleteResult>("POST", `/api/agents/${agent.id}/files/delete`, { paths: ["workspace/links/rel-link"] })).data;
+    expect(del.deleted).toHaveLength(1);
+    const bin = (await call<DeletedAgentFile[]>("GET", `/api/agents/${agent.id}/files/deleted`)).data;
+    expect(bin.map((b) => b.path)).toContain("workspace/links/rel-link");
+    const back = await call<{ path: string }>("POST", `/api/agents/${agent.id}/files/deleted/${del.deleted[0]!.id}/restore`);
+    expect(back.data.path).toBe("workspace/links/rel-link");
+    expect(readFileSync(at("workspace/links/rel-link"), "utf8")).toBe("t");
+  });
+
+  test("moves: top-level names, links next to a note and [[names]] follow; nothing goes into tmp/ or uploads/", async () => {
+    put("todo.txt", "loose");
+    put("memory/clients/index.md", "# Clients\n- [todo](todo.txt)\n- [Acme](acme.md)\n- See [[acme]] and [[acme|the Acme note]]\n");
+    put("memory/clients/acme.md", "# Acme\n");
+    put("memory/clients/todo.txt", "client todo");
+    const top = await call<AgentFileMoveResult>("POST", `/api/agents/${agent.id}/files/move`, { from: "todo.txt", to: "workspace/todo.txt" });
+    expect(top.status).toBe(200);
+    expect(readFileSync(at("memory/clients/index.md"), "utf8")).toContain("[todo](todo.txt)");
+
+    const note = await call<AgentFileMoveResult>("POST", `/api/agents/${agent.id}/files/move`, { from: "memory/clients/acme.md", to: "memory/accounts/acme-gmbh.md" });
+    expect(note.data.rewritten).toContain("memory/clients/index.md");
+    const index = readFileSync(at("memory/clients/index.md"), "utf8");
+    expect(index).toContain("[Acme](../accounts/acme-gmbh.md)");
+    expect(index).toContain("[[acme-gmbh]] and [[acme-gmbh|the Acme note]]");
+
+    expect((await call("POST", `/api/agents/${agent.id}/files/move`, { from: "workspace/todo.txt", to: "workspace/tmp/todo.txt" })).status).toBe(400);
+    expect((await call("POST", `/api/agents/${agent.id}/files/move`, { from: "workspace/todo.txt", to: "workspace/TMP/todo.txt" })).status).toBe(400);
+    expect((await call("POST", `/api/agents/${agent.id}/files/move`, { from: "workspace/todo.txt", to: "workspace/uploads/todo.txt" })).status).toBe(400);
+    expect((await call("POST", `/api/agents/${agent.id}/files/folder`, { path: "workspace/tmp/new" })).status).toBe(400);
+  });
+
+  test("locked paths stay locked in any spelling", async () => {
+    const res = (await call<AgentFilesDeleteResult>("POST", `/api/agents/${agent.id}/files/delete`, { paths: ["memory.md", "Workspace", "Conversations", "workspace/TMP"] })).data;
+    expect(res.deleted).toEqual([]);
+    expect(res.refused).toHaveLength(4);
+    expect(existsSync(at("MEMORY.md"))).toBe(true);
+  });
+
+  test("a memory note named in the instructions counts as named, not unlinked", async () => {
+    put("memory/pinned-playbook.md", "# Pinned\n");
+    await call("PATCH", `/api/agents/${agent.id}`, { instructions: "Before a release read memory/pinned-playbook.md." });
+    const review = (await call<FileReview>("GET", `/api/agents/${agent.id}/files/review?fresh=1`)).data;
+    expect(review.items.find((i) => i.path === "memory/pinned-playbook.md")).toBeUndefined();
+    const info = (await call<AgentFileInfo[]>("POST", `/api/agents/${agent.id}/files/inspect`, { paths: ["memory/pinned-playbook.md"] })).data;
+    expect(info[0]!.namedBy).toEqual(["the instructions"]);
+  });
+
+  test("the bin: a tampered entry goes nowhere, a broken one doesn't break the list", async () => {
+    put("workspace/tamper.md", "x");
+    const del = (await call<AgentFilesDeleteResult>("POST", `/api/agents/${agent.id}/files/delete`, { paths: ["workspace/tamper.md"] })).data;
+    const entry = del.deleted[0]!;
+    const binRoot = join(dataDir, "agents", ".deleted-files", agent.id);
+    writeFileSync(join(binRoot, entry.id, "entry.json"), JSON.stringify({ ...entry, path: ".claude/settings.json" }));
+    expect((await call("POST", `/api/agents/${agent.id}/files/deleted/${entry.id}/restore`)).status).toBe(400);
+    expect(existsSync(at(".claude/settings.json"))).toBe(false);
+    mkdirSync(join(binRoot, "brokenentry1"), { recursive: true });
+    writeFileSync(join(binRoot, "brokenentry1", "entry.json"), JSON.stringify({ path: "workspace/x.md" }));
+    const bin = await call<DeletedAgentFile[]>("GET", `/api/agents/${agent.id}/files/deleted`);
+    expect(bin.status).toBe(200);
+    expect(bin.data.map((b) => b.id)).toContain(entry.id);
+    expect((await call("GET", "/api/files/overview")).status).toBe(200);
+  });
+});
diff --git a/packages/shared/src/api.ts b/packages/shared/src/api.ts
index 4c5dff47..c8ad532d 100644
--- a/packages/shared/src/api.ts
+++ b/packages/shared/src/api.ts
@@ -555,6 +555,116 @@ export interface AgentFileEntry {
   modifiedAt: string;
 }
 
+/* ------------------------------------------------------------------ */
+/* Files page: the human tidies an agent's repository                  */
+/* ------------------------------------------------------------------ */
+
+/** Size of a file or folder: every file below it counted, symlinks never followed. */
+export interface AgentFileSize {
+  path: string;
+  bytes: number;
+  files: number;
+  /** Newest change of a file in it (a folder without files: its own). */
+  modifiedAt: string | null;
+  /** The count stopped early (a very large folder): at least this much. */
+  partial: boolean;
+}
+
+/** GET /api/files/overview — one row per agent, for picking the one to tidy. */
+export interface AgentFilesOverview {
+  agentId: ID;
+  /** workspace/, memory/ and MEMORY.md together. */
+  bytes: number;
+  workspaceBytes: number;
+  /** Of that, what lies in workspace/tmp (Godmode clears it by itself). */
+  scratchBytes: number;
+  /** Markdown notes in memory/ and workspace/ (tmp/ and uploads/ left out). */
+  notes: number;
+  memoryChars: number;
+  /** Entries in the agent's bin (deleted on the Files page, not yet emptied). */
+  deleted: number;
+  partial: boolean;
+}
+
+/** What the agent keeps about a path, before it is moved or deleted. */
+export interface AgentFileInfo extends AgentFileSize {
+  type: "file" | "dir";
+  /** Where it is named ("MEMORY.md", "the automation …"); empty = nowhere. */
+  namedBy: string[];
+  /** Why it can't be moved or deleted here (null = it can). */
+  locked: string | null;
+}
+
+export type FileReviewKind = "build" | "junk" | "empty" | "duplicate" | "large" | "scratch" | "stale" | "loose" | "unlinked-note" | "broken-link";
+
+/** One thing on the Files page's Review list. */
+export interface FileReviewItem {
+  kind: FileReviewKind;
+  path: string;
+  type: "file" | "dir";
+  bytes: number;
+  files: number;
+  modifiedAt: string | null;
+  /** Why it is on the list, in a sentence. */
+  detail: string;
+  /** Where the agent names it (it may still need it); null = nowhere. */
+  namedBy: string | null;
+  /** duplicate: the copy that stays. broken-link: the file that links to the missing path. */
+  related: string | null;
+}
+
+export interface FileReview {
+  agentId: ID;
+  checkedAt: ISODate;
+  items: FileReviewItem[];
+  /** The look stopped early (a very large repository): there may be more. */
+  partial: boolean;
+}
+
+/** A Markdown note of the agent, for the Notes list. */
+export interface AgentNote {
+  path: string;
+  title: string;
+  bytes: number;
+  modifiedAt: string;
+  /** MEMORY.md, or a note MEMORY.md or another memory note links to (unlinked memory notes are rarely read). */
+  linked: boolean;
+  namedBy: string | null;
+}
+
+export interface AgentFileSearchHit {
+  path: string;
+  type: "file" | "dir";
+  /** 1-based line of the first match in the content; null = the name matched. */
+  line: number | null;
+  snippet: string | null;
+}
+
+/** An entry the human deleted on the Files page: kept in the agent's bin until it is put back or emptied. */
+export interface DeletedAgentFile {
+  id: string;
+  path: string;
+  type: "file" | "dir";
+  bytes: number;
+  files: number;
+  deletedAt: ISODate;
+}
+
+export interface AgentFilesDeleteResult {
+  deleted: DeletedAgentFile[];
+  refused: { path: string; reason: string }[];
+}
+
+export interface AgentFileMoveResult {
+  path: string;
+  /** Memory files whose mentions of the old path now point at the new one. */
+  rewritten: string[];
+}
+
+export interface AgentFileRestoreResult {
+  path: string;
+}
+
 export interface GitCommit {
   oid: string;
   message: string;
diff --git a/packages/shared/src/models.ts b/packages/shared/src/models.ts
index 21fc9575..e30f6d21 100644
--- a/packages/shared/src/models.ts
+++ b/packages/shared/src/models.ts
@@ -1792,7 +1792,8 @@ export type CleanupId =
   | "vm-images"
   | "agent-scratch"
   | "agent-run-logs"
-  | "agent-history";
+  | "agent-history"
+  | "deleted-files";
 
 export interface CleanupEntry {
   name: string;