Add ChatPlan paste/export loop with check-off and FSE annotations.

app/chat_plan.py

@@ -0,0 +1,353 @@
+"""Map ChatPlan JSON ↔ DayPlanPut / BlockFeedback for external AI chat loop."""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+from uuid import uuid4
+
+from app.schedule_math import minutes_between, overlaps, validate_blocks
+from app.schedule_store import (
+    BlockFeedback,
+    DayPlan,
+    DayPlanPut,
+    DayReview,
+    ScheduledBlock,
+)
+
+KIND_SET = {
+    "earn_ship",
+    "admin_spain",
+    "body_care",
+    "move_out",
+    "boundary",
+    "food_out",
+    "stabilize",
+    "explore",
+    "restore_fun",
+    "sleep_window",
+    "other",
+}
+INTENT_SET = {"duty", "explore", "restore_fun", "measure"}
+PRIORITY_SET = {"P0", "P1", "P2"}
+STATUS_SET = {"planned", "done", "partial", "skipped", "moved", "cancelled"}
+DID_SET = {"done", "partial", "skipped"}
+
+
+class ChatPlanError(Exception):
+    """Validation failure with structured messages."""
+
+    def __init__(self, errors: list[str]) -> None:
+        self.errors = errors
+        Exception.__init__(self, "; ".join(errors))
+
+
+def _as_list(value: Any) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return [str(x).strip() for x in value if str(x).strip()]
+    text = str(value).strip()
+    return [text] if text else []
+
+
+def _coerce_kind(raw: Any, notes: str) -> tuple[str, str]:
+    kind = str(raw or "other").strip() or "other"
+    if kind in KIND_SET:
+        return kind, notes
+    prefix = f"[kind:{kind}]"
+    merged = f"{prefix} {notes}".strip() if notes else prefix
+    return "other", merged
+
+
+def _status_from_review(status: str, review: dict[str, Any] | None) -> str:
+    if not review:
+        return status if status in STATUS_SET else "planned"
+    did = review.get("did")
+    if did in DID_SET and status in ("planned", "", None):
+        return str(did)
+    return status if status in STATUS_SET else "planned"
+
+
+def is_legacy_day_plan_put(payload: dict[str, Any]) -> bool:
+    """True when body looks like DayPlanPut (agent format), not ChatPlan."""
+
+    blocks = payload.get("blocks")
+    if not isinstance(blocks, list) or not blocks:
+        return False
+    first = blocks[0] if isinstance(blocks[0], dict) else {}
+    has_planned = "planned_min" in first
+    chatty = (
+        "intention" in payload
+        or "day_review" in payload
+        or "schema_version" in payload
+        or any(isinstance(b, dict) and "review" in b for b in blocks)
+    )
+    return has_planned and not chatty
+
+
+def unwrap_import_payload(body: dict[str, Any]) -> tuple[dict[str, Any], Literal["replace", "merge"]]:
+    mode_raw = str(body.get("mode") or "replace").lower()
+    mode: Literal["replace", "merge"] = "merge" if mode_raw == "merge" else "replace"
+    if isinstance(body.get("plan"), dict) and "blocks" in body["plan"]:
+        return body["plan"], mode
+    if "blocks" in body:
+        chat = {k: v for k, v in body.items() if k != "mode"}
+        return chat, mode
+    raise ChatPlanError(["Expected ChatPlan with blocks (or {plan, mode})"])
+
+
+def chat_plan_to_day_put(
+    chat: dict[str, Any],
+    day: str,
+    *,
+    max_blocks: int = 7,
+    previous_blocks: list[dict[str, Any]] | None = None,
+    mode: Literal["replace", "merge"] = "replace",
+) -> tuple[DayPlanPut, list[BlockFeedback], list[str]]:
+    """Map ChatPlan → DayPlanPut + optional feedback rows + warnings."""
+
+    errors: list[str] = []
+    warnings: list[str] = []
+
+    if chat.get("date") and str(chat["date"]) != day:
+        errors.append(f"date mismatch: JSON {chat['date']} vs URL {day}")
+
+    blocks_in = chat.get("blocks")
+    if not isinstance(blocks_in, list) or len(blocks_in) == 0:
+        errors.append("blocks must be a non-empty array")
+        raise ChatPlanError(errors)
+
+    if is_legacy_day_plan_put(chat):
+        put = DayPlanPut.model_validate({**chat, "source": chat.get("source") or "cursor"})
+        for block in put.blocks:
+            block.date = day
+        return put, [], warnings
+
+    mapped: list[ScheduledBlock] = []
+    feedbacks: list[BlockFeedback] = []
+
+    for raw in blocks_in:
+        if not isinstance(raw, dict):
+            errors.append("each block must be an object")
+            continue
+        start = str(raw.get("start") or "").strip()
+        end = str(raw.get("end") or "").strip()
+        title = str(raw.get("title") or "").strip() or "Untitled"
+        notes = str(raw.get("notes") or "")
+        kind, notes = _coerce_kind(raw.get("kind"), notes)
+        if str(raw.get("kind") or "") and str(raw.get("kind")) not in KIND_SET:
+            warnings.append(f"unknown kind coerced to other: {raw.get('kind')}")
+        intent = str(raw.get("intent") or "duty")
+        if intent not in INTENT_SET:
+            intent = "duty"
+        priority = str(raw.get("priority") or "P1")
+        if priority not in PRIORITY_SET:
+            priority = "P1"
+        review = raw.get("review") if isinstance(raw.get("review"), dict) else None
+        status = _status_from_review(str(raw.get("status") or "planned"), review)
+        try:
+            planned = int(raw.get("planned_min") or 0)
+            if planned <= 0:
+                planned = max(1, minutes_between(start, end))
+        except Exception:  # noqa: BLE001
+            errors.append(f"invalid times for block {title}")
+            continue
+        block_id = str(raw.get("id") or "").strip() or str(uuid4())
+        locked = bool(raw.get("locked")) if raw.get("locked") is not None else priority == "P0"
+        block = ScheduledBlock(
+            id=block_id,
+            date=day,
+            start=start,
+            end=end,
+            title=title[:200],
+            kind=kind,  # type: ignore[arg-type]
+            intent=intent,  # type: ignore[arg-type]
+            priority=priority,  # type: ignore[arg-type]
+            planned_min=planned,
+            status=status,  # type: ignore[arg-type]
+            source="chat",
+            locked=locked,
+            notes=notes,
+        )
+        mapped.append(block)
+        if review and review.get("did") in DID_SET:
+            minutes = review.get("minutes")
+            intensity = review.get("intensity")
+            try:
+                intensity_i = int(intensity) if intensity is not None else None
+            except (TypeError, ValueError):
+                intensity_i = None
+            try:
+                actual = int(minutes) if minutes is not None else None
+            except (TypeError, ValueError):
+                actual = None
+            skip = review.get("skip_reason")
+            feedbacks.append(
+                BlockFeedback(
+                    block_id=block_id,
+                    date=day,
+                    did=str(review["did"]),  # type: ignore[arg-type]
+                    actual_min=actual,
+                    quality=review.get("quality"),
+                    fun=review.get("fun"),
+                    energy_after=review.get("energy_after"),
+                    note=str(review.get("comment") or ""),
+                    emotions=_as_list(review.get("emotions")),
+                    fse_event=str(review.get("fse_event") or ""),
+                    intensity=intensity_i,
+                    skip_reason=skip if skip in {
+                        "time", "fear", "fse", "locks", "boring", "urge", "other"
+                    } else None,
+                )
+            )
+
+    if mode == "merge" and previous_blocks:
+        kept = list(previous_blocks)
+        for block in mapped:
+            conflict = False
+            for prev in kept:
+                if overlaps(
+                    block.start,
+                    block.end,
+                    str(prev.get("start")),
+                    str(prev.get("end")),
+                ):
+                    errors.append(
+                        f"overlap merge conflict: {block.title} vs {prev.get('title')}"
+                    )
+                    conflict = True
+                    break
+            if not conflict:
+                kept.append(block.model_dump())
+        # Rebuild mapped from kept
+        mapped = [ScheduledBlock.model_validate({**b, "date": day}) for b in kept]
+
+    val_errors, soft = validate_blocks(
+        [b.model_dump() for b in mapped],
+        max_blocks=max_blocks,
+        previous_p0=None,
+        allow_p0_move=True,
+        must_include_explore_or_restore=False,
+        capacity_hint=None,
+    )
+    errors.extend(val_errors)
+    warnings.extend(soft)
+    if errors:
+        raise ChatPlanError(errors)
+
+    review_raw = chat.get("day_review") if isinstance(chat.get("day_review"), dict) else {}
+    day_review = DayReview(
+        comment=str(review_raw.get("comment") or ""),
+        emotions=_as_list(review_raw.get("emotions")),
+        fse_events=str(review_raw.get("fse_events") or ""),
+        what_moved=str(review_raw.get("what_moved") or ""),
+        what_avoided=str(review_raw.get("what_avoided") or ""),
+        tomorrow_change=str(review_raw.get("tomorrow_change") or ""),
+    )
+    put = DayPlanPut(
+        blocks=mapped,
+        source="chat",
+        notes=str(chat.get("notes") or ""),
+        title=str(chat.get("title") or ""),
+        intention=str(chat.get("intention") or ""),
+        constraints=_as_list(chat.get("constraints")),
+        day_review=day_review,
+        force_p0_move=True,
+    )
+    return put, feedbacks, warnings
+
+
+def plan_and_feedback_to_chat_plan(
+    plan: DayPlan | dict[str, Any],
+    feedbacks_by_block_id: dict[str, dict[str, Any]],
+) -> dict[str, Any]:
+    """Build ChatPlan for export (includes summary)."""
+
+    if isinstance(plan, DayPlan):
+        pdata = plan.model_dump(mode="json")
+    else:
+        pdata = plan
+
+    blocks_out: list[dict[str, Any]] = []
+    blocks_done = 0
+    blocks_skipped = 0
+    p0_done = 0
+    p0_total = 0
+    planned_sum = 0
+    actual_sum = 0
+
+    for block in pdata.get("blocks") or []:
+        bid = str(block.get("id") or "")
+        fb = feedbacks_by_block_id.get(bid) or block.get("feedback") or {}
+        status = str(block.get("status") or "planned")
+        did = fb.get("did") if fb.get("did") in DID_SET else (
+            status if status in DID_SET else None
+        )
+        if status == "done" or did == "done":
+            blocks_done += 1
+        if status == "skipped" or did == "skipped":
+            blocks_skipped += 1
+        if block.get("priority") == "P0":
+            p0_total += 1
+            if status == "done" or did == "done":
+                p0_done += 1
+        planned_sum += int(block.get("planned_min") or 0)
+        if fb.get("actual_min") is not None:
+            actual_sum += int(fb.get("actual_min") or 0)
+
+        blocks_out.append(
+            {
+                "id": bid,
+                "start": block.get("start"),
+                "end": block.get("end"),
+                "title": block.get("title"),
+                "priority": block.get("priority"),
+                "kind": block.get("kind"),
+                "intent": block.get("intent"),
+                "notes": block.get("notes") or "",
+                "locked": bool(block.get("locked")),
+                "status": status if status in STATUS_SET else "planned",
+                "review": {
+                    "did": did,
+                    "minutes": fb.get("actual_min"),
+                    "quality": fb.get("quality"),
+                    "fun": fb.get("fun"),
+                    "energy_after": fb.get("energy_after"),
+                    "comment": fb.get("note") or "",
+                    "emotions": list(fb.get("emotions") or []),
+                    "fse_event": fb.get("fse_event") or "",
+                    "intensity": fb.get("intensity"),
+                    "skip_reason": fb.get("skip_reason"),
+                },
+            }
+        )
+
+    day_review = pdata.get("day_review") or {}
+    if hasattr(day_review, "model_dump"):
+        day_review = day_review.model_dump()
+
+    return {
+        "schema_version": 1,
+        "date": pdata.get("date"),
+        "title": pdata.get("title") or "",
+        "intention": pdata.get("intention") or "",
+        "constraints": list(pdata.get("constraints") or []),
+        "blocks": blocks_out,
+        "day_review": {
+            "comment": day_review.get("comment") or "",
+            "emotions": list(day_review.get("emotions") or []),
+            "fse_events": day_review.get("fse_events") or "",
+            "what_moved": day_review.get("what_moved") or "",
+            "what_avoided": day_review.get("what_avoided") or "",
+            "tomorrow_change": day_review.get("tomorrow_change") or "",
+        },
+        "summary": {
+            "blocks_total": len(blocks_out),
+            "blocks_done": blocks_done,
+            "blocks_skipped": blocks_skipped,
+            "p0_done": p0_done,
+            "p0_total": p0_total,
+            "planned_min_sum": planned_sum,
+            "actual_min_sum": actual_sum,
+        },
+    }

app/routers/plan.py

@@ -5,18 +5,33 @@ Session-authenticated; mirrors the app envelope pattern.
 
 from __future__ import annotations
 
+import json
 from datetime import date
 from typing import Any
 
 from fastapi import APIRouter, Depends, Request, status
+from fastapi.responses import Response
 from pydantic import BaseModel
 
+from app.chat_plan import (
+    ChatPlanError,
+    chat_plan_to_day_put,
+    plan_and_feedback_to_chat_plan,
+    unwrap_import_payload,
+)
 from app.deps import require_login
 from app.models import ApiEnvelope, err, ok
 from app.schedule_math import capacity_hint, trigger_operators
 from app.schedule_reschedule import seed_starter_blocks
 from app.schedule_risk import risk_from_stores
-from app.schedule_store import BlockCreate, BlockFeedback, BlockPatch, DayPlanPut
+from app.schedule_store import (
+    BlockCheckBody,
+    BlockCreate,
+    BlockFeedback,
+    BlockPatch,
+    DayPlanPut,
+    PlanMetaPatch,
+)
 
 router = APIRouter(tags=["plan"], dependencies=[Depends(require_login)])
 
@@ -68,6 +83,15 @@ def _enrich_plan(request: Request, day: date) -> dict[str, Any]:
     return data
 
 
+def _feedback_map(store: Any, day: str) -> dict[str, dict[str, Any]]:
+    by_block: dict[str, dict[str, Any]] = {}
+    for row in store.feedback_for_plan(day):
+        bid = str(row.get("block_id") or "")
+        if bid:
+            by_block[bid] = row
+    return by_block
+
+
 @router.get("/api/plan/{day}", response_model=ApiEnvelope)
 def get_plan(request: Request, day: date) -> dict[str, Any]:
     return ok(_enrich_plan(request, day))
@@ -138,6 +162,105 @@ def post_feedback(
         return err("not_found", "Block not found", status.HTTP_404_NOT_FOUND)
 
 
+@router.post("/api/plan/{day}/blocks/{block_id}/check", response_model=ApiEnvelope)
+def check_block(
+    request: Request,
+    day: date,
+    block_id: str,
+    body: BlockCheckBody,
+) -> object:
+    """Fast checkbox — status only, no full feedback required."""
+
+    try:
+        _store(request).patch_block(
+            day.isoformat(),
+            block_id,
+            BlockPatch(status=body.status),
+        )
+        if body.status == "skipped" and body.skip_reason:
+            try:
+                _store(request).submit_feedback(
+                    day.isoformat(),
+                    BlockFeedback(
+                        block_id=block_id,
+                        date=day.isoformat(),
+                        did="skipped",
+                        skip_reason=body.skip_reason,
+                    ),
+                )
+            except KeyError:
+                pass
+        return ok(_enrich_plan(request, day))
+    except KeyError:
+        return err("not_found", "Block not found", status.HTTP_404_NOT_FOUND)
+    except ValueError as exc:
+        return err("validation_error", str(exc), status.HTTP_422_UNPROCESSABLE_ENTITY)
+
+
+@router.patch("/api/plan/{day}/meta", response_model=ApiEnvelope)
+def patch_plan_meta(request: Request, day: date, body: PlanMetaPatch) -> object:
+    try:
+        _store(request).patch_meta(day.isoformat(), body)
+        return ok(_enrich_plan(request, day))
+    except ValueError as exc:
+        return err("validation_error", str(exc), status.HTTP_422_UNPROCESSABLE_ENTITY)
+
+
+@router.post("/api/plan/{day}/import", response_model=ApiEnvelope)
+def import_chat_plan(request: Request, day: date, body: dict[str, Any]) -> object:
+    store = _store(request)
+    day_s = day.isoformat()
+    try:
+        chat, mode = unwrap_import_payload(body)
+        current = store.get_plan(day_s)
+        put, feedbacks, warnings = chat_plan_to_day_put(
+            chat,
+            day_s,
+            max_blocks=request.app.state.settings.schedule_max_blocks,
+            previous_blocks=[b.model_dump() for b in current.blocks],
+            mode=mode,
+        )
+        store.save_plan(day_s, put, bump_version=True)
+        for fb in feedbacks:
+            try:
+                store.submit_feedback(day_s, fb)
+            except KeyError:
+                warnings.append(f"feedback skipped for missing block {fb.block_id}")
+        data = _enrich_plan(request, day)
+        data["import_warnings"] = warnings
+        data["import_mode"] = mode
+        return ok(data)
+    except ChatPlanError as exc:
+        return err("validation_error", str(exc), status.HTTP_422_UNPROCESSABLE_ENTITY)
+    except ValueError as exc:
+        return err("validation_error", str(exc), status.HTTP_422_UNPROCESSABLE_ENTITY)
+
+
+@router.get("/api/plan/{day}/export", response_model=ApiEnvelope)
+def export_chat_plan(request: Request, day: date) -> dict[str, Any]:
+    store = _store(request)
+    day_s = day.isoformat()
+    plan = store.get_plan(day_s)
+    chat = plan_and_feedback_to_chat_plan(plan, _feedback_map(store, day_s))
+    return ok(chat)
+
+
+@router.get("/api/plan/{day}/export.txt")
+def export_chat_plan_file(request: Request, day: date) -> Response:
+    store = _store(request)
+    day_s = day.isoformat()
+    plan = store.get_plan(day_s)
+    chat = plan_and_feedback_to_chat_plan(plan, _feedback_map(store, day_s))
+    body = json.dumps(chat, ensure_ascii=False, indent=2) + "\n"
+    return Response(
+        content=body,
+        media_type="application/json",
+        headers={
+            "Content-Disposition": f'attachment; filename="plan-{day_s}.json"'
+        },
+    )
+
+
 @router.post("/api/plan/{day}/seed", response_model=ApiEnvelope)
 def seed_plan(request: Request, day: date) -> object:
     """Fill an empty day from templates under live capacity (P0 locked)."""

app/schedule_store.py

@@ -44,13 +44,26 @@ BlockStatus = Literal["planned", "done", "partial", "skipped", "moved", "cancell
 Did = Literal["done", "partial", "skipped"]
 WouldRepeat = Literal["yes", "no", "maybe"]
 SkipReason = Literal["time", "fear", "fse", "locks", "boring", "urge", "other"]
-PlanSource = Literal["cursor", "openrouter", "user", "rules"]
+PlanSource = Literal["cursor", "openrouter", "user", "rules", "chat"]
 
 
 def utc_now() -> datetime:
     return datetime.now(timezone.utc)
 
 
+class DayReview(BaseModel):
+    """End-of-day review for chat export / import."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    comment: str = ""
+    emotions: list[str] = Field(default_factory=list)
+    fse_events: str = ""
+    what_moved: str = ""
+    what_avoided: str = ""
+    tomorrow_change: str = ""
+
+
 class ScheduledBlock(BaseModel):
     """One timed block on a day plan."""
 
@@ -100,6 +113,9 @@ class BlockFeedback(BaseModel):
     would_repeat: WouldRepeat | None = None
     skip_reason: SkipReason | None = None
     note: str = ""
+    emotions: list[str] = Field(default_factory=list)
+    fse_event: str = ""
+    intensity: int | None = Field(default=None, ge=1, le=10)
     strong: bool = False
     ts: datetime = Field(default_factory=utc_now)
 
@@ -120,6 +136,10 @@ class DayPlan(BaseModel):
     blocks: list[ScheduledBlock] = Field(default_factory=list)
     capacity_hint: float = Field(default=1.0, ge=0.0, le=1.0)
     notes: str = ""
+    title: str = ""
+    intention: str = ""
+    constraints: list[str] = Field(default_factory=list)
+    day_review: DayReview = Field(default_factory=DayReview)
     warnings: list[str] = Field(default_factory=list)
     updated_at: datetime = Field(default_factory=utc_now)
     parent_version: int | None = None
@@ -167,9 +187,33 @@ class DayPlanPut(BaseModel):
     source: PlanSource | str = "user"
     capacity_hint: float | None = Field(default=None, ge=0.0, le=1.0)
     notes: str = ""
+    title: str | None = None
+    intention: str | None = None
+    constraints: list[str] | None = None
+    day_review: DayReview | None = None
     force_p0_move: bool = False
 
 
+class PlanMetaPatch(BaseModel):
+    """Day-level chat meta without touching blocks."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    title: str | None = None
+    intention: str | None = None
+    constraints: list[str] | None = None
+    day_review: DayReview | None = None
+
+
+class BlockCheckBody(BaseModel):
+    """Fast checkbox status without full feedback."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    status: Literal["done", "partial", "skipped", "planned"]
+    skip_reason: SkipReason | None = None
+
+
 class ScheduleStore:
     """Read and mutate schedule plans and priors."""
 
@@ -203,7 +247,12 @@ class ScheduleStore:
             data["date"] = day
             if not data.get("planned_min"):
                 data["planned_min"] = max(1, minutes_between(data["start"], data["end"]))
-            if data.get("priority") == "P0" and put.source in ("openrouter", "rules", "cursor"):
+            if data.get("priority") == "P0" and put.source in (
+                "openrouter",
+                "rules",
+                "cursor",
+                "chat",
+            ):
                 data["locked"] = True if data.get("locked") is None else data["locked"]
             blocks.append(ScheduledBlock.model_validate(data))
 
@@ -224,13 +273,24 @@ class ScheduleStore:
         version = current.version + 1 if bump_version and current.blocks else max(1, current.version)
         if not current.blocks and not bump_version:
             version = 1
+        day_review = (
+            put.day_review
+            if put.day_review is not None
+            else current.day_review
+        )
         plan = DayPlan(
             date=day,
             version=version,
             source=put.source,
             blocks=blocks,
             capacity_hint=put.capacity_hint if put.capacity_hint is not None else current.capacity_hint,
-            notes=put.notes,
+            notes=put.notes if put.notes is not None else current.notes,
+            title=put.title if put.title is not None else current.title,
+            intention=put.intention if put.intention is not None else current.intention,
+            constraints=(
+                put.constraints if put.constraints is not None else current.constraints
+            ),
+            day_review=day_review,
             warnings=warnings,
             updated_at=utc_now(),
             parent_version=current.version if current.blocks else None,
@@ -238,6 +298,49 @@ class ScheduleStore:
         self._write_plan(plan)
         return plan
 
+    def patch_meta(self, day: str, patch: PlanMetaPatch) -> DayPlan:
+        plan = self.get_plan(day)
+        data = plan.model_dump()
+        if patch.title is not None:
+            data["title"] = patch.title
+        if patch.intention is not None:
+            data["intention"] = patch.intention
+        if patch.constraints is not None:
+            data["constraints"] = patch.constraints
+        if patch.day_review is not None:
+            data["day_review"] = patch.day_review.model_dump()
+        data["updated_at"] = utc_now().isoformat()
+        updated = DayPlan.model_validate(data)
+        self._write_plan(updated)
+        return updated
+
+    def put_preserving_meta(
+        self,
+        day: str,
+        blocks: list[ScheduledBlock],
+        *,
+        source: str = "user",
+        force_p0_move: bool = True,
+        bump_version: bool = False,
+        notes: str | None = None,
+    ) -> DayPlan:
+        plan = self.get_plan(day)
+        return self.save_plan(
+            day,
+            DayPlanPut(
+                blocks=blocks,
+                source=source,
+                capacity_hint=plan.capacity_hint,
+                notes=notes if notes is not None else plan.notes,
+                title=plan.title,
+                intention=plan.intention,
+                constraints=plan.constraints,
+                day_review=plan.day_review,
+                force_p0_move=force_p0_move,
+            ),
+            bump_version=bump_version,
+        )
+
     def _write_plan(self, plan: DayPlan) -> None:
         path = self.paths.plan_path(plan.date)
         payload = json.dumps(plan.model_dump(mode="json"), ensure_ascii=False, indent=2)
@@ -263,17 +366,7 @@ class ScheduleStore:
             version_added=plan.version,
         )
         blocks = list(plan.blocks) + [block]
-        return self.save_plan(
-            day,
-            DayPlanPut(
-                blocks=blocks,
-                source="user",
-                capacity_hint=plan.capacity_hint,
-                notes=plan.notes,
-                force_p0_move=True,
-            ),
-            bump_version=False,
-        )
+        return self.put_preserving_meta(day, blocks, bump_version=False)
 
     def patch_block(self, day: str, block_id: str, patch: BlockPatch) -> DayPlan:
         plan = self.get_plan(day)
@@ -293,34 +386,14 @@ class ScheduleStore:
             blocks.append(ScheduledBlock.model_validate(data))
         if not found:
             raise KeyError(block_id)
-        return self.save_plan(
-            day,
-            DayPlanPut(
-                blocks=blocks,
-                source="user",
-                capacity_hint=plan.capacity_hint,
-                notes=plan.notes,
-                force_p0_move=True,
-            ),
-            bump_version=False,
-        )
+        return self.put_preserving_meta(day, blocks, bump_version=False)
 
     def delete_block(self, day: str, block_id: str) -> DayPlan:
         plan = self.get_plan(day)
         blocks = [b for b in plan.blocks if b.id != block_id]
         if len(blocks) == len(plan.blocks):
             raise KeyError(block_id)
-        return self.save_plan(
-            day,
-            DayPlanPut(
-                blocks=blocks,
-                source="user",
-                capacity_hint=plan.capacity_hint,
-                notes=plan.notes,
-                force_p0_move=True,
-            ),
-            bump_version=False,
-        )
+        return self.put_preserving_meta(day, blocks, bump_version=False)
 
     def list_feedback(self, day: str | None = None) -> list[dict[str, Any]]:
         rows = read_jsonl(self.paths.schedule_feedback)

docs/SCHEDULE.md

@@ -132,7 +132,18 @@ TZ / SCHEDULE_TIMEZONE=Africa/Dar_es_Salaam
 |-------|------|
 | `#/plan` | Day timeline 06:00–23:00, now line, colored blocks |
 | Block sheet | Complete with did / minutes / quality / fun (no PERMA Qs) |
-| Home | Next 1–2 blocks + overdue feedback banner |
+| Home | Next 1–2 blocks + overdue feedback banner; empty → Paste plan CTA |
+| Plan | Paste ChatPlan / Export for chat / checklist check-off / day review |
+
+### ChatPlan loop (external AI)
+
+- `POST /api/plan/{day}/import` — ChatPlan JSON (or `{plan, mode}`) → timetable
+- `GET /api/plan/{day}/export` — filled ChatPlan in envelope
+- `GET /api/plan/{day}/export.txt` — downloadable JSON attachment
+- `POST /api/plan/{day}/blocks/{id}/check` — fast status without thick feedback
+- `PATCH /api/plan/{day}/meta` — title / intention / constraints / day_review
+- Feedback additive: `emotions[]`, `fse_event`, `intensity`
+
 
 ## Reschedule
 

frontend/src/api.ts

@@ -408,10 +408,22 @@ export type BlockFeedback = {
   would_repeat: "yes" | "no" | "maybe" | null;
   skip_reason: string | null;
   note: string;
+  emotions?: string[];
+  fse_event?: string;
+  intensity?: number | null;
   strong: boolean;
   ts: string;
 };
 
+export type DayReview = {
+  comment: string;
+  emotions: string[];
+  fse_events: string;
+  what_moved: string;
+  what_avoided: string;
+  tomorrow_change: string;
+};
+
 export type DayPlanView = {
   date: string;
   version: number;
@@ -419,6 +431,11 @@ export type DayPlanView = {
   blocks: ScheduledBlock[];
   capacity_hint: number;
   notes: string;
+  title?: string;
+  intention?: string;
+  constraints?: string[];
+  day_review?: DayReview;
+  warnings?: string[];
   updated_at: string;
   parent_version: number | null;
   health?: {
@@ -428,6 +445,26 @@ export type DayPlanView = {
     p0_done_rate: number;
     explore_or_restore_done: boolean;
   };
+  import_warnings?: string[];
+};
+
+export type ChatPlan = {
+  schema_version: number;
+  date: string;
+  title: string;
+  intention: string;
+  constraints: string[];
+  blocks: Array<Record<string, unknown>>;
+  day_review: DayReview;
+  summary?: {
+    blocks_total: number;
+    blocks_done: number;
+    blocks_skipped: number;
+    p0_done: number;
+    p0_total: number;
+    planned_min_sum: number;
+    actual_min_sum: number;
+  };
 };
 
 export type ScheduleTemplate = {
@@ -530,6 +567,47 @@ export function seedPlan(day: string): Promise<DayPlanView> {
   return api(`/api/plan/${day}/seed`, { method: "POST", body: "{}" });
 }
 
+export function importChatPlan(
+  day: string,
+  plan: unknown,
+  mode: "replace" | "merge" = "replace",
+): Promise<DayPlanView> {
+  return api(`/api/plan/${day}/import`, {
+    method: "POST",
+    body: JSON.stringify({ plan, mode }),
+  });
+}
+
+export function exportChatPlan(day: string): Promise<ChatPlan> {
+  return api(`/api/plan/${day}/export`);
+}
+
+export function checkPlanBlock(
+  day: string,
+  id: string,
+  payload: { status: "done" | "partial" | "skipped" | "planned"; skip_reason?: string },
+): Promise<DayPlanView> {
+  return api(`/api/plan/${day}/blocks/${encodeURIComponent(id)}/check`, {
+    method: "POST",
+    body: JSON.stringify(payload),
+  });
+}
+
+export function patchPlanMeta(
+  day: string,
+  payload: {
+    title?: string;
+    intention?: string;
+    constraints?: string[];
+    day_review?: Partial<DayReview>;
+  },
+): Promise<DayPlanView> {
+  return api(`/api/plan/${day}/meta`, {
+    method: "PATCH",
+    body: JSON.stringify(payload),
+  });
+}
+
 export type LoopSummary = {
   days: number;
   as_of: string;

frontend/src/components/BlockSheet.tsx

@@ -57,6 +57,10 @@ export function BlockSheet({ open, day, block, mode, onClose, onChanged }: Props
   const [skipReason, setSkipReason] = useState("");
   const [note, setNote] = useState("");
   const [money, setMoney] = useState("");
+  const [emotions, setEmotions] = useState<string[]>([]);
+  const [fseEvent, setFseEvent] = useState("");
+  const [intensity, setIntensity] = useState(5);
+  const [showThick, setShowThick] = useState(false);
   const [busy, setBusy] = useState(false);
   const [templates, setTemplates] = useState<ScheduleTemplate[]>([]);
 
@@ -75,15 +79,19 @@ export function BlockSheet({ open, day, block, mode, onClose, onChanged }: Props
         .catch(() => setTemplates([]));
     }
     if (mode === "view" && block) {
-      setActualMin(block.planned_min || 30);
-      setDid("done");
-      setQuality(3);
-      setFun(3);
-      setEnergy(0);
-      setWouldRepeat("");
-      setSkipReason("");
-      setNote("");
-      setMoney("");
+      setActualMin(block.feedback?.actual_min ?? block.planned_min ?? 30);
+      setDid((block.feedback?.did as typeof did) || (block.status === "skipped" ? "skipped" : "done"));
+      setQuality(block.feedback?.quality ?? 3);
+      setFun(block.feedback?.fun ?? 3);
+      setEnergy(block.feedback?.energy_after ?? 0);
+      setWouldRepeat((block.feedback?.would_repeat as typeof wouldRepeat) || "");
+      setSkipReason(block.feedback?.skip_reason || "");
+      setNote(block.feedback?.note || "");
+      setMoney(block.feedback?.money_amount != null ? String(block.feedback.money_amount) : "");
+      setEmotions(block.feedback?.emotions || []);
+      setFseEvent(block.feedback?.fse_event || "");
+      setIntensity(block.feedback?.intensity ?? 5);
+      setShowThick(false);
     }
     if (mode === "create") {
       setTitle("New block");
@@ -117,13 +125,16 @@ export function BlockSheet({ open, day, block, mode, onClose, onChanged }: Props
       await postBlockFeedback(day, block.id, {
         did,
         actual_min: did === "skipped" ? null : actualMin,
-        quality: did === "skipped" ? null : quality,
-        fun: did === "skipped" ? null : fun,
-        energy_after: energy,
+        quality: did === "skipped" || !showThick ? null : quality,
+        fun: did === "skipped" || !showThick ? null : fun,
+        energy_after: showThick ? energy : null,
         money_amount: money ? Number(money) : null,
         would_repeat: wouldRepeat || null,
         skip_reason: did === "skipped" ? skipReason || "other" : null,
         note,
+        emotions,
+        fse_event: fseEvent,
+        intensity: did === "skipped" ? null : intensity,
       });
       toast.show("Saved");
       onChanged();
@@ -270,18 +281,87 @@ export function BlockSheet({ open, day, block, mode, onClose, onChanged }: Props
             ))}
           </div>
           {did !== "skipped" && (
+            <label class="field-label">
+              Actual minutes
+              <input
+                class="field-input"
+                type="number"
+                min={0}
+                max={24 * 60}
+                value={actualMin}
+                onInput={(e) => setActualMin(Number((e.target as HTMLInputElement).value))}
+              />
+            </label>
+          )}
+          <label class="field-label">
+            Comment
+            <textarea
+              class="field-textarea"
+              value={note}
+              onInput={(e) => setNote((e.target as HTMLTextAreaElement).value)}
+              placeholder="What happened?"
+            />
+          </label>
+          <span class="field-label">Emotions</span>
+          <div class="chip-row" role="group">
+            {["calm", "shame", "urge", "anxiety", "anger", "lonely", "tired", "hope"].map((em) => (
+              <Pressable
+                key={em}
+                className="chip"
+                ariaPressed={emotions.includes(em)}
+                onClick={() =>
+                  setEmotions((cur) =>
+                    cur.includes(em) ? cur.filter((x) => x !== em) : [...cur, em],
+                  )
+                }
+              >
+                {em}
+              </Pressable>
+            ))}
+          </div>
+          <label class="field-label">
+            FSE event (short phrase)
+            <input
+              class="field-input"
+              value={fseEvent}
+              onInput={(e) => setFseEvent((e.target as HTMLInputElement).value)}
+              placeholder="What spiked?"
+            />
+          </label>
+          {did !== "skipped" && (
+            <label class="field-label">
+              Intensity · {intensity}
+              <input
+                type="range"
+                min={1}
+                max={10}
+                value={intensity}
+                onInput={(e) => setIntensity(Number((e.target as HTMLInputElement).value))}
+              />
+            </label>
+          )}
+          {did === "skipped" && (
+            <>
+              <span class="field-label">Why skipped?</span>
+              <div class="segment-row">
+                {["time", "fear", "urge", "boring", "fse", "other"].map((v) => (
+                  <Pressable
+                    key={v}
+                    className="segment"
+                    ariaPressed={skipReason === v}
+                    onClick={() => setSkipReason(v)}
+                  >
+                    {v}
+                  </Pressable>
+                ))}
+              </div>
+            </>
+          )}
+          <Pressable className="btn btn-plain" onClick={() => setShowThick((v) => !v)}>
+            {showThick ? "Hide quality / fun / energy" : "More: quality, fun, energy, money"}
+          </Pressable>
+          {showThick && did !== "skipped" && (
             <>
-              <label class="field-label">
-                Actual minutes
-                <input
-                  class="field-input"
-                  type="number"
-                  min={0}
-                  max={24 * 60}
-                  value={actualMin}
-                  onInput={(e) => setActualMin(Number((e.target as HTMLInputElement).value))}
-                />
-              </label>
               <span class="field-label">Quality</span>
               <div class="segment-row">
                 {[1, 2, 3, 4, 5].map((n) => (
@@ -298,75 +378,46 @@ export function BlockSheet({ open, day, block, mode, onClose, onChanged }: Props
                   </Pressable>
                 ))}
               </div>
-            </>
-          )}
-          <span class="field-label">Energy after</span>
-          <div class="segment-row">
-            {([-2, -1, 0, 1, 2] as const).map((v) => (
-              <Pressable
-                key={String(v)}
-                className="segment"
-                ariaPressed={energy === v}
-                onClick={() => setEnergy(v)}
-              >
-                {v > 0 ? `+${v}` : String(v)}
-              </Pressable>
-            ))}
-          </div>
-          {did !== "skipped" && (
-            <>
-              <span class="field-label">Would repeat?</span>
+              <span class="field-label">Energy after</span>
               <div class="segment-row">
-                {(["yes", "maybe", "no"] as const).map((v) => (
+                {([-2, -1, 0, 1, 2] as const).map((v) => (
                   <Pressable
-                    key={v}
+                    key={String(v)}
                     className="segment"
-                    ariaPressed={wouldRepeat === v}
-                    onClick={() => setWouldRepeat(v)}
+                    ariaPressed={energy === v}
+                    onClick={() => setEnergy(v)}
                   >
-                    {v}
+                    {v > 0 ? `+${v}` : String(v)}
                   </Pressable>
                 ))}
               </div>
-            </>
-          )}
-          {did === "skipped" && (
-            <>
-              <span class="field-label">Why skipped?</span>
+              <span class="field-label">Would repeat?</span>
               <div class="segment-row">
-                {["time", "fear", "urge", "boring", "other"].map((v) => (
+                {(["yes", "maybe", "no"] as const).map((v) => (
                   <Pressable
                     key={v}
                     className="segment"
-                    ariaPressed={skipReason === v}
-                    onClick={() => setSkipReason(v)}
+                    ariaPressed={wouldRepeat === v}
+                    onClick={() => setWouldRepeat(v)}
                   >
                     {v}
                   </Pressable>
                 ))}
               </div>
+              <label class="field-label">
+                Money (optional)
+                <input
+                  class="field-input"
+                  type="number"
+                  value={money}
+                  onInput={(e) => setMoney((e.target as HTMLInputElement).value)}
+                />
+              </label>
             </>
           )}
-          <label class="field-label">
-            Money (optional, TZS)
-            <input
-              class="field-input"
-              inputMode="decimal"
-              value={money}
-              onInput={(e) => setMoney((e.target as HTMLInputElement).value)}
-            />
-          </label>
-          <label class="field-label">
-            Note
-            <input
-              class="field-input"
-              value={note}
-              onInput={(e) => setNote((e.target as HTMLInputElement).value)}
-            />
-          </label>
-          <div class="resolve-sticky stack">
+          <div class="resolve-sticky">
             <Button className="btn-large" disabled={busy} onClick={saveFeedback}>
-              {busy ? "Saving…" : "Save feedback"}
+              {busy ? "Saving…" : "Save how it went"}
             </Button>
             <Button className="btn-secondary" disabled={busy} onClick={removeBlock}>
               Remove block

frontend/src/pages/Home.tsx

@@ -262,7 +262,12 @@ export function Home() {
             </Pressable>
           </div>
           {!nextBlocks.length ? (
-            <p class="muted">No upcoming blocks. Open Plan to add one.</p>
+            <div class="stack">
+              <p class="muted">No upcoming blocks.</p>
+              <Pressable className="chip-btn" onClick={() => navigate("/plan")}>
+                Paste plan from chat
+              </Pressable>
+            </div>
           ) : (
             <div class="stack">
               {nextBlocks.map((b) => (
@@ -272,7 +277,11 @@ export function Home() {
                   onClick={() => navigate("/plan")}
                 >
                   <span class="entry-row-main">
-                    <span class="entry-preview">{b.title}</span>
+                    <span class="entry-preview">
+                      {b.status === "planned" ? "○ " : "✓ "}
+                      {b.priority === "P0" ? "P0 · " : ""}
+                      {b.title}
+                    </span>
                     <time>
                       {b.start}–{b.end}
                     </time>

frontend/src/pages/Plan.tsx

@@ -1,20 +1,24 @@
-/** Plan day view: iOS-like timeline, seed, reschedule, add/complete blocks.
-
-Nav IA: Home | Plan | (+) Log | Daily | Settings (History via Home).
-*/
+/** Plan day: timeline, paste ChatPlan, check-off, annotate, day review, export. */
 
 import { ChevronLeft, ChevronRight } from "lucide-preact";
-import { useEffect, useState } from "preact/hooks";
+import { useEffect, useMemo, useState } from "preact/hooks";
 import {
+  ApiError,
+  checkPlanBlock,
+  exportChatPlan,
   getPlan,
+  importChatPlan,
+  patchPlanMeta,
   reschedulePlan,
   seedPlan,
   type DayPlanView,
+  type DayReview,
   type ScheduledBlock,
 } from "../api";
 import { BlockSheet } from "../components/BlockSheet";
 import { Button } from "../components/Button";
 import { Pressable } from "../components/Pressable";
+import { Sheet } from "../components/Sheet";
 import { Timeline } from "../components/Timeline";
 import { useToast } from "../components/Toast";
 import { isoDate } from "../dates";
@@ -34,6 +38,20 @@ function friendly(day: string): string {
   });
 }
 
+function parseMin(hhmm: string): number {
+  const [h, m] = hhmm.split(":").map(Number);
+  return h * 60 + m;
+}
+
+const EMPTY_REVIEW: DayReview = {
+  comment: "",
+  emotions: [],
+  fse_events: "",
+  what_moved: "",
+  what_avoided: "",
+  tomorrow_change: "",
+};
+
 export function Plan({ initialDate }: { initialDate?: string }) {
   const toast = useToast();
   const [day, setDay] = useState(initialDate || isoDate(new Date()));
@@ -42,12 +60,20 @@ export function Plan({ initialDate }: { initialDate?: string }) {
   const [selected, setSelected] = useState<ScheduledBlock | null>(null);
   const [sheetMode, setSheetMode] = useState<"view" | "create">("view");
   const [sheetOpen, setSheetOpen] = useState(false);
+  const [pasteOpen, setPasteOpen] = useState(false);
+  const [pasteText, setPasteText] = useState("");
+  const [pasteMode, setPasteMode] = useState<"replace" | "merge">("replace");
+  const [pasteError, setPasteError] = useState("");
+  const [dayReview, setDayReview] = useState<DayReview>(EMPTY_REVIEW);
 
   const load = async (date: string) => {
     try {
-      setPlan(await getPlan(date));
+      const next = await getPlan(date);
+      setPlan(next);
+      setDayReview({ ...EMPTY_REVIEW, ...(next.day_review || {}) });
     } catch {
       setPlan(null);
+      setDayReview(EMPTY_REVIEW);
     }
   };
 
@@ -60,6 +86,15 @@ export function Plan({ initialDate }: { initialDate?: string }) {
     navigate(`/plan/${day}`);
   }, [day]);
 
+  const progress = useMemo(() => {
+    const blocks = plan?.blocks ?? [];
+    const total = blocks.length;
+    const done = blocks.filter((b) => b.status === "done" || b.status === "partial").length;
+    const p0 = blocks.filter((b) => b.priority === "P0");
+    const p0Left = p0.filter((b) => b.status === "planned").length;
+    return { total, done, p0Left, p0Total: p0.length };
+  }, [plan]);
+
   const openBlock = (block: ScheduledBlock) => {
     setSelected(block);
     setSheetMode("view");
@@ -98,9 +133,95 @@ export function Plan({ initialDate }: { initialDate?: string }) {
     }
   };
 
+  const onExport = async () => {
+    setBusy(true);
+    try {
+      const chat = await exportChatPlan(day);
+      await navigator.clipboard.writeText(JSON.stringify(chat, null, 2));
+      toast.show("Copied — paste to your chat");
+    } catch (e) {
+      toast.show(e instanceof Error ? e.message : "Export failed", "error");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const onPasteSubmit = async () => {
+    setPasteError("");
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(pasteText);
+    } catch {
+      setPasteError("Not valid JSON");
+      return;
+    }
+    setBusy(true);
+    try {
+      const next = await importChatPlan(day, parsed, pasteMode);
+      setPlan(next);
+      setDayReview({ ...EMPTY_REVIEW, ...(next.day_review || {}) });
+      setPasteOpen(false);
+      setPasteText("");
+      toast.show("Plan pasted");
+      if (next.import_warnings?.length) {
+        toast.show(next.import_warnings[0], "error");
+      }
+    } catch (e) {
+      const msg = e instanceof ApiError ? e.message : e instanceof Error ? e.message : "Import failed";
+      setPasteError(msg);
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const toggleCheck = async (block: ScheduledBlock) => {
+    const nextStatus = block.status === "done" || block.status === "partial" ? "planned" : "done";
+    setBusy(true);
+    try {
+      setPlan(await checkPlanBlock(day, block.id, { status: nextStatus }));
+    } catch (e) {
+      toast.show(e instanceof Error ? e.message : "Check failed", "error");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const skipBlock = async (block: ScheduledBlock) => {
+    setBusy(true);
+    try {
+      setPlan(
+        await checkPlanBlock(day, block.id, {
+          status: "skipped",
+          skip_reason: "other",
+        }),
+      );
+    } catch (e) {
+      toast.show(e instanceof Error ? e.message : "Skip failed", "error");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const saveDayReview = async () => {
+    setBusy(true);
+    try {
+      const next = await patchPlanMeta(day, { day_review: dayReview });
+      setPlan(next);
+      toast.show("Day review saved");
+    } catch (e) {
+      toast.show(e instanceof Error ? e.message : "Save failed", "error");
+    } finally {
+      setBusy(false);
+    }
+  };
+
   const capacity = plan?.capacity_hint ?? 1;
   const health = plan?.health;
   const empty = !plan?.blocks.length;
+  const nowMin = new Date().getHours() * 60 + new Date().getMinutes();
+  const sorted = [...(plan?.blocks ?? [])].sort(
+    (a, b) => parseMin(a.start) - parseMin(b.start),
+  );
 
   return (
     <div class="app-shell">
@@ -130,7 +251,21 @@ export function Plan({ initialDate }: { initialDate?: string }) {
               Health {Math.round(health.score * 100)}% · v{plan?.version ?? 1}
             </span>
           )}
+          {!empty && (
+            <span class="caption">
+              {progress.done}/{progress.total}
+              {progress.p0Total ? ` · P0 left ${progress.p0Left}` : ""}
+            </span>
+          )}
         </div>
+
+        {(plan?.title || plan?.intention) && (
+          <section class="tip-card" role="status">
+            {plan?.title ? <strong>{plan.title}</strong> : null}
+            {plan?.intention ? <p class="muted">{plan.intention}</p> : null}
+          </section>
+        )}
+
         {capacity < 0.55 && (
           <div class="tip-card" role="status">
             <p>High load risk — lighter plan recommended.</p>
@@ -138,6 +273,12 @@ export function Plan({ initialDate }: { initialDate?: string }) {
         )}
 
         <div class="plan-actions">
+          <Button className="btn-secondary" disabled={busy} onClick={() => setPasteOpen(true)}>
+            Paste plan
+          </Button>
+          <Button className="btn-secondary" disabled={busy || empty} onClick={onExport}>
+            Export / Copy
+          </Button>
           <Button className="btn-secondary" disabled={busy} onClick={openCreate}>
             + Block
           </Button>
@@ -146,10 +287,18 @@ export function Plan({ initialDate }: { initialDate?: string }) {
           </Button>
         </div>
 
+        <p class="muted">
+          Paste the JSON your chat wrote. Check off when done in the real world. Export and paste
+          back for review.
+        </p>
+
         {empty ? (
           <section class="surface-card empty-card stack">
-            <p>No blocks yet. Seed a light starter day, or add one block.</p>
-            <Button disabled={busy} onClick={onSeed}>
+            <p>No blocks yet. Paste a plan from chat, seed a starter day, or add one block.</p>
+            <Button disabled={busy} onClick={() => setPasteOpen(true)}>
+              Paste plan from chat
+            </Button>
+            <Button className="btn-secondary" disabled={busy} onClick={onSeed}>
               Seed starter day
             </Button>
             <Button className="btn-secondary" disabled={busy} onClick={openCreate}>
@@ -157,10 +306,119 @@ export function Plan({ initialDate }: { initialDate?: string }) {
             </Button>
           </section>
         ) : (
-          <section class="surface-card timeline-card">
-            <Timeline blocks={plan!.blocks} onSelect={openBlock} />
-          </section>
+          <>
+            <section class="surface-card stack" aria-label="Checklist">
+              <h2 class="section-title">Checklist</h2>
+              {sorted.map((block) => {
+                const overdue =
+                  day === isoDate(new Date()) &&
+                  block.status === "planned" &&
+                  parseMin(block.end) < nowMin;
+                const checked = block.status === "done" || block.status === "partial";
+                return (
+                  <div
+                    key={block.id}
+                    class={`entry-row ${overdue ? "indoors-nudge" : ""}`.trim()}
+                  >
+                    <Pressable
+                      className="chip"
+                      ariaPressed={checked}
+                      ariaLabel={checked ? "Mark planned" : "Mark done"}
+                      onClick={() => void toggleCheck(block)}
+                    >
+                      {checked ? "✓" : "○"}
+                    </Pressable>
+                    <Pressable className="entry-row-main" onClick={() => openBlock(block)}>
+                      <span class="entry-preview">
+                        {block.priority === "P0" ? "P0 · " : ""}
+                        {block.title}
+                      </span>
+                      <time>
+                        {block.start}–{block.end}
+                        {overdue ? " · overdue" : ""}
+                      </time>
+                    </Pressable>
+                    {block.status === "planned" && (
+                      <Pressable className="chip-btn" onClick={() => void skipBlock(block)}>
+                        Skip
+                      </Pressable>
+                    )}
+                  </div>
+                );
+              })}
+            </section>
+
+            <section class="surface-card timeline-card">
+              <Timeline blocks={plan!.blocks} onSelect={openBlock} />
+            </section>
+          </>
         )}
+
+        <section class="surface-card form-card stack" aria-label="Day review">
+          <h2 class="section-title">Day review</h2>
+          <p class="muted">One line is enough. FSE = fear / shame / embarrassment spike — short phrase.</p>
+          <label class="field-label" for="dr-comment">
+            Comment
+          </label>
+          <textarea
+            id="dr-comment"
+            class="field-textarea"
+            value={dayReview.comment}
+            onInput={(e) =>
+              setDayReview({ ...dayReview, comment: (e.target as HTMLTextAreaElement).value })
+            }
+          />
+          <label class="field-label" for="dr-fse">
+            FSE events
+          </label>
+          <input
+            id="dr-fse"
+            class="field-input"
+            value={dayReview.fse_events}
+            onInput={(e) =>
+              setDayReview({ ...dayReview, fse_events: (e.target as HTMLInputElement).value })
+            }
+          />
+          <label class="field-label" for="dr-moved">
+            What moved
+          </label>
+          <input
+            id="dr-moved"
+            class="field-input"
+            value={dayReview.what_moved}
+            onInput={(e) =>
+              setDayReview({ ...dayReview, what_moved: (e.target as HTMLInputElement).value })
+            }
+          />
+          <label class="field-label" for="dr-avoided">
+            What avoided
+          </label>
+          <input
+            id="dr-avoided"
+            class="field-input"
+            value={dayReview.what_avoided}
+            onInput={(e) =>
+              setDayReview({ ...dayReview, what_avoided: (e.target as HTMLInputElement).value })
+            }
+          />
+          <label class="field-label" for="dr-tomorrow">
+            Tomorrow change
+          </label>
+          <input
+            id="dr-tomorrow"
+            class="field-input"
+            value={dayReview.tomorrow_change}
+            onInput={(e) =>
+              setDayReview({
+                ...dayReview,
+                tomorrow_change: (e.target as HTMLInputElement).value,
+              })
+            }
+          />
+          <Button disabled={busy} onClick={() => void saveDayReview()}>
+            Save day review
+          </Button>
+        </section>
       </main>
 
       <BlockSheet
@@ -171,6 +429,40 @@ export function Plan({ initialDate }: { initialDate?: string }) {
         onClose={() => setSheetOpen(false)}
         onChanged={() => void load(day)}
       />
+
+      <Sheet open={pasteOpen} title="Paste plan" onClose={() => setPasteOpen(false)} tall>
+        <div class="stack">
+          <p class="muted">Paste the JSON your chat wrote.</p>
+          <textarea
+            class="field-textarea"
+            rows={14}
+            value={pasteText}
+            onInput={(e) => setPasteText((e.target as HTMLTextAreaElement).value)}
+            placeholder='{ "schema_version": 1, "blocks": [ ... ] }'
+          />
+          <span class="field-label">Mode</span>
+          <div class="chip-row" role="group">
+            <Pressable
+              className="chip"
+              ariaPressed={pasteMode === "replace"}
+              onClick={() => setPasteMode("replace")}
+            >
+              Replace
+            </Pressable>
+            <Pressable
+              className="chip"
+              ariaPressed={pasteMode === "merge"}
+              onClick={() => setPasteMode("merge")}
+            >
+              Merge
+            </Pressable>
+          </div>
+          {pasteError ? <p class="muted" role="alert">{pasteError}</p> : null}
+          <Button disabled={busy || !pasteText.trim()} onClick={() => void onPasteSubmit()}>
+            Import plan
+          </Button>
+        </div>
+      </Sheet>
     </div>
   );
 }

static/index.html

@@ -20,7 +20,7 @@
     <link rel="manifest" href="/manifest.webmanifest" />
     <link rel="apple-touch-icon" href="/icons/icon-192.png" />
     <title>Habit Journal</title>
-    <script type="module" crossorigin src="/assets/index-kJxQGPW0.js"></script>
+    <script type="module" crossorigin src="/assets/index-DYDM6L-p.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CK7MU-TQ.css">
   </head>
   <body>

static/sw.js

@@ -1,6 +1,6 @@
 
 const CACHE = "habit-journal-v3";
-const SHELL = ["/","/index.html","/manifest.webmanifest","/icons/icon-192.png","/icons/icon-512.png","/illustrations/hero-home.svg","/illustrations/pending.svg","/illustrations/scores.svg","/illustrations/coach.svg","/illustrations/empty.svg","/assets/index-CK7MU-TQ.css","/assets/index-kJxQGPW0.js","/assets/index-kJxQGPW0.js.map"];
+const SHELL = ["/","/index.html","/manifest.webmanifest","/icons/icon-192.png","/icons/icon-512.png","/illustrations/hero-home.svg","/illustrations/pending.svg","/illustrations/scores.svg","/illustrations/coach.svg","/illustrations/empty.svg","/assets/index-CK7MU-TQ.css","/assets/index-DYDM6L-p.js","/assets/index-DYDM6L-p.js.map"];
 self.addEventListener("install", event => event.waitUntil(caches.open(CACHE).then(cache => cache.addAll(SHELL)).then(() => self.skipWaiting())));
 self.addEventListener("activate", event => event.waitUntil(caches.keys().then(keys => Promise.all(keys.filter(key => key !== CACHE).map(key => caches.delete(key)))).then(() => self.clients.claim())));
 self.addEventListener("fetch", event => {

tests/test_chat_plan.py

@@ -0,0 +1,198 @@
+"""ChatPlan mapper and import/export round-trip tests."""
+
+from __future__ import annotations
+
+from datetime import date
+
+from app.chat_plan import (
+    ChatPlanError,
+    chat_plan_to_day_put,
+    plan_and_feedback_to_chat_plan,
+)
+from app.schedule_store import DayPlan, DayReview, ScheduledBlock
+
+
+SAMPLE = {
+    "schema_version": 1,
+    "date": "2026-07-24",
+    "title": "Spain pack day",
+    "intention": "AXA + stay proof + hold PDF. No embassy. No flight pay.",
+    "constraints": ["wallet home on walk", "Weeknd only after proof"],
+    "blocks": [
+        {
+            "start": "08:00",
+            "end": "08:25",
+            "title": "Interrupt walk (no headphones)",
+            "priority": "P0",
+            "kind": "body_care",
+            "intent": "measure",
+            "notes": "Eyes outside.",
+            "status": "planned",
+            "review": {
+                "did": None,
+                "minutes": None,
+                "comment": "",
+                "emotions": [],
+                "fse_event": "",
+                "intensity": None,
+            },
+        },
+        {
+            "start": "09:00",
+            "end": "10:30",
+            "title": "Fix AXA residence Tanzania",
+            "priority": "P0",
+            "kind": "admin_spain",
+            "intent": "duty",
+            "notes": "26 Aug–5 Sep 2026; PDF",
+            "locked": True,
+            "status": "planned",
+            "review": {
+                "did": None,
+                "minutes": None,
+                "comment": "",
+                "emotions": [],
+                "fse_event": "",
+                "intensity": None,
+            },
+        },
+    ],
+    "day_review": {
+        "comment": "",
+        "emotions": [],
+        "fse_events": "",
+        "what_moved": "",
+        "what_avoided": "",
+        "tomorrow_change": "",
+    },
+}
+
+
+def test_chat_to_put_basic() -> None:
+    put, fbs, warnings = chat_plan_to_day_put(SAMPLE, "2026-07-24")
+    assert put.title == "Spain pack day"
+    assert put.intention.startswith("AXA")
+    assert put.constraints == ["wallet home on walk", "Weeknd only after proof"]
+    assert len(put.blocks) == 2
+    assert put.blocks[0].planned_min == 25
+    assert put.blocks[1].kind == "admin_spain"
+    assert put.source == "chat"
+    assert fbs == []
+    assert isinstance(warnings, list)
+
+
+def test_date_mismatch() -> None:
+    try:
+        chat_plan_to_day_put(SAMPLE, "2026-07-25")
+        assert False, "expected error"
+    except ChatPlanError as exc:
+        assert any("date mismatch" in e for e in exc.errors)
+
+
+def test_empty_blocks() -> None:
+    try:
+        chat_plan_to_day_put({"blocks": []}, "2026-07-24")
+        assert False
+    except ChatPlanError:
+        pass
+
+
+def test_unknown_kind_coerced() -> None:
+    chat = {
+        "blocks": [
+            {
+                "start": "10:00",
+                "end": "10:30",
+                "title": "Weird",
+                "kind": "embassy_run",
+                "priority": "P1",
+            }
+        ]
+    }
+    put, _, warnings = chat_plan_to_day_put(chat, "2026-07-24")
+    assert put.blocks[0].kind == "other"
+    assert "[kind:embassy_run]" in put.blocks[0].notes
+    assert any("embassy_run" in w for w in warnings)
+
+
+def test_overlap_validation() -> None:
+    chat = {
+        "blocks": [
+            {"start": "09:00", "end": "10:00", "title": "A", "kind": "other"},
+            {"start": "09:30", "end": "10:30", "title": "B", "kind": "other"},
+        ]
+    }
+    try:
+        chat_plan_to_day_put(chat, "2026-07-24")
+        assert False
+    except ChatPlanError as exc:
+        assert any("overlap" in e for e in exc.errors)
+
+
+def test_export_round_trip_fields() -> None:
+    put, _, _ = chat_plan_to_day_put(SAMPLE, "2026-07-24")
+    plan = DayPlan(
+        date="2026-07-24",
+        blocks=put.blocks,
+        title=put.title or "",
+        intention=put.intention or "",
+        constraints=put.constraints or [],
+        day_review=put.day_review or DayReview(),
+        source="chat",
+    )
+    # Annotate first block
+    fb = {
+        put.blocks[0].id: {
+            "block_id": put.blocks[0].id,
+            "did": "done",
+            "actual_min": 20,
+            "note": "walked",
+            "emotions": ["calm"],
+            "fse_event": "",
+            "intensity": 3,
+        }
+    }
+    plan.blocks[0] = plan.blocks[0].model_copy(update={"status": "done"})
+    out = plan_and_feedback_to_chat_plan(plan, fb)
+    assert out["title"] == "Spain pack day"
+    assert out["intention"].startswith("AXA")
+    assert out["blocks"][0]["review"]["comment"] == "walked"
+    assert out["blocks"][0]["review"]["emotions"] == ["calm"]
+    assert out["summary"]["blocks_total"] == 2
+    assert out["summary"]["blocks_done"] == 1
+    assert out["summary"]["p0_total"] == 2
+    assert out["summary"]["p0_done"] == 1
+    assert out["summary"]["actual_min_sum"] == 20
+
+
+def test_old_plan_without_day_review_loads() -> None:
+    plan = DayPlan.model_validate(
+        {
+            "date": "2026-01-01",
+            "blocks": [],
+            "source": "user",
+        }
+    )
+    assert plan.day_review.comment == ""
+    assert plan.title == ""
+    assert plan.constraints == []
+
+
+def test_review_did_sets_status() -> None:
+    chat = {
+        "blocks": [
+            {
+                "start": "11:00",
+                "end": "11:30",
+                "title": "Done already",
+                "kind": "other",
+                "status": "planned",
+                "review": {"did": "done", "minutes": 25, "comment": "ok", "emotions": ["hope"]},
+            }
+        ]
+    }
+    put, fbs, _ = chat_plan_to_day_put(chat, "2026-07-24")
+    assert put.blocks[0].status == "done"
+    assert len(fbs) == 1
+    assert fbs[0].emotions == ["hope"]
+    assert fbs[0].actual_min == 25