Add “Make my homework”, and finish the mobile polish pass

Homework (/homework — entry points in the drawer and on the create screen)

- Assignment intake reuses the study pipeline: pasted text, photos
  (camera/picker, compressed in the browser) and documents (PDF/DOCX/PPTX/
  ODT/text) through lib/image + lib/documents, the same vision step and the
  same language guard. Raw files never leave the device — only text and JPEG
  data URLs reach the server.
- Two large choice cards: “Just make it” returns the finished homework
  (answer only, plain text, copy + make it again); “Explain how to make this
  homework” builds an interactive guide.
- The guide is one step per screen in the study-feed snap layout:
  explanation, three progressive hints (nudge -> hint -> the answer) and an
  optional checkpoint rendered by the existing activity components (graded
  through /api/grade). The last screen assembles the solution from the step
  answers, with a copy button. Checkpoints carry xp 0 so the guide stays free
  of XP/streak chrome.
- Results live in freezmo.homework.v1 with a small history (open/delete);
  “Make it again” re-runs from the stored assignment text (the vision
  transcription when photos were used) — no original files are stored.
- The answer and the guide are written in the assignment's language, never
  translated into the UI language.

Server

- POST /api/homework: NDJSON stage events like /api/generate, the same
  http-guard, auth checked before parsing, and its own RATE_LIMIT_HOMEWORK
  (documented in .env.example + the README table).
- New prompts in lib/prompts.ts and zod schemas in lib/schemas.ts with the
  same single repair retry; TEXT_MODEL for content, VISION_MODEL only for
  photos. New shared client pieces: useNotesIntake, lib/homework store,
  lib/clipboard, and a shared NDJSON reader in lib/client-api.

Also finishing the mobile polish pass from the previous request

- Phone ice scene: the top-left orb moved behind the glass header (it sat
  behind the page heading/subtitle). The settings sheet's scroll cue is now a
  bare chevron inside a content fade (mask) instead of a chip over the status
  banner, and the API key card's note/disclosure/actions are tightened.
- theme-color now follows the in-app theme (SSR metas still fall back to the
  OS preference); apple-mobile-web-app-status-bar-style stays “default”
  because iOS fixes the status-bar text colour at launch.

Verified: 78/78 homework checks (text/photo/PDF, both modes, EN+CS, dark+light,
360/390px, copy, history persistence, storage privacy, API language, axe), plus
the existing suites re-run (mobile 47/47, pixel contrast 0 below AA, i18n 27/27,
desktop regression 72/72). Lint + build clean; service worker freezmo-v6.

lib/homework.ts

@@ -0,0 +1,160 @@
+"use client";
+
+/**
+ * Homework results backed by localStorage. Same tiny observable store as the
+ * deck library, but deliberately smaller: no folders, no attempts — just the
+ * assignment text (so “Make it again” works) and the result.
+ *
+ * Original photos/documents are never stored; they were reduced to text on the
+ * client before this point.
+ */
+
+import {
+  homeworkRecordSchema,
+  type HomeworkGuideRecord,
+  type HomeworkMode,
+  type HomeworkRecord,
+  type HomeworkStep,
+} from "./schemas";
+import { uid } from "./utils";
+
+const STORAGE_KEY = "freezmo.homework.v1";
+const EMPTY: HomeworkRecord[] = [];
+/** Enough to regenerate from, while staying well under the storage quota. */
+export const MAX_STORED_SOURCE = 24_000;
+
+type Listener = () => void;
+
+let records: HomeworkRecord[] | null = null;
+let cached: HomeworkRecord[] = EMPTY;
+const listeners = new Set<Listener>();
+
+function read(): HomeworkRecord[] {
+  if (typeof window === "undefined") return EMPTY;
+  try {
+    const raw = window.localStorage.getItem(STORAGE_KEY);
+    if (!raw) return EMPTY;
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return EMPTY;
+    const valid: HomeworkRecord[] = [];
+    for (const entry of parsed) {
+      const result = homeworkRecordSchema.safeParse(entry);
+      if (result.success) valid.push(result.data as HomeworkRecord);
+      else console.warn("[freezmo] skipping invalid homework record", result.error.issues);
+    }
+    return valid;
+  } catch (error) {
+    console.warn("[freezmo] could not read the homework history", error);
+    return EMPTY;
+  }
+}
+
+function ensureLoaded(): void {
+  if (records !== null) return;
+  records = read();
+  cached = records;
+}
+
+function write(next: HomeworkRecord[]): void {
+  records = next;
+  cached = next;
+  try {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(next));
+  } catch (error) {
+    console.warn("[freezmo] could not save the homework history (storage full?)", error);
+  }
+  listeners.forEach((listener) => listener());
+}
+
+export const homeworkStore = {
+  subscribe(listener: Listener): () => void {
+    ensureLoaded();
+    listeners.add(listener);
+    const onStorage = (event: StorageEvent) => {
+      if (event.key === STORAGE_KEY) {
+        records = null;
+        ensureLoaded();
+        listeners.forEach((l) => l());
+      }
+    };
+    window.addEventListener("storage", onStorage);
+    return () => {
+      listeners.delete(listener);
+      window.removeEventListener("storage", onStorage);
+    };
+  },
+  getSnapshot(): HomeworkRecord[] {
+    ensureLoaded();
+    return cached;
+  },
+  getServerSnapshot(): HomeworkRecord[] {
+    return EMPTY;
+  },
+};
+
+/** Newest first. */
+export function sortHomework(list: HomeworkRecord[]): HomeworkRecord[] {
+  return [...list].sort((a, b) => b.updatedAt - a.updatedAt);
+}
+
+export function getHomework(id: string): HomeworkRecord | undefined {
+  return homeworkStore.getSnapshot().find((record) => record.id === id);
+}
+
+/** Everything needed to store a result (the route's payload plus the source). */
+export type NewHomeworkResult =
+  | { mode: "make"; title: string; language?: string; sourceText: string; answer: string }
+  | { mode: "guide"; title: string; language?: string; sourceText: string; steps: HomeworkStep[] };
+
+function buildRecord(
+  base: { id: string; createdAt: number; updatedAt: number },
+  input: NewHomeworkResult,
+): HomeworkRecord {
+  const shared = {
+    ...base,
+    title: input.title.slice(0, 200),
+    language: input.language,
+    sourceText: input.sourceText.slice(0, MAX_STORED_SOURCE),
+  };
+  if (input.mode === "make") return { ...shared, mode: "make", answer: input.answer };
+  return { ...shared, mode: "guide", steps: input.steps };
+}
+
+export function saveHomework(input: NewHomeworkResult): HomeworkRecord {
+  ensureLoaded();
+  const now = Date.now();
+  const record = buildRecord({ id: uid("hw"), createdAt: now, updatedAt: now }, input);
+  write([record, ...homeworkStore.getSnapshot()]);
+  return record;
+}
+
+/** “Make it again” keeps the same history row. */
+export function updateHomework(id: string, input: NewHomeworkResult): HomeworkRecord | undefined {
+  ensureLoaded();
+  const existing = homeworkStore.getSnapshot().find((record) => record.id === id);
+  if (!existing) return undefined;
+  const updated = buildRecord(
+    { id: existing.id, createdAt: existing.createdAt, updatedAt: Date.now() },
+    input,
+  );
+  write(homeworkStore.getSnapshot().map((record) => (record.id === id ? updated : record)));
+  return updated;
+}
+
+export function deleteHomework(id: string): void {
+  ensureLoaded();
+  write(homeworkStore.getSnapshot().filter((record) => record.id !== id));
+}
+
+/** The final screen's text: the step answers assembled into one solution. */
+export function assembleSolution(record: HomeworkGuideRecord): string {
+  const parts = record.steps.map((step, index) => `${index + 1}. ${step.title}\n${step.answer}`);
+  return [record.title, ...parts].join("\n\n");
+}
+
+/** Label for a row in the history list. */
+export function homeworkModeLabelKey(mode: HomeworkMode): string {
+  return mode === "make" ? "homework.history.made" : "homework.history.guide";
+}
+
+export type { HomeworkGuideRecord };