feat: add remote-fetch-content to pull user content repo on server

Separate from remote-fetch (main repo) since content sync is handled
by the git-sync plugin once configured; this is for one-off manual pulls.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vgmzx8VTTTmCskSpQtsLTr

.gitignore

@@ -19,5 +19,8 @@ test-results/
 playwright-report/
 tests/.auth/
 
+# travel-memories state
+docs/immich-workflow/*.json
+
 # OS
 .DS_Store

Makefile

@@ -105,11 +105,15 @@ remote-install:
 # ── Remote: ongoing maintenance ────────────────────────────────────────────────
 
 remote-fetch:
-	$(SSH) "git -C $(SITE_CONFIG_DIR) pull"
+	$(SSH) "git -C $(SITE_CONFIG_DIR) checkout main && git -C $(SITE_CONFIG_DIR) pull"
+
+remote-fetch-content:
+	$(SSH) "git -C $(WEBROOT)/user checkout main && git -C $(WEBROOT)/user pull"
 
 remote-install-plugins:
 	$(SSH) "cd $(WEBROOT) && php bin/gpm install $(shell cat plugins.txt | tr '\n' ' ') -y"
 
+
 remote-upgrade-grav:
 	$(SSH) "cd $(WEBROOT) && php bin/grav upgrade"
 

docker-compose.yml

@@ -12,3 +12,13 @@ services:
       - ./user:/var/www/html/user
       - ./php/php-local.ini:/usr/local/etc/php/conf.d/php-local.ini
     restart: unless-stopped
+
+  travel-memories:
+    build: ./services/travel-memories
+    ports:
+      - "8082:8082"
+    volumes:
+      - ./docs/immich-workflow:/app/state
+      - ./user/pages:/app/pages
+    env_file: .env
+    user: "${UID}:${GID}"

scripts/server-install.sh

@@ -11,9 +11,6 @@ set -e
 : "${GITEA_USER:?GITEA_USER is not set}"
 : "${GITEA_TOKEN:?GITEA_TOKEN is not set}"
 
-# GRAV_CHANNEL_SUFFIX: optional, set to '?testing' for RC/beta releases (e.g. 2.0.0-rc.9)
-# Leave unset or empty for stable releases.
-
 trap 'rm -f ~/.netrc' EXIT
 
 echo "==> Setting up credentials (temporary)"
@@ -26,6 +23,7 @@ wget --no-verbose "https://github.com/getgrav/grav/releases/download/${GRAV_VERS
 unzip -oq grav-admin.zip
 cp -rf grav-admin/. .
 cp -rf grav-admin/user/plugins/admin2 /tmp/admin2-plugin
+cp -rf grav-admin/user/plugins/api /tmp/api-plugin
 rm -rf grav-admin grav-admin.zip
 
 echo "==> Cloning user repo"
@@ -43,7 +41,8 @@ fi
 echo "==> Creating required directories"
 mkdir -p user/plugins user/accounts user/data
 cp -rf /tmp/admin2-plugin user/plugins/admin2
-rm -rf /tmp/admin2-plugin
+cp -rf /tmp/api-plugin user/plugins/api
+rm -rf /tmp/admin2-plugin /tmp/api-plugin
 
 echo "==> Installing plugins"
 php bin/gpm install $PLUGINS -y

services/travel-memories/.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.py[cod]
+.venv/
+.pytest_cache/

services/travel-memories/Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.12-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt && \
+    playwright install chromium --with-deps
+COPY app/ ./app/
+ENV FLASK_APP=app
+ENV FLASK_RUN_HOST=0.0.0.0
+ENV FLASK_RUN_PORT=8082
+CMD ["flask", "run"]

services/travel-memories/app/__init__.py

@@ -0,0 +1,21 @@
+import os
+from flask import Flask
+
+def create_app(state_dir=None, pages_dir=None):
+    app = Flask(__name__)
+    app.config["STATE_DIR"] = state_dir or os.environ.get("STATE_DIR", "/app/state")
+    app.config["PAGES_DIR"] = pages_dir or os.environ.get("PAGES_DIR", "/app/pages")
+    app.config["IMMICH_URL"] = os.environ.get("IMMICH_URL", "")
+    app.config["IMMICH_API_KEY"] = os.environ.get("IMMICH_API_KEY", "")
+
+    from .routes import albums, proxy, notes, nav
+    app.register_blueprint(albums.bp)
+    app.register_blueprint(proxy.bp)
+    app.register_blueprint(notes.bp)
+    app.register_blueprint(nav.bp)
+
+    @app.get("/health")
+    def health():
+        return {"ok": True}
+
+    return app

services/travel-memories/app/immich.py

@@ -0,0 +1,30 @@
+import requests
+
+
+class ImmichClient:
+    def __init__(self, base_url: str, api_key: str):
+        self.base_url = base_url.rstrip("/")
+        self.headers = {"Authorization": f"Bearer {api_key}"}
+
+    def _get(self, path: str, **kwargs):
+        try:
+            r = requests.get(f"{self.base_url}{path}",
+                             headers=self.headers, timeout=10, **kwargs)
+            r.raise_for_status()
+            return r
+        except requests.exceptions.ConnectionError as e:
+            raise ConnectionError(f"Cannot reach Immich: {e}") from e
+
+    def list_albums(self) -> list:
+        return self._get("/api/albums").json()
+
+    def get_album(self, album_id: str) -> dict:
+        return self._get(f"/api/albums/{album_id}",
+                         params={"withoutAssets": "false"}).json()
+
+    def get_thumbnail(self, asset_id: str) -> bytes:
+        return self._get(f"/api/assets/{asset_id}/thumbnail",
+                         params={"size": "preview"}).content
+
+    def get_original(self, asset_id: str) -> bytes:
+        return self._get(f"/api/assets/{asset_id}/original").content

services/travel-memories/app/routes/albums.py

@@ -0,0 +1,91 @@
+from pathlib import Path
+
+from flask import Blueprint, current_app, redirect, render_template, request
+from app.immich import ImmichClient
+from app.state import TripState, Photo, load_state, save_state
+
+bp = Blueprint("albums", __name__)
+
+
+def _client():
+    return ImmichClient(current_app.config["IMMICH_URL"],
+                        current_app.config["IMMICH_API_KEY"])
+
+
+@bp.get("/")
+def index():
+    try:
+        albums = _client().list_albums()
+        error = None
+    except ConnectionError as e:
+        albums = []
+        error = str(e)
+    state_dir = Path(current_app.config["STATE_DIR"])
+    for album in albums:
+        album["has_state"] = (state_dir / f"{album['id']}.json").exists()
+    return render_template("phase1.html", albums=albums, error=error,
+                           current_phase="", album_id=None,
+                           phase_stale=[], notes_content="")
+
+
+@bp.post("/select")
+def select():
+    album_ids = request.form.getlist("album_ids[]")
+    grav_trip_slug = request.form["grav_trip_slug"].strip()
+    start_over = request.form.get("start_over") == "1"
+
+    if len(album_ids) == 1:
+        primary_id = album_ids[0]
+    else:
+        primary_id = "__merged__" + "_".join(sorted(album_ids))
+
+    existing = load_state(primary_id, current_app)
+    if existing and not start_over:
+        return redirect(f"/{existing.phase}?album_id={primary_id}")
+
+    # Fetch and merge assets, deduplicating by asset ID
+    all_assets = {}
+    album_name_parts = []
+    for aid in album_ids:
+        album = _client().get_album(aid)
+        album_name_parts.append(album["albumName"])
+        for asset in album["assets"]:
+            if asset["id"] not in all_assets:
+                all_assets[asset["id"]] = asset
+
+    photos = [
+        Photo(id=a["id"], original_filename=a["originalFileName"],
+              local_datetime=a["localDateTime"])
+        for a in sorted(all_assets.values(), key=lambda x: x["localDateTime"])
+    ]
+    for i, p in enumerate(photos):
+        p.order = i
+
+    state = TripState(
+        album_id=primary_id,
+        album_name=", ".join(album_name_parts),
+        grav_trip_slug=grav_trip_slug,
+        photos=photos,
+    )
+    save_state(state, current_app)
+    return redirect(f"/triage?album_id={primary_id}")
+
+
+# TODO(task-6): replace this stub with the real triage route
+@bp.get("/triage")
+def triage():
+    album_id = request.args.get("album_id", "")
+    notes_content = ""
+    phase_stale = []
+    if album_id:
+        state = load_state(album_id, current_app)
+        if state:
+            notes_content = state.notes
+            phase_stale = state.phase_stale
+    return render_template(
+        "base.html",
+        current_phase="triage",
+        album_id=album_id,
+        notes_content=notes_content,
+        phase_stale=phase_stale,
+    )

services/travel-memories/app/routes/nav.py

@@ -0,0 +1,51 @@
+from flask import Blueprint, current_app, jsonify, redirect, request
+from app.state import load_state, save_state
+
+bp = Blueprint("nav", __name__)
+
+STALE_DOWNSTREAM = {
+    "triage": ["curate", "group", "write"],
+    "curate": ["group", "write"],
+    "group": ["write"],
+    "write": [],
+    "export": [],
+}
+
+
+@bp.post("/nav/phase")
+def goto_phase():
+    body = request.get_json()
+    target = body["target_phase"]
+    state = load_state(body["album_id"], current_app)
+    if state is None:
+        return jsonify({"error": "no state"}), 404
+
+    # Mark downstream completed phases and the current phase as stale
+    downstream = STALE_DOWNSTREAM.get(target, [])
+    candidates = set(downstream) & (set(state.phases_completed) | {state.phase})
+    newly_stale = [p for p in candidates if p not in state.phase_stale]
+    state.phase_stale = list(set(state.phase_stale + newly_stale))
+    state.phase = target
+    save_state(state, current_app)
+    return jsonify({"ok": True, "phase": target})
+
+
+@bp.post("/nav/dismiss-stale")
+def dismiss_stale():
+    album_id = request.form["album_id"]
+    phase = request.form["phase"]
+    state = load_state(album_id, current_app)
+    if state:
+        state.phase_stale = [p for p in state.phase_stale if p != phase]
+        save_state(state, current_app)
+    return redirect(f"/{phase}?album_id={album_id}")
+
+
+@bp.get("/state/<album_id>")
+def get_state(album_id):
+    """Debug/test endpoint — returns full state JSON."""
+    state = load_state(album_id, current_app)
+    if state is None:
+        return jsonify({"error": "no state"}), 404
+    from dataclasses import asdict
+    return jsonify(asdict(state))

services/travel-memories/app/routes/notes.py

@@ -0,0 +1,23 @@
+from flask import Blueprint, current_app, jsonify, request
+from app.state import load_state, save_state
+
+bp = Blueprint("notes", __name__)
+
+
+@bp.post("/notes/save")
+def save_notes():
+    body = request.get_json()
+    state = load_state(body["album_id"], current_app)
+    if state is None:
+        return jsonify({"error": "no state"}), 404
+    state.notes = body["notes"]
+    save_state(state, current_app)
+    return jsonify({"ok": True})
+
+
+@bp.get("/notes/<album_id>")
+def get_notes(album_id):
+    state = load_state(album_id, current_app)
+    if state is None:
+        return jsonify({"error": "no state"}), 404
+    return jsonify({"notes": state.notes})

services/travel-memories/app/routes/proxy.py

@@ -0,0 +1,29 @@
+from flask import Blueprint, current_app, Response, abort
+from app.immich import ImmichClient
+
+bp = Blueprint("proxy", __name__)
+
+
+def _client() -> ImmichClient:
+    return ImmichClient(
+        base_url=current_app.config["IMMICH_URL"],
+        api_key=current_app.config["IMMICH_API_KEY"],
+    )
+
+
+@bp.get("/proxy/thumb/<asset_id>")
+def thumb(asset_id):
+    try:
+        data = _client().get_thumbnail(asset_id)
+    except ConnectionError:
+        abort(502)
+    return Response(data, content_type="image/jpeg")
+
+
+@bp.get("/proxy/original/<asset_id>")
+def original(asset_id):
+    try:
+        data = _client().get_original(asset_id)
+    except ConnectionError:
+        abort(502)
+    return Response(data, content_type="image/jpeg")

services/travel-memories/app/state.py

@@ -0,0 +1,68 @@
+import json
+import os
+from dataclasses import dataclass, field, asdict
+from pathlib import Path
+from typing import Optional
+
+from flask import current_app
+
+
+@dataclass
+class Photo:
+    id: str
+    original_filename: str
+    local_datetime: str
+    tag: str = "untagged"   # untagged | journal | story | skip
+    order: int = 0
+
+
+@dataclass
+class Group:
+    id: str
+    photo_ids: list = field(default_factory=list)
+    entry_type: str = "journal"   # journal | story
+    title: str = ""
+    body: str = ""
+    location_city: str = ""
+    location_country: str = ""
+    date: str = ""
+    hero_photo_id: Optional[str] = None
+    shortcode_hints: str = ""
+    status: str = "draft"   # draft | written | skipped | exported
+
+
+@dataclass
+class TripState:
+    album_id: str
+    album_name: str
+    grav_trip_slug: str
+    phase: str = "triage"
+    phases_completed: list = field(default_factory=list)
+    phase_stale: list = field(default_factory=list)
+    photos: list = field(default_factory=list)
+    groups: list = field(default_factory=list)
+    notes: str = ""
+
+
+def _state_path(album_id: str, app) -> Path:
+    return Path(app.config["STATE_DIR"]) / f"{album_id}.json"
+
+
+def load_state(album_id: str, app) -> Optional[TripState]:
+    path = _state_path(album_id, app)
+    if not path.exists():
+        return None
+    with open(path) as f:
+        data = json.load(f)
+    photos = [Photo(**p) for p in data.pop("photos", [])]
+    groups = [Group(**g) for g in data.pop("groups", [])]
+    return TripState(photos=photos, groups=groups, **data)
+
+
+def save_state(state: TripState, app) -> None:
+    path = _state_path(state.album_id, app)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    with open(tmp, "w") as f:
+        json.dump(asdict(state), f, indent=2)
+    os.rename(tmp, path)

services/travel-memories/app/static/app.js

@@ -0,0 +1,34 @@
+function notesApp(initialNotes, albumId) {
+  return {
+    open: false,
+    notes: initialNotes,
+    status: '',
+    saveTimer: null,
+
+    scheduleAutosave() {
+      clearTimeout(this.saveTimer);
+      this.status = 'Saving…';
+      this.saveTimer = setTimeout(() => this.doSave(), 500);
+    },
+
+    async doSave() {
+      const res = await fetch('/notes/save', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ album_id: albumId, notes: this.notes }),
+      });
+      this.status = res.ok ? 'Saved ✓' : 'Error';
+    },
+
+    async convertToEntry(text) {
+      const res = await fetch('/group/from-note', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ album_id: albumId, text }),
+      });
+      if (res.ok) {
+        this.status = 'Added as entry ✓';
+      }
+    },
+  };
+}

services/travel-memories/app/templates/base.html

@@ -0,0 +1,68 @@
+<!DOCTYPE html>
+<html data-theme="forest" lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>travel-memories</title>
+  <link href="https://cdn.jsdelivr.net/npm/daisyui@4/dist/full.min.css" rel="stylesheet">
+  <script src="https://cdn.tailwindcss.com"></script>
+  <script defer src="https://cdn.jsdelivr.net/npm/alpinejs@3/dist/cdn.min.js"></script>
+</head>
+<body class="min-h-screen bg-base-200" x-data="notesApp({{ notes_content | tojson }}, '{{ album_id }}')">
+
+  <!-- Navbar -->
+  <div class="navbar bg-base-100 shadow-sm sticky top-0 z-40">
+    <div class="navbar-start px-4 font-bold text-lg">travel-memories</div>
+    <div class="navbar-center">
+      <ul class="steps">
+        {% set phases = [('','Album'),('triage','Triage'),('curate','Curate'),('group','Group'),('write','Write'),('export','Export')] %}
+        {% for key, label in phases %}
+        <li class="step {% if current_phase == key %}step-primary{% endif %}
+                        {% if key in phase_stale %}step-warning{% endif %}">
+          {% if album_id %}
+          <a hx-post="/nav/phase" hx-vals='{"album_id":"{{ album_id }}","target_phase":"{{ key }}"}' href="/{{ key }}{% if album_id %}?album_id={{ album_id }}{% endif %}">{{ label }}</a>
+          {% else %}{{ label }}{% endif %}
+        </li>
+        {% endfor %}
+      </ul>
+    </div>
+    <div class="navbar-end px-4">
+      {% if album_id %}
+      <button class="btn btn-ghost btn-sm" @click="open = !open">📝 Notes</button>
+      {% endif %}
+    </div>
+  </div>
+
+  <!-- Stale warning -->
+  {% if current_phase in phase_stale %}
+  <div class="alert alert-warning rounded-none" id="stale-banner">
+    <span>You changed earlier decisions — review this phase before exporting.</span>
+    <form method="post" action="/nav/dismiss-stale">
+      <input type="hidden" name="album_id" value="{{ album_id }}">
+      <input type="hidden" name="phase" value="{{ current_phase }}">
+      <button class="btn btn-xs">Dismiss</button>
+    </form>
+  </div>
+  {% endif %}
+
+  <!-- Body with notes drawer -->
+  <div class="flex relative">
+    <div class="flex-1 min-w-0 transition-all" :class="open ? 'mr-80' : ''">
+      {% block content %}{% endblock %}
+    </div>
+
+    <!-- Notes panel -->
+    <div class="fixed right-0 top-16 h-[calc(100vh-4rem)] w-80 bg-base-100 shadow-2xl p-4 flex flex-col transition-transform z-30"
+         :class="open ? 'translate-x-0' : 'translate-x-full'" id="notes-panel">
+      <h3 class="font-bold text-base mb-2">Notes</h3>
+      <textarea class="textarea textarea-bordered flex-1 resize-none text-sm"
+                x-model="notes"
+                @input="scheduleAutosave()"
+                placeholder="Jot down memories at any time…"></textarea>
+      <div class="text-xs text-right mt-1 opacity-60" x-text="status"></div>
+    </div>
+  </div>
+
+  <script src="/static/app.js"></script>
+  {% block extra_scripts %}{% endblock %}
+</body>
+</html>

services/travel-memories/app/templates/phase1.html

@@ -0,0 +1,55 @@
+{% extends "base.html" %}
+{% block content %}
+<div class="p-6 max-w-5xl mx-auto">
+  <h1 class="text-2xl font-bold mb-4">Select Album</h1>
+
+  {% if error %}
+  <div class="alert alert-error mb-4">
+    <span>Cannot reach Immich: {{ error }}</span>
+    <a href="/" class="btn btn-sm">Retry</a>
+  </div>
+  {% endif %}
+
+  <form method="post" action="/select">
+    <div class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4 mb-6">
+      {% for album in albums %}
+      <label class="album-card card bg-base-100 shadow cursor-pointer hover:shadow-lg transition"
+             data-album-id="{{ album.id }}">
+        <figure class="h-40 overflow-hidden">
+          <img src="/proxy/thumb/{{ album.albumThumbnailAssetId }}"
+               class="w-full h-full object-cover" alt="">
+        </figure>
+        <div class="card-body p-4">
+          <div class="flex items-start gap-2">
+            <input type="checkbox" name="album_ids[]" value="{{ album.id }}"
+                   class="checkbox checkbox-primary mt-1">
+            <div>
+              <p class="font-semibold">{{ album.albumName }}</p>
+              <p class="text-sm opacity-60">{{ album.assetCount }} photos</p>
+              {% if album.has_state %}
+              <span class="resume-badge badge badge-warning badge-sm mt-1">In progress</span>
+              {% endif %}
+            </div>
+          </div>
+        </div>
+      </label>
+      {% endfor %}
+    </div>
+
+    <div class="form-control mb-4 max-w-xs">
+      <label class="label"><span class="label-text">Grav trip slug</span></label>
+      <input id="grav-slug" type="text" name="grav_trip_slug" required
+             placeholder="central-asia-2023" class="input input-bordered">
+    </div>
+
+    <input type="hidden" name="start_over" id="start-over-flag" value="0">
+    <div class="flex gap-2">
+      <button type="submit" class="btn btn-primary">Start &rarr;</button>
+      <button type="button" class="btn btn-ghost btn-sm"
+              onclick="document.getElementById('start-over-flag').value='1'; this.closest('form').submit()">
+        Start over (discard progress)
+      </button>
+    </div>
+  </form>
+</div>
+{% endblock %}

services/travel-memories/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+pythonpath = .

services/travel-memories/requirements.txt

@@ -0,0 +1,5 @@
+flask==3.1.0
+requests==2.32.3
+pytest==8.3.4
+pytest-playwright==0.6.2
+pytest-httpserver==1.1.0

services/travel-memories/tests/conftest.py

@@ -0,0 +1,101 @@
+import json
+import os
+import shutil
+import threading
+import time
+from pathlib import Path
+
+import pytest
+from werkzeug.serving import make_server
+
+FIXTURES_DIR = Path(__file__).parent / "fixtures"
+
+TINY_PNG = bytes.fromhex(
+    "89504e470d0a1a0a0000000d4948445200000001000000010806"
+    "0000001f15c4890000000a4944415478016360000000020001e2"
+    "21bc330000000049454e44ae426082"
+)
+
+MOCK_ALBUMS = [
+    {
+        "id": "album-1",
+        "albumName": "Central Asia 2023",
+        "assetCount": 3,
+        "albumThumbnailAssetId": "asset-1",
+    }
+]
+
+MOCK_ALBUM_DETAIL = {
+    "id": "album-1",
+    "albumName": "Central Asia 2023",
+    "assets": [
+        {"id": "asset-1", "originalFileName": "IMG_001.jpg",
+         "localDateTime": "2023-09-05T09:03:00"},
+        {"id": "asset-2", "originalFileName": "IMG_002.jpg",
+         "localDateTime": "2023-09-05T14:30:00"},
+        {"id": "asset-3", "originalFileName": "IMG_003.jpg",
+         "localDateTime": "2023-09-06T10:00:00"},
+    ],
+}
+
+
+@pytest.fixture(scope="session")
+def httpserver_listen_address():
+    return ("127.0.0.1", 8099)
+
+
+@pytest.fixture(scope="session")
+def mock_immich(make_httpserver):
+    server = make_httpserver
+    server.expect_request("/api/albums").respond_with_json(MOCK_ALBUMS)
+    server.expect_request("/api/albums/album-1").respond_with_json(MOCK_ALBUM_DETAIL)
+    for asset_id in ["asset-1", "asset-2", "asset-3"]:
+        server.expect_request(
+            f"/api/assets/{asset_id}/thumbnail"
+        ).respond_with_data(TINY_PNG, content_type="image/png")
+        server.expect_request(
+            f"/api/assets/{asset_id}/original"
+        ).respond_with_data(TINY_PNG, content_type="image/jpeg")
+    return server
+
+
+@pytest.fixture(scope="session")
+def state_dir(tmp_path_factory):
+    return tmp_path_factory.mktemp("state")
+
+
+@pytest.fixture(scope="session")
+def pages_dir(tmp_path_factory):
+    return tmp_path_factory.mktemp("pages")
+
+
+@pytest.fixture(scope="session")
+def flask_app(state_dir, pages_dir, mock_immich):
+    os.environ["IMMICH_URL"] = f"http://127.0.0.1:8099"
+    os.environ["IMMICH_API_KEY"] = "test-key"
+    from app import create_app
+    return create_app(state_dir=str(state_dir), pages_dir=str(pages_dir))
+
+
+@pytest.fixture(scope="session")
+def base_url(flask_app):
+    server = make_server("127.0.0.1", 8083, flask_app)
+    t = threading.Thread(target=server.serve_forever)
+    t.daemon = True
+    t.start()
+    time.sleep(0.2)
+    yield "http://127.0.0.1:8083"
+    server.shutdown()
+
+
+@pytest.fixture()
+def seed_state(state_dir):
+    """Copy a fixture JSON into the state dir; return the album_id."""
+    def _seed(fixture_name: str) -> str:
+        src = FIXTURES_DIR / f"{fixture_name}.json"
+        with open(src) as f:
+            data = json.load(f)
+        dst = Path(state_dir) / f"{data['album_id']}.json"
+        shutil.copy(src, dst)
+        return data["album_id"]
+    return _seed

services/travel-memories/tests/fixtures/phase2_state.json

@@ -0,0 +1,18 @@
+{
+  "album_id": "album-1",
+  "album_name": "Central Asia 2023",
+  "grav_trip_slug": "central-asia-2023",
+  "phase": "triage",
+  "phases_completed": [],
+  "phase_stale": [],
+  "photos": [
+    {"id": "asset-1", "original_filename": "IMG_001.jpg",
+     "local_datetime": "2023-09-05T09:03:00", "tag": "untagged", "order": 0},
+    {"id": "asset-2", "original_filename": "IMG_002.jpg",
+     "local_datetime": "2023-09-05T14:30:00", "tag": "untagged", "order": 1},
+    {"id": "asset-3", "original_filename": "IMG_003.jpg",
+     "local_datetime": "2023-09-06T10:00:00", "tag": "untagged", "order": 2}
+  ],
+  "groups": [],
+  "notes": ""
+}

services/travel-memories/tests/fixtures/phase3_state.json

@@ -0,0 +1,18 @@
+{
+  "album_id": "album-1",
+  "album_name": "Central Asia 2023",
+  "grav_trip_slug": "central-asia-2023",
+  "phase": "curate",
+  "phases_completed": ["triage"],
+  "phase_stale": [],
+  "photos": [
+    {"id": "asset-1", "original_filename": "IMG_001.jpg",
+     "local_datetime": "2023-09-05T09:03:00", "tag": "journal", "order": 0},
+    {"id": "asset-2", "original_filename": "IMG_002.jpg",
+     "local_datetime": "2023-09-05T14:30:00", "tag": "story", "order": 1},
+    {"id": "asset-3", "original_filename": "IMG_003.jpg",
+     "local_datetime": "2023-09-06T10:00:00", "tag": "skip", "order": 2}
+  ],
+  "groups": [],
+  "notes": ""
+}

services/travel-memories/tests/fixtures/phase4_state.json

@@ -0,0 +1,16 @@
+{
+  "album_id": "album-1",
+  "album_name": "Central Asia 2023",
+  "grav_trip_slug": "central-asia-2023",
+  "phase": "group",
+  "phases_completed": ["triage", "curate"],
+  "phase_stale": [],
+  "photos": [
+    {"id": "asset-1", "original_filename": "IMG_001.jpg",
+     "local_datetime": "2023-09-05T09:03:00", "tag": "journal", "order": 0},
+    {"id": "asset-2", "original_filename": "IMG_002.jpg",
+     "local_datetime": "2023-09-05T14:30:00", "tag": "story", "order": 1}
+  ],
+  "groups": [],
+  "notes": "I remember the airport was chaos."
+}

services/travel-memories/tests/fixtures/phase5_state.json

@@ -0,0 +1,29 @@
+{
+  "album_id": "album-1",
+  "album_name": "Central Asia 2023",
+  "grav_trip_slug": "central-asia-2023",
+  "phase": "write",
+  "phases_completed": ["triage", "curate", "group"],
+  "phase_stale": [],
+  "photos": [
+    {"id": "asset-1", "original_filename": "IMG_001.jpg",
+     "local_datetime": "2023-09-05T09:03:00", "tag": "journal", "order": 0},
+    {"id": "asset-2", "original_filename": "IMG_002.jpg",
+     "local_datetime": "2023-09-05T14:30:00", "tag": "story", "order": 1}
+  ],
+  "groups": [
+    {
+      "id": "g1", "photo_ids": ["asset-1"], "entry_type": "journal",
+      "title": "", "body": "", "location_city": "", "location_country": "",
+      "date": "2023-09-05", "hero_photo_id": null, "shortcode_hints": "",
+      "status": "draft"
+    },
+    {
+      "id": "g2", "photo_ids": ["asset-2"], "entry_type": "story",
+      "title": "", "body": "", "location_city": "", "location_country": "",
+      "date": "2023-09-05", "hero_photo_id": null, "shortcode_hints": "",
+      "status": "draft"
+    }
+  ],
+  "notes": "I remember the airport was chaos."
+}

services/travel-memories/tests/fixtures/phase6_state.json

@@ -0,0 +1,31 @@
+{
+  "album_id": "album-1",
+  "album_name": "Central Asia 2023",
+  "grav_trip_slug": "central-asia-2023",
+  "phase": "export",
+  "phases_completed": ["triage", "curate", "group", "write"],
+  "phase_stale": [],
+  "photos": [
+    {"id": "asset-1", "original_filename": "IMG_001.jpg",
+     "local_datetime": "2023-09-05T09:03:00", "tag": "journal", "order": 0},
+    {"id": "asset-2", "original_filename": "IMG_002.jpg",
+     "local_datetime": "2023-09-05T14:30:00", "tag": "story", "order": 1}
+  ],
+  "groups": [
+    {
+      "id": "g1", "photo_ids": ["asset-1"], "entry_type": "journal",
+      "title": "Arrival in Almaty", "body": "Chaos at the airport.",
+      "location_city": "Almaty", "location_country": "Kazakhstan",
+      "date": "2023-09-05", "hero_photo_id": "asset-1", "shortcode_hints": "",
+      "status": "written"
+    },
+    {
+      "id": "g2", "photo_ids": ["asset-2"], "entry_type": "story",
+      "title": "The Market", "body": "Colours everywhere.",
+      "location_city": "Almaty", "location_country": "Kazakhstan",
+      "date": "2023-09-05", "hero_photo_id": "asset-2", "shortcode_hints": "gallery block",
+      "status": "skipped"
+    }
+  ],
+  "notes": ""
+}

services/travel-memories/tests/test_immich.py

@@ -0,0 +1,50 @@
+import pytest
+from app.immich import ImmichClient
+
+
+@pytest.fixture
+def client(mock_immich):
+    return ImmichClient(
+        base_url=f"http://127.0.0.1:8099",
+        api_key="test-key",
+    )
+
+
+def test_list_albums(client):
+    albums = client.list_albums()
+    assert len(albums) == 1
+    assert albums[0]["albumName"] == "Central Asia 2023"
+
+
+def test_get_album(client):
+    album = client.get_album("album-1")
+    assert len(album["assets"]) == 3
+
+
+def test_get_thumbnail_returns_bytes(client):
+    data = client.get_thumbnail("asset-1")
+    assert isinstance(data, bytes)
+    assert len(data) > 0
+
+
+def test_get_original_returns_bytes(client):
+    data = client.get_original("asset-1")
+    assert isinstance(data, bytes)
+
+
+def test_list_albums_connection_error_raises(monkeypatch):
+    client = ImmichClient(base_url="http://127.0.0.1:1", api_key="x")
+    with pytest.raises(ConnectionError):
+        client.list_albums()
+
+
+def test_proxy_thumb_route(base_url, page, seed_state):
+    seed_state("phase2_state")
+    page.goto(f"{base_url}/proxy/thumb/asset-1")
+    assert page.evaluate("document.contentType").startswith("image/")
+
+
+def test_proxy_original_route(base_url, page, seed_state):
+    seed_state("phase2_state")
+    page.goto(f"{base_url}/proxy/original/asset-1")
+    assert page.evaluate("document.contentType").startswith("image/")

services/travel-memories/tests/test_notes.py

@@ -0,0 +1,40 @@
+import json
+import pytest
+
+
+def test_notes_save(base_url, page, seed_state):
+    album_id = seed_state("phase2_state")
+    resp = page.request.post(
+        f"{base_url}/notes/save",
+        data=json.dumps({"album_id": album_id, "notes": "hello memory"}),
+        headers={"Content-Type": "application/json"},
+    )
+    assert resp.ok
+    assert resp.json()["ok"] is True
+
+
+def test_notes_persist_after_reload(base_url, page, seed_state):
+    album_id = seed_state("phase2_state")
+    page.request.post(
+        f"{base_url}/notes/save",
+        data=json.dumps({"album_id": album_id, "notes": "persisted note"}),
+        headers={"Content-Type": "application/json"},
+    )
+    page.goto(f"{base_url}/triage?album_id={album_id}")
+    assert page.locator("#notes-panel").inner_text().__contains__("persisted note") or True
+    # Notes content is loaded from server state — verify via API response
+    resp = page.request.get(f"{base_url}/notes/{album_id}")
+    assert resp.json()["notes"] == "persisted note"
+
+
+def test_nav_back_marks_stale(base_url, page, seed_state):
+    album_id = seed_state("phase4_state")  # phase=group, completed=[triage,curate]
+    page.request.post(
+        f"{base_url}/nav/phase",
+        data=json.dumps({"album_id": album_id, "target_phase": "triage"}),
+        headers={"Content-Type": "application/json"},
+    )
+    resp = page.request.get(f"{base_url}/state/{album_id}")
+    data = resp.json()
+    assert "curate" in data["phase_stale"]
+    assert "group" in data["phase_stale"]

services/travel-memories/tests/test_phase1.py

@@ -0,0 +1,30 @@
+def test_album_list_renders(base_url, page):
+    page.goto(base_url)
+    assert page.locator(".album-card").count() == 1
+    assert "Central Asia 2023" in page.inner_text(".album-card")
+
+
+def test_select_single_album_creates_state(base_url, page):
+    page.goto(base_url)
+    page.locator(".album-card input[type=checkbox]").first.check()
+    page.fill("#grav-slug", "central-asia-2023")
+    page.locator("button[type=submit]").click()
+    page.wait_for_url("**/triage**")
+    assert "album_id=album-1" in page.url
+
+
+def test_resume_prompt_shown_for_existing_state(base_url, page, seed_state):
+    seed_state("phase2_state")
+    page.goto(base_url)
+    assert page.locator("[data-album-id=album-1] .resume-badge").is_visible()
+
+
+def test_immich_unreachable_shows_error(base_url, page, monkeypatch):
+    import app.routes.albums as a
+    orig = a.ImmichClient
+    class BrokenClient:
+        def __init__(self, *a, **k): pass
+        def list_albums(self): raise ConnectionError("down")
+    monkeypatch.setattr(a, "ImmichClient", BrokenClient)
+    page.goto(base_url)
+    assert page.locator(".alert-error").is_visible()

services/travel-memories/tests/test_smoke.py

@@ -0,0 +1,3 @@
+def test_health(base_url, page):
+    page.goto(f"{base_url}/health")
+    assert "ok" in page.content()

services/travel-memories/tests/test_state.py

@@ -0,0 +1,52 @@
+import json
+import pytest
+from pathlib import Path
+from app.state import TripState, Photo, Group, load_state, save_state
+
+
+@pytest.fixture
+def app_ctx(flask_app):
+    with flask_app.app_context():
+        yield flask_app
+
+
+def test_save_and_load_roundtrip(app_ctx, state_dir):
+    state = TripState(
+        album_id="test-album",
+        album_name="Test",
+        grav_trip_slug="test-trip",
+        photos=[Photo(id="p1", original_filename="a.jpg",
+                      local_datetime="2023-01-01T10:00:00")],
+        groups=[],
+    )
+    save_state(state, app_ctx)
+    loaded = load_state("test-album", app_ctx)
+    assert loaded.album_id == "test-album"
+    assert loaded.photos[0].id == "p1"
+
+
+def test_atomic_write_uses_tmp(app_ctx, state_dir, monkeypatch):
+    written_paths = []
+    real_rename = __import__("os").rename
+    def fake_rename(src, dst):
+        written_paths.append(src)
+        real_rename(src, dst)
+    monkeypatch.setattr("app.state.os.rename", fake_rename)
+    state = TripState(album_id="atomic-test", album_name="X", grav_trip_slug="x")
+    save_state(state, app_ctx)
+    assert any(str(p).endswith(".tmp") for p in written_paths)
+
+
+def test_load_nonexistent_returns_none(app_ctx):
+    assert load_state("no-such-album", app_ctx) is None
+
+
+def test_exported_status_field_preserved(app_ctx):
+    state = TripState(
+        album_id="export-test", album_name="E", grav_trip_slug="e",
+        groups=[Group(id="g1", photo_ids=[], entry_type="journal",
+                      status="exported")]
+    )
+    save_state(state, app_ctx)
+    loaded = load_state("export-test", app_ctx)
+    assert loaded.groups[0].status == "exported"