diff --git a/.env.example b/.env.example
index 53ee8b9..ac25192 100644
--- a/.env.example
+++ b/.env.example
@@ -12,3 +12,11 @@ SUPABASE_SERVICE_ROLE_KEY=
 MUMBL_TOKEN_HASH_SECRET=
 MUMBL_SIDE_QUEST_ENCRYPTION_KEY=
 CRON_SECRET=
+
+# Server-only AI settings for opt-in dump field-note drafts.
+OPENAI_API_KEY=
+OPENAI_MODEL_FIELD_NOTE=gpt-5.4-nano
+OPENAI_MAX_DAILY_DRAFTS=20
+
+# Server-only memory graph settings for private dump map sync/search.
+SUPERMEMORY_API_KEY=
diff --git a/AGENTS.md b/AGENTS.md
index 6aabdaf..c7861d7 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -34,6 +34,7 @@ When deciding whether to add a feature, ask whether it makes Mumbl feel more lik
 Work like a senior engineer:
 
 - Inspect existing patterns before adding new ones.
+- Use TypeScript for new code going forward. When touching existing JavaScript files, opportunistically migrate them to TypeScript only when it is low-risk, keeps the change scoped, and does not break existing behavior. Prefer explicit local types for API payloads, server responses, and component props as files are migrated.
 - Keep changes tightly scoped to the request.
 - Prefer simple modules and explicit data flow over clever abstractions.
 - Add abstractions only when they remove real duplication or match an existing local pattern.
diff --git a/app/[publicHandle]/page.jsx b/app/[publicHandle]/page.jsx
new file mode 100644
index 0000000..7116205
--- /dev/null
+++ b/app/[publicHandle]/page.jsx
@@ -0,0 +1,14 @@
+import { notFound } from "next/navigation";
+import PublicProfilePage, { getPublicProfileMetadata } from "../../src/components/PublicProfilePage";
+
+export async function generateMetadata({ params }) {
+  const { publicHandle } = await params;
+  if (!publicHandle?.startsWith("@")) return {};
+  return getPublicProfileMetadata(publicHandle);
+}
+
+export default async function RootPublicProfilePage({ params }) {
+  const { publicHandle } = await params;
+  if (!publicHandle?.startsWith("@")) notFound();
+  return <PublicProfilePage rawHandle={publicHandle} />;
+}
diff --git a/app/api/dumps/[dumpId]/route.js b/app/api/dumps/[dumpId]/route.js
new file mode 100644
index 0000000..2b356cf
--- /dev/null
+++ b/app/api/dumps/[dumpId]/route.js
@@ -0,0 +1,62 @@
+import { badRequest, notFound, ok, serverError } from "../../../../src/server/http";
+import { hashToken } from "../../../../src/server/hash";
+import { makeLocalReflection, serializeDump } from "../../../../src/server/dumps";
+import { getSupabaseAdmin } from "../../../../src/server/supabase";
+import { cleanString } from "../../../../src/server/validation";
+
+export async function PATCH(request, { params }) {
+  try {
+    const { dumpId } = await params;
+    const body = await request.json();
+    const sessionToken = cleanString(body.sessionToken, 256);
+    const content = cleanString(body.content, 4000);
+    const wantsReflection = body.wantsReflection === true;
+
+    if (!dumpId) return badRequest("dump id is required");
+    if (!sessionToken) return badRequest("session token is required");
+    if (!content) return badRequest("dump content is required");
+
+    const supabase = getSupabaseAdmin();
+    const { data: dump, error } = await supabase
+      .from("dumps")
+      .update({
+        content,
+        ai_reflection: wantsReflection ? makeLocalReflection(content) : null,
+        updated_at: new Date().toISOString(),
+      })
+      .eq("id", dumpId)
+      .eq("session_token_hash", hashToken(sessionToken))
+      .select("*")
+      .single();
+    if (error?.code === "PGRST116") return notFound("dump not found");
+    if (error) throw error;
+
+    return ok({ dump: serializeDump(dump) });
+  } catch (error) {
+    return serverError(error);
+  }
+}
+
+export async function DELETE(request, { params }) {
+  try {
+    const { dumpId } = await params;
+    const body = await request.json();
+    const sessionToken = cleanString(body.sessionToken, 256);
+
+    if (!dumpId) return badRequest("dump id is required");
+    if (!sessionToken) return badRequest("session token is required");
+
+    const supabase = getSupabaseAdmin();
+    const { error, count } = await supabase
+      .from("dumps")
+      .delete({ count: "exact" })
+      .eq("id", dumpId)
+      .eq("session_token_hash", hashToken(sessionToken));
+    if (error) throw error;
+    if (!count) return notFound("dump not found");
+
+    return ok({ deleted: true });
+  } catch (error) {
+    return serverError(error);
+  }
+}
diff --git a/app/api/dumps/[dumpId]/team/route.js b/app/api/dumps/[dumpId]/team/route.js
new file mode 100644
index 0000000..0ab558b
--- /dev/null
+++ b/app/api/dumps/[dumpId]/team/route.js
@@ -0,0 +1,9 @@
+import { badRequest, serverError } from "../../../../../src/server/http";
+
+export async function POST(request, { params }) {
+  try {
+    return badRequest("raw dumps stay private. draft and publish a field note instead.");
+  } catch (error) {
+    return serverError(error);
+  }
+}
diff --git a/app/api/dumps/field-notes/[fieldNoteId]/public/route.js b/app/api/dumps/field-notes/[fieldNoteId]/public/route.js
new file mode 100644
index 0000000..1220136
--- /dev/null
+++ b/app/api/dumps/field-notes/[fieldNoteId]/public/route.js
@@ -0,0 +1,92 @@
+import { badRequest, notFound, ok, serverError } from "../../../../../../src/server/http";
+import { hashToken } from "../../../../../../src/server/hash";
+import { serializeFieldNote } from "../../../../../../src/server/dumps";
+import { getSupabaseAdmin } from "../../../../../../src/server/supabase";
+import { cleanString } from "../../../../../../src/server/validation";
+import { normalizeHandle, serializePublicProfile } from "../../../../../../src/server/publicProfiles";
+
+export async function PATCH(request, { params }) {
+  try {
+    const { fieldNoteId } = await params;
+    const body = await request.json();
+    const sessionToken = cleanString(body.sessionToken, 256);
+    const isPublic = body.isPublic === true;
+    const handle = normalizeHandle(body.handle);
+
+    if (!fieldNoteId) return badRequest("field note id is required");
+    if (!sessionToken) return badRequest("session token is required");
+    if (isPublic && !handle) return badRequest("choose a public handle first");
+
+    const supabase = getSupabaseAdmin();
+    const sessionTokenHash = hashToken(sessionToken);
+    const { data: fieldNote, error: noteError } = await supabase
+      .from("field_notes")
+      .select("*")
+      .eq("id", fieldNoteId)
+      .eq("session_token_hash", sessionTokenHash)
+      .single();
+    if (noteError?.code === "PGRST116") return notFound("field note not found");
+    if (isMissingColumnError(noteError) || isMissingTableError(noteError)) return serverError(missingPublicProfileMigrationError());
+    if (noteError) throw noteError;
+    if (isPublic && !fieldNote.is_published) return badRequest("publish to team reads before putting this on your profile");
+
+    let profile = null;
+    if (isPublic) {
+      const { data: profileRow, error: profileError } = await supabase
+        .from("public_profiles")
+        .select("*")
+        .eq("session_token_hash", sessionTokenHash)
+        .eq("handle", handle)
+        .single();
+      if (profileError?.code === "PGRST116") return badRequest("create that public handle first");
+      if (isMissingTableError(profileError)) return serverError(missingPublicProfileMigrationError());
+      if (profileError) throw profileError;
+      profile = profileRow;
+    }
+
+    const updates = isPublic
+      ? {
+          is_public: true,
+          public_profile_id: profile.id,
+          public_published_at: fieldNote.public_published_at || new Date().toISOString(),
+        }
+      : {
+          is_public: false,
+          public_profile_id: null,
+          public_published_at: null,
+        };
+
+    const { data: updatedNote, error: updateError } = await supabase
+      .from("field_notes")
+      .update(updates)
+      .eq("id", fieldNote.id)
+      .eq("session_token_hash", sessionTokenHash)
+      .select("*")
+      .single();
+    if (isMissingColumnError(updateError)) return serverError(missingPublicProfileMigrationError());
+    if (updateError) throw updateError;
+
+    return ok({
+      fieldNote: serializeFieldNote(updatedNote),
+      profile: profile ? serializePublicProfile(profile) : null,
+    });
+  } catch (error) {
+    return serverError(error);
+  }
+}
+
+function isMissingTableError(error) {
+  const message = `${error?.message || ""} ${error?.details || ""} ${error?.hint || ""}`.toLowerCase();
+  return error?.code === "42P01" || error?.code === "PGRST205" || message.includes("could not find the table");
+}
+
+function isMissingColumnError(error) {
+  const message = `${error?.message || ""} ${error?.details || ""} ${error?.hint || ""}`.toLowerCase();
+  return error?.code === "42703" || error?.code === "PGRST204" || (message.includes("could not find") && message.includes("column"));
+}
+
+function missingPublicProfileMigrationError() {
+  const error = new Error("Public profile migration is not applied yet. Run supabase/migrations/0015_public_profiles.sql.");
+  error.status = 503;
+  return error;
+}
diff --git a/app/api/dumps/field-notes/[fieldNoteId]/publish/route.js b/app/api/dumps/field-notes/[fieldNoteId]/publish/route.js
new file mode 100644
index 0000000..4ac948d
--- /dev/null
+++ b/app/api/dumps/field-notes/[fieldNoteId]/publish/route.js
@@ -0,0 +1,82 @@
+import { badRequest, notFound, ok, serverError } from "../../../../../../src/server/http";
+import { enforceRateLimit } from "../../../../../../src/server/rateLimit";
+import { hashToken } from "../../../../../../src/server/hash";
+import { serializeFieldNote } from "../../../../../../src/server/dumps";
+import { getSupabaseAdmin } from "../../../../../../src/server/supabase";
+import { cleanString } from "../../../../../../src/server/validation";
+
+export async function POST(request, { params }) {
+  try {
+    const { fieldNoteId } = await params;
+    const body = await request.json();
+    const slug = cleanString(body.slug, 64);
+    const sessionToken = cleanString(body.sessionToken, 256);
+    const title = cleanString(body.title, 120);
+    const content = cleanString(body.content, 4000);
+    const isAnonymous = body.isAnonymous !== false;
+    const displayName = isAnonymous ? null : cleanString(body.displayName, 48) || "someone brave";
+
+    if (!fieldNoteId) return badRequest("field note id is required");
+    if (!slug) return badRequest("space slug is required");
+    if (!sessionToken) return badRequest("session token is required");
+    if (!title) return badRequest("field note title is required");
+    if (!content) return badRequest("field note content is required");
+
+    const supabase = getSupabaseAdmin();
+    await enforceRateLimit({ supabase, action: "post", sessionToken });
+    const sessionTokenHash = hashToken(sessionToken);
+
+    const [{ data: fieldNote, error: noteError }, { data: space, error: spaceError }] = await Promise.all([
+      supabase.from("field_notes").select("*").eq("id", fieldNoteId).eq("session_token_hash", sessionTokenHash).single(),
+      supabase.from("spaces").select("id").eq("slug", slug).single(),
+    ]);
+    if (noteError?.code === "PGRST116") return notFound("field note not found");
+    if (spaceError?.code === "PGRST116") return notFound("space not found");
+    if (noteError) throw noteError;
+    if (spaceError) throw spaceError;
+    if (fieldNote.is_published) return badRequest("field note is already published");
+
+    const { data: post, error: postError } = await supabase
+      .from("posts")
+      .insert({
+        space_id: space.id,
+        type: "field_note",
+        field_note_title: title,
+        content,
+        is_anonymous: isAnonymous,
+        display_name: displayName,
+      })
+      .select()
+      .single();
+    if (postError) throw postError;
+
+    const { data: updatedNote, error: updateError } = await supabase
+      .from("field_notes")
+      .update({
+        team_room_id: space.id,
+        title,
+        content,
+        is_published: true,
+        published_post_id: post.id,
+        published_at: new Date().toISOString(),
+      })
+      .eq("id", fieldNote.id)
+      .eq("session_token_hash", sessionTokenHash)
+      .select("*")
+      .single();
+    if (updateError) throw updateError;
+
+    if (isAnonymous) {
+      await supabase.from("anon_audit").insert({
+        post_id: post.id,
+        session_token_hash: sessionTokenHash,
+      });
+    }
+
+    await supabase.from("spaces").update({ first_post_done: true }).eq("id", space.id);
+
+    return ok({ fieldNote: serializeFieldNote(updatedNote), post });
+  } catch (error) {
+    return serverError(error);
+  }
+}
diff --git a/app/api/dumps/field-notes/[fieldNoteId]/route.js b/app/api/dumps/field-notes/[fieldNoteId]/route.js
new file mode 100644
index 0000000..09c4300
--- /dev/null
+++ b/app/api/dumps/field-notes/[fieldNoteId]/route.js
@@ -0,0 +1,91 @@
+import { badRequest, notFound, ok, serverError } from "../../../../../src/server/http";
+import { hashToken } from "../../../../../src/server/hash";
+import { serializeFieldNote } from "../../../../../src/server/dumps";
+import { getSupabaseAdmin } from "../../../../../src/server/supabase";
+import { cleanString } from "../../../../../src/server/validation";
+
+export async function PATCH(request, { params }) {
+  try {
+    const { fieldNoteId } = await params;
+    const body = await request.json();
+    const sessionToken = cleanString(body.sessionToken, 256);
+    const title = cleanString(body.title, 120);
+    const content = cleanString(body.content, 4000);
+
+    if (!fieldNoteId) return badRequest("field note id is required");
+    if (!sessionToken) return badRequest("session token is required");
+    if (!title) return badRequest("field note title is required");
+    if (!content) return badRequest("field note content is required");
+
+    const supabase = getSupabaseAdmin();
+    const sessionTokenHash = hashToken(sessionToken);
+    const { data: fieldNote, error: noteError } = await supabase
+      .from("field_notes")
+      .select("*")
+      .eq("id", fieldNoteId)
+      .eq("session_token_hash", sessionTokenHash)
+      .single();
+    if (noteError?.code === "PGRST116") return notFound("field note not found");
+    if (noteError) throw noteError;
+
+    const updates = { title, content };
+    const { data: updatedNote, error: updateError } = await supabase
+      .from("field_notes")
+      .update(updates)
+      .eq("id", fieldNote.id)
+      .eq("session_token_hash", sessionTokenHash)
+      .select("*")
+      .single();
+    if (updateError) throw updateError;
+
+    if (fieldNote.is_published && fieldNote.published_post_id) {
+      const { error: postError } = await supabase
+        .from("posts")
+        .update({ field_note_title: title, content })
+        .eq("id", fieldNote.published_post_id);
+      if (postError) throw postError;
+    }
+
+    return ok({ fieldNote: serializeFieldNote(updatedNote) });
+  } catch (error) {
+    return serverError(error);
+  }
+}
+
+export async function DELETE(request, { params }) {
+  try {
+    const { fieldNoteId } = await params;
+    const body = await request.json();
+    const sessionToken = cleanString(body.sessionToken, 256);
+
+    if (!fieldNoteId) return badRequest("field note id is required");
+    if (!sessionToken) return badRequest("session token is required");
+
+    const supabase = getSupabaseAdmin();
+    const sessionTokenHash = hashToken(sessionToken);
+    const { data: fieldNote, error: noteError } = await supabase
+      .from("field_notes")
+      .select("*")
+      .eq("id", fieldNoteId)
+      .eq("session_token_hash", sessionTokenHash)
+      .single();
+    if (noteError?.code === "PGRST116") return notFound("field note not found");
+    if (noteError) throw noteError;
+
+    if (fieldNote.published_post_id) {
+      const { error: postError } = await supabase.from("posts").delete().eq("id", fieldNote.published_post_id);
+      if (postError) throw postError;
+    }
+
+    const { error: deleteError } = await supabase
+      .from("field_notes")
+      .delete()
+      .eq("id", fieldNote.id)
+      .eq("session_token_hash", sessionTokenHash);
+    if (deleteError) throw deleteError;
+
+    return ok({ deleted: true });
+  } catch (error) {
+    return serverError(error);
+  }
+}
diff --git a/app/api/dumps/field-notes/draft/route.js b/app/api/dumps/field-notes/draft/route.js
new file mode 100644
index 0000000..0a04980
--- /dev/null
+++ b/app/api/dumps/field-notes/draft/route.js
@@ -0,0 +1,52 @@
+import { badRequest, ok, serverError } from "../../../../../src/server/http";
+import { draftFieldNote } from "../../../../../src/server/fieldNotes";
+import { hashToken } from "../../../../../src/server/hash";
+import { enforceRateLimit } from "../../../../../src/server/rateLimit";
+import { serializeFieldNote } from "../../../../../src/server/dumps";
+import { getSupabaseAdmin } from "../../../../../src/server/supabase";
+import { cleanString } from "../../../../../src/server/validation";
+
+const MAX_DUMPS_PER_DRAFT = 10;
+
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const sessionToken = cleanString(body.sessionToken, 256);
+    const dumpIds = Array.isArray(body.dumpIds) ? body.dumpIds.map((id) => cleanString(id, 64)).filter(Boolean) : [];
+
+    if (!sessionToken) return badRequest("session token is required");
+    if (!dumpIds.length) return badRequest("choose at least one dump");
+    if (dumpIds.length > MAX_DUMPS_PER_DRAFT) return badRequest(`choose ${MAX_DUMPS_PER_DRAFT} dumps or fewer`);
+
+    const supabase = getSupabaseAdmin();
+    await enforceRateLimit({ supabase, action: "field_note", sessionToken });
+
+    const sessionTokenHash = hashToken(sessionToken);
+    const { data: dumps, error: dumpsError } = await supabase
+      .from("dumps")
+      .select("*")
+      .eq("session_token_hash", sessionTokenHash)
+      .in("id", dumpIds);
+    if (dumpsError) throw dumpsError;
+    if (!dumps?.length) return badRequest("no matching private dumps found");
+
+    const orderedDumps = dumpIds.map((id) => dumps.find((dump) => dump.id === id)).filter(Boolean);
+    const draft = await draftFieldNote({ dumps: orderedDumps });
+
+    const { data: fieldNote, error: noteError } = await supabase
+      .from("field_notes")
+      .insert({
+        session_token_hash: sessionTokenHash,
+        source_dump_ids: draft.sourceDumpIds,
+        title: draft.title || "field note",
+        content: draft.content,
+      })
+      .select("*")
+      .single();
+    if (noteError) throw noteError;
+
+    return ok({ fieldNote: serializeFieldNote(fieldNote), visibilityReminder: draft.visibilityReminder });
+  } catch (error) {
+    return serverError(error);
+  }
+}
diff --git a/app/api/dumps/map/route.ts b/app/api/dumps/map/route.ts
new file mode 100644
index 0000000..d639296
--- /dev/null
+++ b/app/api/dumps/map/route.ts
@@ -0,0 +1,339 @@
+import { badRequest, ok, serverError } from "../../../../src/server/http";
+import { hashToken } from "../../../../src/server/hash";
+import { getSupabaseAdmin } from "../../../../src/server/supabase";
+import { cleanString } from "../../../../src/server/validation";
+import {
+  addFieldNoteMemory,
+  addPrivateDumpMemory,
+  type DumpSearchProbe,
+  isSupermemoryConfigured,
+  makeDumpGraph,
+  searchPrivateDumpMemories,
+  searchFieldNoteMemories,
+} from "../../../../src/server/supermemory";
+
+const SYNC_BATCH_SIZE = 12;
+const SEARCH_PROBES: DumpSearchProbe[] = [
+  {
+    id: "blockers",
+    label: "blockers and stuck loops",
+    tone: "clay",
+    query: "private work notes about blockers, stuck loops, confusion, waiting, unresolved friction, things that keep coming back",
+  },
+  {
+    id: "momentum",
+    label: "momentum and wins",
+    tone: "mint",
+    query: "private work notes about wins, shipped work, progress, useful decisions, flow, energy, what is working",
+  },
+  {
+    id: "team-process",
+    label: "team process signals",
+    tone: "gold",
+    query: "private work notes about meetings, standup, planning, collaboration, handoffs, team process, communication gaps",
+  },
+  {
+    id: "load",
+    label: "load and attention",
+    tone: "violet",
+    query: "private work notes about tiredness, overload, attention, context switching, burnout, hard days, emotional load",
+  },
+];
+
+type DumpRow = {
+  id: string;
+  content: string;
+  created_at: string;
+  supermemory_id?: string | null;
+  supermemory_status?: string | null;
+};
+
+type FieldNoteRow = {
+  id: string;
+  title: string;
+  content: string;
+  source_dump_ids: string[];
+  is_published: boolean;
+  published_at?: string | null;
+  created_at: string;
+  supermemory_id?: string | null;
+  supermemory_status?: string | null;
+  supermemory_synced_at?: string | null;
+};
+
+type SupabaseAdmin = ReturnType<typeof getSupabaseAdmin>;
+
+export async function GET(request: Request) {
+  try {
+    const url = new URL(request.url);
+    const sessionToken = cleanString(url.searchParams.get("sessionToken"), 256);
+    const includePrivateDumps = url.searchParams.get("includePrivateDumps") === "true";
+    if (!sessionToken) return badRequest("session token is required");
+
+    const supabase = getSupabaseAdmin();
+    const sessionTokenHash = hashToken(sessionToken);
+    const [{ data: dumps, error }, { data: fieldNotes, error: fieldNotesError }] = await Promise.all([
+      supabase
+        .from("dumps")
+        .select("id, content, created_at, supermemory_id, supermemory_status")
+        .eq("session_token_hash", sessionTokenHash)
+        .order("created_at", { ascending: false })
+        .limit(80),
+      supabase
+        .from("field_notes")
+        .select("*")
+        .eq("session_token_hash", sessionTokenHash)
+        .order("created_at", { ascending: false })
+        .limit(50),
+    ]);
+    const hasFieldNoteSupermemoryColumns = !isMissingColumnError(fieldNotesError);
+    if (isMissingTableError(error) || isMissingTableError(fieldNotesError)) {
+      return serverError(missingDumpMigrationError());
+    }
+    if (error) throw error;
+    if (fieldNotesError && hasFieldNoteSupermemoryColumns) throw fieldNotesError;
+
+    const fallbackFieldNotes = hasFieldNoteSupermemoryColumns
+      ? fieldNotes || []
+      : await loadFieldNotesWithoutSupermemoryColumns({ supabase, sessionTokenHash });
+
+    const dumpRows = dumps || [];
+    const fieldNoteRows = fallbackFieldNotes;
+    let source: "local" | "supermemory" = "local";
+    let syncError = "";
+    let searchResults: unknown[] = [];
+
+    if (isSupermemoryConfigured() && hasFieldNoteSupermemoryColumns && (fieldNoteRows.length || (includePrivateDumps && dumpRows.length))) {
+      try {
+        await syncMissingFieldNotes({ supabase, fieldNotes: fieldNoteRows, sessionTokenHash });
+        if (includePrivateDumps) {
+          await syncOptedInPrivateDumps({ supabase, dumps: dumpRows, sessionTokenHash });
+        }
+        searchResults = (
+          await Promise.all(
+            SEARCH_PROBES.map(async (probe) => {
+              const fieldNoteResults = await searchFieldNoteMemories({
+                sessionTokenHash,
+                query: probe.query,
+                limit: 6,
+              });
+              const privateDumpResults = includePrivateDumps
+                ? await searchPrivateDumpMemories({
+                    sessionTokenHash,
+                    query: probe.query,
+                    limit: 6,
+                  })
+                : [];
+              return [...fieldNoteResults, ...privateDumpResults].map((result) => ({
+                ...(result && typeof result === "object" ? result : {}),
+                probe: {
+                  id: probe.id,
+                  label: probe.label,
+                  tone: probe.tone,
+                },
+              }));
+            }),
+          )
+        ).flat();
+        source = "supermemory";
+      } catch (error) {
+        console.warn("Supermemory map sync failed", error);
+        syncError = error instanceof Error ? error.message : "Supermemory sync failed";
+      }
+    }
+
+    const memoryStatus = makeMemoryStatus({
+      configured: isSupermemoryConfigured(),
+      hasFieldNoteSupermemoryColumns,
+      includePrivateDumps,
+      source,
+      syncError,
+      fieldNoteCount: fieldNoteRows.length,
+      dumpCount: dumpRows.length,
+    });
+
+    return ok({
+      graph: makeDumpGraph({ dumps: dumpRows, fieldNotes: fieldNoteRows, includePrivateDumps, searchResults, source }),
+      supermemory: {
+        configured: isSupermemoryConfigured(),
+        status: memoryStatus.status,
+        label: memoryStatus.label,
+        detail: memoryStatus.detail,
+        source,
+        syncError: syncError ? "Memory sync is unavailable right now. Showing a lower-confidence local read." : "",
+        includePrivateDumps,
+      },
+    });
+  } catch (error) {
+    return serverError(error);
+  }
+}
+
+function makeMemoryStatus({
+  configured,
+  hasFieldNoteSupermemoryColumns,
+  includePrivateDumps,
+  source,
+  syncError,
+  fieldNoteCount,
+  dumpCount,
+}: {
+  configured: boolean;
+  hasFieldNoteSupermemoryColumns: boolean;
+  includePrivateDumps: boolean;
+  source: "local" | "supermemory";
+  syncError: string;
+  fieldNoteCount: number;
+  dumpCount: number;
+}) {
+  if (!configured) {
+    return {
+      status: "local",
+      label: "local only",
+      detail: "Supermemory is not configured. Field notes stay local to this session view.",
+    };
+  }
+
+  if (!hasFieldNoteSupermemoryColumns) {
+    return {
+      status: "waiting",
+      label: "memory migration needed",
+      detail: "Apply migration 0014 to enable Supermemory sync for field notes. Showing a local read for now.",
+    };
+  }
+
+  if (syncError) {
+    return {
+      status: "unavailable",
+      label: "memory unavailable",
+      detail: "Supermemory could not sync right now. The page is showing a lower-confidence local read.",
+    };
+  }
+
+  if (source === "supermemory") {
+    return {
+      status: "active",
+      label: "supermemory active",
+      detail: includePrivateDumps
+        ? "Field notes and opted-in private dumps can shape this graph."
+        : "Field notes are shaping this graph.",
+    };
+  }
+
+  if (!fieldNoteCount && !(includePrivateDumps && dumpCount)) {
+    return {
+      status: "waiting",
+      label: "memory waiting",
+      detail: includePrivateDumps
+        ? "Write a few dumps or draft a field note to start the memory graph."
+        : "Draft a field note to start the memory graph.",
+    };
+  }
+
+  return {
+    status: "local",
+    label: "local read",
+    detail: "Memory sources exist, but Supermemory has not shaped this view yet.",
+  };
+}
+
+function isMissingTableError(error: unknown) {
+  const supabaseError = error as { code?: string; message?: string; details?: string; hint?: string } | null;
+  const message = `${supabaseError?.message || ""} ${supabaseError?.details || ""} ${supabaseError?.hint || ""}`.toLowerCase();
+  return supabaseError?.code === "42P01" || supabaseError?.code === "PGRST205" || message.includes("could not find the table");
+}
+
+function isMissingColumnError(error: unknown) {
+  const supabaseError = error as { code?: string; message?: string; details?: string; hint?: string } | null;
+  const message = `${supabaseError?.message || ""} ${supabaseError?.details || ""} ${supabaseError?.hint || ""}`.toLowerCase();
+  return supabaseError?.code === "PGRST204" || message.includes("could not find") && message.includes("column");
+}
+
+async function loadFieldNotesWithoutSupermemoryColumns({
+  supabase,
+  sessionTokenHash,
+}: {
+  supabase: SupabaseAdmin;
+  sessionTokenHash: string;
+}) {
+  const { data, error } = await supabase
+    .from("field_notes")
+    .select("id, title, content, source_dump_ids, is_published, published_at, created_at")
+    .eq("session_token_hash", sessionTokenHash)
+    .order("created_at", { ascending: false })
+    .limit(50);
+  if (error) throw error;
+  return data || [];
+}
+
+function missingDumpMigrationError() {
+  const error = new Error("Dump database migration is not applied yet. Run supabase/migrations/0011_mumbl_dump.sql.");
+  (error as Error & { status?: number }).status = 503;
+  return error;
+}
+
+async function syncMissingFieldNotes({
+  supabase,
+  fieldNotes,
+  sessionTokenHash,
+}: {
+  supabase: SupabaseAdmin;
+  fieldNotes: FieldNoteRow[];
+  sessionTokenHash: string;
+}) {
+  const missing = fieldNotes
+    .filter((fieldNote) => !fieldNote.supermemory_id || !fieldNote.supermemory_status?.startsWith("field_note_scoped:"))
+    .slice(0, SYNC_BATCH_SIZE);
+
+  for (const fieldNote of missing) {
+    const result = await addFieldNoteMemory({ fieldNote, sessionTokenHash });
+    if (!result?.id) continue;
+
+    const { error } = await supabase
+      .from("field_notes")
+      .update({
+        supermemory_id: result.id,
+        supermemory_status: result.status,
+        supermemory_synced_at: new Date().toISOString(),
+      })
+      .eq("id", fieldNote.id)
+      .eq("session_token_hash", sessionTokenHash);
+    if (error) throw error;
+
+    fieldNote.supermemory_id = result.id;
+    fieldNote.supermemory_status = result.status;
+  }
+}
+
+async function syncOptedInPrivateDumps({
+  supabase,
+  dumps,
+  sessionTokenHash,
+}: {
+  supabase: SupabaseAdmin;
+  dumps: DumpRow[];
+  sessionTokenHash: string;
+}) {
+  const missing = dumps
+    .filter((dump) => !dump.supermemory_id || !dump.supermemory_status?.startsWith("private_dump_opt_in:"))
+    .slice(0, SYNC_BATCH_SIZE);
+
+  for (const dump of missing) {
+    const result = await addPrivateDumpMemory({ dump, sessionTokenHash });
+    if (!result?.id) continue;
+
+    const { error } = await supabase
+      .from("dumps")
+      .update({
+        supermemory_id: result.id,
+        supermemory_status: result.status,
+        supermemory_synced_at: new Date().toISOString(),
+      })
+      .eq("id", dump.id)
+      .eq("session_token_hash", sessionTokenHash);
+    if (error) throw error;
+
+    dump.supermemory_id = result.id;
+    dump.supermemory_status = result.status;
+  }
+}
diff --git a/app/api/dumps/route.js b/app/api/dumps/route.js
new file mode 100644
index 0000000..fcbcaad
--- /dev/null
+++ b/app/api/dumps/route.js
@@ -0,0 +1,77 @@
+import { badRequest, ok, serverError } from "../../../src/server/http";
+import { hashToken } from "../../../src/server/hash";
+import { serializeDump, serializeFieldNote, makeLocalReflection } from "../../../src/server/dumps";
+import { getSupabaseAdmin } from "../../../src/server/supabase";
+import { cleanString } from "../../../src/server/validation";
+
+export async function GET(request) {
+  try {
+    const url = new URL(request.url);
+    const sessionToken = cleanString(url.searchParams.get("sessionToken"), 256);
+    if (!sessionToken) return badRequest("session token is required");
+
+    const supabase = getSupabaseAdmin();
+    const sessionTokenHash = hashToken(sessionToken);
+    const [{ data: dumps, error }, { data: fieldNotes, error: fieldNotesError }] = await Promise.all([
+      supabase.from("dumps").select("*").eq("session_token_hash", sessionTokenHash).order("created_at", { ascending: false }).limit(80),
+      supabase
+        .from("field_notes")
+        .select("*")
+        .eq("session_token_hash", sessionTokenHash)
+        .order("created_at", { ascending: false })
+        .limit(20),
+    ]);
+    if (isMissingTableError(error)) {
+      return serverError(missingDumpMigrationError());
+    }
+    if (error) throw error;
+    if (fieldNotesError && !isMissingTableError(fieldNotesError)) throw fieldNotesError;
+
+    return ok({ dumps: (dumps || []).map(serializeDump), fieldNotes: fieldNotesError ? [] : (fieldNotes || []).map(serializeFieldNote) });
+  } catch (error) {
+    return serverError(error);
+  }
+}
+
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const sessionToken = cleanString(body.sessionToken, 256);
+    const content = cleanString(body.content, 4000);
+    const wantsReflection = body.wantsReflection === true;
+
+    if (!sessionToken) return badRequest("session token is required");
+    if (!content) return badRequest("dump content is required");
+
+    const supabase = getSupabaseAdmin();
+    const { data: dump, error } = await supabase
+      .from("dumps")
+      .insert({
+        session_token_hash: hashToken(sessionToken),
+        content,
+        visibility: "private",
+        ai_reflection: wantsReflection ? makeLocalReflection(content) : null,
+      })
+      .select("*")
+      .single();
+    if (isMissingTableError(error)) {
+      return serverError(missingDumpMigrationError());
+    }
+    if (error) throw error;
+
+    return ok({ dump: serializeDump(dump) });
+  } catch (error) {
+    return serverError(error);
+  }
+}
+
+function isMissingTableError(error) {
+  const message = `${error?.message || ""} ${error?.details || ""} ${error?.hint || ""}`.toLowerCase();
+  return error?.code === "42P01" || error?.code === "PGRST205" || message.includes("could not find the table");
+}
+
+function missingDumpMigrationError() {
+  const error = new Error("Dump database migration is not applied yet. Run supabase/migrations/0011_mumbl_dump.sql.");
+  error.status = 503;
+  return error;
+}
diff --git a/app/api/public-profiles/[handle]/route.js b/app/api/public-profiles/[handle]/route.js
new file mode 100644
index 0000000..b739062
--- /dev/null
+++ b/app/api/public-profiles/[handle]/route.js
@@ -0,0 +1,42 @@
+import { notFound, ok, serverError } from "../../../../src/server/http";
+import { getSupabaseAdmin } from "../../../../src/server/supabase";
+import { normalizeHandle, serializePublicProfile } from "../../../../src/server/publicProfiles";
+
+export async function GET(_request, { params }) {
+  try {
+    const { handle: rawHandle } = await params;
+    const handle = normalizeHandle(rawHandle);
+    if (!handle) return notFound("public profile not found");
+
+    const supabase = getSupabaseAdmin();
+    const { data: profile, error } = await supabase.from("public_profiles").select("*").eq("handle", handle).single();
+    if (error?.code === "PGRST116") return notFound("public profile not found");
+    if (isMissingTableError(error)) return notFound("public profile not found");
+    if (error) throw error;
+
+    const { data: fieldNotes, error: notesError } = await supabase
+      .from("field_notes")
+      .select("id, title, content, created_at, public_published_at")
+      .eq("public_profile_id", profile.id)
+      .eq("is_public", true)
+      .eq("is_published", true)
+      .order("public_published_at", { ascending: false })
+      .limit(40);
+    if (isMissingTableError(notesError) || isMissingColumnError(notesError)) return notFound("public profile not found");
+    if (notesError) throw notesError;
+
+    return ok({ profile: serializePublicProfile(profile, fieldNotes || []) });
+  } catch (error) {
+    return serverError(error);
+  }
+}
+
+function isMissingTableError(error) {
+  const message = `${error?.message || ""} ${error?.details || ""} ${error?.hint || ""}`.toLowerCase();
+  return error?.code === "42P01" || error?.code === "PGRST205" || message.includes("could not find the table");
+}
+
+function isMissingColumnError(error) {
+  const message = `${error?.message || ""} ${error?.details || ""} ${error?.hint || ""}`.toLowerCase();
+  return error?.code === "42703" || error?.code === "PGRST204" || (message.includes("could not find") && message.includes("column"));
+}
diff --git a/app/api/public-profiles/route.js b/app/api/public-profiles/route.js
new file mode 100644
index 0000000..19bb225
--- /dev/null
+++ b/app/api/public-profiles/route.js
@@ -0,0 +1,95 @@
+import { badRequest, ok, serverError } from "../../../src/server/http";
+import { hashToken } from "../../../src/server/hash";
+import { getSupabaseAdmin } from "../../../src/server/supabase";
+import { cleanString } from "../../../src/server/validation";
+import { isValidHandle, normalizeHandle, serializePublicProfile } from "../../../src/server/publicProfiles";
+
+export async function GET(request) {
+  try {
+    const url = new URL(request.url);
+    const sessionToken = cleanString(url.searchParams.get("sessionToken"), 256);
+    if (!sessionToken) return badRequest("session token is required");
+
+    const supabase = getSupabaseAdmin();
+    const sessionTokenHash = hashToken(sessionToken);
+    const { data: profile, error } = await supabase
+      .from("public_profiles")
+      .select("*")
+      .eq("session_token_hash", sessionTokenHash)
+      .order("created_at", { ascending: true })
+      .limit(1)
+      .maybeSingle();
+
+    if (isMissingTableError(error)) {
+      return ok({ profile: null, migrationRequired: true });
+    }
+    if (error) throw error;
+
+    return ok({ profile: profile ? serializePublicProfile(profile) : null });
+  } catch (error) {
+    return serverError(error);
+  }
+}
+
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const sessionToken = cleanString(body.sessionToken, 256);
+    const handle = normalizeHandle(body.handle);
+    const displayName = cleanString(body.displayName || handle, 80);
+    const bio = cleanString(body.bio, 220);
+
+    if (!sessionToken) return badRequest("session token is required");
+    if (!isValidHandle(handle)) return badRequest("choose a handle with 2-30 letters, numbers, underscores, or dashes");
+
+    const supabase = getSupabaseAdmin();
+    const sessionTokenHash = hashToken(sessionToken);
+    const { data: existingForHandle, error: handleError } = await supabase
+      .from("public_profiles")
+      .select("*")
+      .eq("handle", handle)
+      .maybeSingle();
+    if (isMissingTableError(handleError)) return serverError(missingPublicProfileMigrationError());
+    if (handleError) throw handleError;
+    if (existingForHandle && existingForHandle.session_token_hash !== sessionTokenHash) {
+      return badRequest("that handle is already taken");
+    }
+
+    const { data: existingForSession, error: sessionError } = await supabase
+      .from("public_profiles")
+      .select("*")
+      .eq("session_token_hash", sessionTokenHash)
+      .order("created_at", { ascending: true })
+      .limit(1)
+      .maybeSingle();
+    if (sessionError) throw sessionError;
+
+    const mutation = existingForSession
+      ? supabase
+          .from("public_profiles")
+          .update({ handle, display_name: displayName || handle, bio, updated_at: new Date().toISOString() })
+          .eq("id", existingForSession.id)
+      : supabase
+          .from("public_profiles")
+          .insert({ session_token_hash: sessionTokenHash, handle, display_name: displayName || handle, bio });
+
+    const { data: profile, error } = await mutation.select("*").single();
+    if (error?.code === "23505") return badRequest("that handle is already taken");
+    if (error) throw error;
+
+    return ok({ profile: serializePublicProfile(profile) });
+  } catch (error) {
+    return serverError(error);
+  }
+}
+
+function isMissingTableError(error) {
+  const message = `${error?.message || ""} ${error?.details || ""} ${error?.hint || ""}`.toLowerCase();
+  return error?.code === "42P01" || error?.code === "PGRST205" || message.includes("could not find the table");
+}
+
+function missingPublicProfileMigrationError() {
+  const error = new Error("Public profile migration is not applied yet. Run supabase/migrations/0015_public_profiles.sql.");
+  error.status = 503;
+  return error;
+}
diff --git a/app/api/spaces/[slug]/posts/route.js b/app/api/spaces/[slug]/posts/route.js
index 977d0d9..5e48b8c 100644
--- a/app/api/spaces/[slug]/posts/route.js
+++ b/app/api/spaces/[slug]/posts/route.js
@@ -9,14 +9,17 @@ export async function POST(request, { params }) {
     const { slug } = await params;
     const body = await request.json();
     const type = cleanString(body.type, 24);
-    const content = cleanString(body.content, 420);
+    const content = cleanString(body.content, type === "dump" || type === "field_note" ? 4000 : 420);
     const isAnonymous = body.isAnonymous !== false;
     const displayName = isAnonymous ? null : cleanString(body.displayName, 48) || "someone brave";
     const sessionToken = cleanString(body.sessionToken, 256);
     const promptId = cleanString(body.promptId, 64) || null;
+    const dumpId = cleanString(body.dumpId, 64) || null;
+    const fieldNoteTitle = type === "field_note" ? cleanString(body.title, 120) : null;
 
     if (!slug) return badRequest("space slug is required");
     if (!isValidPostType(type)) return badRequest("unsupported post type");
+    if (type === "dump") return badRequest("raw dumps stay private. publish a field note to team reads instead.");
     if (!content) return badRequest("post content is required");
     if (!sessionToken) return badRequest("session token is required");
 
@@ -32,6 +35,8 @@ export async function POST(request, { params }) {
       .insert({
         space_id: space.id,
         prompt_id: promptId,
+        dump_id: dumpId,
+        field_note_title: fieldNoteTitle,
         type,
         content,
         is_anonymous: isAnonymous,
diff --git a/app/api/spaces/[slug]/route.js b/app/api/spaces/[slug]/route.js
index 58587a1..927a38f 100644
--- a/app/api/spaces/[slug]/route.js
+++ b/app/api/spaces/[slug]/route.js
@@ -8,7 +8,7 @@ import { cleanString } from "../../../../src/server/validation";
 
 const DEFAULT_POST_LIMIT = 20;
 const MAX_POST_LIMIT = 40;
-const POST_TYPES = new Set(["find", "thought", "rant", "win", "lol"]);
+const POST_TYPES = new Set(["find", "thought", "rant", "win", "lol", "dump", "field_note"]);
 
 export async function GET(request, { params }) {
   try {
@@ -39,7 +39,10 @@ export async function GET(request, { params }) {
       .limit(postLimit + 1);
     let postCountQuery = supabase.from("posts").select("id", { count: "exact", head: true }).eq("space_id", space.id);
 
-    if (postType) {
+    if (postType === "reads") {
+      postsQuery = postsQuery.eq("type", "field_note");
+      postCountQuery = postCountQuery.eq("type", "field_note");
+    } else if (postType) {
       postsQuery = postsQuery.eq("type", postType);
       postCountQuery = postCountQuery.eq("type", postType);
     }
@@ -121,6 +124,7 @@ function parsePostCursor(value) {
 }
 
 function parsePostType(value) {
+  if (value === "reads") return "reads";
   return POST_TYPES.has(value) ? value : "";
 }
 
diff --git a/app/dump/map/page.jsx b/app/dump/map/page.jsx
new file mode 100644
index 0000000..e383e77
--- /dev/null
+++ b/app/dump/map/page.jsx
@@ -0,0 +1,9 @@
+import DumpPageClient from "../../../src/components/DumpPageClient";
+
+export const metadata = {
+  title: "dump map",
+};
+
+export default function DumpMapPage() {
+  return <DumpPageClient mode="map" />;
+}
diff --git a/app/dump/new/page.jsx b/app/dump/new/page.jsx
new file mode 100644
index 0000000..6e341d3
--- /dev/null
+++ b/app/dump/new/page.jsx
@@ -0,0 +1,9 @@
+import DumpPageClient from "../../../src/components/DumpPageClient";
+
+export const metadata = {
+  title: "new dump",
+};
+
+export default function NewDumpPage() {
+  return <DumpPageClient mode="new" />;
+}
diff --git a/app/dump/page.jsx b/app/dump/page.jsx
new file mode 100644
index 0000000..36e1b0f
--- /dev/null
+++ b/app/dump/page.jsx
@@ -0,0 +1,10 @@
+import DumpPageClient from "../../src/components/DumpPageClient";
+
+export const metadata = {
+  title: "your dump",
+  description: "a private-first place to put what is sitting in your head at work.",
+};
+
+export default function DumpPage() {
+  return <DumpPageClient />;
+}
diff --git a/app/public/[handle]/page.jsx b/app/public/[handle]/page.jsx
new file mode 100644
index 0000000..a43e6b8
--- /dev/null
+++ b/app/public/[handle]/page.jsx
@@ -0,0 +1,11 @@
+import PublicProfilePage, { getPublicProfileMetadata } from "../../../src/components/PublicProfilePage";
+
+export async function generateMetadata({ params }) {
+  const { handle } = await params;
+  return getPublicProfileMetadata(handle);
+}
+
+export default async function RewrittenPublicProfilePage({ params }) {
+  const { handle } = await params;
+  return <PublicProfilePage rawHandle={handle} />;
+}
diff --git a/docs/backend-plan.md b/docs/backend-plan.md
index f8f659e..42e1a10 100644
--- a/docs/backend-plan.md
+++ b/docs/backend-plan.md
@@ -89,6 +89,18 @@ create table anon_audit (
 - `POST /api/spaces/:slug/first-post-dismissed` marks the creator-first prompt as dismissed.
 - `POST /api/cron/heartbeats` generates weekly heartbeats from anonymised post data.
 
+## Dump V1
+
+The dump feature keeps the no-signup model. Private dump entries are owned by the same browser session token pattern, but the database stores only `session_token_hash`, never the raw token. A dump is private on creation and cannot be posted directly into a room.
+
+Team reads show only approved field notes. The flow is: select private dumps, request an OpenAI draft through a server route, save the draft in `field_notes`, let the author edit it, then publish it as `posts.type = 'field_note'`. The old raw-dump team endpoint is intentionally blocked so private dumps stay for dumping thoughts, not public reading.
+
+`OPENAI_API_KEY`, `OPENAI_MODEL_FIELD_NOTE`, and `OPENAI_MAX_DAILY_DRAFTS` are server-only. The default model should stay cost-sensitive, currently `gpt-5.4-nano`, and the draft route sends only selected dumps, capped at 10 per request. Field-note drafting should produce publishable working-process notes: specific, human, readable, and useful enough for team reads or a public profile, while staying grounded only in the selected dumps.
+
+Public profiles and account migration are not in this implementation yet. When identity lands, signup must migrate existing dump rows and field-note drafts without changing visibility.
+
+Prototype public profiles now exist as a no-signup bridge: a browser session can claim one public handle and selectively add already-published field notes to `mumbl.wtf/@handle`. Private dumps and field-note drafts never appear there. This is intentionally per-note opt-in and should be replaced or migrated carefully when full identity arrives.
+
 ## Local Setup
 
 1. Create a Supabase project.
diff --git a/docs/free-tier-compromises.md b/docs/free-tier-compromises.md
index 87e2621..1a0a4c7 100644
--- a/docs/free-tier-compromises.md
+++ b/docs/free-tier-compromises.md
@@ -53,3 +53,19 @@ Current compromise:
 Future improvements:
 - Use daily culture snapshots once public-space volume grows.
 - Generate public culture summaries in a scheduled job instead of on-demand reads.
+
+## Dump
+
+Current compromise:
+- Per-entry AI reflection uses a deterministic local reflector in the route handler, not an external AI provider.
+- Team field-note drafting uses OpenAI only when the user clicks draft, sends selected dumps only, caps selection size, and rate-limits drafts per session with `OPENAI_MAX_DAILY_DRAFTS`.
+- The private map is rendered from the user's fetched dump text in the browser, with no weekly insight cron yet.
+- Team reads reuse the existing posts infrastructure, but only for approved `field_note` posts. Raw dumps are blocked from reads.
+
+Why:
+- External AI calls and weekly insight jobs would add cost, secrets, and retry behavior before the core private dump loop is proven.
+- The v1 promise is explicit visibility control and low-cost drafting, not model quality.
+
+Future improvements:
+- Add provider-backed reflection behind an opt-in toggle once budget and privacy copy are settled.
+- Generate `dump_insights` weekly for users with enough dumps, using a daily-or-weekly cron posture compatible with the current free-tier lane.
diff --git a/docs/mumbl-dump-feature.md b/docs/mumbl-dump-feature.md
new file mode 100644
index 0000000..5b37a26
--- /dev/null
+++ b/docs/mumbl-dump-feature.md
@@ -0,0 +1,237 @@
+# mumbl dump — feature spec
+
+## what this is
+
+a private-first space inside mumbl where anyone can dump what's on their mind about work — a thought, a process, a feeling, a realisation, a half-formed idea — at any point in the day. no pressure, no format, no audience unless you want one. over time it becomes a personal record of how you think and work. you can choose to share a dump with your team, or publish it publicly on your mumbl profile for anyone to read.
+
+the core principle: **private by default, public by deliberate choice. never the other way around.**
+
+the vibe: your dump is yours. messy is fine. one sentence is fine. a wall of text at 2am is fine. this is the place where you don't have to perform.
+
+---
+
+## the three layers
+
+### 1. private dump (default)
+- every entry is private by default. only you can see it.
+- no signup required to start — works like the rest of mumbl, anonymous session first.
+- write one sentence or five paragraphs. no format enforced. no title required.
+- optional: AI reflection (not editing). after you write, AI can surface a thread — "you mentioned feeling stuck three times today — want to say more?" it reflects, it doesn't rewrite. ever.
+- over time, AI builds a personal map of your dumps: recurring themes, emotional patterns, peak flow days, what you were working on and how it felt. shown as a private timeline only you can see.
+- **nothing leaves your private dump without an explicit action from you.**
+
+### 2. team dump
+- from any private dump, you can choose to drop it into your mumbl team space.
+- it appears in the team feed with a different visual treatment — labelled "dump", longer form, more personal tone than a rant/win/lol post.
+- teammates can react (same reaction system as the rest of mumbl) but cannot publicly comment — keeps it from feeling exposed.
+- still anonymous by default unless the user has explicitly chosen to attach their name.
+
+### 3. team reads (the good part)
+- inside every team room, a tab called **reads** surfaces dumps that team members have opted into sharing there.
+- opt-in is per dump, not a global setting. you choose which dumps appear in reads.
+- this is not a feed of everything — it's a curated window into how your teammates actually think.
+- reading a senior engineer's dump on how they debug a hard problem, or how they felt about a rough sprint, is how coworkers stop being usernames and start being people.
+- no reactions in the reads tab in v1 — just reading. keeps it feeling like a library not a performance stage.
+- nothing appears in reads without an explicit opt-in action per dump.
+
+### 4. public profile
+- you can publish any dump to your public mumbl profile: `mumbl.wtf/@username`
+- this requires creating an identity — either by logging in with github/google or creating a mumbl handle.
+- once public, it's readable by anyone visiting your profile.
+- your profile becomes a public record of how you actually think and work. not a portfolio. not a linkedin. not a blog. a dump.
+- every published entry can be unpublished at any time. no questions asked.
+
+Prototype note: before full auth exists, Mumbl supports a lighter version where an anonymous browser session claims a handle and adds selected published field notes to `mumbl.wtf/@handle`. This is still deliberate per-entry publishing. Drafts and private dumps stay out.
+
+---
+
+## identity and persistence model
+
+this is the most important thing to get right. nothing is ever lost, nothing is ever exposed without explicit action.
+
+```
+anonymous session
+      ↓
+starts dumping (stored locally + server-side with anon session token)
+      ↓
+[optional] create mumbl handle OR link github/google
+      → all previous dumps migrate to the account
+      → nothing is lost
+      ↓
+[optional] choose to go public — per entry, never global
+      → dumps remain private unless explicitly published one by one
+```
+
+- **anonymous users can dump and keep everything private.** entries persist via session token in localStorage + server.
+- **creating an account changes nothing about visibility.** zero entries become public on signup.
+- **public is always a per-entry deliberate action.** there is no "make all public" setting.
+
+---
+
+## data model additions
+
+### dump table
+```
+id                  uuid primary key
+session_id          string (anon session OR user id after account creation)
+content             text
+created_at          timestamp
+updated_at          timestamp
+visibility          enum: 'private' | 'team' | 'public'
+team_room_id        uuid nullable (set when shared to team)
+ai_reflection       text nullable (shown only to author, never auto-generated)
+published_at        timestamp nullable
+```
+
+### user_profile table (new)
+```
+id                  uuid primary key
+handle              string unique (e.g. 'disha')
+display_name        string nullable
+bio                 string nullable
+auth_provider       enum: 'github' | 'google' | 'email' nullable
+created_at          timestamp
+```
+
+### dump_insights table (new)
+```
+id                  uuid primary key
+session_id          string
+insight_type        enum: 'theme' | 'pattern' | 'streak' | 'graph_node'
+content             jsonb
+generated_at        timestamp
+```
+
+---
+
+## routes
+
+| route | description |
+|---|---|
+| `/dump` | private dump home — write, view past dumps, see your map |
+| `/dump/new` | quick dump composer — open immediately, no friction |
+| `/dump/map` | personal knowledge map — themes, patterns, timeline |
+| `/room/:id/reads` | team reads tab — opt-in dumps from teammates |
+| `/@:handle` | public profile — all published dumps |
+| `/@:handle/:dump-id` | single published dump |
+
+---
+
+## UI behaviour
+
+### dump composer
+- dead simple. one text area, full width, no toolbar, no formatting options.
+- placeholder rotates to keep it fresh. examples:
+  - `what are you actually thinking about right now?`
+  - `say the thing you didn't say in standup.`
+  - `what happened today?`
+  - `what's been sitting in your head all week?`
+  - `dump it here.`
+- character count optional, not enforced.
+- below the text area, after writing: three soft action buttons
+  - `keep it private` (default, always the first option)
+  - `drop it in the team room` (only if user is in a room)
+  - `publish to my profile` (only if user has a handle)
+- optional AI reflection — a small toggle labelled "ask AI to reflect on this." off by default. if on, after saving, a short reflection appears below the dump in muted text. it never modifies the original entry.
+
+### private dump feed
+- chronological list, newest first.
+- each dump shows: relative time ("3 hours ago"), first two lines, a small visibility pill (private / team / public).
+- tap/click to expand.
+- hover reveals: `share to team` and `publish` as ghost buttons — present but not pushy.
+
+### dump map (`/dump/map`)
+- visual timeline of dumps with recurring themes as coloured threads.
+- AI summary at the top, refreshed weekly: "lately you've been dumping about deployment anxiety, the new project, and something good that happened on thursdays."
+- feels like looking at your own brain from the outside. private only. never shareable.
+
+### public profile (`/@handle`)
+- clean reading experience. generous whitespace. no clutter.
+- dumps listed newest first with the first line as the title and relative date.
+- no reactions, no comments on public profiles in v1 — reading only.
+- small "follow" placeholder button (UI only for now, no backend needed yet).
+- bio at the top, short, written by the user. optional.
+
+---
+
+## AI integration
+
+### 1. reflection (per dump, opt-in)
+- triggered: user taps "ask AI to reflect on this" before or after saving.
+- behaviour: reads the dump, identifies emotional texture and recurring threads, returns one short reflection — a question or an observation. does not summarise. does not rewrite. just listens and reflects back.
+- shown inline below the dump in muted text, clearly labelled "ai reflection."
+- can be dismissed or hidden.
+
+### 2. dump map insights (private, weekly)
+- triggered: background job, weekly, for users with 5+ dumps.
+- generates: top recurring themes, emotional arc of the week, flow vs stuck ratio, notable patterns.
+- stored in `dump_insights` table, rendered in `/dump/map`.
+- never shared externally. never visible to the team or public.
+
+### 3. heartbeat contribution (optional, future)
+- if a user drops a dump into a team space, it can optionally contribute signal to the monday heartbeat alongside rant/win/lol posts.
+- opt-in per dump. labelled separately in the heartbeat output as "from the dump."
+
+---
+
+## what NOT to build (keep this list)
+
+- **no global explore or discover feed.** there is no browse-all-public-dumps feed for strangers. public profiles are visit-only via direct link.
+- **no AI rewriting.** AI reflects and surfaces patterns. it never touches the content of a dump.
+- **no forced signup.** anonymous dumping must work fully without an account. forever.
+- **no public-by-default.** ever. not even as an option in settings.
+- **no comments on public profiles in v1.** reactions and comments stay inside the team space only.
+- **no notifications that feel like pressure.** no "you haven't dumped in 3 days!" no streaks. no guilt.
+
+---
+
+## copy and microcopy
+
+get the words right — this is what makes it feel fun not clinical.
+
+| element | copy |
+|---|---|
+| page title | `your dump` |
+| empty state | `nothing here yet. what's been sitting in your head?` |
+| save button | `keep it private` |
+| share button | `drop it in the room` |
+| publish button | `put it out there` |
+| AI reflection label | `ai heard this` |
+| map empty state | `dump more to see patterns form.` |
+| public profile tagline | `how [name] actually thinks at work.` |
+| reads tab label | `reads` |
+| reads empty state | `no one has dropped anything here yet. share a dump with the team.` |
+| reads opt-in button | `add to team reads` |
+| after first dump | `it's in the dump. no one can see it but you.` |
+
+---
+
+## demo flow (for YC video)
+
+1. open mumbl.wtf — no signup. tap "start your dump."
+2. write something real about today. one paragraph. save privately.
+3. AI reflection appears below — one line, honest, not cheesy.
+4. show the dump map with a seeded demo state — themes forming, a small timeline.
+5. drop one dump into the team room — it appears in the feed, longer form, different texture to the rant/win/lol posts.
+6. publish one dump to a profile — `mumbl.wtf/@disha` loads. clean. human. real.
+7. end on the profile. let it sit for a second. no voiceover needed.
+
+---
+
+## build order
+
+1. dump composer + private entry storage (anon session)
+2. private dump feed
+3. account creation + entry migration
+4. team drop action + feed integration
+5. public profile + publish action
+6. AI reflection (per entry, opt-in)
+7. dump map + weekly insights
+
+---
+
+## the point
+
+every feature in mumbl returns something human to the person who gave something honest. the dump is the most personal version of that. you write to understand yourself. the team layer helps your coworkers understand you. the public layer helps the world know how you actually think and work.
+
+the mission is the same across all of it: make the biggest part of the day feel like a life, not something to get through.
diff --git a/next-env.d.ts b/next-env.d.ts
new file mode 100644
index 0000000..9edff1c
--- /dev/null
+++ b/next-env.d.ts
@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+import "./.next/types/routes.d.ts";
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.
diff --git a/next.config.mjs b/next.config.mjs
index e95c05f..83d1a2b 100644
--- a/next.config.mjs
+++ b/next.config.mjs
@@ -1,6 +1,14 @@
 /** @type {import('next').NextConfig} */
 const nextConfig = {
   allowedDevOrigins: ["127.0.0.1", "192.168.31.16"],
+  async rewrites() {
+    return [
+      {
+        source: "/@:handle",
+        destination: "/public/:handle",
+      },
+    ];
+  },
 };
 
 export default nextConfig;
diff --git a/package-lock.json b/package-lock.json
index 5365b78..e8014e4 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -14,7 +14,11 @@
         "react-dom": "^19.0.0"
       },
       "devDependencies": {
-        "supabase": "^2.98.2"
+        "@types/node": "^25.9.1",
+        "@types/react": "^19.2.15",
+        "@types/react-dom": "^19.2.3",
+        "supabase": "^2.98.2",
+        "typescript": "^6.0.3"
       }
     },
     "node_modules/@emnapi/runtime": {
@@ -796,12 +800,32 @@
       }
     },
     "node_modules/@types/node": {
-      "version": "25.6.2",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.6.2.tgz",
-      "integrity": "sha512-sokuT28dxf9JT5Kady1fsXOvI4HVpjZa95NKT5y9PNTIrs2AsobR4GFAA90ZG8M+nxVRLysCXsVj6eGC7Vbrlw==",
+      "version": "25.9.1",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.9.1.tgz",
+      "integrity": "sha512-xfrlY7UD5rMJk3ZVJP8BNzS28J36YJg+xp+LPXV1TdWxr8uMH5A860QNxYDGQe/ylDSgjxE52Q9VnO7p75tJxg==",
       "license": "MIT",
       "dependencies": {
-        "undici-types": "~7.19.0"
+        "undici-types": ">=7.24.0 <7.24.7"
+      }
+    },
+    "node_modules/@types/react": {
+      "version": "19.2.15",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.15.tgz",
+      "integrity": "sha512-eRwcGNHve+E8qtEQSSRl6urh+rFop4v8gm6O8rGv25CodbvFdLjA1vVQ1KkiFE0w0UPOnb8tDiFKL5lp0rtY5Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "19.2.3",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz",
+      "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "^19.2.0"
       }
     },
     "node_modules/@types/ws": {
@@ -898,6 +922,13 @@
         "node": "^20.17.0 || >=22.9.0"
       }
     },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/data-uri-to-buffer": {
       "version": "4.0.1",
       "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
@@ -1374,10 +1405,24 @@
       "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
       "license": "0BSD"
     },
+    "node_modules/typescript": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.3.tgz",
+      "integrity": "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
     "node_modules/undici-types": {
-      "version": "7.19.2",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.19.2.tgz",
-      "integrity": "sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg==",
+      "version": "7.24.6",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.24.6.tgz",
+      "integrity": "sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==",
       "license": "MIT"
     },
     "node_modules/web-streams-polyfill": {
diff --git a/package.json b/package.json
index d683006..575c1a6 100644
--- a/package.json
+++ b/package.json
@@ -23,6 +23,10 @@
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "supabase": "^2.98.2"
+    "@types/node": "^25.9.1",
+    "@types/react": "^19.2.15",
+    "@types/react-dom": "^19.2.3",
+    "supabase": "^2.98.2",
+    "typescript": "^6.0.3"
   }
 }
diff --git a/src/components/AppShell.jsx b/src/components/AppShell.jsx
index cbab5f6..119b101 100644
--- a/src/components/AppShell.jsx
+++ b/src/components/AppShell.jsx
@@ -25,6 +25,9 @@ export default function AppShell({ children }) {
           <Link className="ghost-button button-link" href="/mission">
             mission
           </Link>
+          <Link className="ghost-button button-link" href="/dump">
+            dump
+          </Link>
           <Link className="ghost-button button-link topbar-feedback" href={feedbackRoom.href}>
             help shape mumbl
           </Link>
diff --git a/src/components/DumpPageClient.jsx b/src/components/DumpPageClient.jsx
new file mode 100644
index 0000000..f8d9462
--- /dev/null
+++ b/src/components/DumpPageClient.jsx
@@ -0,0 +1,1086 @@
+"use client";
+
+import Link from "next/link";
+import { useEffect, useMemo, useState } from "react";
+import {
+  createDump,
+  deleteDump,
+  deleteFieldNote,
+  draftFieldNote,
+  fetchDumpMap,
+  fetchDumps,
+  fetchPublicProfileForSession,
+  publishFieldNote,
+  savePublicProfile,
+  setFieldNotePublic,
+  updateDump,
+  updateFieldNote,
+} from "../lib/api";
+import { getDumpMemoryOptIn, getRecentSlug, setDumpMemoryOptIn } from "../lib/storage";
+import Toast from "./Toast";
+
+const placeholders = [
+  "what are you actually thinking about right now?",
+  "say the thing you didn't say in standup.",
+  "what happened today?",
+  "what's been sitting in your head all week?",
+  "dump it here.",
+];
+
+export default function DumpPageClient({ mode = "home" }) {
+  const [dumps, setDumps] = useState([]);
+  const [status, setStatus] = useState("loading");
+  const [fieldNotes, setFieldNotes] = useState([]);
+  const [activePanel, setActivePanel] = useState("dumps");
+  const [content, setContent] = useState("");
+  const [wantsReflection, setWantsReflection] = useState(false);
+  const [isSaving, setIsSaving] = useState(false);
+  const [expandedId, setExpandedId] = useState("");
+  const [recentSlug, setRecentSlug] = useState("");
+  const [shareSlug, setShareSlug] = useState("");
+  const [publishAnonymous, setPublishAnonymous] = useState(true);
+  const [displayName, setDisplayName] = useState("");
+  const [publicProfile, setPublicProfile] = useState(null);
+  const [publicProfileStatus, setPublicProfileStatus] = useState("loading");
+  const [publicHandleDraft, setPublicHandleDraft] = useState("");
+  const [publicNameDraft, setPublicNameDraft] = useState("");
+  const [publicBioDraft, setPublicBioDraft] = useState("");
+  const [publicModalOpen, setPublicModalOpen] = useState(false);
+  const [selectedDumpIds, setSelectedDumpIds] = useState([]);
+  const [pendingDraft, setPendingDraft] = useState(false);
+  const [publishingNoteId, setPublishingNoteId] = useState("");
+  const [mutatingNoteId, setMutatingNoteId] = useState("");
+  const [publicMutatingNoteId, setPublicMutatingNoteId] = useState("");
+  const [toast, setToast] = useState("");
+  const placeholder = placeholders[(dumps.length + content.length) % placeholders.length];
+
+  useEffect(() => {
+    setRecentSlug(getRecentSlug(""));
+  }, []);
+
+  useEffect(() => {
+    let mounted = true;
+    async function load() {
+      try {
+        const [result, profileResult] = await Promise.all([fetchDumps(), fetchPublicProfileForSession()]);
+        if (!mounted) return;
+        setDumps(result.dumps || []);
+        setFieldNotes(result.fieldNotes || []);
+        const nextProfile = profileResult.profile || null;
+        setPublicProfile(nextProfile);
+        setPublicProfileStatus(profileResult.migrationRequired ? "migration" : "ready");
+        if (nextProfile) {
+          setPublicHandleDraft(nextProfile.handle || "");
+          setPublicNameDraft(nextProfile.displayName || "");
+          setPublicBioDraft(nextProfile.bio || "");
+        }
+        setStatus("ready");
+      } catch (error) {
+        if (!mounted) return;
+        setStatus("error");
+        setPublicProfileStatus("error");
+        setToast(error.message || "couldn't open your dump yet.");
+      }
+    }
+    load();
+    return () => {
+      mounted = false;
+    };
+  }, []);
+
+  const map = useMemo(() => makeDumpMap(dumps), [dumps]);
+  const selectedDumps = dumps.filter((dump) => selectedDumpIds.includes(dump.id));
+
+  async function handleSave(event) {
+    event.preventDefault();
+    const trimmed = content.trim();
+    if (!trimmed || isSaving) return;
+
+    setIsSaving(true);
+    try {
+      const result = await createDump({ content: trimmed, wantsReflection });
+      setDumps((current) => [result.dump, ...current]);
+      setContent("");
+      setWantsReflection(false);
+      setExpandedId(result.dump.id);
+      setToast("it's in the dump. no one can see it but you.");
+    } catch (error) {
+      setToast(error.message || "couldn't keep that yet.");
+    } finally {
+      setIsSaving(false);
+    }
+  }
+
+  async function handleUpdateDump(dump, nextContent, nextWantsReflection) {
+    try {
+      const result = await updateDump({ dumpId: dump.id, content: nextContent, wantsReflection: nextWantsReflection });
+      setDumps((current) => current.map((item) => (item.id === dump.id ? result.dump : item)));
+      setToast("saved.");
+      return result.dump;
+    } catch (error) {
+      setToast(error.message || "couldn't save that edit.");
+      throw error;
+    }
+  }
+
+  async function handleDeleteDump(dump) {
+    try {
+      await deleteDump(dump.id);
+      setDumps((current) => current.filter((item) => item.id !== dump.id));
+      setSelectedDumpIds((current) => current.filter((id) => id !== dump.id));
+      setExpandedId((current) => (current === dump.id ? "" : current));
+      setToast("deleted from your dump.");
+    } catch (error) {
+      setToast(error.message || "couldn't delete that dump.");
+      throw error;
+    }
+  }
+
+  async function handleDraftFieldNote() {
+    if (!selectedDumpIds.length || pendingDraft) {
+      setToast("pick one or more dumps first.");
+      return;
+    }
+
+    setPendingDraft(true);
+    try {
+      const result = await draftFieldNote({ dumpIds: selectedDumpIds });
+      setFieldNotes((current) => [result.fieldNote, ...current]);
+      setSelectedDumpIds([]);
+      setActivePanel("notes");
+      setToast(result.visibilityReminder || "draft ready. read it before it goes anywhere.");
+    } catch (error) {
+      setToast(error.message || "couldn't draft that field note.");
+    } finally {
+      setPendingDraft(false);
+    }
+  }
+
+  async function handlePublishFieldNote(fieldNote, edits) {
+    const slug = (shareSlug || recentSlug).trim();
+    if (!slug || publishingNoteId) {
+      setToast("paste a room slug first.");
+      return;
+    }
+
+    setPublishingNoteId(fieldNote.id);
+    try {
+      const result = await publishFieldNote({
+        fieldNoteId: fieldNote.id,
+        slug,
+        title: edits.title,
+        content: edits.content,
+        isAnonymous: publishAnonymous,
+        displayName,
+      });
+      setFieldNotes((current) => current.map((item) => (item.id === fieldNote.id ? result.fieldNote : item)));
+      setRecentSlug(slug);
+      setShareSlug("");
+      setDisplayName("");
+      setToast("published to team reads.");
+    } catch (error) {
+      setToast(error.message || "couldn't publish that field note.");
+    } finally {
+      setPublishingNoteId("");
+    }
+  }
+
+  async function handleUpdateFieldNote(fieldNote, edits) {
+    setMutatingNoteId(fieldNote.id);
+    try {
+      const result = await updateFieldNote({ fieldNoteId: fieldNote.id, title: edits.title, content: edits.content });
+      setFieldNotes((current) => current.map((item) => (item.id === fieldNote.id ? result.fieldNote : item)));
+      setToast(fieldNote.isPublished ? "updated in team reads." : "draft saved.");
+    } catch (error) {
+      setToast(error.message || "couldn't save that field note.");
+      throw error;
+    } finally {
+      setMutatingNoteId("");
+    }
+  }
+
+  async function handleDeleteFieldNote(fieldNote) {
+    setMutatingNoteId(fieldNote.id);
+    try {
+      await deleteFieldNote(fieldNote.id);
+      setFieldNotes((current) => current.filter((item) => item.id !== fieldNote.id));
+      setToast(fieldNote.isPublished ? "removed from team reads." : "draft deleted.");
+    } catch (error) {
+      setToast(error.message || "couldn't delete that field note.");
+      throw error;
+    } finally {
+      setMutatingNoteId("");
+    }
+  }
+
+  async function handleSavePublicProfile(event) {
+    event?.preventDefault();
+    if (publicProfileStatus === "saving") return;
+
+    setPublicProfileStatus("saving");
+    try {
+      const result = await savePublicProfile({
+        handle: publicHandleDraft,
+        displayName: publicNameDraft,
+        bio: publicBioDraft,
+      });
+      setPublicProfile(result.profile);
+      setPublicHandleDraft(result.profile.handle || "");
+      setPublicNameDraft(result.profile.displayName || "");
+      setPublicBioDraft(result.profile.bio || "");
+      setPublicProfileStatus("ready");
+      setToast(`@${result.profile.handle} is yours. choose which field notes go public.`);
+    } catch (error) {
+      setPublicProfileStatus("ready");
+      setToast(error.message || "couldn't save that public handle.");
+    }
+  }
+
+  async function handleToggleFieldNotePublic(fieldNote, isPublic) {
+    if (!publicProfile?.handle) {
+      setToast("choose a public handle first.");
+      return;
+    }
+
+    setPublicMutatingNoteId(fieldNote.id);
+    try {
+      const result = await setFieldNotePublic({ fieldNoteId: fieldNote.id, isPublic, handle: publicProfile.handle });
+      setFieldNotes((current) => current.map((item) => (item.id === fieldNote.id ? result.fieldNote : item)));
+      setToast(isPublic ? `added to @${publicProfile.handle}.` : `removed from @${publicProfile.handle}.`);
+    } catch (error) {
+      setToast(error.message || "couldn't update your public profile.");
+    } finally {
+      setPublicMutatingNoteId("");
+    }
+  }
+
+  function toggleSelected(dumpId) {
+    setSelectedDumpIds((current) =>
+      current.includes(dumpId) ? current.filter((id) => id !== dumpId) : [...current, dumpId].slice(0, 10),
+    );
+  }
+
+  if (mode === "map") {
+    return <DumpMap dumps={dumps} fieldNotes={fieldNotes} map={map} status={status} toast={toast} setToast={setToast} />;
+  }
+
+  return (
+    <section className={`dump-view ${mode === "new" ? "dump-view-focus" : ""}`}>
+      <div className="dump-hero compact">
+        <div>
+          <p className="eyebrow">private · first</p>
+          <h1>your dump</h1>
+          <p>Write the messy thing. Keep it private. Turn only the useful thread into a field note later.</p>
+        </div>
+        <div className="dump-nav">
+          <Link className="ghost-button button-link" href="/dump/map">
+            see the map
+          </Link>
+          <button className="ghost-button" type="button" onClick={() => setPublicModalOpen(true)}>
+            go public
+          </button>
+          {recentSlug && (
+            <Link className="ghost-button button-link" href={`/r/${recentSlug}/reads`}>
+              team reads
+            </Link>
+          )}
+        </div>
+      </div>
+
+      <div className="dump-workspace">
+        <form className="dump-composer" onSubmit={handleSave} aria-busy={isSaving}>
+          <textarea
+            value={content}
+            onChange={(event) => setContent(event.target.value)}
+            maxLength={4000}
+            placeholder={placeholder}
+            autoFocus={mode === "new"}
+            disabled={isSaving}
+            required
+          />
+          <div className="dump-composer-bottom">
+            <label className="reflection-toggle">
+              <input
+                type="checkbox"
+                checked={wantsReflection}
+                onChange={(event) => setWantsReflection(event.target.checked)}
+                disabled={isSaving}
+              />
+              reflect after saving
+            </label>
+            <span>{content.trim().length} chars</span>
+          </div>
+          <div className="dump-actions">
+            <button className="solid-button button-with-loader" type="submit" disabled={isSaving}>
+              {isSaving && <span className="mini-loader" aria-hidden="true" />}
+              {isSaving ? "keeping..." : "keep private"}
+            </button>
+          </div>
+        </form>
+
+        <aside className="dump-rail">
+          <div className="dump-rail-card private-card">
+            <span>private space</span>
+            <strong>Nothing here goes to the team until you publish a field note.</strong>
+          </div>
+          <div className="dump-rail-card draft-card">
+            <span>make readable</span>
+            <strong>{selectedDumpIds.length ? `${selectedDumpIds.length} selected` : "select dumps from history"}</strong>
+            <p>{selectedDumps.length ? selectedDumps.map((dump) => firstLine(dump.content)).join(" · ") : "Pick related dumps. Mumbl turns the thread into a publishable field note. You edit. Then you decide."}</p>
+            <button
+              className="share-button button-with-loader"
+              type="button"
+              onClick={handleDraftFieldNote}
+              disabled={!selectedDumpIds.length || pendingDraft}
+            >
+              {pendingDraft && <span className="mini-loader" aria-hidden="true" />}
+              {pendingDraft ? "drafting..." : "draft a good read"}
+            </button>
+          </div>
+        </aside>
+      </div>
+
+      <div className="dump-panel-tabs" role="tablist" aria-label="dump workspace">
+        <button className={activePanel === "dumps" ? "active" : ""} type="button" onClick={() => setActivePanel("dumps")}>
+          private dumps <span>{dumps.length}</span>
+        </button>
+        <button className={activePanel === "notes" ? "active" : ""} type="button" onClick={() => setActivePanel("notes")}>
+          field notes <span>{fieldNotes.length}</span>
+        </button>
+      </div>
+
+      {activePanel === "dumps" ? (
+        <section className="dump-history">
+          <div className="dump-section-heading">
+            <div>
+              <span>history</span>
+              <h2>private dumps</h2>
+            </div>
+            <small>{dumps.length} saved</small>
+          </div>
+          <div className="dump-feed">
+            {status === "loading" ? <div className="empty-state">opening your dump...</div> : null}
+            {status === "ready" && !dumps.length ? (
+              <div className="empty-state">nothing here yet. what's been sitting in your head?</div>
+            ) : null}
+            {dumps.map((dump) => (
+              <DumpCard
+                dump={dump}
+                key={dump.id}
+                expanded={expandedId === dump.id}
+                setExpandedId={setExpandedId}
+                selected={selectedDumpIds.includes(dump.id)}
+                toggleSelected={() => toggleSelected(dump.id)}
+                updateDump={handleUpdateDump}
+                deleteDump={handleDeleteDump}
+              />
+            ))}
+          </div>
+        </section>
+      ) : (
+        <FieldNoteDrafts
+          fieldNotes={fieldNotes}
+          recentSlug={recentSlug}
+          shareSlug={shareSlug}
+          setShareSlug={setShareSlug}
+          publishAnonymous={publishAnonymous}
+          setPublishAnonymous={setPublishAnonymous}
+          displayName={displayName}
+          setDisplayName={setDisplayName}
+          publishingNoteId={publishingNoteId}
+          mutatingNoteId={mutatingNoteId}
+          handlePublishFieldNote={handlePublishFieldNote}
+          handleUpdateFieldNote={handleUpdateFieldNote}
+          handleDeleteFieldNote={handleDeleteFieldNote}
+        />
+      )}
+
+      {publicModalOpen && (
+        <GoPublicModal
+          close={() => setPublicModalOpen(false)}
+          fieldNotes={fieldNotes}
+          publicProfile={publicProfile}
+          publicProfileStatus={publicProfileStatus}
+          publicHandleDraft={publicHandleDraft}
+          publicNameDraft={publicNameDraft}
+          publicBioDraft={publicBioDraft}
+          publicMutatingNoteId={publicMutatingNoteId}
+          setPublicHandleDraft={setPublicHandleDraft}
+          setPublicNameDraft={setPublicNameDraft}
+          setPublicBioDraft={setPublicBioDraft}
+          handleSavePublicProfile={handleSavePublicProfile}
+          handleToggleFieldNotePublic={handleToggleFieldNotePublic}
+        />
+      )}
+
+      {toast && <Toast message={toast} onDone={() => setToast("")} />}
+    </section>
+  );
+}
+
+function DumpCard({ dump, expanded, setExpandedId, selected, toggleSelected, updateDump, deleteDump }) {
+  const [isEditing, setIsEditing] = useState(false);
+  const [editContent, setEditContent] = useState(dump.content);
+  const [editReflection, setEditReflection] = useState(Boolean(dump.aiReflection));
+  const [isMutating, setIsMutating] = useState(false);
+  const [confirmDelete, setConfirmDelete] = useState(false);
+
+  useEffect(() => {
+    setEditContent(dump.content);
+    setEditReflection(Boolean(dump.aiReflection));
+  }, [dump.content, dump.aiReflection]);
+
+  async function handleSaveEdit() {
+    const trimmed = editContent.trim();
+    if (!trimmed || isMutating) return;
+    setIsMutating(true);
+    try {
+      await updateDump(dump, trimmed, editReflection);
+      setIsEditing(false);
+    } finally {
+      setIsMutating(false);
+    }
+  }
+
+  async function handleDelete() {
+    if (!confirmDelete) {
+      setConfirmDelete(true);
+      return;
+    }
+    setIsMutating(true);
+    try {
+      await deleteDump(dump);
+    } finally {
+      setIsMutating(false);
+    }
+  }
+
+  return (
+    <article className={`dump-card ${expanded ? "expanded" : ""} ${selected ? "selected" : ""}`}>
+      <div className="dump-card-main">
+        <button className="dump-card-open" type="button" onClick={() => setExpandedId(expanded ? "" : dump.id)}>
+          <span className={`dump-pill ${dump.visibility}`}>{dump.visibility}</span>
+          <strong>{firstLine(dump.content)}</strong>
+          <span>{formatDumpDate(dump.createdAt)}</span>
+        </button>
+        <button className={`dump-select ${selected ? "active" : ""}`} type="button" onClick={toggleSelected}>
+          {selected ? "selected" : "select"}
+        </button>
+      </div>
+      {expanded && (
+        <div className="dump-card-body">
+          {isEditing ? (
+            <>
+              <textarea
+                className="dump-edit-textarea"
+                value={editContent}
+                onChange={(event) => setEditContent(event.target.value)}
+                maxLength={4000}
+                disabled={isMutating}
+              />
+              <div className="dump-composer-bottom edit-bottom">
+                <label className="reflection-toggle">
+                  <input
+                    type="checkbox"
+                    checked={editReflection}
+                    onChange={(event) => setEditReflection(event.target.checked)}
+                    disabled={isMutating}
+                  />
+                  reflect on save
+                </label>
+                <span>{editContent.trim().length} chars</span>
+              </div>
+            </>
+          ) : (
+            <p>{dump.content}</p>
+          )}
+          {!isEditing && dump.aiReflection && (
+            <div className="dump-reflection">
+              <span>ai heard this</span>
+              <p>{dump.aiReflection.replace(/^ai heard this:\s*/i, "")}</p>
+            </div>
+          )}
+          <div className="dump-card-actions">
+            {isEditing ? (
+              <>
+                <button className="solid-button button-with-loader" type="button" onClick={handleSaveEdit} disabled={isMutating}>
+                  {isMutating && <span className="mini-loader" aria-hidden="true" />}
+                  save edit
+                </button>
+                <button className="ghost-button" type="button" onClick={() => setIsEditing(false)} disabled={isMutating}>
+                  cancel
+                </button>
+              </>
+            ) : (
+              <>
+                <button className="ghost-button" type="button" onClick={() => setIsEditing(true)}>
+                  edit
+                </button>
+                <button className="ghost-button danger" type="button" onClick={handleDelete} disabled={isMutating}>
+                  {confirmDelete ? "delete forever" : "delete"}
+                </button>
+              </>
+            )}
+          </div>
+        </div>
+      )}
+    </article>
+  );
+}
+
+function FieldNoteDrafts({
+  fieldNotes,
+  recentSlug,
+  shareSlug,
+  setShareSlug,
+  publishAnonymous,
+  setPublishAnonymous,
+  displayName,
+  setDisplayName,
+  publishingNoteId,
+  mutatingNoteId,
+  handlePublishFieldNote,
+  handleUpdateFieldNote,
+  handleDeleteFieldNote,
+}) {
+  return (
+    <section className="field-note-drafts">
+      <div className="field-note-drafts-header">
+        <span>field notes</span>
+        <p>Drafts and published notes live here. Team reads only sees published notes.</p>
+      </div>
+      {!fieldNotes.length && <div className="empty-state">no field notes yet. select a few dumps and draft one when a thread appears.</div>}
+      {fieldNotes.map((fieldNote) => (
+        <FieldNoteDraft
+          fieldNote={fieldNote}
+          key={fieldNote.id}
+          recentSlug={recentSlug}
+          shareSlug={shareSlug}
+          setShareSlug={setShareSlug}
+          publishAnonymous={publishAnonymous}
+          setPublishAnonymous={setPublishAnonymous}
+          displayName={displayName}
+          setDisplayName={setDisplayName}
+          publishingNoteId={publishingNoteId}
+          mutatingNoteId={mutatingNoteId}
+          handlePublishFieldNote={handlePublishFieldNote}
+          handleUpdateFieldNote={handleUpdateFieldNote}
+          handleDeleteFieldNote={handleDeleteFieldNote}
+        />
+      ))}
+    </section>
+  );
+}
+
+function FieldNoteDraft({
+  fieldNote,
+  recentSlug,
+  shareSlug,
+  setShareSlug,
+  publishAnonymous,
+  setPublishAnonymous,
+  displayName,
+  setDisplayName,
+  publishingNoteId,
+  mutatingNoteId,
+  handlePublishFieldNote,
+  handleUpdateFieldNote,
+  handleDeleteFieldNote,
+}) {
+  const [title, setTitle] = useState(fieldNote.title);
+  const [noteContent, setNoteContent] = useState(fieldNote.content);
+  const [isEditing, setIsEditing] = useState(!fieldNote.isPublished);
+  const [confirmDelete, setConfirmDelete] = useState(false);
+  const isPublished = fieldNote.isPublished;
+  const isMutating = mutatingNoteId === fieldNote.id || publishingNoteId === fieldNote.id;
+
+  useEffect(() => {
+    setTitle(fieldNote.title);
+    setNoteContent(fieldNote.content);
+  }, [fieldNote.title, fieldNote.content]);
+
+  async function saveEdits() {
+    const trimmedTitle = title.trim();
+    const trimmedContent = noteContent.trim();
+    if (!trimmedTitle || !trimmedContent || isMutating) return;
+    await handleUpdateFieldNote(fieldNote, { title: trimmedTitle, content: trimmedContent });
+    setIsEditing(false);
+  }
+
+  async function deleteNote() {
+    if (!confirmDelete) {
+      setConfirmDelete(true);
+      return;
+    }
+    await handleDeleteFieldNote(fieldNote);
+  }
+
+  return (
+    <article className={`field-note-card ${isPublished ? "published" : ""}`}>
+      <div className="field-note-card-top">
+        <div className="field-note-pills">
+          <span className={`dump-pill ${isPublished ? "team" : "private"}`}>{isPublished ? "published" : "draft"}</span>
+          {fieldNote.isPublic && <span className="dump-pill public">public</span>}
+        </div>
+        <small>{fieldNote.sourceDumpIds.length} dump{fieldNote.sourceDumpIds.length === 1 ? "" : "s"}</small>
+      </div>
+      {isEditing ? (
+        <>
+          <label>
+            title
+            <input value={title} onChange={(event) => setTitle(event.target.value)} disabled={isMutating} />
+          </label>
+          <label>
+            field note
+            <textarea value={noteContent} onChange={(event) => setNoteContent(event.target.value)} disabled={isMutating} />
+          </label>
+        </>
+      ) : (
+        <div className="field-note-read">
+          <h3>{fieldNote.title}</h3>
+          <p>{fieldNote.content}</p>
+        </div>
+      )}
+      {!isPublished && (
+        <div className="dump-share-fields">
+          <label>
+            room slug
+            <input
+              value={shareSlug}
+              onChange={(event) => setShareSlug(event.target.value)}
+              placeholder={recentSlug || "backend-team"}
+              disabled={isMutating}
+            />
+          </label>
+          <label className={`display-name-row ${publishAnonymous ? "hidden" : ""}`}>
+            display handle
+            <input
+              value={displayName}
+              onChange={(event) => setDisplayName(event.target.value)}
+              placeholder="e.g. sam from infra"
+              disabled={isMutating}
+            />
+          </label>
+        </div>
+      )}
+      <div className="dump-actions field-note-actions">
+        {isEditing ? (
+          <>
+            <button className="solid-button button-with-loader" type="button" onClick={saveEdits} disabled={isMutating}>
+              {mutatingNoteId === fieldNote.id && <span className="mini-loader" aria-hidden="true" />}
+              save note
+            </button>
+            <button className="ghost-button" type="button" onClick={() => setIsEditing(false)} disabled={isMutating}>
+              cancel
+            </button>
+          </>
+        ) : (
+          <button className="ghost-button" type="button" onClick={() => setIsEditing(true)} disabled={isMutating}>
+            edit
+          </button>
+        )}
+        {!isPublished && (
+          <>
+            <button
+              className={`anon-toggle ${publishAnonymous ? "" : "off"}`}
+              type="button"
+              onClick={() => setPublishAnonymous(!publishAnonymous)}
+              disabled={isMutating}
+            >
+              {publishAnonymous ? "anonymous on" : "posting with handle"}
+            </button>
+            <button
+              className="solid-button button-with-loader"
+              type="button"
+              onClick={() => handlePublishFieldNote(fieldNote, { title, content: noteContent })}
+              disabled={isMutating}
+            >
+              {publishingNoteId === fieldNote.id && <span className="mini-loader" aria-hidden="true" />}
+              publish to team reads
+            </button>
+          </>
+        )}
+        <button className="ghost-button danger" type="button" onClick={deleteNote} disabled={isMutating}>
+          {confirmDelete ? (isPublished ? "remove forever" : "delete forever") : isPublished ? "remove" : "delete"}
+        </button>
+      </div>
+    </article>
+  );
+}
+
+function GoPublicModal({
+  close,
+  fieldNotes,
+  publicProfile,
+  publicProfileStatus,
+  publicHandleDraft,
+  publicNameDraft,
+  publicBioDraft,
+  publicMutatingNoteId,
+  setPublicHandleDraft,
+  setPublicNameDraft,
+  setPublicBioDraft,
+  handleSavePublicProfile,
+  handleToggleFieldNotePublic,
+}) {
+  const publishedNotes = fieldNotes.filter((note) => note.isPublished);
+  const publicCount = fieldNotes.filter((note) => note.isPublic).length;
+  const profileDisabled = publicProfileStatus === "saving" || publicProfileStatus === "migration";
+
+  return (
+    <div className="modal-backdrop" onClick={close}>
+      <div className="modal go-public-modal" role="dialog" aria-modal="true" aria-labelledby="go-public-title" onClick={(event) => event.stopPropagation()}>
+        <div className="go-public-head">
+          <div>
+            <p className="eyebrow">go public</p>
+            <h2 id="go-public-title">{publicProfile ? `@${publicProfile.handle}` : "claim a handle"}</h2>
+            <p>
+              {publicProfileStatus === "migration"
+                ? "Public profiles need migration 0015 before this can save."
+                : "Choose the field notes that belong on your public working-process shelf. Nothing is added by default."}
+            </p>
+          </div>
+          <button className="ghost-button" type="button" onClick={close}>
+            close
+          </button>
+        </div>
+
+        <form className="go-public-form" onSubmit={handleSavePublicProfile}>
+          <div className="public-profile-fields">
+            <label>
+              handle
+              <input
+                value={publicHandleDraft}
+                onChange={(event) => setPublicHandleDraft(event.target.value)}
+                placeholder="disha"
+                disabled={profileDisabled}
+              />
+            </label>
+            <label>
+              display name
+              <input
+                value={publicNameDraft}
+                onChange={(event) => setPublicNameDraft(event.target.value)}
+                placeholder="Disha"
+                disabled={profileDisabled}
+              />
+            </label>
+          </div>
+          <label>
+            bio
+            <input
+              value={publicBioDraft}
+              onChange={(event) => setPublicBioDraft(event.target.value)}
+              placeholder="building, debugging, learning in public"
+              disabled={profileDisabled}
+            />
+          </label>
+          <div className="public-profile-actions">
+            <button className="solid-button button-with-loader" type="submit" disabled={profileDisabled}>
+              {publicProfileStatus === "saving" && <span className="mini-loader" aria-hidden="true" />}
+              {publicProfile ? "save handle" : "claim handle"}
+            </button>
+            {publicProfile && (
+              <Link className="ghost-button button-link" href={`/@${publicProfile.handle}`} target="_blank" rel="noreferrer">
+                view profile
+              </Link>
+            )}
+            <small>{publicCount} public field note{publicCount === 1 ? "" : "s"}</small>
+          </div>
+        </form>
+
+        <div className="go-public-picker">
+          <div className="go-public-picker-head">
+            <span>choose field notes</span>
+            <small>{publishedNotes.length} published</small>
+          </div>
+          {!publishedNotes.length && (
+            <div className="empty-state">publish a field note to team reads first. then you can choose it for your public profile.</div>
+          )}
+          {publishedNotes.map((note) => {
+            const isMutating = publicMutatingNoteId === note.id;
+            return (
+              <label className={`public-note-option ${note.isPublic ? "selected" : ""}`} key={note.id}>
+                <input
+                  type="checkbox"
+                  checked={note.isPublic}
+                  onChange={(event) => handleToggleFieldNotePublic(note, event.target.checked)}
+                  disabled={!publicProfile || isMutating}
+                />
+                <span>
+                  <strong>{note.title}</strong>
+                  <small>{note.isPublic ? "on your public profile" : "private to team reads"}</small>
+                </span>
+                {isMutating && <span className="mini-loader" aria-hidden="true" />}
+              </label>
+            );
+          })}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function DumpMap({ dumps, fieldNotes, map, status, toast, setToast }) {
+  const [graphState, setGraphState] = useState({ status: "loading", graph: null, supermemory: null });
+  const [selectedPatternId, setSelectedPatternId] = useState("");
+  const [includePrivateDumps, setIncludePrivateDumps] = useState(false);
+
+  useEffect(() => {
+    setIncludePrivateDumps(getDumpMemoryOptIn());
+  }, []);
+
+  useEffect(() => {
+    let mounted = true;
+    async function loadGraph() {
+      try {
+        const result = await fetchDumpMap({ includePrivateDumps });
+        if (!mounted) return;
+        setGraphState({ status: "ready", graph: result.graph, supermemory: result.supermemory });
+      } catch (error) {
+        if (!mounted) return;
+        setGraphState({ status: "error", graph: null, supermemory: null });
+        setToast(error.message || "couldn't build the graph yet.");
+      }
+    }
+    loadGraph();
+    return () => {
+      mounted = false;
+    };
+  }, [includePrivateDumps, setToast]);
+
+  function handlePrivateDumpMemoryToggle(event) {
+    const isEnabled = event.target.checked;
+    setDumpMemoryOptIn(isEnabled);
+    setIncludePrivateDumps(isEnabled);
+    setGraphState((current) => ({ ...current, status: "loading" }));
+    setToast(isEnabled ? "private dumps can now shape only your memory graph." : "memory graph is back to field notes only.");
+  }
+
+  const graph = graphState.graph || {
+    nodes: [],
+    edges: [],
+    source: "local",
+    syncedCount: 0,
+    patterns: [],
+    insights: [],
+  };
+  const evidenceNodes = graph.nodes.filter((node) => node.kind === (includePrivateDumps ? "dump" : "field_note"));
+  const themes = graph.nodes.filter((node) => node.kind === "theme");
+  const sourceName = includePrivateDumps ? "opted-in dumps" : "field notes";
+  const patterns = graph.patterns?.length
+    ? graph.patterns
+    : [
+        {
+          id: "pattern-local",
+          title: themes[0] ? `${themes[0].label} keeps coming back` : "No repeat pattern yet",
+          read: themes[0]?.detail || "There is not enough repeated material yet to say something useful without overreaching.",
+          why: `${dumps.length} private dump${dumps.length === 1 ? "" : "s"} saved.`,
+          nextStep: dumps.length > 2 ? "Draft the useful version, then decide if it belongs in Team Reads." : "Add a little more raw material before trusting the pattern.",
+          fieldNoteSeed: themes[0] ? `What I am noticing about ${themes[0].label}` : "Nothing to draft yet.",
+          privacy: "review before sharing",
+          tone: "blue",
+          evidenceIds: evidenceNodes.slice(0, 3).map((node) => node.id),
+        },
+      ];
+  const selectedPattern = patterns.find((pattern) => pattern.id === selectedPatternId) || patterns[0] || null;
+  const patternEvidence = evidenceNodes.filter((node) => selectedPattern?.evidenceIds?.includes(node.id)).slice(0, 4);
+  const summary = graph.summary || {
+    headline: themes[0] ? `${themes[0].label} keeps coming back` : "No strong pattern yet",
+    detail: graphState.supermemory?.source === "supermemory" ? `Reading your ${sourceName} for repeat work patterns.` : map.summary,
+    nextStep: dumps.length > 2 ? "Turn one useful thread into a field note when it is ready for the team." : "Add more raw material before trusting the read.",
+  };
+  const insights = graph.insights?.length
+    ? graph.insights
+    : [
+        {
+          label: "source",
+          value: sourceName,
+          detail: includePrivateDumps ? "Private dumps are opted in for this browser." : "Private dumps stay out by default.",
+          tone: "blue",
+        },
+      ];
+  const memoryStatus = graphState.supermemory || {};
+  const sourceCount = includePrivateDumps ? dumps.length : fieldNotes.length;
+  const isGraphLoading = graphState.status === "loading";
+  const statusLabel =
+    isGraphLoading ? "checking memory" : memoryStatus.label || (memoryStatus.configured ? "memory ready" : "local only");
+  const statusValue =
+    isGraphLoading
+      ? "syncing..."
+      : memoryStatus.status === "active"
+        ? `${sourceName} connected`
+        : memoryStatus.status === "unavailable"
+          ? "local, lower confidence"
+          : memoryStatus.status === "waiting"
+            ? "waiting for sources"
+            : "local read";
+  const statusDetail = memoryStatus.syncError || memoryStatus.detail || "";
+
+  useEffect(() => {
+    if (!selectedPatternId && patterns[0]) {
+      setSelectedPatternId(patterns[0].id);
+    }
+    if (selectedPatternId && !patterns.some((pattern) => pattern.id === selectedPatternId)) {
+      setSelectedPatternId(patterns[0]?.id || "");
+    }
+  }, [patterns, selectedPatternId]);
+
+  return (
+    <section className="dump-view">
+      <div className="dump-hero">
+        <div>
+          <p className="eyebrow">private patterns</p>
+          <h1>your working map</h1>
+          <p>See what keeps coming up, what it might mean, and which thread is worth turning into a team read.</p>
+        </div>
+        <Link className="ghost-button button-link" href="/dump">
+          back to dump
+        </Link>
+      </div>
+      <div className="dump-map-panel">
+        {status === "loading" ? <div className="empty-state">looking for patterns...</div> : null}
+        {status !== "loading" && sourceCount < 1 ? (
+          <div className="empty-state">
+            {includePrivateDumps ? "write a dump to start your private map." : "draft a field note to start the working map."}
+          </div>
+        ) : null}
+        {status !== "loading" && sourceCount >= 1 && (
+          <>
+            <div className={`dump-graph-status ${memoryStatus.status || "local"}`}>
+              <span>{statusLabel}</span>
+              <strong>{statusValue}</strong>
+              {statusDetail && <p>{statusDetail}</p>}
+            </div>
+
+            <label className={`dump-memory-toggle ${includePrivateDumps ? "on" : ""}`}>
+              <input type="checkbox" checked={includePrivateDumps} onChange={handlePrivateDumpMemoryToggle} />
+              <span>
+                <strong>use private dumps for my graph</strong>
+                <small>
+                  {includePrivateDumps
+                    ? "only for your private graph. nothing gets posted."
+                    : "off by default. published/drafted field notes shape this view."}
+                </small>
+              </span>
+            </label>
+
+            {isGraphLoading ? (
+              <div className="dump-map-loading">
+                <strong>reading your {sourceName}...</strong>
+                <p>The map only uses private dumps if you switch them on.</p>
+              </div>
+            ) : (
+              <>
+                <div className={`dump-map-summary ${selectedPattern?.tone || "blue"}`}>
+                  <div className="dump-map-summary-copy">
+                    <span>strongest read</span>
+                    <strong>{summary.headline}</strong>
+                    <p>{summary.detail}</p>
+                  </div>
+                  <div className="dump-map-next">
+                    <span>next move</span>
+                    <p>{summary.nextStep}</p>
+                    <Link className="solid-button button-link" href="/dump">
+                      draft a field note
+                    </Link>
+                  </div>
+                </div>
+
+                <div className="dump-insight-strip" aria-label="Map confidence">
+                  {insights.slice(0, 3).map((insight) => (
+                    <div className={`dump-insight ${insight.tone || "blue"}`} key={`${insight.label}-${insight.value}`}>
+                      <span>{insight.label}</span>
+                      <strong>{insight.value}</strong>
+                      <p>{insight.detail}</p>
+                    </div>
+                  ))}
+                </div>
+
+                <div className="dump-pattern-board">
+                  <div className="dump-pattern-list" aria-label="Private pattern insights">
+                    {patterns.map((pattern) => (
+                      <button
+                        className={`dump-pattern-card ${pattern.tone || "blue"} ${selectedPattern?.id === pattern.id ? "active" : ""}`}
+                        key={pattern.id}
+                        type="button"
+                        onClick={() => setSelectedPatternId(pattern.id)}
+                      >
+                        <span>{pattern.privacy}</span>
+                        <strong>{pattern.title}</strong>
+                        <p>{pattern.nextStep}</p>
+                      </button>
+                    ))}
+                  </div>
+
+                  <article className={`dump-pattern-detail ${selectedPattern?.tone || "blue"}`}>
+                    <span>selected read</span>
+                    <h2>{selectedPattern?.title || "No pattern selected"}</h2>
+                    <p>{selectedPattern?.read || "Pick a pattern to see the read."}</p>
+                    <div className="dump-pattern-meta">
+                      <div>
+                        <small>why this matters</small>
+                        <strong>{selectedPattern?.why || "Waiting for enough private material."}</strong>
+                      </div>
+                      <div>
+                        <small>field note angle</small>
+                        <strong>{selectedPattern?.fieldNoteSeed || "Nothing to publish yet."}</strong>
+                      </div>
+                    </div>
+                    <div className="dump-pattern-evidence">
+                      <small>{includePrivateDumps ? "private evidence" : "field note evidence"}</small>
+                      {patternEvidence.length ? (
+                        patternEvidence.map((dump) => (
+                          <div className="dump-pattern-evidence-item" key={dump.id}>
+                            <span>{formatDumpDate(dump.createdAt)}</span>
+                            <strong>{dump.label}</strong>
+                          </div>
+                        ))
+                      ) : (
+                        <p>No connected evidence yet. Draft a field note or opt private dumps in for a richer read.</p>
+                      )}
+                    </div>
+                  </article>
+                </div>
+              </>
+            )}
+          </>
+        )}
+      </div>
+      {toast && <Toast message={toast} onDone={() => setToast("")} />}
+    </section>
+  );
+}
+
+function makeDumpMap(dumps) {
+  const buckets = [
+    { label: "stuck threads", tone: "clay", words: ["stuck", "blocked", "waiting", "confused"] },
+    { label: "process static", tone: "gold", words: ["meeting", "standup", "process", "planning"] },
+    { label: "ship energy", tone: "mint", words: ["shipped", "fixed", "win", "done"] },
+    { label: "heavy weather", tone: "violet", words: ["tired", "burn", "hard", "rough"] },
+  ];
+  const threads = buckets
+    .map((bucket) => ({
+      ...bucket,
+      count: dumps.filter((dump) => bucket.words.some((word) => dump.content.toLowerCase().includes(word))).length,
+    }))
+    .filter((bucket) => bucket.count > 0);
+
+  const top = threads.slice().sort((a, b) => b.count - a.count)[0];
+  return {
+    threads: threads.length ? threads : [{ label: "loose thoughts", tone: "blue", count: dumps.length }],
+    summary: top
+      ? `lately you've been dumping around ${top.label}. still private. still yours.`
+      : "a few loose thoughts are down. the shape appears after you give it a little more material.",
+  };
+}
+
+function firstLine(content) {
+  return content.split(/\n/).find(Boolean)?.slice(0, 96) || "untitled dump";
+}
+
+function formatDumpDate(timestamp) {
+  return new Intl.DateTimeFormat("en", { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" }).format(
+    new Date(timestamp),
+  );
+}
diff --git a/src/components/ExpandableText.jsx b/src/components/ExpandableText.jsx
new file mode 100644
index 0000000..bebbc04
--- /dev/null
+++ b/src/components/ExpandableText.jsx
@@ -0,0 +1,23 @@
+"use client";
+
+import { useState } from "react";
+
+const DEFAULT_LIMIT = 620;
+
+export default function ExpandableText({ text, className = "", limit = DEFAULT_LIMIT }) {
+  const [expanded, setExpanded] = useState(false);
+  const content = String(text || "");
+  const needsClamp = content.length > limit;
+  const visibleText = !needsClamp || expanded ? content : `${content.slice(0, limit).trimEnd()}...`;
+
+  return (
+    <div className={`expandable-read ${expanded ? "expanded" : ""} ${className}`}>
+      <p>{visibleText}</p>
+      {needsClamp && (
+        <button className="read-more-button" type="button" onClick={() => setExpanded((current) => !current)}>
+          {expanded ? "show less" : "show more"}
+        </button>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/HomeView.jsx b/src/components/HomeView.jsx
index b62e332..a949004 100644
--- a/src/components/HomeView.jsx
+++ b/src/components/HomeView.jsx
@@ -23,6 +23,9 @@ export default function HomeView() {
             no polished survey energy.
           </p>
           <div className="hero-actions">
+            <Link className="solid-button button-link" href="/dump">
+              start your dump
+            </Link>
             <Link className="solid-button button-link" href="/create">
               create your space
             </Link>
@@ -59,8 +62,8 @@ export default function HomeView() {
             <p className="muted">the ticket lied, the tests recovered, and people absolutely noticed.</p>
           </div>
           <div className="artifact post-it">
-            <strong>drop it on mumbl</strong>
-            <p className="muted">someone else is probably already thinking it.</p>
+            <strong>your dump</strong>
+            <p className="muted">private first. team-readable only when you choose.</p>
           </div>
           <Link className="artifact open-room" href={publicDemoRoom.href} aria-label={`open ${publicDemoRoom.name}`}>
             <div className="artifact-title">
diff --git a/src/components/PublicProfilePage.jsx b/src/components/PublicProfilePage.jsx
new file mode 100644
index 0000000..d94c9c0
--- /dev/null
+++ b/src/components/PublicProfilePage.jsx
@@ -0,0 +1,90 @@
+import { notFound } from "next/navigation";
+import ExpandableText from "./ExpandableText";
+import { getSupabaseAdmin } from "../server/supabase";
+import { normalizeHandle, serializePublicProfile } from "../server/publicProfiles";
+
+export async function getPublicProfileMetadata(rawHandle) {
+  const handle = normalizeHandle(rawHandle);
+  if (!handle) return {};
+
+  return {
+    title: `@${handle}`,
+    description: `how ${handle} actually thinks at work.`,
+  };
+}
+
+export default async function PublicProfilePage({ rawHandle }) {
+  const handle = normalizeHandle(rawHandle);
+  if (!handle) notFound();
+
+  const supabase = getSupabaseAdmin();
+  const { data: profile, error } = await supabase.from("public_profiles").select("*").eq("handle", handle).single();
+  if (error?.code === "PGRST116") {
+    return <PublicProfileShell publicProfile={{ handle, displayName: handle, bio: "", posts: [] }} />;
+  }
+  if (isMissingTableError(error)) notFound();
+  if (error) throw error;
+
+  const { data: fieldNotes, error: notesError } = await supabase
+    .from("field_notes")
+    .select("id, title, content, created_at, public_published_at")
+    .eq("public_profile_id", profile.id)
+    .eq("is_public", true)
+    .eq("is_published", true)
+    .order("public_published_at", { ascending: false })
+    .limit(40);
+  if (isMissingTableError(notesError) || isMissingColumnError(notesError)) notFound();
+  if (notesError) throw notesError;
+
+  return <PublicProfileShell publicProfile={serializePublicProfile(profile, fieldNotes || [])} />;
+}
+
+function PublicProfileShell({ publicProfile }) {
+  return (
+    <section className="public-profile-view">
+      <header className="public-profile-hero">
+        <div>
+          <p className="eyebrow">public mumbl</p>
+          <h1>@{publicProfile.handle}</h1>
+          <p>how {publicProfile.displayName || publicProfile.handle} actually thinks at work.</p>
+          {publicProfile.bio ? <p className="public-profile-bio">{publicProfile.bio}</p> : null}
+        </div>
+        <button className="ghost-button" type="button" disabled>
+          follow soon
+        </button>
+      </header>
+
+      <div className="public-profile-list">
+        {!publicProfile.posts.length && (
+          <div className="empty-state">nothing public here yet. the good stuff appears only when @{publicProfile.handle} chooses it.</div>
+        )}
+        {publicProfile.posts.map((post) => (
+          <article className="public-note-card" key={post.id}>
+            <div className="public-note-meta">
+              <span>field note</span>
+              <time dateTime={new Date(post.publishedAt || post.createdAt).toISOString()}>
+                {formatPublicDate(post.publishedAt || post.createdAt)}
+              </time>
+            </div>
+            <h2>{post.title}</h2>
+            <ExpandableText className="public-note-text" text={post.content} limit={760} />
+          </article>
+        ))}
+      </div>
+    </section>
+  );
+}
+
+function formatPublicDate(timestamp) {
+  return new Intl.DateTimeFormat("en", { month: "short", day: "numeric", year: "numeric" }).format(new Date(timestamp));
+}
+
+function isMissingTableError(error) {
+  const message = `${error?.message || ""} ${error?.details || ""} ${error?.hint || ""}`.toLowerCase();
+  return error?.code === "42P01" || error?.code === "PGRST205" || message.includes("could not find the table");
+}
+
+function isMissingColumnError(error) {
+  const message = `${error?.message || ""} ${error?.details || ""} ${error?.hint || ""}`.toLowerCase();
+  return error?.code === "42703" || error?.code === "PGRST204" || (message.includes("could not find") && message.includes("column"));
+}
diff --git a/src/components/SpacePageClient.jsx b/src/components/SpacePageClient.jsx
index 7e80359..a6a0b03 100644
--- a/src/components/SpacePageClient.jsx
+++ b/src/components/SpacePageClient.jsx
@@ -19,7 +19,7 @@ import Toast from "./Toast";
 
 export default function SpacePageClient({ slug, tab }) {
   const activeTab = validTabs.includes(tab) ? tab : "feed";
-  const postTypeFilter = activeTab === "wins" ? "win" : "";
+  const postTypeFilter = activeTab === "wins" ? "win" : activeTab === "reads" ? "reads" : "";
   const {
     space,
     status,
@@ -116,6 +116,9 @@ export default function SpacePageClient({ slug, tab }) {
             <TabLink slug={space.slug} tab="wins" activeTab={activeTab}>
               wins
             </TabLink>
+            <TabLink slug={space.slug} tab="reads" activeTab={activeTab}>
+              reads
+            </TabLink>
             <TabLink slug={space.slug} tab="heartbeat" activeTab={activeTab}>
               heartbeat
             </TabLink>
@@ -182,6 +185,8 @@ export default function SpacePageClient({ slug, tab }) {
             />
           )}
 
+          {activeTab === "reads" && <ReadsView posts={posts} space={space} loadOlderPosts={loadOlderPosts} pageStatus={pageStatus} />}
+
           {activeTab === "heartbeat" && <HeartbeatView space={space} />}
         </div>
         <aside className="side-panel">
@@ -222,6 +227,29 @@ function WinsView({ posts, space, toggleReaction, loadOlderPosts, pageStatus })
   );
 }
 
+function ReadsView({ posts, space, loadOlderPosts, pageStatus }) {
+  return (
+    <>
+      <div className="reads-intro">
+        <span>team reads</span>
+        <p>Published field notes from teammates. Drafted from private dumps, approved by the person who wrote them.</p>
+        <Link className="ghost-button button-link" href="/dump">
+          open your dump
+        </Link>
+      </div>
+      <PostList
+        posts={posts}
+        space={space}
+        toggleReaction={async () => {}}
+        loadOlderPosts={loadOlderPosts}
+        pageStatus={pageStatus}
+        emptyText="no one has dropped anything here yet. share a dump with the team."
+        showReactions={false}
+      />
+    </>
+  );
+}
+
 function formatCreatedDate(timestamp) {
   return new Intl.DateTimeFormat("en", { month: "short", day: "numeric", year: "numeric" }).format(new Date(timestamp));
 }
@@ -233,6 +261,7 @@ function PostList({
   loadOlderPosts,
   pageStatus,
   emptyText = "quiet room. dangerous. drop the first mumbl.",
+  showReactions = true,
 }) {
   const page = space.postsPage || {};
   const hasMore = Boolean(page.hasMore);
@@ -242,7 +271,9 @@ function PostList({
   return (
     <div className="feed-list">
       {posts.length ? (
-        posts.map((post) => <PostCard post={post} space={space} toggleReaction={toggleReaction} key={post.id} />)
+        posts.map((post) => (
+          <PostCard post={post} space={space} toggleReaction={toggleReaction} showReactions={showReactions} key={post.id} />
+        ))
       ) : (
         <div className="empty-state">{emptyText}</div>
       )}
diff --git a/src/components/space/ComposeBox.jsx b/src/components/space/ComposeBox.jsx
index 7cd7b4b..d9b9b67 100644
--- a/src/components/space/ComposeBox.jsx
+++ b/src/components/space/ComposeBox.jsx
@@ -78,7 +78,9 @@ export default function ComposeBox({
         />
       </label>
       <div className="type-grid">
-        {Object.entries(postTypes).map(([key, type]) => (
+        {Object.entries(postTypes)
+          .filter(([key]) => key !== "dump")
+          .map(([key, type]) => (
           <button
             className={`type-button ${selectedType === key ? "active" : ""}`}
             type="button"
diff --git a/src/components/space/PostCard.jsx b/src/components/space/PostCard.jsx
index 053eeeb..2d263a4 100644
--- a/src/components/space/PostCard.jsx
+++ b/src/components/space/PostCard.jsx
@@ -1,10 +1,11 @@
 "use client";
 
 import { useState } from "react";
+import ExpandableText from "../ExpandableText";
 import { getReactionLabels } from "../../lib/heartbeat";
 import { timeAgo } from "../../lib/storage";
 
-export default function PostCard({ space, post, toggleReaction }) {
+export default function PostCard({ space, post, toggleReaction, showReactions = true }) {
   const author = post.isAnonymous ? "anonymous" : post.displayName || "someone brave";
   const initials = post.isAnonymous ? "?" : (post.displayName || "m").trim().charAt(0).toLowerCase();
   const reactionLabels = getReactionLabels(space, post);
@@ -22,7 +23,7 @@ export default function PostCard({ space, post, toggleReaction }) {
   }
 
   return (
-    <article className="post-card">
+    <article className={`post-card ${post.type === "dump" ? "dump-post" : ""}`}>
       <span className="avatar">{initials}</span>
       <div>
         <div className="post-meta">
@@ -30,28 +31,31 @@ export default function PostCard({ space, post, toggleReaction }) {
           <span>{timeAgo(post.createdAt)}</span>
           <span className={`badge ${post.type}`}>{post.type}</span>
         </div>
-        <p className="post-text">{post.content}</p>
-        <div className="post-footer">
-          {reactionLabels.map((label) => {
-            const reactionValue = post.reactions?.[label] || 0;
-            const count = Array.isArray(reactionValue) ? reactionValue.length : reactionValue;
-            const active = post.activeReactions?.includes(label) || false;
-            const isPending = pendingLabel === label;
-            return (
-              <button
-                className={`reaction-button ${active ? "active" : ""} ${isPending ? "pending" : ""}`}
-                type="button"
-                key={label}
-                onClick={() => handleReaction(label)}
-                disabled={Boolean(pendingLabel)}
-                aria-busy={isPending}
-              >
-                {isPending && <span className="mini-loader" aria-hidden="true" />}
-                {label} · {count}
-              </button>
-            );
-          })}
-        </div>
+        {post.title && <h3 className="post-title">{post.title}</h3>}
+        <ExpandableText className="post-text" text={post.content} limit={post.type === "field_note" ? 520 : 720} />
+        {showReactions && (
+          <div className="post-footer">
+            {reactionLabels.map((label) => {
+              const reactionValue = post.reactions?.[label] || 0;
+              const count = Array.isArray(reactionValue) ? reactionValue.length : reactionValue;
+              const active = post.activeReactions?.includes(label) || false;
+              const isPending = pendingLabel === label;
+              return (
+                <button
+                  className={`reaction-button ${active ? "active" : ""} ${isPending ? "pending" : ""}`}
+                  type="button"
+                  key={label}
+                  onClick={() => handleReaction(label)}
+                  disabled={Boolean(pendingLabel)}
+                  aria-busy={isPending}
+                >
+                  {isPending && <span className="mini-loader" aria-hidden="true" />}
+                  {label} · {count}
+                </button>
+              );
+            })}
+          </div>
+        )}
       </div>
     </article>
   );
diff --git a/src/lib/api.js b/src/lib/api.js
index 6a912db..5e43bf8 100644
--- a/src/lib/api.js
+++ b/src/lib/api.js
@@ -43,6 +43,98 @@ export async function createRemotePost({ slug, type, content, isAnonymous, displ
   return parseJson(response);
 }
 
+export async function fetchDumps() {
+  const sessionToken = loadSession();
+  const response = await fetch(`/api/dumps?sessionToken=${encodeURIComponent(sessionToken)}`, {
+    cache: "no-store",
+  });
+  return parseJson(response);
+}
+
+export async function fetchDumpMap({ includePrivateDumps = false } = {}) {
+  const sessionToken = loadSession();
+  const params = new URLSearchParams({ sessionToken });
+  if (includePrivateDumps) params.set("includePrivateDumps", "true");
+  const response = await fetch(`/api/dumps/map?${params.toString()}`, {
+    cache: "no-store",
+  });
+  return parseJson(response);
+}
+
+export async function createDump({ content, wantsReflection = false }) {
+  const response = await fetch("/api/dumps", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ content, wantsReflection, sessionToken: loadSession() }),
+  });
+  return parseJson(response);
+}
+
+export async function updateDump({ dumpId, content, wantsReflection = false }) {
+  const response = await fetch(`/api/dumps/${dumpId}`, {
+    method: "PATCH",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ content, wantsReflection, sessionToken: loadSession() }),
+  });
+  return parseJson(response);
+}
+
+export async function deleteDump(dumpId) {
+  const response = await fetch(`/api/dumps/${dumpId}`, {
+    method: "DELETE",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ sessionToken: loadSession() }),
+  });
+  return parseJson(response);
+}
+
+export async function shareDumpToRoom({ dumpId, slug, isAnonymous = true, displayName = "" }) {
+  const response = await fetch(`/api/dumps/${dumpId}/team`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ slug, isAnonymous, displayName, sessionToken: loadSession() }),
+  });
+  return parseJson(response);
+}
+
+export async function draftFieldNote({ dumpIds }) {
+  const response = await fetch("/api/dumps/field-notes/draft", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ dumpIds, sessionToken: loadSession() }),
+  });
+  return parseJson(response);
+}
+
+export async function publishFieldNote({ fieldNoteId, slug, title, content, isAnonymous = true, displayName = "" }) {
+  const response = await fetch(`/api/dumps/field-notes/${fieldNoteId}/publish`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ slug, title, content, isAnonymous, displayName, sessionToken: loadSession() }),
+  });
+  const data = await parseJson(response);
+  rememberRecentSlug(slug);
+  return data;
+}
+
+export async function updateFieldNote({ fieldNoteId, title, content }) {
+  const response = await fetch(`/api/dumps/field-notes/${fieldNoteId}`, {
+    method: "PATCH",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ title, content, sessionToken: loadSession() }),
+  });
+  return parseJson(response);
+}
+
+export async function deleteFieldNote(fieldNoteId) {
+  const response = await fetch(`/api/dumps/field-notes/${fieldNoteId}`, {
+    method: "DELETE",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ sessionToken: loadSession() }),
+  });
+  return parseJson(response);
+}
+
 export async function updateRemoteSpaceVisibility({ slug, isPublic, publicName }) {
   const response = await fetch(`/api/spaces/${slug}`, {
     method: "PATCH",
@@ -174,8 +266,42 @@ export async function reportSideQuestRoom(roomId) {
   return parseJson(response);
 }
 
+export async function fetchPublicProfileForSession() {
+  const response = await fetch(`/api/public-profiles?sessionToken=${encodeURIComponent(loadSession())}`, {
+    cache: "no-store",
+  });
+  return parseJson(response);
+}
+
+export async function savePublicProfile({ handle, displayName = "", bio = "" }) {
+  const response = await fetch("/api/public-profiles", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ handle, displayName, bio, sessionToken: loadSession() }),
+  });
+  return parseJson(response);
+}
+
+export async function setFieldNotePublic({ fieldNoteId, isPublic, handle }) {
+  const response = await fetch(`/api/dumps/field-notes/${fieldNoteId}/public`, {
+    method: "PATCH",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ isPublic, handle, sessionToken: loadSession() }),
+  });
+  return parseJson(response);
+}
+
 async function parseJson(response) {
-  const data = await response.json();
+  const contentType = response.headers.get("content-type") || "";
+  const isJson = contentType.includes("application/json");
+  const data = isJson ? await response.json() : null;
+
+  if (!isJson) {
+    const text = await response.text().catch(() => "");
+    const fallback = response.ok ? "mumbl expected JSON but got a non-JSON response" : "mumbl api request returned a non-JSON error";
+    throw new Error(`${fallback} (${response.status} ${response.url})${text.includes("<!DOCTYPE") ? "" : `: ${text.slice(0, 160)}`}`);
+  }
+
   if (!response.ok) {
     throw new Error(data.error || "mumbl api request failed");
   }
diff --git a/src/lib/constants.js b/src/lib/constants.js
index 1b1ebe5..786a17e 100644
--- a/src/lib/constants.js
+++ b/src/lib/constants.js
@@ -31,9 +31,11 @@ export const postTypes = {
   win: { label: "win", hint: "brag or shoutout", placeholder: "okay i need to brag for one second..." },
   find: { label: "find", hint: "link, tool, paper", placeholder: "sharing something useful i found..." },
   lol: { label: "lol", hint: "work got weird", placeholder: "this just happened and i cannot..." },
+  dump: { label: "dump", hint: "longer, messier, real", placeholder: "what are you actually thinking about right now?" },
+  field_note: { label: "field note", hint: "drafted from dumps", placeholder: "the week, made readable..." },
 };
 
-export const validTabs = ["feed", "wins", "heartbeat"];
+export const validTabs = ["feed", "wins", "reads", "heartbeat"];
 
 export const publicDemoRoom = {
   slug: "it-works-on-my-machine",
diff --git a/src/lib/heartbeat.js b/src/lib/heartbeat.js
index c4497ae..16b2a3d 100644
--- a/src/lib/heartbeat.js
+++ b/src/lib/heartbeat.js
@@ -48,6 +48,8 @@ export function getReactionLabels(space, post) {
     win: ["legend", "we are not worthy", "ship it"],
     find: ["saving this", "same energy", "worth a look"],
     lol: ["deeply cursed", "same energy", "sending help"],
+    dump: ["i felt this", "sat with this", "quietly true"],
+    field_note: ["sat with this", "quietly true", "worth a reread"],
     thought: vibes[space.vibe].reactions,
   };
   return [...new Set([...(byType[post.type] || vibes[space.vibe].reactions), ...existing])].slice(0, 4);
diff --git a/src/lib/storage.js b/src/lib/storage.js
index ffe5009..517ee21 100644
--- a/src/lib/storage.js
+++ b/src/lib/storage.js
@@ -1,6 +1,7 @@
 export const SESSION_KEY = "mumbl:session";
 export const RECENT_SPACE_KEY = "mumbl:recent-space";
 export const CREATOR_TOKEN_PREFIX = "mumbl:creator-token:";
+export const DUMP_MEMORY_OPT_IN_KEY = "mumbl:dump-memory-opt-in";
 
 export function loadSession() {
   const existing = window.localStorage.getItem(SESSION_KEY);
@@ -19,6 +20,15 @@ export function rememberRecentSlug(slug) {
   window.localStorage.setItem(RECENT_SPACE_KEY, slug);
 }
 
+export function getDumpMemoryOptIn() {
+  if (typeof window === "undefined") return false;
+  return window.localStorage.getItem(DUMP_MEMORY_OPT_IN_KEY) === "true";
+}
+
+export function setDumpMemoryOptIn(isEnabled) {
+  window.localStorage.setItem(DUMP_MEMORY_OPT_IN_KEY, isEnabled ? "true" : "false");
+}
+
 export function saveCreatorToken(slug, token) {
   window.localStorage.setItem(`${CREATOR_TOKEN_PREFIX}${slug}`, token);
 }
diff --git a/src/server/dumps.js b/src/server/dumps.js
new file mode 100644
index 0000000..053c6f3
--- /dev/null
+++ b/src/server/dumps.js
@@ -0,0 +1,48 @@
+export function serializeDump(dump) {
+  return {
+    id: dump.id,
+    content: dump.content,
+    visibility: dump.visibility,
+    teamRoomId: dump.team_room_id || "",
+    aiReflection: dump.ai_reflection || "",
+    supermemoryId: dump.supermemory_id || "",
+    supermemoryStatus: dump.supermemory_status || "",
+    publishedAt: dump.published_at ? new Date(dump.published_at).getTime() : null,
+    createdAt: new Date(dump.created_at).getTime(),
+    updatedAt: new Date(dump.updated_at).getTime(),
+  };
+}
+
+export function serializeFieldNote(note) {
+  return {
+    id: note.id,
+    title: note.title,
+    content: note.content,
+    sourceDumpIds: note.source_dump_ids || [],
+    teamRoomId: note.team_room_id || "",
+    isPublished: note.is_published || false,
+    publishedPostId: note.published_post_id || "",
+    isPublic: note.is_public || false,
+    publicProfileId: note.public_profile_id || "",
+    createdAt: new Date(note.created_at).getTime(),
+    publishedAt: note.published_at ? new Date(note.published_at).getTime() : null,
+    publicPublishedAt: note.public_published_at ? new Date(note.public_published_at).getTime() : null,
+  };
+}
+
+export function makeLocalReflection(content) {
+  const text = content.toLowerCase();
+  if (text.includes("stuck") || text.includes("blocked")) {
+    return "ai heard this: there is a stuck thread here. what part feels blocked by the work, and what part feels blocked by the room around it?";
+  }
+  if (text.includes("tired") || text.includes("burn") || text.includes("exhaust")) {
+    return "ai heard this: this sounds less like laziness and more like load. what would make tomorrow ten percent lighter?";
+  }
+  if (text.includes("win") || text.includes("shipped") || text.includes("fixed")) {
+    return "ai heard this: there is a small win in here. what made it possible, and who else should know it mattered?";
+  }
+  if (text.includes("meeting") || text.includes("standup") || text.includes("process")) {
+    return "ai heard this: the process is taking up emotional space. what is the smallest part you wish someone would just name out loud?";
+  }
+  return "ai heard this: there is a real thread here. what are you trying to understand by putting it down?";
+}
diff --git a/src/server/env.js b/src/server/env.js
index 36f2b62..5aff779 100644
--- a/src/server/env.js
+++ b/src/server/env.js
@@ -6,6 +6,10 @@ export function getServerEnv() {
     tokenHashSecret: process.env.MUMBL_TOKEN_HASH_SECRET,
     sideQuestEncryptionKey: process.env.MUMBL_SIDE_QUEST_ENCRYPTION_KEY,
     cronSecret: process.env.CRON_SECRET,
+    openAiApiKey: process.env.OPENAI_API_KEY,
+    openAiFieldNoteModel: process.env.OPENAI_MODEL_FIELD_NOTE || "gpt-5.4-nano",
+    openAiMaxDailyDrafts: Number.parseInt(process.env.OPENAI_MAX_DAILY_DRAFTS || "20", 10),
+    supermemoryApiKey: process.env.SUPERMEMORY_API_KEY,
   };
 }
 
diff --git a/src/server/fieldNotes.js b/src/server/fieldNotes.js
new file mode 100644
index 0000000..12cd73e
--- /dev/null
+++ b/src/server/fieldNotes.js
@@ -0,0 +1,116 @@
+import { getServerEnv } from "./env";
+
+const FIELD_NOTE_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    title: { type: "string" },
+    content: { type: "string" },
+    visibilityReminder: { type: "string" },
+  },
+  required: ["title", "content", "visibilityReminder"],
+};
+
+const FIELD_NOTE_SYSTEM_PROMPT = `
+You turn private messy work dumps from an engineer into a publishable Mumbl field note.
+
+The output should feel like a short working-process blog someone would be happy to publish on a public profile or share with a team:
+- specific, human, and useful
+- written in first person when the dumps are personal
+- clear enough for a stranger to understand the working lesson
+- honest without sounding like therapy, HR, LinkedIn, or a productivity guru
+- grounded only in the provided dumps
+
+What to make:
+- a strong title, not a summary label
+- a 350-750 word draft when there is enough material
+- a readable arc: context, what the writer noticed, what changed or became clearer, and what someone else can learn
+- bullets only where they improve scanning, such as principles, signals, or takeaways
+- short paragraphs with breathing room
+- optional section labels in plain text, not markdown headings, when they help readability
+
+Privacy and taste rules:
+- Do not invent names, outcomes, metrics, tools, teams, or drama.
+- Do not preserve overly identifying details unless they are essential to the lesson.
+- Do not flatten the writer's voice into corporate polish.
+- Do not call it a "blog post" inside the draft.
+- Do not mention "private dumps", "AI", "prompt", or "selected dumps".
+- Keep the draft editable. It is not final truth.
+`.trim();
+
+export async function draftFieldNote({ dumps }) {
+  const env = getServerEnv();
+  if (!env.openAiApiKey) {
+    const error = new Error("OPENAI_API_KEY is required to draft a field note");
+    error.status = 503;
+    throw error;
+  }
+
+  const selectedDumps = dumps.map((dump, index) => ({
+    id: dump.id,
+    label: `dump ${index + 1}`,
+    content: dump.content,
+  }));
+
+  const response = await fetch("https://api.openai.com/v1/responses", {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${env.openAiApiKey}`,
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      model: env.openAiFieldNoteModel,
+      input: [
+        {
+          role: "system",
+          content: FIELD_NOTE_SYSTEM_PROMPT,
+        },
+        {
+          role: "user",
+          content: `Create one publishable field note from these work notes. Use every note that adds signal, but do not force weak material in.\n\nReturn JSON only with:
+- title: a specific, compelling title
+- content: the full draft, with paragraphs and bullets where useful
+- visibilityReminder: one short reminder that the author should review before publishing\n\nWork notes:\n${JSON.stringify(selectedDumps)}`,
+        },
+      ],
+      text: {
+        format: {
+          type: "json_schema",
+          name: "field_note_draft",
+          schema: FIELD_NOTE_SCHEMA,
+          strict: true,
+        },
+      },
+      max_output_tokens: 2600,
+    }),
+  });
+
+  const data = await response.json();
+  if (!response.ok) {
+    const message = data?.error?.message || "OpenAI field note draft failed";
+    const error = new Error(message);
+    error.status = response.status;
+    throw error;
+  }
+
+  const parsed = JSON.parse(extractResponseText(data));
+  return {
+    title: String(parsed.title || "").trim().slice(0, 120),
+    content: String(parsed.content || "").trim().slice(0, 4000),
+    visibilityReminder:
+      String(parsed.visibilityReminder || "").trim().slice(0, 180) || "Only publish this if it still feels true.",
+    sourceDumpIds: dumps.map((dump) => dump.id),
+  };
+}
+
+function extractResponseText(data) {
+  if (data.output_text) return data.output_text;
+
+  for (const item of data.output || []) {
+    for (const content of item.content || []) {
+      if (content.type === "output_text" && content.text) return content.text;
+    }
+  }
+
+  throw new Error("OpenAI response did not include a field note draft");
+}
diff --git a/src/server/http.js b/src/server/http.js
index 6b61ab3..08a6c3b 100644
--- a/src/server/http.js
+++ b/src/server/http.js
@@ -17,7 +17,10 @@ export function rateLimited(message = "too many requests") {
 }
 
 export function serverError(error) {
-  const message = error instanceof Error ? error.message : "unexpected backend error";
+  const message =
+    error instanceof Error
+      ? error.message
+      : error?.message || error?.details || error?.hint || error?.code || "unexpected backend error";
   const status = error?.status || (message.startsWith("Missing backend environment variables") ? 503 : 500);
   return NextResponse.json({ error: message }, { status });
 }
diff --git a/src/server/publicProfiles.js b/src/server/publicProfiles.js
new file mode 100644
index 0000000..ac286b2
--- /dev/null
+++ b/src/server/publicProfiles.js
@@ -0,0 +1,34 @@
+import { cleanString } from "./validation";
+
+export function normalizeHandle(value) {
+  return cleanString(value, 32)
+    .toLowerCase()
+    .replace(/^@+/, "")
+    .replace(/[^a-z0-9_-]/g, "")
+    .slice(0, 30);
+}
+
+export function isValidHandle(handle) {
+  return /^[a-z0-9][a-z0-9_-]{1,29}$/.test(handle);
+}
+
+export function serializePublicProfile(profile, fieldNotes = []) {
+  return {
+    id: profile.id,
+    handle: profile.handle,
+    displayName: profile.display_name || profile.handle,
+    bio: profile.bio || "",
+    createdAt: new Date(profile.created_at).getTime(),
+    posts: fieldNotes.map(serializePublicFieldNote),
+  };
+}
+
+export function serializePublicFieldNote(note) {
+  return {
+    id: note.id,
+    title: note.title,
+    content: note.content,
+    publishedAt: note.public_published_at ? new Date(note.public_published_at).getTime() : null,
+    createdAt: new Date(note.created_at).getTime(),
+  };
+}
diff --git a/src/server/rateLimit.js b/src/server/rateLimit.js
index 2f8716e..a0078ca 100644
--- a/src/server/rateLimit.js
+++ b/src/server/rateLimit.js
@@ -1,4 +1,5 @@
 import { hashToken } from "./hash";
+import { getServerEnv } from "./env";
 
 const LIMITS = {
   post: { limit: 5, windowSeconds: 10 * 60 },
@@ -6,10 +7,11 @@ const LIMITS = {
   side_quest_create: { limit: 6, windowSeconds: 10 * 60 },
   side_quest_pick: { limit: 20, windowSeconds: 10 * 60 },
   side_quest_message: { limit: 60, windowSeconds: 5 * 60 },
+  field_note: { limit: 20, windowSeconds: 24 * 60 * 60 },
 };
 
 export async function enforceRateLimit({ supabase, action, sessionToken }) {
-  const config = LIMITS[action];
+  const config = getLimitConfig(action);
   if (!config || !sessionToken) return;
 
   const { data: allowed, error } = await supabase.rpc("check_rate_limit", {
@@ -27,6 +29,17 @@ export async function enforceRateLimit({ supabase, action, sessionToken }) {
   }
 }
 
+function getLimitConfig(action) {
+  if (action === "field_note") {
+    return {
+      ...LIMITS.field_note,
+      limit: getServerEnv().openAiMaxDailyDrafts,
+    };
+  }
+
+  return LIMITS[action];
+}
+
 function windowStartIso(windowSeconds) {
   const now = Date.now();
   return new Date(Math.floor(now / (windowSeconds * 1000)) * windowSeconds * 1000).toISOString();
diff --git a/src/server/serializers.js b/src/server/serializers.js
index 6ce5a42..12211eb 100644
--- a/src/server/serializers.js
+++ b/src/server/serializers.js
@@ -61,9 +61,11 @@ export function serializePost(post, reactionRows = [], activeReactionKeys = new
     id: post.id,
     type: post.type,
     content: post.content,
+    title: post.field_note_title || "",
     isAnonymous: post.is_anonymous,
     displayName: post.display_name || "",
     promptId: post.prompt_id || "",
+    dumpId: post.dump_id || "",
     createdAt: new Date(post.created_at).getTime(),
     reactions,
     activeReactions,
diff --git a/src/server/supermemory.ts b/src/server/supermemory.ts
new file mode 100644
index 0000000..3bf0042
--- /dev/null
+++ b/src/server/supermemory.ts
@@ -0,0 +1,731 @@
+import { getServerEnv } from "./env";
+
+const SUPERMEMORY_BASE_URL = "https://api.supermemory.ai";
+
+type PrivateDumpRow = {
+  id: string;
+  content: string;
+  created_at: string;
+  supermemory_id?: string | null;
+  supermemory_status?: string | null;
+};
+
+type FieldNoteRow = {
+  id: string;
+  title: string;
+  content: string;
+  created_at: string;
+  published_at?: string | null;
+  is_published?: boolean | null;
+  supermemory_id?: string | null;
+  supermemory_status?: string | null;
+};
+
+type AddMemoryResult = {
+  id: string;
+  status: string;
+};
+
+type GraphInsight = {
+  label: string;
+  value: string;
+  detail: string;
+  tone: "gold" | "mint" | "violet" | "clay" | "blue";
+};
+
+type GraphPattern = {
+  id: string;
+  title: string;
+  read: string;
+  why: string;
+  nextStep: string;
+  fieldNoteSeed: string;
+  privacy: string;
+  tone: GraphInsight["tone"];
+  evidenceIds: string[];
+};
+
+type GraphNode = {
+  id: string;
+  kind: "theme" | "dump" | "field_note";
+  label: string;
+  detail?: string;
+  createdAt?: string;
+  weight?: number;
+};
+
+type ThemeNode = GraphNode & {
+  kind: "theme";
+  words: string[];
+  tone: GraphInsight["tone"];
+  semanticEvidenceIds?: string[];
+  semanticMatchCount?: number;
+};
+
+type GraphEdge = {
+  from: string;
+  to: string;
+  label: string;
+};
+
+export type DumpSearchProbe = {
+  id: string;
+  label: string;
+  query: string;
+  tone: GraphInsight["tone"];
+};
+
+type DumpSearchResult = {
+  id?: string;
+  memory?: string;
+  chunk?: string;
+  similarity?: number;
+  metadata?: {
+    dump_id?: string;
+    field_note_id?: string;
+    created_at?: string;
+    type?: string;
+  };
+  probe?: Pick<DumpSearchProbe, "id" | "label" | "tone">;
+};
+
+type SemanticThemeGroup = {
+  probe: NonNullable<DumpSearchResult["probe"]>;
+  evidenceIds: Set<string>;
+  snippets: string[];
+  similarities: number[];
+};
+
+type GraphSourceItem = {
+  id: string;
+  content: string;
+};
+
+export function isSupermemoryConfigured() {
+  return Boolean(getServerEnv().supermemoryApiKey);
+}
+
+export async function addFieldNoteMemory({
+  fieldNote,
+  sessionTokenHash,
+}: {
+  fieldNote: FieldNoteRow;
+  sessionTokenHash: string;
+}): Promise<AddMemoryResult | null> {
+  const env = getServerEnv();
+  if (!env.supermemoryApiKey) return null;
+  const userId = dumpUserId(sessionTokenHash);
+
+  const response = await fetch(`${SUPERMEMORY_BASE_URL}/v3/memories`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${env.supermemoryApiKey}`,
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      customId: `mumbl-field-note-v1-${sessionTokenHash.slice(0, 32)}-${fieldNote.id}`,
+      userId,
+      content: `${fieldNote.title}\n\n${fieldNote.content}`,
+      metadata: {
+        product: "mumbl",
+        type: "field_note",
+        session_hash: sessionTokenHash,
+        user_id: userId,
+        field_note_id: fieldNote.id,
+        title: fieldNote.title,
+        is_published: Boolean(fieldNote.is_published),
+        created_at: fieldNote.created_at,
+        published_at: fieldNote.published_at || "",
+      },
+      containerTags: dumpContainerTags(sessionTokenHash),
+    }),
+  });
+
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(data?.error?.message || data?.message || "Supermemory add memory failed");
+  }
+
+  return {
+    id: data.id || data.memoryId || "",
+    status: `field_note_scoped:${data.status || "queued"}`,
+  };
+}
+
+export async function addPrivateDumpMemory({
+  dump,
+  sessionTokenHash,
+}: {
+  dump: PrivateDumpRow;
+  sessionTokenHash: string;
+}): Promise<AddMemoryResult | null> {
+  const env = getServerEnv();
+  if (!env.supermemoryApiKey) return null;
+  const userId = dumpUserId(sessionTokenHash);
+
+  const response = await fetch(`${SUPERMEMORY_BASE_URL}/v3/memories`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${env.supermemoryApiKey}`,
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      customId: `mumbl-private-dump-opt-in-v1-${sessionTokenHash.slice(0, 32)}-${dump.id}`,
+      userId,
+      content: dump.content,
+      metadata: {
+        product: "mumbl",
+        type: "private_dump_opt_in",
+        session_hash: sessionTokenHash,
+        user_id: userId,
+        dump_id: dump.id,
+        created_at: dump.created_at,
+      },
+      containerTags: dumpContainerTags(sessionTokenHash),
+    }),
+  });
+
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(data?.error?.message || data?.message || "Supermemory private dump sync failed");
+  }
+
+  return {
+    id: data.id || data.memoryId || "",
+    status: `private_dump_opt_in:${data.status || "queued"}`,
+  };
+}
+
+export async function searchDumpMemories({
+  sessionTokenHash,
+  query,
+  limit = 12,
+  threshold = 0.45,
+  memoryType = "field_note",
+}: {
+  sessionTokenHash: string;
+  query: string;
+  limit?: number;
+  threshold?: number;
+  memoryType?: "field_note" | "private_dump_opt_in";
+}) {
+  const env = getServerEnv();
+  if (!env.supermemoryApiKey) return [];
+  const userId = dumpUserId(sessionTokenHash);
+
+  const response = await fetch(`${SUPERMEMORY_BASE_URL}/v3/search`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${env.supermemoryApiKey}`,
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      q: query,
+      userId,
+      containerTags: dumpContainerTags(sessionTokenHash),
+      searchMode: "hybrid",
+      limit,
+      documentThreshold: threshold,
+      chunkThreshold: threshold,
+      onlyMatchingChunks: true,
+      rerank: true,
+      filters: {
+        AND: [
+          { key: "product", value: "mumbl" },
+          { key: "session_hash", value: sessionTokenHash },
+          { key: "type", value: memoryType },
+        ],
+      },
+    }),
+  });
+
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(data?.error?.message || data?.message || "Supermemory search failed");
+  }
+
+  return Array.isArray(data.results) ? data.results : [];
+}
+
+export { searchDumpMemories as searchFieldNoteMemories };
+
+export function searchPrivateDumpMemories(args: Omit<Parameters<typeof searchDumpMemories>[0], "memoryType">) {
+  return searchDumpMemories({ ...args, memoryType: "private_dump_opt_in" });
+}
+
+export function makeDumpGraph({
+  dumps,
+  fieldNotes = [],
+  includePrivateDumps = false,
+  searchResults = [],
+  source = "local",
+}: {
+  dumps: PrivateDumpRow[];
+  fieldNotes?: FieldNoteRow[];
+  includePrivateDumps?: boolean;
+  searchResults?: unknown[];
+  source?: "local" | "supermemory";
+}) {
+  const dumpNodes = dumps.slice(0, 24).map((dump) => ({
+    id: dump.id,
+    kind: "dump" as const,
+    label: firstLine(dump.content),
+    detail: dump.content,
+    createdAt: dump.created_at,
+  }));
+  const fieldNoteNodes = fieldNotes.slice(0, 24).map((fieldNote) => ({
+    id: fieldNote.id,
+    kind: "field_note" as const,
+    label: fieldNote.title,
+    detail: fieldNote.content,
+    createdAt: fieldNote.created_at,
+  }));
+  const evidenceNodes = includePrivateDumps ? dumpNodes : fieldNoteNodes;
+
+  const sourceItems = makeGraphSourceItems({ dumps, fieldNotes, includePrivateDumps });
+  const themeNodes = inferThemeNodes(sourceItems, fieldNotes, searchResults, includePrivateDumps);
+  const rawEdges: GraphEdge[] = [];
+
+  for (const theme of themeNodes) {
+    for (const evidenceId of theme.semanticEvidenceIds || []) {
+      if (evidenceNodes.some((node) => node.id === evidenceId)) {
+        rawEdges.push({ from: theme.id, to: evidenceId, label: "semantic match" });
+      }
+    }
+
+    for (const item of sourceItems) {
+      const text = item.content.toLowerCase();
+      if (theme.words.some((word) => text.includes(word))) {
+        rawEdges.push({ from: theme.id, to: item.id, label: "shows up in" });
+      }
+    }
+  }
+
+  if (!rawEdges.length && sourceItems.length) {
+    for (const item of sourceItems.slice(0, 8)) {
+      rawEdges.push({ from: "theme-loose-thoughts", to: item.id, label: "contains" });
+    }
+    if (!themeNodes.some((theme) => theme.id === "theme-loose-thoughts")) {
+      themeNodes.push({
+        id: "theme-loose-thoughts",
+        kind: "theme",
+        label: "loose thoughts",
+        detail: includePrivateDumps
+          ? "Early graph shape from opted-in private dumps."
+          : "Early graph shape from field notes you drafted.",
+        weight: sourceItems.length,
+        words: [],
+        tone: "blue",
+      });
+    }
+  }
+
+  const topTheme = themeNodes.slice().sort((a, b) => (b.weight || 0) - (a.weight || 0))[0];
+  const edges = dedupeEdges(rawEdges);
+
+  return {
+    source,
+    syncedCount: includePrivateDumps
+      ? fieldNotes.filter((fieldNote) => fieldNote.supermemory_id).length + dumps.filter((dump) => dump.supermemory_id).length
+      : fieldNotes.filter((fieldNote) => fieldNote.supermemory_id).length,
+    summary: makeGraphSummary({ dumps, fieldNotes, source, topTheme, includePrivateDumps }),
+    insights: makeGraphInsights({ dumps, fieldNotes, source, topTheme, searchResults, includePrivateDumps }),
+    patterns: makeGraphPatterns({ themes: themeNodes, evidenceNodes, dumps, fieldNotes, edges, source, includePrivateDumps }),
+    nodes: [...themeNodes.map(stripThemeWords), ...evidenceNodes],
+    edges,
+  };
+}
+
+function makeGraphSourceItems({
+  dumps,
+  fieldNotes,
+  includePrivateDumps,
+}: {
+  dumps: PrivateDumpRow[];
+  fieldNotes: FieldNoteRow[];
+  includePrivateDumps: boolean;
+}): GraphSourceItem[] {
+  if (includePrivateDumps) {
+    return dumps.map((dump) => ({
+      id: dump.id,
+      content: dump.content,
+    }));
+  }
+
+  return fieldNotes.map((fieldNote) => ({
+    id: fieldNote.id,
+    content: `${fieldNote.title}\n\n${fieldNote.content}`,
+  }));
+}
+
+function inferThemeNodes(
+  sourceItems: GraphSourceItem[],
+  fieldNotes: FieldNoteRow[],
+  searchResults: unknown[],
+  includePrivateDumps: boolean,
+): ThemeNode[] {
+  const semanticThemes = inferSemanticThemes(fieldNotes, searchResults, includePrivateDumps);
+  const buckets = [
+    {
+      id: "theme-stuck",
+      label: "blocked decisions",
+      words: ["stuck", "blocked", "waiting", "confused", "decision", "owner", "unclear"],
+      tone: "clay" as const,
+      advice: "The useful move is to name the missing decision, owner, or context.",
+    },
+    {
+      id: "theme-process",
+      label: "handoff friction",
+      words: ["meeting", "standup", "process", "planning", "handoff", "review", "comment", "scope"],
+      tone: "gold" as const,
+      advice: "This can become a team read if it is framed as a system pattern.",
+    },
+    {
+      id: "theme-ship",
+      label: "momentum clues",
+      words: ["shipped", "fixed", "win", "done", "demo", "merged", "worked"],
+      tone: "mint" as const,
+      advice: "Capture what made the work move so the team can repeat it.",
+    },
+    {
+      id: "theme-heavy",
+      label: "attention load",
+      words: ["tired", "burn", "hard", "rough", "context", "switching", "load", "overload"],
+      tone: "violet" as const,
+      advice: "Keep this private until the ask is small and safe to say.",
+    },
+  ];
+
+  const fromDumps: ThemeNode[] = buckets
+    .map((bucket) => {
+      const weight = sourceItems.filter((item) => bucket.words.some((word) => item.content.toLowerCase().includes(word))).length;
+      return {
+        ...bucket,
+        kind: "theme" as const,
+        detail: `${weight} source${weight === 1 ? "" : "s"}. ${bucket.advice}`,
+        weight,
+      };
+    })
+    .filter((bucket) => bucket.weight > 0);
+
+  return [...semanticThemes, ...fromDumps].slice(0, 7);
+}
+
+function stripThemeWords(theme: ThemeNode): GraphNode {
+  const { words, semanticEvidenceIds, semanticMatchCount, ...publicTheme } = theme;
+  return publicTheme;
+}
+
+function inferSemanticThemes(fieldNotes: FieldNoteRow[], searchResults: unknown[], includePrivateDumps: boolean): ThemeNode[] {
+  const grouped = new Map<string, SemanticThemeGroup>();
+  const fieldNoteIds = new Set(fieldNotes.map((fieldNote) => fieldNote.id));
+
+  for (const result of searchResults as DumpSearchResult[]) {
+    if (!result?.probe?.id) continue;
+    const evidenceId = includePrivateDumps && result.metadata?.dump_id ? result.metadata.dump_id : result.metadata?.field_note_id || "";
+    if (!evidenceId || (!includePrivateDumps && !fieldNoteIds.has(evidenceId))) continue;
+
+    const group: SemanticThemeGroup =
+      grouped.get(result.probe.id) || {
+        probe: result.probe,
+        evidenceIds: new Set<string>(),
+        snippets: [],
+        similarities: [],
+      };
+
+    group.evidenceIds.add(evidenceId);
+    const snippet = firstLine(result.memory || result.chunk || "");
+    if (snippet && group.snippets.length < 2) group.snippets.push(snippet);
+    if (typeof result.similarity === "number") group.similarities.push(result.similarity);
+    grouped.set(result.probe.id, group);
+  }
+
+  return [...grouped.values()]
+    .map((group) => {
+      const averageSimilarity = group.similarities.length
+        ? Math.round((group.similarities.reduce((total, value) => total + value, 0) / group.similarities.length) * 100)
+        : null;
+      const evidenceCount = group.evidenceIds.size;
+      return {
+        id: `theme-semantic-${group.probe.id}`,
+        kind: "theme" as const,
+        label: group.probe.label,
+        detail: `${evidenceCount} related source${evidenceCount === 1 ? "" : "s"}${averageSimilarity ? ` · ${averageSimilarity}% match` : ""}. ${
+          group.snippets[0] ? `Closest note: ${group.snippets[0]}` : "Connected by meaning, not just exact words."
+        }`,
+        weight: evidenceCount,
+        words: [],
+        tone: group.probe.tone,
+        semanticEvidenceIds: [...group.evidenceIds],
+        semanticMatchCount: group.similarities.length,
+      };
+    })
+    .filter((theme) => theme.weight > 0)
+    .sort((a, b) => (b.weight || 0) - (a.weight || 0));
+}
+
+function dedupeEdges(edges: GraphEdge[]) {
+  const seen = new Set<string>();
+  return edges.filter((edge) => {
+    const key = `${edge.from}:${edge.to}:${edge.label}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function makeGraphPatterns({
+  themes,
+  evidenceNodes,
+  dumps,
+  fieldNotes,
+  edges,
+  source,
+  includePrivateDumps,
+}: {
+  themes: ThemeNode[];
+  evidenceNodes: GraphNode[];
+  dumps: PrivateDumpRow[];
+  fieldNotes: FieldNoteRow[];
+  edges: GraphEdge[];
+  source: "local" | "supermemory";
+  includePrivateDumps: boolean;
+}): GraphPattern[] {
+  const patterns = themes
+    .slice()
+    .sort((a, b) => (b.weight || 0) - (a.weight || 0))
+    .slice(0, evidenceNodes.length < 2 ? 1 : 4)
+    .map((theme) => {
+      const evidenceIds = edges
+        .filter((edge) => edge.from === theme.id)
+        .map((edge) => edge.to)
+        .filter((id) => evidenceNodes.some((node) => node.id === id))
+        .slice(0, 4);
+      const evidenceCount = evidenceIds.length || theme.weight || 0;
+
+      return {
+        id: `pattern-${theme.id}`,
+        title: patternTitle(theme),
+        read: patternRead(theme, source),
+        why: patternWhy(theme, evidenceCount, source),
+        nextStep: patternNextStep(theme),
+        fieldNoteSeed: patternFieldNoteSeed(theme),
+        privacy: patternPrivacy(theme),
+        tone: theme.tone,
+        evidenceIds,
+      };
+    });
+
+  if (patterns.length) return patterns;
+
+  if (!includePrivateDumps && !fieldNotes.length) {
+    return [
+      {
+        id: "pattern-field-note-needed",
+        title: "No memory graph yet",
+        read: "Mumbl only builds the memory graph from field notes by default. Private dumps stay out unless you opt in.",
+        why: dumps.length
+          ? `${dumps.length} private dump${dumps.length === 1 ? "" : "s"} saved, but none have been turned into field notes yet.`
+          : "No private dumps or field notes yet.",
+        nextStep: "Select a few related dumps and draft a field note when something feels worth keeping.",
+        fieldNoteSeed: "Pick a recurring thread first.",
+        privacy: "field notes only",
+        tone: "blue",
+        evidenceIds: [],
+      },
+    ];
+  }
+
+  return [
+    {
+      id: "pattern-forming",
+      title: "The shape is still forming",
+      read: "There is not enough repeated material yet to say something useful without overreaching.",
+      why: includePrivateDumps
+        ? `${dumps.length} opted-in private dump${dumps.length === 1 ? "" : "s"} available. A few more will make the pattern read stronger.`
+        : `${fieldNotes.length} field note${fieldNotes.length === 1 ? "" : "s"} available. A few more will make the memory read stronger.`,
+      nextStep: includePrivateDumps
+        ? "Keep dumping in plain language, or turn the useful thread into a field note."
+        : "Draft another field note when a thread feels useful.",
+      fieldNoteSeed: "Nothing to publish yet.",
+      privacy: "Keep this private for now.",
+      tone: "blue",
+      evidenceIds: includePrivateDumps ? dumps.slice(0, 3).map((dump) => dump.id) : fieldNotes.slice(0, 3).map((fieldNote) => fieldNote.id),
+    },
+  ];
+}
+
+function patternTitle(theme: ThemeNode) {
+  if (theme.id.includes("blockers") || theme.id.includes("stuck")) return "Decisions are getting stuck before the work is";
+  if (theme.id.includes("momentum") || theme.id.includes("ship")) return "Small visible progress is changing the room";
+  if (theme.id.includes("process") || theme.id.includes("team")) return "The handoff is carrying hidden work";
+  if (theme.id.includes("load") || theme.id.includes("heavy")) return "Context switching is becoming the work";
+  return `${theme.label} keeps coming back`;
+}
+
+function patternRead(theme: ThemeNode, source: "local" | "supermemory") {
+  const prefix =
+    source === "supermemory"
+      ? "Connected by meaning, not just matching words: "
+      : "Based on repeated language in your notes: ";
+
+  if (theme.id.includes("blockers") || theme.id.includes("stuck")) {
+    return `${prefix}the same kind of blocked energy is showing up more than once. The problem may not be effort; it may be an unnamed decision, owner, or missing bit of context.`;
+  }
+  if (theme.id.includes("momentum") || theme.id.includes("ship")) {
+    return `${prefix}the useful moments are clustering around visible progress. This is worth keeping because it says what helps the team move faster without making it a process lecture.`;
+  }
+  if (theme.id.includes("process") || theme.id.includes("team")) {
+    return `${prefix}handoffs, planning, or review comments are carrying more work than expected. This is publishable if it names the system, not a person.`;
+  }
+  if (theme.id.includes("load") || theme.id.includes("heavy")) {
+    return `${prefix}attention load is showing up as a real work constraint. Keep the raw version private; the useful version is probably a smaller ask.`;
+  }
+  return `${prefix}${theme.label} appears across nearby notes. Treat it as a useful lead, not a verdict.`;
+}
+
+function patternWhy(theme: ThemeNode, evidenceCount: number, source: "local" | "supermemory") {
+  const basis = source === "supermemory" ? "semantic memory search" : "repeated language";
+  const count = evidenceCount || theme.weight || 1;
+  return `${count} source${count === 1 ? " points" : "s point"} at the same work pattern via ${basis}.`;
+}
+
+function patternNextStep(theme: ThemeNode) {
+  if (theme.id.includes("load") || theme.id.includes("heavy")) return "Keep it private for now. Rewrite it as one small ask before sharing.";
+  if (theme.id.includes("momentum") || theme.id.includes("ship")) return "Draft the pattern while it is fresh. The team should know what worked.";
+  if (theme.id.includes("process") || theme.id.includes("team")) return "Draft it as a field note about the system, not the people in it.";
+  if (theme.id.includes("blockers") || theme.id.includes("stuck")) return "Turn it into one concrete question the team can answer.";
+  return "Open the connected notes and decide whether there is a team-readable thread.";
+}
+
+function patternFieldNoteSeed(theme: ThemeNode) {
+  if (theme.id.includes("load") || theme.id.includes("heavy")) return "The hidden cost of context switching this week";
+  if (theme.id.includes("momentum") || theme.id.includes("ship")) return "The small thing that helped work move";
+  if (theme.id.includes("process") || theme.id.includes("team")) return "Where our handoff is doing too much work";
+  if (theme.id.includes("blockers") || theme.id.includes("stuck")) return "The decision that would unblock the thread";
+  return `What I am noticing about ${theme.label}`;
+}
+
+function patternPrivacy(theme: ThemeNode) {
+  if (theme.id.includes("load") || theme.id.includes("heavy")) return "private-first";
+  if (theme.id.includes("momentum") || theme.id.includes("ship")) return "safe to draft";
+  if (theme.id.includes("process") || theme.id.includes("team")) return "draft carefully";
+  return "review before sharing";
+}
+
+function makeGraphSummary({
+  dumps,
+  fieldNotes,
+  source,
+  topTheme,
+  includePrivateDumps,
+}: {
+  dumps: PrivateDumpRow[];
+  fieldNotes: FieldNoteRow[];
+  source: "local" | "supermemory";
+  topTheme?: ThemeNode;
+  includePrivateDumps: boolean;
+}) {
+  if (!fieldNotes.length && !includePrivateDumps) {
+    return {
+      headline: "field notes unlock the working map",
+      detail: "Private dumps stay out by default. The map starts with field notes because those are the thoughts you intentionally cleaned up.",
+      nextStep: dumps.length ? "Select related dumps and draft one field note." : "Write a few dumps first, then draft one field note.",
+    };
+  }
+
+  if (includePrivateDumps && !dumps.length) {
+    return {
+      headline: "nothing mapped yet",
+      detail: "The map needs a few notes before it can say anything useful.",
+      nextStep: "Write a couple of honest dumps first.",
+    };
+  }
+
+  if (!topTheme) {
+    return {
+      headline: "no strong repeat yet",
+      detail: includePrivateDumps
+        ? "Opted-in private dumps are available, but the map is not seeing the same concern twice yet."
+        : "Field notes are available, but the map is not seeing the same concern twice yet.",
+      nextStep: "Keep writing. Trust the map once a concern repeats.",
+    };
+  }
+
+  return {
+    headline: `${topTheme.label} keeps coming back`,
+    detail:
+      source === "supermemory"
+        ? "This read is using memory search to connect notes that mean similar things."
+        : "This read is local and lower-confidence until memory search is available.",
+    nextStep: topTheme.weight && topTheme.weight > 1 ? "This is probably worth a field note draft." : "Watch whether this repeats.",
+  };
+}
+
+function makeGraphInsights({
+  dumps,
+  fieldNotes,
+  source,
+  topTheme,
+  searchResults,
+  includePrivateDumps,
+}: {
+  dumps: PrivateDumpRow[];
+  fieldNotes: FieldNoteRow[];
+  source: "local" | "supermemory";
+  topTheme?: ThemeNode;
+  searchResults: unknown[];
+  includePrivateDumps: boolean;
+}): GraphInsight[] {
+  const sourceRows = includePrivateDumps ? dumps : fieldNotes;
+  const newest = sourceRows[0];
+  const oldest = sourceRows[sourceRows.length - 1];
+  const daySpan =
+    newest && oldest
+      ? Math.max(1, Math.ceil((new Date(newest.created_at).getTime() - new Date(oldest.created_at).getTime()) / 86400000) + 1)
+      : 0;
+
+  return [
+    {
+      label: "strongest thread",
+      value: topTheme?.label || "still forming",
+      detail: topTheme ? topTheme.detail || "A recurring work pattern in your notes." : "No theme has repeated enough yet.",
+      tone: topTheme?.tone || "blue",
+    },
+    {
+      label: "source material",
+      value: includePrivateDumps
+        ? `${dumps.length} dump${dumps.length === 1 ? "" : "s"}`
+        : `${fieldNotes.length} field note${fieldNotes.length === 1 ? "" : "s"}`,
+      detail: daySpan ? `Across roughly ${daySpan} day${daySpan === 1 ? "" : "s"} of notes.` : "Start with one field note.",
+      tone: "gold",
+    },
+    {
+      label: "memory source",
+      value: source === "supermemory" ? "meaning-aware" : "local",
+      detail:
+        source === "supermemory"
+          ? searchResults.length
+            ? `${searchResults.length} nearby memories helped shape this read.`
+            : "Memory sync is on; this read is currently shaped by the saved field notes."
+          : "Lower confidence: based on local keyword signals for now.",
+      tone: source === "supermemory" ? "mint" : "violet",
+    },
+  ];
+}
+
+function firstLine(content: string) {
+  return content.split(/\n/).find(Boolean)?.slice(0, 72) || "untitled dump";
+}
+
+function dumpContainerTags(sessionTokenHash: string) {
+  return ["mumbl_dump", dumpContainerTag(sessionTokenHash), dumpUserId(sessionTokenHash)];
+}
+
+function dumpContainerTag(sessionTokenHash: string) {
+  return `mumbl_session_${sessionTokenHash.slice(0, 32)}`;
+}
+
+function dumpUserId(sessionTokenHash: string) {
+  return `mumbl_dump_${sessionTokenHash.slice(0, 32)}`;
+}
diff --git a/styles.css b/styles.css
index a7c1728..40343ad 100644
--- a/styles.css
+++ b/styles.css
@@ -837,13 +837,59 @@ textarea:focus {
   color: var(--mint-ink);
 }
 
-.post-text {
+.badge.dump,
+.dump-pill.team {
+  background: var(--violet);
+  color: var(--violet-ink);
+}
+
+.dump-post {
+  background: #fffefa;
+}
+
+.dump-post .post-text p {
+  font-size: 1.03rem;
+  line-height: 1.62;
+}
+
+.post-text p {
   margin-bottom: 14px;
   white-space: pre-wrap;
   overflow-wrap: anywhere;
   line-height: 1.5;
 }
 
+.expandable-read {
+  position: relative;
+  display: grid;
+  gap: 8px;
+}
+
+.expandable-read p {
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+
+.read-more-button {
+  justify-self: start;
+  min-height: 30px;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  color: var(--blue-ink);
+  font-size: 0.82rem;
+  font-weight: 900;
+  text-decoration: underline;
+  text-underline-offset: 3px;
+}
+
+.post-title {
+  margin-bottom: 8px;
+  font-size: clamp(1.25rem, 3vw, 1.75rem);
+  line-height: 1.08;
+  overflow-wrap: anywhere;
+}
+
 .post-footer {
   justify-content: flex-start;
   flex-wrap: wrap;
@@ -892,6 +938,40 @@ textarea:focus {
   line-height: 1.45;
 }
 
+.reads-intro {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 8px 14px;
+  align-items: center;
+  margin-bottom: 14px;
+  padding: 16px;
+  border: 1px solid var(--ink);
+  border-radius: var(--radius);
+  background: var(--violet);
+  box-shadow: 4px 4px 0 var(--ink);
+}
+
+.reads-intro span {
+  color: var(--violet-ink);
+  font-size: 0.78rem;
+  font-weight: 900;
+  text-transform: lowercase;
+}
+
+.reads-intro p {
+  grid-column: 1;
+  margin: 0;
+  color: var(--ink);
+  font-weight: 760;
+  line-height: 1.35;
+}
+
+.reads-intro .ghost-button {
+  grid-column: 2;
+  grid-row: 1 / span 2;
+  min-height: 38px;
+}
+
 .side-quests-panel {
   display: grid;
   gap: 14px;
@@ -1200,122 +1280,1297 @@ textarea:focus {
   font-weight: 800;
 }
 
-@media (max-width: 860px) {
-  .topbar {
-    align-items: flex-start;
-  }
+.dump-view {
+  width: min(1040px, calc(100% - 32px));
+  margin: 0 auto;
+  padding: 32px 0 72px;
+}
 
-  .topbar-actions {
-    flex-wrap: wrap;
-    justify-content: flex-end;
-  }
+.dump-view-focus {
+  width: min(900px, calc(100% - 32px));
+}
 
-  .hero,
-  .create-grid,
-  .space-grid {
-    grid-template-columns: 1fr;
-  }
+.dump-hero {
+  display: flex;
+  align-items: flex-end;
+  justify-content: space-between;
+  gap: 18px;
+  margin-bottom: 18px;
+}
 
-  .hero {
-    min-height: auto;
-    padding-top: 28px;
-  }
+.dump-hero.compact {
+  align-items: flex-start;
+  margin-bottom: 14px;
+}
 
-  .artifact-board {
-    min-height: 460px;
-  }
+.dump-hero h1 {
+  margin-bottom: 10px;
+  font-size: clamp(3rem, 10vw, 6.8rem);
+  line-height: 0.86;
+}
 
-  .space-header {
-    align-items: flex-start;
-    flex-direction: column;
-  }
+.dump-hero p {
+  max-width: 620px;
+  margin-bottom: 0;
+  color: var(--muted);
+  font-size: clamp(1rem, 2vw, 1.24rem);
+  line-height: 1.45;
+}
 
-  .compose-header {
-    align-items: flex-start;
-    flex-direction: column;
-  }
+.dump-nav,
+.dump-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+  align-items: center;
+}
 
-  .compose-title {
-    min-width: 0;
-  }
+.dump-grid,
+.dump-workspace {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) 260px;
+  gap: 16px;
+  align-items: start;
+}
 
-  .side-panel {
-    position: static;
-  }
+.dump-workspace {
+  grid-template-columns: minmax(0, 1fr) minmax(250px, 310px);
+}
 
-  .side-quest-mobile-link {
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    gap: 12px;
-    margin: -6px 0 16px;
-    padding: 11px 12px;
-    border: 1px solid var(--ink);
-    border-radius: var(--radius);
-    background: #f3fff1;
-    box-shadow: 3px 3px 0 var(--ink);
-    color: var(--ink);
-    text-decoration: none;
-  }
+.dump-composer,
+.dump-side-note,
+.dump-rail-card,
+.dump-card,
+.dump-map-panel {
+  border: 1px solid var(--ink);
+  border-radius: var(--radius);
+  background: var(--panel);
+  box-shadow: 4px 4px 0 var(--ink);
+}
 
-  .side-quest-mobile-link span {
-    flex: 0 0 auto;
-    font-weight: 900;
-    text-transform: lowercase;
-  }
+.dump-composer {
+  padding: clamp(16px, 3vw, 24px);
+}
 
-  .side-quest-mobile-link small {
-    min-width: 0;
-    color: var(--muted);
-    font-size: 0.8rem;
-    font-weight: 800;
-    line-height: 1.2;
-    text-align: right;
-  }
+.dump-composer textarea {
+  min-height: clamp(220px, 42vh, 420px);
+  border: 0;
+  border-radius: 0;
+  background: transparent;
+  padding: 0;
+  font-size: clamp(1.2rem, 2.4vw, 1.75rem);
+  line-height: 1.42;
 }
 
-@media (max-width: 560px) {
-  .topbar {
-    min-height: 62px;
-    padding: 12px 14px;
-  }
+.dump-composer textarea:focus {
+  box-shadow: none;
+}
 
-  .brand span:last-child {
-    display: none;
-  }
+.dump-composer-bottom {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  margin: 14px 0;
+  color: var(--muted);
+  font-size: 0.82rem;
+  font-weight: 850;
+}
 
-  .topbar-actions button.ghost-button {
-    display: none;
-  }
+.reflection-toggle {
+  display: flex;
+  grid-template-columns: none;
+  align-items: center;
+  gap: 8px;
+}
 
-  .topbar-actions {
-    gap: 6px;
-  }
+.reflection-toggle input {
+  width: 18px;
+  min-height: 18px;
+  accent-color: var(--ink);
+}
 
-  .topbar-actions .button-link {
-    min-height: 34px;
-    padding: 0 10px;
-    font-size: 0.86rem;
-  }
+.dump-side-note {
+  display: grid;
+  gap: 10px;
+  padding: 18px;
+  background: var(--mint);
+}
 
-  .side-quest-mobile-link {
-    align-items: flex-start;
-    flex-direction: column;
-    gap: 4px;
-  }
+.dump-side-note strong {
+  font-size: 1.2rem;
+}
 
-  .side-quest-mobile-link small {
-    text-align: left;
-  }
+.dump-side-note p {
+  margin-bottom: 0;
+  color: var(--mint-ink);
+  line-height: 1.42;
+}
 
-  .vibe-grid,
-  .type-grid,
-  .share-link-row,
-  .feed-actions,
-  .feed-pagination {
-    grid-template-columns: 1fr;
-    flex-direction: column;
-    align-items: stretch;
+.dump-rail {
+  display: grid;
+  gap: 12px;
+  min-width: 0;
+}
+
+.dump-rail-card {
+  display: grid;
+  gap: 10px;
+  padding: 16px;
+}
+
+.dump-rail-card span,
+.dump-section-heading span {
+  color: var(--muted);
+  font-size: 0.76rem;
+  font-weight: 900;
+  text-transform: lowercase;
+}
+
+.dump-rail-card strong {
+  line-height: 1.18;
+}
+
+.dump-rail-card p {
+  margin-bottom: 0;
+  color: var(--muted);
+  font-size: 0.9rem;
+  line-height: 1.4;
+}
+
+.private-card {
+  background: var(--gold);
+}
+
+.draft-card {
+  background: var(--mint);
+}
+
+.dump-selection-count {
+  color: var(--mint-ink);
+  font-size: 0.78rem;
+  font-weight: 900;
+  text-transform: lowercase;
+}
+
+.ghost-button.selected {
+  background: var(--gold);
+  box-shadow: 2px 2px 0 var(--ink);
+}
+
+.dump-feed {
+  display: grid;
+  gap: 12px;
+  margin-top: 18px;
+}
+
+.dump-history {
+  margin-top: 22px;
+}
+
+.dump-panel-tabs {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-top: 22px;
+  padding: 6px;
+  border: 1px solid var(--ink);
+  border-radius: var(--radius);
+  background: #fffefa;
+  box-shadow: 3px 3px 0 var(--ink);
+}
+
+.dump-panel-tabs button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  min-height: 38px;
+  padding: 0 12px;
+  border: 1px solid transparent;
+  border-radius: var(--radius);
+  background: transparent;
+  color: var(--muted);
+  font-weight: 900;
+}
+
+.dump-panel-tabs button.active {
+  border-color: var(--ink);
+  background: var(--gold);
+  color: var(--ink);
+  box-shadow: 2px 2px 0 var(--ink);
+}
+
+.dump-panel-tabs span {
+  display: inline-grid;
+  place-items: center;
+  min-width: 22px;
+  height: 22px;
+  padding: 0 6px;
+  border: 1px solid currentColor;
+  border-radius: 999px;
+  font-size: 0.75rem;
+}
+
+.dump-section-heading {
+  display: flex;
+  align-items: flex-end;
+  justify-content: space-between;
+  gap: 14px;
+  margin-bottom: 10px;
+}
+
+.dump-section-heading h2 {
+  margin-bottom: 0;
+  font-size: clamp(1.6rem, 4vw, 2.6rem);
+  line-height: 1;
+}
+
+.dump-section-heading small {
+  color: var(--muted);
+  font-size: 0.82rem;
+  font-weight: 850;
+}
+
+.dump-section-heading p {
+  max-width: 420px;
+  margin-bottom: 0;
+  color: var(--muted);
+  font-size: 0.86rem;
+  line-height: 1.35;
+  text-align: right;
+}
+
+.dump-card {
+  overflow: hidden;
+}
+
+.dump-card-main {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 12px;
+  align-items: center;
+  width: 100%;
+  padding: 15px;
+}
+
+.dump-card.selected {
+  background: #fff8e4;
+}
+
+.dump-card-open {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  gap: 12px;
+  align-items: center;
+  min-width: 0;
+  border: 0;
+  background: transparent;
+  color: var(--ink);
+  text-align: left;
+}
+
+.dump-card-open strong {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.dump-card-open > span:last-child {
+  color: var(--muted);
+  font-size: 0.82rem;
+  font-weight: 800;
+  white-space: nowrap;
+}
+
+.dump-select {
+  min-height: 32px;
+  padding: 0 10px;
+  border: 1px solid var(--line-strong);
+  border-radius: 999px;
+  background: transparent;
+  color: var(--muted);
+  font-size: 0.78rem;
+  font-weight: 900;
+}
+
+.dump-select.active {
+  border-color: var(--ink);
+  background: var(--mint);
+  color: var(--mint-ink);
+}
+
+.dump-pill {
+  display: inline-flex;
+  align-items: center;
+  min-height: 24px;
+  padding: 0 8px;
+  border: 1px solid var(--ink);
+  border-radius: 999px;
+  background: var(--blue);
+  color: var(--blue-ink);
+  font-size: 0.72rem;
+  font-weight: 900;
+}
+
+.dump-pill.private {
+  background: var(--gold);
+  color: var(--gold-ink);
+}
+
+.dump-pill.public {
+  background: var(--violet);
+  color: var(--violet-ink);
+}
+
+.dump-card-body {
+  display: grid;
+  gap: 14px;
+  padding: 0 15px 15px;
+}
+
+.dump-card-body > p {
+  margin: 0;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  line-height: 1.6;
+}
+
+.dump-reflection,
+.dump-share-box {
+  padding: 13px;
+  border: 1px dashed var(--line-strong);
+  border-radius: var(--radius);
+  background: #fffefa;
+}
+
+.dump-reflection span {
+  display: block;
+  margin-bottom: 5px;
+  color: var(--violet-ink);
+  font-size: 0.76rem;
+  font-weight: 900;
+  text-transform: lowercase;
+}
+
+.dump-reflection p,
+.dump-share-box p {
+  margin: 0;
+  color: var(--muted);
+  line-height: 1.45;
+}
+
+.dump-share-box {
+  display: grid;
+  gap: 12px;
+}
+
+.dump-card-actions {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 10px;
+}
+
+.dump-card-actions .ghost-button,
+.dump-card-actions .solid-button {
+  min-height: 36px;
+  padding: 0 12px;
+  font-size: 0.82rem;
+}
+
+.ghost-button.danger {
+  color: var(--clay-ink);
+}
+
+.dump-edit-textarea {
+  min-height: 190px;
+}
+
+.edit-bottom {
+  margin: -2px 0 0;
+}
+
+.dump-share-fields {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+  gap: 10px;
+}
+
+.field-note-drafts {
+  display: grid;
+  gap: 12px;
+  margin-top: 18px;
+}
+
+.field-note-drafts-header,
+.public-profile-card,
+.field-note-card {
+  border: 1px solid var(--ink);
+  border-radius: var(--radius);
+  background: var(--panel);
+  box-shadow: 4px 4px 0 var(--ink);
+}
+
+.field-note-drafts-header {
+  padding: 15px;
+  background: var(--violet);
+}
+
+.field-note-drafts-header span {
+  display: block;
+  margin-bottom: 4px;
+  color: var(--violet-ink);
+  font-size: 0.78rem;
+  font-weight: 900;
+  text-transform: lowercase;
+}
+
+.field-note-drafts-header p {
+  margin-bottom: 0;
+  line-height: 1.4;
+}
+
+.public-profile-card {
+  display: grid;
+  gap: 12px;
+  padding: 15px;
+  background: var(--gold);
+}
+
+.public-profile-card span {
+  display: block;
+  margin-bottom: 4px;
+  color: var(--gold-ink);
+  font-size: 0.78rem;
+  font-weight: 900;
+  text-transform: lowercase;
+}
+
+.public-profile-card h3 {
+  margin-bottom: 6px;
+  font-size: clamp(1.35rem, 3vw, 2rem);
+  line-height: 1.04;
+  overflow-wrap: anywhere;
+}
+
+.public-profile-card p {
+  max-width: 720px;
+  margin-bottom: 0;
+  color: var(--gold-ink);
+  line-height: 1.42;
+}
+
+.public-profile-fields {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+  gap: 10px;
+}
+
+.public-profile-actions,
+.field-note-pills {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  align-items: center;
+}
+
+.public-profile-actions small {
+  color: var(--gold-ink);
+  font-size: 0.8rem;
+  font-weight: 850;
+}
+
+.go-public-modal {
+  display: grid;
+  gap: 16px;
+  width: min(760px, 100%);
+  max-height: min(88vh, 820px);
+  overflow: auto;
+}
+
+.go-public-head {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 14px;
+  align-items: start;
+}
+
+.go-public-head h2 {
+  margin-bottom: 8px;
+}
+
+.go-public-head p {
+  max-width: 600px;
+  margin-bottom: 0;
+  color: var(--muted);
+  line-height: 1.45;
+}
+
+.go-public-form {
+  display: grid;
+  gap: 10px;
+  padding: 14px;
+  border: 1px solid var(--ink);
+  border-radius: var(--radius);
+  background: var(--gold);
+  box-shadow: 3px 3px 0 var(--ink);
+}
+
+.go-public-picker {
+  display: grid;
+  gap: 10px;
+}
+
+.go-public-picker-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.go-public-picker-head span {
+  color: var(--muted);
+  font-size: 0.78rem;
+  font-weight: 900;
+  text-transform: lowercase;
+}
+
+.go-public-picker-head small {
+  color: var(--muted);
+  font-weight: 850;
+}
+
+.public-note-option {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  gap: 12px;
+  align-items: center;
+  padding: 12px;
+  border: 1px solid var(--ink);
+  border-radius: var(--radius);
+  background: #fffefa;
+  box-shadow: 2px 2px 0 var(--ink);
+  cursor: pointer;
+}
+
+.public-note-option.selected {
+  background: var(--violet);
+}
+
+.public-note-option input {
+  width: 20px;
+  min-height: 20px;
+  accent-color: var(--ink);
+}
+
+.public-note-option span {
+  display: grid;
+  gap: 3px;
+  min-width: 0;
+}
+
+.public-note-option strong {
+  overflow-wrap: anywhere;
+  line-height: 1.15;
+}
+
+.public-note-option small {
+  color: var(--muted);
+  font-size: 0.78rem;
+  font-weight: 850;
+}
+
+.field-note-card {
+  display: grid;
+  gap: 12px;
+  padding: 15px;
+  background: #fffefa;
+}
+
+.field-note-card.published {
+  background: var(--mint);
+}
+
+.field-note-card textarea {
+  min-height: 180px;
+}
+
+.field-note-card-top {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.field-note-card-top small {
+  color: var(--muted);
+  font-size: 0.78rem;
+  font-weight: 850;
+}
+
+.field-note-read {
+  display: grid;
+  gap: 10px;
+}
+
+.field-note-read h3 {
+  margin-bottom: 0;
+  font-size: clamp(1.3rem, 3vw, 1.9rem);
+  line-height: 1.05;
+  overflow-wrap: anywhere;
+}
+
+.field-note-read p {
+  margin-bottom: 0;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  line-height: 1.6;
+}
+
+.field-note-actions {
+  justify-content: flex-end;
+}
+
+.dump-map-panel {
+  display: grid;
+  gap: 16px;
+  padding: clamp(18px, 3vw, 26px);
+  background: #fffefa;
+}
+
+.dump-graph-status {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+  padding: 12px 14px;
+  border: 1px solid var(--ink);
+  border-radius: var(--radius);
+  background: var(--mint);
+  box-shadow: 3px 3px 0 var(--ink);
+}
+
+.dump-graph-status.unavailable {
+  background: var(--clay);
+}
+
+.dump-graph-status.waiting,
+.dump-graph-status.local {
+  background: #fff8e4;
+}
+
+.dump-graph-status.active {
+  background: var(--mint);
+}
+
+.dump-graph-status span {
+  color: var(--muted);
+  font-size: 0.78rem;
+  font-weight: 900;
+  text-transform: lowercase;
+}
+
+.dump-graph-status strong {
+  font-size: 0.88rem;
+}
+
+.dump-graph-status p {
+  flex-basis: 100%;
+  margin-bottom: 0;
+  color: var(--muted);
+  font-size: 0.84rem;
+  line-height: 1.35;
+}
+
+.dump-memory-toggle {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr);
+  gap: 12px;
+  align-items: center;
+  padding: 12px 14px;
+  border: 1px solid var(--ink);
+  border-radius: var(--radius);
+  background: #fffefa;
+  box-shadow: 3px 3px 0 var(--ink);
+  cursor: pointer;
+}
+
+.dump-memory-toggle.on {
+  background: var(--violet);
+}
+
+.dump-memory-toggle input {
+  width: 22px;
+  min-height: 22px;
+  accent-color: var(--ink);
+}
+
+.dump-memory-toggle span {
+  display: grid;
+  gap: 3px;
+  min-width: 0;
+}
+
+.dump-memory-toggle strong {
+  line-height: 1.15;
+}
+
+.dump-memory-toggle small {
+  color: var(--muted);
+  font-size: 0.82rem;
+  font-weight: 820;
+  line-height: 1.25;
+}
+
+.dump-map-loading {
+  display: grid;
+  gap: 6px;
+  padding: 18px;
+  border: 1px dashed var(--line-strong);
+  border-radius: var(--radius);
+  background: #fff8e4;
+}
+
+.dump-map-loading strong {
+  font-size: 1.1rem;
+}
+
+.dump-map-loading p {
+  margin-bottom: 0;
+  color: var(--muted);
+  font-weight: 780;
+}
+
+.dump-map-summary {
+  display: grid;
+  grid-template-columns: minmax(0, 1.35fr) minmax(220px, 0.65fr);
+  gap: clamp(14px, 3vw, 24px);
+  align-items: stretch;
+  padding: clamp(16px, 3vw, 22px);
+  border: 1px solid var(--ink);
+  border-radius: var(--radius);
+  background: var(--blue);
+  box-shadow: 4px 4px 0 var(--ink);
+}
+
+.dump-map-summary.gold {
+  background: var(--gold);
+}
+
+.dump-map-summary.mint {
+  background: var(--mint);
+}
+
+.dump-map-summary.violet {
+  background: var(--violet);
+}
+
+.dump-map-summary.clay {
+  background: var(--clay);
+}
+
+.dump-map-summary-copy,
+.dump-map-next {
+  display: grid;
+  align-content: start;
+  gap: 8px;
+  min-width: 0;
+}
+
+.dump-map-summary span,
+.dump-insight span,
+.dump-pattern-card span,
+.dump-pattern-detail > span,
+.dump-pattern-meta small,
+.dump-pattern-evidence small {
+  color: var(--muted);
+  font-size: 0.76rem;
+  font-weight: 900;
+  text-transform: lowercase;
+}
+
+.dump-map-summary strong {
+  font-size: clamp(2rem, 5vw, 4rem);
+  line-height: 0.98;
+  overflow-wrap: anywhere;
+}
+
+.dump-map-summary p {
+  max-width: 760px;
+  margin-bottom: 0;
+  color: var(--muted);
+  line-height: 1.42;
+}
+
+.dump-map-next {
+  padding: 14px;
+  border: 1px dashed rgba(22, 20, 18, 0.45);
+  border-radius: var(--radius);
+  background: rgba(255, 254, 250, 0.62);
+}
+
+.dump-map-next p {
+  color: var(--ink);
+  font-weight: 830;
+}
+
+.dump-map-next .button-link {
+  align-self: end;
+  justify-self: start;
+  margin-top: 4px;
+}
+
+.dump-insight-strip {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 10px;
+}
+
+.dump-insight {
+  display: grid;
+  align-content: start;
+  gap: 6px;
+  min-width: 0;
+  padding: 13px;
+  border: 1px solid var(--ink);
+  border-radius: var(--radius);
+  background: var(--blue);
+  box-shadow: 3px 3px 0 var(--ink);
+}
+
+.dump-insight.gold {
+  background: var(--gold);
+}
+
+.dump-insight.mint {
+  background: var(--mint);
+}
+
+.dump-insight.violet {
+  background: var(--violet);
+}
+
+.dump-insight.clay {
+  background: var(--clay);
+}
+
+.dump-insight strong {
+  font-size: clamp(1.08rem, 2vw, 1.35rem);
+  line-height: 1.05;
+  overflow-wrap: anywhere;
+}
+
+.dump-insight p {
+  margin-bottom: 0;
+  color: var(--muted);
+  font-size: 0.86rem;
+  font-weight: 760;
+  line-height: 1.35;
+}
+
+.dump-pattern-board {
+  display: grid;
+  grid-template-columns: minmax(220px, 0.82fr) minmax(0, 1.5fr);
+  gap: 12px;
+  align-items: stretch;
+}
+
+.dump-pattern-list {
+  display: grid;
+  gap: 10px;
+}
+
+.dump-pattern-card,
+.dump-pattern-detail,
+.dump-pattern-evidence-item {
+  border: 1px solid var(--ink);
+  border-radius: var(--radius);
+  box-shadow: 3px 3px 0 var(--ink);
+}
+
+.dump-pattern-card {
+  display: grid;
+  gap: 7px;
+  width: 100%;
+  min-width: 0;
+  padding: 13px;
+  background: var(--blue);
+  color: var(--ink);
+  text-align: left;
+  cursor: pointer;
+}
+
+.dump-pattern-card.active,
+.dump-pattern-card:hover {
+  translate: -1px -1px;
+  box-shadow: 5px 5px 0 var(--ink);
+}
+
+.dump-pattern-card.gold,
+.dump-pattern-detail.gold {
+  background: var(--gold);
+}
+
+.dump-pattern-card.mint,
+.dump-pattern-detail.mint {
+  background: var(--mint);
+}
+
+.dump-pattern-card.violet,
+.dump-pattern-detail.violet {
+  background: var(--violet);
+}
+
+.dump-pattern-card.clay,
+.dump-pattern-detail.clay {
+  background: var(--clay);
+}
+
+.dump-pattern-card strong {
+  font-size: 1rem;
+  line-height: 1.1;
+  overflow-wrap: anywhere;
+}
+
+.dump-pattern-card p {
+  margin-bottom: 0;
+  color: var(--muted);
+  font-size: 0.86rem;
+  line-height: 1.35;
+}
+
+.dump-pattern-detail {
+  display: grid;
+  align-content: start;
+  gap: 14px;
+  min-width: 0;
+  padding: clamp(16px, 3vw, 22px);
+  background: var(--blue);
+}
+
+.dump-pattern-detail h2 {
+  max-width: 820px;
+  margin-bottom: 0;
+  font-size: clamp(1.6rem, 3.5vw, 3rem);
+  line-height: 0.96;
+  overflow-wrap: anywhere;
+}
+
+.dump-pattern-detail > p {
+  max-width: 760px;
+  margin-bottom: 0;
+  font-size: 1.03rem;
+  line-height: 1.48;
+}
+
+.dump-pattern-meta {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 10px;
+}
+
+.dump-pattern-meta div {
+  display: grid;
+  gap: 5px;
+  min-width: 0;
+  padding: 12px;
+  border: 1px dashed var(--line-strong);
+  border-radius: var(--radius);
+  background: rgba(255, 254, 250, 0.52);
+}
+
+.dump-pattern-meta strong {
+  font-size: 0.98rem;
+  line-height: 1.25;
+  overflow-wrap: anywhere;
+}
+
+.dump-pattern-evidence {
+  display: grid;
+  gap: 8px;
+}
+
+.dump-pattern-evidence-item {
+  display: grid;
+  grid-template-columns: 96px minmax(0, 1fr);
+  gap: 10px;
+  align-items: center;
+  min-width: 0;
+  padding: 10px;
+  background: #fffefa;
+  color: var(--ink);
+}
+
+.dump-pattern-evidence-item span {
+  color: var(--muted);
+  font-size: 0.76rem;
+  font-weight: 850;
+}
+
+.dump-pattern-evidence-item strong {
+  overflow-wrap: anywhere;
+  line-height: 1.18;
+}
+
+.dump-pattern-evidence p {
+  margin-bottom: 0;
+  color: var(--muted);
+}
+
+.public-profile-view {
+  width: min(880px, calc(100% - 32px));
+  margin: 0 auto;
+  padding: 34px 0 72px;
+}
+
+.public-profile-hero {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 16px;
+  align-items: start;
+  margin-bottom: 18px;
+  padding-bottom: 18px;
+  border-bottom: 1px solid var(--line-strong);
+}
+
+.public-profile-hero h1 {
+  margin-bottom: 10px;
+  font-size: clamp(3.4rem, 11vw, 7.5rem);
+  line-height: 0.86;
+}
+
+.public-profile-hero p {
+  max-width: 640px;
+  margin-bottom: 0;
+  color: var(--muted);
+  font-size: clamp(1rem, 2vw, 1.24rem);
+  line-height: 1.45;
+}
+
+.public-profile-bio {
+  margin-top: 12px;
+  color: var(--ink) !important;
+  font-weight: 820;
+}
+
+.public-profile-list {
+  display: grid;
+  gap: 14px;
+}
+
+.public-note-card {
+  display: grid;
+  gap: 12px;
+  padding: clamp(18px, 4vw, 28px);
+  border: 1px solid var(--ink);
+  border-radius: var(--radius);
+  background: #fffefa;
+  box-shadow: 4px 4px 0 var(--ink);
+}
+
+.public-note-meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  align-items: center;
+  justify-content: space-between;
+  color: var(--muted);
+  font-size: 0.78rem;
+  font-weight: 900;
+  text-transform: lowercase;
+}
+
+.public-note-card h2 {
+  max-width: 760px;
+  margin-bottom: 0;
+  font-size: clamp(1.8rem, 5vw, 3.4rem);
+  line-height: 0.98;
+  overflow-wrap: anywhere;
+}
+
+.public-note-text p {
+  margin-bottom: 0;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  font-size: 1.06rem;
+  line-height: 1.68;
+}
+
+.public-note-text .read-more-button {
+  margin-top: 2px;
+}
+
+@media (max-width: 860px) {
+  .topbar {
+    align-items: flex-start;
+  }
+
+  .topbar-actions {
+    flex-wrap: wrap;
+    justify-content: flex-end;
+  }
+
+  .hero,
+  .create-grid,
+  .space-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .hero {
+    min-height: auto;
+    padding-top: 28px;
+  }
+
+  .artifact-board {
+    min-height: 460px;
+  }
+
+  .space-header {
+    align-items: flex-start;
+    flex-direction: column;
+  }
+
+  .compose-header {
+    align-items: flex-start;
+    flex-direction: column;
+  }
+
+  .compose-title {
+    min-width: 0;
+  }
+
+  .side-panel {
+    position: static;
+  }
+
+  .dump-hero,
+  .public-profile-hero,
+  .dump-grid,
+  .dump-workspace,
+  .dump-pattern-board,
+  .dump-insight-strip,
+  .reads-intro {
+    grid-template-columns: 1fr;
+    align-items: flex-start;
+    flex-direction: column;
+  }
+
+  .reads-intro .ghost-button,
+  .reads-intro p {
+    grid-column: auto;
+    grid-row: auto;
+  }
+
+  .side-quest-mobile-link {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 12px;
+    margin: -6px 0 16px;
+    padding: 11px 12px;
+    border: 1px solid var(--ink);
+    border-radius: var(--radius);
+    background: #f3fff1;
+    box-shadow: 3px 3px 0 var(--ink);
+    color: var(--ink);
+    text-decoration: none;
+  }
+
+  .side-quest-mobile-link span {
+    flex: 0 0 auto;
+    font-weight: 900;
+    text-transform: lowercase;
+  }
+
+  .side-quest-mobile-link small {
+    min-width: 0;
+    color: var(--muted);
+    font-size: 0.8rem;
+    font-weight: 800;
+    line-height: 1.2;
+    text-align: right;
+  }
+}
+
+@media (max-width: 560px) {
+  .topbar {
+    min-height: 62px;
+    padding: 12px 14px;
+  }
+
+  .brand span:last-child {
+    display: none;
+  }
+
+  .topbar-actions button.ghost-button {
+    display: none;
+  }
+
+  .topbar-actions {
+    gap: 6px;
+  }
+
+  .topbar-actions .button-link {
+    min-height: 34px;
+    padding: 0 10px;
+    font-size: 0.86rem;
+  }
+
+  .side-quest-mobile-link {
+    align-items: flex-start;
+    flex-direction: column;
+    gap: 4px;
+  }
+
+  .side-quest-mobile-link small {
+    text-align: left;
+  }
+
+  .vibe-grid,
+  .type-grid,
+  .share-link-row,
+  .feed-actions,
+  .feed-pagination,
+  .dump-panel-tabs,
+  .dump-card-main,
+  .dump-card-open,
+  .dump-share-fields,
+  .go-public-head,
+  .public-profile-fields,
+  .public-note-option,
+  .dump-composer-bottom,
+  .dump-map-summary,
+  .dump-pattern-meta,
+  .dump-pattern-evidence-item {
+    grid-template-columns: 1fr;
+    flex-direction: column;
+    align-items: stretch;
+  }
+
+  .dump-map-summary .button-link {
+    width: 100%;
+  }
+
+  .dump-section-heading {
+    align-items: flex-start;
+    flex-direction: column;
+  }
+
+  .dump-section-heading p {
+    text-align: left;
+  }
+
+  .dump-card-open > span:last-child {
+    white-space: normal;
+  }
+
+  .dump-select,
+  .dump-panel-tabs button,
+  .dump-card-actions .ghost-button,
+  .dump-card-actions .solid-button {
+    width: 100%;
   }
 
   .feed-pagination .ghost-button {
diff --git a/supabase/migrations/0011_mumbl_dump.sql b/supabase/migrations/0011_mumbl_dump.sql
new file mode 100644
index 0000000..bbde7c0
--- /dev/null
+++ b/supabase/migrations/0011_mumbl_dump.sql
@@ -0,0 +1,63 @@
+alter table posts drop constraint if exists posts_type_check;
+alter table posts add constraint posts_type_check check (type in ('find', 'thought', 'rant', 'win', 'lol', 'dump', 'field_note'));
+
+alter table posts drop constraint if exists posts_content_check;
+alter table posts add constraint posts_content_check check (
+  (type in ('dump', 'field_note') and char_length(content) between 1 and 4000)
+  or
+  (type not in ('dump', 'field_note') and char_length(content) between 1 and 420)
+);
+
+create table if not exists dumps (
+  id uuid primary key default gen_random_uuid(),
+  session_token_hash text not null,
+  content text not null check (char_length(content) between 1 and 4000),
+  visibility text not null default 'private' check (visibility in ('private', 'team', 'public')),
+  team_room_id uuid references spaces(id) on delete set null,
+  ai_reflection text,
+  published_at timestamptz,
+  created_at timestamptz not null default now(),
+  updated_at timestamptz not null default now(),
+  check (
+    (visibility = 'team' and team_room_id is not null)
+    or
+    (visibility <> 'team')
+  )
+);
+
+create index if not exists dumps_session_created_idx on dumps (session_token_hash, created_at desc);
+create index if not exists dumps_team_created_idx on dumps (team_room_id, created_at desc) where visibility = 'team';
+
+alter table posts add column if not exists dump_id uuid references dumps(id) on delete set null;
+alter table posts add column if not exists field_note_title text check (field_note_title is null or char_length(field_note_title) between 1 and 120);
+create index if not exists posts_dump_idx on posts (dump_id);
+
+create table if not exists field_notes (
+  id uuid primary key default gen_random_uuid(),
+  session_token_hash text not null,
+  team_room_id uuid references spaces(id) on delete set null,
+  source_dump_ids uuid[] not null default '{}',
+  title text not null check (char_length(title) between 1 and 120),
+  content text not null check (char_length(content) between 1 and 4000),
+  is_published boolean not null default false,
+  published_post_id uuid references posts(id) on delete set null,
+  created_at timestamptz not null default now(),
+  published_at timestamptz
+);
+
+create index if not exists field_notes_session_created_idx on field_notes (session_token_hash, created_at desc);
+create index if not exists field_notes_team_idx on field_notes (team_room_id, published_at desc) where is_published = true;
+
+create table if not exists dump_insights (
+  id uuid primary key default gen_random_uuid(),
+  session_token_hash text not null,
+  insight_type text not null check (insight_type in ('theme', 'pattern', 'streak', 'graph_node')),
+  content jsonb not null,
+  generated_at timestamptz not null default now()
+);
+
+create index if not exists dump_insights_session_idx on dump_insights (session_token_hash, generated_at desc);
+
+alter table dumps enable row level security;
+alter table field_notes enable row level security;
+alter table dump_insights enable row level security;
diff --git a/supabase/migrations/0012_field_notes.sql b/supabase/migrations/0012_field_notes.sql
new file mode 100644
index 0000000..783829e
--- /dev/null
+++ b/supabase/migrations/0012_field_notes.sql
@@ -0,0 +1,31 @@
+alter table posts drop constraint if exists posts_type_check;
+alter table posts add constraint posts_type_check check (type in ('find', 'thought', 'rant', 'win', 'lol', 'dump', 'field_note'));
+
+alter table posts drop constraint if exists posts_content_check;
+alter table posts add constraint posts_content_check check (
+  (type in ('dump', 'field_note') and char_length(content) between 1 and 4000)
+  or
+  (type not in ('dump', 'field_note') and char_length(content) between 1 and 420)
+);
+
+alter table posts add column if not exists field_note_title text check (field_note_title is null or char_length(field_note_title) between 1 and 120);
+
+create table if not exists field_notes (
+  id uuid primary key default gen_random_uuid(),
+  session_token_hash text not null,
+  team_room_id uuid references spaces(id) on delete set null,
+  source_dump_ids uuid[] not null default '{}',
+  title text not null check (char_length(title) between 1 and 120),
+  content text not null check (char_length(content) between 1 and 4000),
+  is_published boolean not null default false,
+  published_post_id uuid references posts(id) on delete set null,
+  created_at timestamptz not null default now(),
+  published_at timestamptz
+);
+
+create index if not exists field_notes_session_created_idx on field_notes (session_token_hash, created_at desc);
+create index if not exists field_notes_team_idx on field_notes (team_room_id, published_at desc) where is_published = true;
+
+alter table field_notes enable row level security;
+
+notify pgrst, 'reload schema';
diff --git a/supabase/migrations/0013_dump_supermemory.sql b/supabase/migrations/0013_dump_supermemory.sql
new file mode 100644
index 0000000..639f3e6
--- /dev/null
+++ b/supabase/migrations/0013_dump_supermemory.sql
@@ -0,0 +1,11 @@
+alter table dumps add column if not exists supermemory_id text;
+alter table dumps add column if not exists supermemory_status text;
+alter table dumps add column if not exists supermemory_synced_at timestamptz;
+
+create index if not exists dumps_supermemory_idx on dumps (supermemory_id) where supermemory_id is not null;
+
+alter table field_notes add column if not exists supermemory_id text;
+alter table field_notes add column if not exists supermemory_status text;
+alter table field_notes add column if not exists supermemory_synced_at timestamptz;
+
+create index if not exists field_notes_supermemory_idx on field_notes (supermemory_id) where supermemory_id is not null;
diff --git a/supabase/migrations/0014_field_notes_supermemory_tracking.sql b/supabase/migrations/0014_field_notes_supermemory_tracking.sql
new file mode 100644
index 0000000..68e4a73
--- /dev/null
+++ b/supabase/migrations/0014_field_notes_supermemory_tracking.sql
@@ -0,0 +1,5 @@
+alter table field_notes add column if not exists supermemory_id text;
+alter table field_notes add column if not exists supermemory_status text;
+alter table field_notes add column if not exists supermemory_synced_at timestamptz;
+
+create index if not exists field_notes_supermemory_idx on field_notes (supermemory_id) where supermemory_id is not null;
diff --git a/supabase/migrations/0015_public_profiles.sql b/supabase/migrations/0015_public_profiles.sql
new file mode 100644
index 0000000..cf5a31f
--- /dev/null
+++ b/supabase/migrations/0015_public_profiles.sql
@@ -0,0 +1,22 @@
+create table if not exists public_profiles (
+  id uuid primary key default gen_random_uuid(),
+  session_token_hash text not null,
+  handle text unique not null check (handle ~ '^[a-z0-9][a-z0-9_-]{1,29}$'),
+  display_name text,
+  bio text,
+  created_at timestamptz not null default now(),
+  updated_at timestamptz not null default now()
+);
+
+create index if not exists public_profiles_session_idx on public_profiles (session_token_hash);
+create index if not exists public_profiles_handle_idx on public_profiles (handle);
+
+alter table field_notes add column if not exists public_profile_id uuid references public_profiles(id) on delete set null;
+alter table field_notes add column if not exists is_public boolean not null default false;
+alter table field_notes add column if not exists public_published_at timestamptz;
+
+create index if not exists field_notes_public_profile_idx
+  on field_notes (public_profile_id, public_published_at desc)
+  where is_public = true;
+
+alter table public_profiles enable row level security;
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..5b45867
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,36 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ]
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}