Complete P1 schedule loop: seed day, live capacity, templates, API tests.

.gitignore

@@ -7,3 +7,5 @@ data/
 frontend/node_modules/
 frontend/dist/
 *.log
+commands.md
+_tmp_*.txt

app/routers/agent.py

@@ -14,6 +14,7 @@ from fastapi import APIRouter, Depends, Request, status
 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_risk import risk_from_stores
 from app.schedule_store import DayPlanPut
 
 router = APIRouter(prefix="/api/agent", tags=["agent"])
@@ -48,62 +49,40 @@ def agent_context(
 
     now = datetime.now(timezone.utc)
     since = now - timedelta(hours=48)
-    hour_ago = now - timedelta(hours=1)
-    yesterday = (target - timedelta(days=1)).isoformat()
-
-    risk_tags = {
-        "urge",
-        "court",
-        "comparison",
-        "corn",
-        "daydream",
-        "bully",
-        "family",
-        "shame",
-        "rerun",
-        "home",
-        "spain",
-        "build",
-    }
+
+    risk_tags_extra = {"home", "spain", "build"}
     entries_48h = []
-    tags_1h: list[str] = []
-    triggers_y: list[str] = []
     for entry in entry_store._load():
         ts = entry.ts if entry.ts.tzinfo else entry.ts.replace(tzinfo=timezone.utc)
         if ts < since:
             continue
-        item = {
-            "id": entry.id,
-            "ts": entry.ts.isoformat(),
-            "tags": entry.tags,
-            "emotions": entry.emotions,
-            "intensity": entry.intensity,
-            "remedy": entry.remedy,
-            "result": entry.result.value,
-            "happened": entry.happened[:280],
-        }
-        entries_48h.append(item)
-        hit = sorted((set(entry.tags) | set(entry.emotions)) & risk_tags)
-        if ts >= hour_ago:
-            tags_1h.extend(hit)
-        if entry.ts.date().isoformat() == yesterday:
-            triggers_y.extend(hit)
-
-    tags_1h = sorted(set(tags_1h))
-    triggers_y = sorted(set(triggers_y))
-    y_daily = daily_store.get(date.fromisoformat(yesterday))
-    t_daily = daily_store.get(target)
-    if y_daily:
-        if y_daily.court == "court":
-            triggers_y.append("court")
-        if y_daily.corn_sessions >= 2:
-            triggers_y.append("corn")
-        if y_daily.daydream == "fc":
-            triggers_y.append("daydream")
-        triggers_y = sorted(set(triggers_y))
-
+        entries_48h.append(
+            {
+                "id": entry.id,
+                "ts": entry.ts.isoformat(),
+                "tags": entry.tags,
+                "emotions": entry.emotions,
+                "intensity": entry.intensity,
+                "remedy": entry.remedy,
+                "result": entry.result.value,
+                "happened": entry.happened[:280],
+            }
+        )
+
+    risk = risk_from_stores(entry_store, daily_store, now=now, target_day=target)
+    # Keep agent context tags slightly broader for Spain/home signals.
+    tags_1h = sorted(set(risk["risk_1h_tags"]))
+    for entry in entry_store._load():
+        ts = entry.ts if entry.ts.tzinfo else entry.ts.replace(tzinfo=timezone.utc)
+        if ts < now - timedelta(hours=1):
+            continue
+        hit = sorted((set(entry.tags) | set(entry.emotions)) & risk_tags_extra)
+        tags_1h = sorted(set(tags_1h) | set(hit))
     risk_score = float(len(tags_1h))
-    last_hour_high = bool({"urge", "court", "corn", "rerun"} & set(tags_1h))
+    last_hour_high = risk["last_hour_high"] or bool(
+        {"urge", "court", "corn", "rerun"} & set(tags_1h)
+    )
+    triggers_y = risk["triggers_yesterday"]
     cap = capacity_hint(
         risk_1h_score=risk_score,
         triggers_yesterday=triggers_y,
@@ -111,10 +90,10 @@ def agent_context(
         last_hour_high=last_hour_high,
     )
     ops = trigger_operators(risk_1h_tags=tags_1h, triggers_yesterday=triggers_y)
-    pending = sum(
-        1 for e in entry_store._load() if e.result.value == "pending"
-    )
+    pending = sum(1 for e in entry_store._load() if e.result.value == "pending")
     priors = store.load_priors()
+    y_daily = daily_store.get(target - timedelta(days=1))
+    t_daily = daily_store.get(target)
 
     return ok(
         {

app/routers/plan.py

@@ -5,15 +5,17 @@ Session-authenticated; mirrors the app envelope pattern.
 
 from __future__ import annotations
 
-from datetime import date, datetime, timedelta, timezone
+from datetime import date
 from typing import Any
 
 from fastapi import APIRouter, Depends, Request, status
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 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
 
 router = APIRouter(tags=["plan"], dependencies=[Depends(require_login)])
@@ -25,7 +27,7 @@ class RescheduleBody(BaseModel):
 
 
 class FeedbackBody(BlockFeedback):
-    block_id: str
+    block_id: str = ""
     date: str | None = None
 
 
@@ -33,58 +35,42 @@ def _store(request: Request):
     return request.app.state.schedule_store
 
 
-def _risk_from_entries(request: Request) -> tuple[float, list[str], list[str]]:
-    """Derive risk_1h and yesterday triggers from recent entries + daily."""
-
-    now = datetime.now(timezone.utc)
-    hour_ago = now - timedelta(hours=1)
-    yesterday = (now.date() - timedelta(days=1)).isoformat()
-    risk_tags = {
-        "urge",
-        "court",
-        "comparison",
-        "corn",
-        "daydream",
-        "bully",
-        "family",
-        "shame",
-        "rerun",
-    }
-    tags_1h: list[str] = []
-    triggers_y: list[str] = []
-    for entry in request.app.state.entry_store._load():
-        ts = entry.ts
-        if ts.tzinfo is None:
-            ts = ts.replace(tzinfo=timezone.utc)
-        entry_tags = set(entry.tags) | set(entry.emotions)
-        hit = sorted(entry_tags & risk_tags)
-        if ts >= hour_ago:
-            tags_1h.extend(hit)
-        if entry.ts.date().isoformat() == yesterday:
-            triggers_y.extend(hit)
-    try:
-        y_daily = request.app.state.daily_store.get(date.fromisoformat(yesterday))
-        if y_daily:
-            if y_daily.court == "court":
-                triggers_y.append("court")
-            if y_daily.corn_sessions >= 2:
-                triggers_y.append("corn")
-            if y_daily.daydream == "fc":
-                triggers_y.append("daydream")
-    except Exception:  # noqa: BLE001
-        pass
-    tags_1h = sorted(set(tags_1h))
-    triggers_y = sorted(set(triggers_y))
-    score = float(len(tags_1h))
-    last_hour_high = bool(
-        {"urge", "court", "corn", "rerun"} & set(tags_1h)
+def _risk_bundle(request: Request, target: date | None = None) -> dict[str, Any]:
+    risk = risk_from_stores(
+        request.app.state.entry_store,
+        request.app.state.daily_store,
+        target_day=target,
+    )
+    cap = capacity_hint(
+        risk_1h_score=risk["risk_1h_score"],
+        triggers_yesterday=risk["triggers_yesterday"],
+        yesterday_trigger=risk["yesterday_trigger"],
+        last_hour_high=risk["last_hour_high"],
+    )
+    ops = trigger_operators(
+        risk_1h_tags=risk["risk_1h_tags"],
+        triggers_yesterday=risk["triggers_yesterday"],
     )
-    return score, tags_1h, triggers_y, last_hour_high
+    return {**risk, "capacity_hint": cap, "operators": ops}
+
+
+def _enrich_plan(request: Request, day: date) -> dict[str, Any]:
+    data = _store(request).plan_with_feedback(day.isoformat())
+    bundle = _risk_bundle(request, day)
+    data["capacity_hint"] = bundle["capacity_hint"]
+    data["operators"] = bundle["operators"]
+    data["risk_1h"] = {
+        "score": bundle["risk_1h_score"],
+        "tags": bundle["risk_1h_tags"],
+        "high": bundle["last_hour_high"],
+    }
+    data["triggers_yesterday"] = bundle["triggers_yesterday"]
+    return data
 
 
 @router.get("/api/plan/{day}", response_model=ApiEnvelope)
 def get_plan(request: Request, day: date) -> dict[str, Any]:
-    return ok(_store(request).plan_with_feedback(day.isoformat()))
+    return ok(_enrich_plan(request, day))
 
 
 @router.put("/api/plan/{day}", response_model=ApiEnvelope)
@@ -92,7 +78,7 @@ def put_plan(request: Request, day: date, body: DayPlanPut) -> object:
     try:
         put = body.model_copy(update={"source": body.source or "user"})
         _store(request).save_plan(day.isoformat(), put)
-        return ok(_store(request).plan_with_feedback(day.isoformat()))
+        return ok(_enrich_plan(request, day))
     except ValueError as exc:
         return err("validation_error", str(exc), status.HTTP_422_UNPROCESSABLE_ENTITY)
 
@@ -101,7 +87,7 @@ def put_plan(request: Request, day: date, body: DayPlanPut) -> object:
 def add_block(request: Request, day: date, body: BlockCreate) -> object:
     try:
         _store(request).add_block(day.isoformat(), body)
-        return ok(_store(request).plan_with_feedback(day.isoformat()))
+        return ok(_enrich_plan(request, day))
     except ValueError as exc:
         return err("validation_error", str(exc), status.HTTP_422_UNPROCESSABLE_ENTITY)
 
@@ -115,7 +101,7 @@ def patch_block(
 ) -> object:
     try:
         _store(request).patch_block(day.isoformat(), block_id, body)
-        return ok(_store(request).plan_with_feedback(day.isoformat()))
+        return ok(_enrich_plan(request, day))
     except KeyError:
         return err("not_found", "Block not found", status.HTTP_404_NOT_FOUND)
     except ValueError as exc:
@@ -126,7 +112,7 @@ def patch_block(
 def delete_block(request: Request, day: date, block_id: str) -> object:
     try:
         _store(request).delete_block(day.isoformat(), block_id)
-        return ok(_store(request).plan_with_feedback(day.isoformat()))
+        return ok(_enrich_plan(request, day))
     except KeyError:
         return err("not_found", "Block not found", status.HTTP_404_NOT_FOUND)
 
@@ -144,7 +130,7 @@ def post_feedback(
         return ok(
             {
                 "feedback": stored.model_dump(mode="json"),
-                "plan": _store(request).plan_with_feedback(day.isoformat()),
+                "plan": _enrich_plan(request, day),
                 "priors": list(_store(request).load_priors().values()),
             }
         )
@@ -152,6 +138,42 @@ def post_feedback(
         return err("not_found", "Block not found", status.HTTP_404_NOT_FOUND)
 
 
+@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)."""
+
+    store = _store(request)
+    existing = store.get_plan(day.isoformat())
+    if existing.blocks:
+        return err(
+            "validation_error",
+            "Day already has blocks — clear or reschedule instead",
+            status.HTTP_422_UNPROCESSABLE_ENTITY,
+        )
+    bundle = _risk_bundle(request, day)
+    blocks = seed_starter_blocks(
+        day.isoformat(),
+        capacity_hint=bundle["capacity_hint"],
+        max_blocks=request.app.state.settings.schedule_max_blocks,
+    )
+    try:
+        store.save_plan(
+            day.isoformat(),
+            DayPlanPut(
+                blocks=blocks,
+                source="rules",
+                capacity_hint=bundle["capacity_hint"],
+                notes="seed",
+                force_p0_move=True,
+            ),
+        )
+        data = _enrich_plan(request, day)
+        data["seeded"] = True
+        return ok(data)
+    except ValueError as exc:
+        return err("validation_error", str(exc), status.HTTP_422_UNPROCESSABLE_ENTITY)
+
+
 @router.get("/api/schedule/priors", response_model=ApiEnvelope)
 def get_priors(request: Request) -> dict[str, Any]:
     kinds = _store(request).load_priors()
@@ -171,29 +193,28 @@ def get_health(request: Request, day: date) -> dict[str, Any]:
 @router.post("/api/plan/{day}/reschedule", response_model=ApiEnvelope)
 def reschedule(request: Request, day: date, body: RescheduleBody | None = None) -> object:
     payload = body or RescheduleBody()
-    risk, tags, triggers, last_hour_high = _risk_from_entries(request)
-    cap = capacity_hint(
-        risk_1h_score=risk,
-        triggers_yesterday=triggers,
-        yesterday_trigger=len(triggers) > 0,
-        last_hour_high=last_hour_high,
-    )
-    ops = trigger_operators(risk_1h_tags=tags, triggers_yesterday=triggers)
+    bundle = _risk_bundle(request, day)
     try:
         result = request.app.state.reschedule_service.reschedule(
             day.isoformat(),
             reason=payload.reason,
             force=payload.force,
-            risk_score=risk,
-            capacity_hint=cap,
+            risk_score=bundle["risk_1h_score"],
+            capacity_hint=bundle["capacity_hint"],
             priors_md=_store(request).priors_table(),
             context_notes=(
-                f"risk_tags={tags}; triggers_y={triggers}; "
-                f"operators={ops}"
+                f"risk_tags={bundle['risk_1h_tags']}; "
+                f"triggers_y={bundle['triggers_yesterday']}; "
+                f"operators={bundle['operators']}"
             ),
         )
-        result["operators"] = ops
-        result["capacity_hint"] = cap
+        result["operators"] = bundle["operators"]
+        result["capacity_hint"] = bundle["capacity_hint"]
+        if "plan" in result:
+            plan = result["plan"]
+            if isinstance(plan, dict):
+                plan["capacity_hint"] = bundle["capacity_hint"]
+                plan["operators"] = bundle["operators"]
         return ok(result)
     except PermissionError as exc:
         return err("rate_limited", str(exc), status.HTTP_429_TOO_MANY_REQUESTS)

app/schedule_math.py

@@ -225,6 +225,37 @@ def validate_blocks(
     return errors
 
 
+def ev_score(
+    *,
+    p_done: float,
+    utility: float,
+    information: float = 0.0,
+    fun: float = 0.0,
+    d_hat_min: float = 30.0,
+    cost: float = 0.0,
+    fse: float = 0.0,
+    gamma: float = 0.25,
+    eta: float = 0.35,
+    lambda_t: float = 0.01,
+    lambda_m: float = 0.15,
+    lambda_f: float = 0.4,
+    raise_eta: bool = False,
+    raise_lambda_f: bool = False,
+) -> float:
+    """Locked EV formula (operators may raise η / λ_f; no δ / H / PERMA terms)."""
+
+    eta_eff = eta * (1.35 if raise_eta else 1.0)
+    lf_eff = lambda_f * (1.4 if raise_lambda_f else 1.0)
+    return (
+        p_done * utility
+        + gamma * information
+        + eta_eff * fun
+        - lambda_t * d_hat_min
+        - lambda_m * cost
+        - lf_eff * fse
+    )
+
+
 def capacity_hint(
     *,
     risk_1h_score: float,

app/schedule_reschedule.py

@@ -16,7 +16,12 @@ import httpx
 from app.config import Settings
 from app.schedule_math import minutes_between, parse_hhmm, trigger_operators
 from app.schedule_store import DayPlanPut, ScheduledBlock, ScheduleStore
-from app.schedule_templates import KIND_LABELS
+from app.schedule_templates import (
+    KIND_LABELS,
+    SEED_SLOTS,
+    seed_template_ids,
+    template_by_id,
+)
 
 
 def _hhmm(minutes: int) -> str:
@@ -24,6 +29,45 @@ def _hhmm(minutes: int) -> str:
     return f"{minutes // 60:02d}:{minutes % 60:02d}"
 
 
+def seed_starter_blocks(
+    day: str,
+    *,
+    capacity_hint: float,
+    max_blocks: int = 7,
+) -> list[ScheduledBlock]:
+    """Build a thin starter day from templates (P0 locked; capacity cuts P2)."""
+
+    slot_map = {tid: (start, end) for tid, start, end in SEED_SLOTS}
+    out: list[ScheduledBlock] = []
+    for tid in seed_template_ids(capacity_hint=capacity_hint):
+        if len(out) >= max_blocks:
+            break
+        tmpl = template_by_id(tid)
+        if not tmpl:
+            continue
+        start, end = slot_map.get(tid, ("10:00", "10:30"))
+        planned = max(1, minutes_between(start, end))
+        out.append(
+            ScheduledBlock(
+                date=day,
+                start=start,
+                end=end,
+                title=str(tmpl["title"]),
+                kind=tmpl["kind"],
+                intent=tmpl["intent"],
+                priority=tmpl["priority"],
+                planned_min=planned,
+                status="planned",
+                source="rules",
+                locked=bool(tmpl.get("locked") or tmpl.get("priority") == "P0"),
+                notes="seed",
+                version_added=1,
+            )
+        )
+    out.sort(key=lambda b: b.start)
+    return out
+
+
 def rules_backup_reschedule(
     plan_blocks: list[dict[str, Any]],
     *,
@@ -36,6 +80,9 @@ def rules_backup_reschedule(
 ) -> list[ScheduledBlock]:
     """Deterministic reschedule: keep P0, drop/shrink P2, optional stabilize/fun."""
 
+    if not plan_blocks:
+        return seed_starter_blocks(day, capacity_hint=capacity_hint, max_blocks=max_blocks)
+
     kept: list[dict[str, Any]] = []
     for block in plan_blocks:
         if block.get("priority") == "P0" or block.get("locked"):

app/schedule_risk.py

@@ -0,0 +1,73 @@
+"""Derive schedule risk signals from entries + daily check-ins.
+
+Shared by human plan routes and agent context — server-owned, not LLM.
+"""
+
+from __future__ import annotations
+
+from datetime import date, datetime, timedelta, timezone
+from typing import Any
+
+RISK_TAGS = frozenset(
+    {
+        "urge",
+        "court",
+        "comparison",
+        "corn",
+        "daydream",
+        "bully",
+        "family",
+        "shame",
+        "rerun",
+    }
+)
+
+LAST_HOUR_HIGH_TAGS = frozenset({"urge", "court", "corn", "rerun"})
+
+
+def risk_from_stores(
+    entry_store: Any,
+    daily_store: Any,
+    *,
+    now: datetime | None = None,
+    target_day: date | None = None,
+) -> dict[str, Any]:
+    """Return risk_1h, triggers_yesterday, and last_hour_high flags."""
+
+    now = now or datetime.now(timezone.utc)
+    target = target_day or now.date()
+    hour_ago = now - timedelta(hours=1)
+    yesterday = (target - timedelta(days=1)).isoformat()
+
+    tags_1h: list[str] = []
+    triggers_y: list[str] = []
+    for entry in entry_store._load():
+        ts = entry.ts
+        if ts.tzinfo is None:
+            ts = ts.replace(tzinfo=timezone.utc)
+        entry_tags = set(entry.tags) | set(entry.emotions)
+        hit = sorted(entry_tags & RISK_TAGS)
+        if ts >= hour_ago:
+            tags_1h.extend(hit)
+        if entry.ts.date().isoformat() == yesterday:
+            triggers_y.extend(hit)
+
+    y_daily = daily_store.get(date.fromisoformat(yesterday))
+    if y_daily:
+        if y_daily.court == "court":
+            triggers_y.append("court")
+        if y_daily.corn_sessions >= 2:
+            triggers_y.append("corn")
+        if y_daily.daydream == "fc":
+            triggers_y.append("daydream")
+
+    tags_1h = sorted(set(tags_1h))
+    triggers_y = sorted(set(triggers_y))
+    last_hour_high = bool(LAST_HOUR_HIGH_TAGS & set(tags_1h))
+    return {
+        "risk_1h_score": float(len(tags_1h)),
+        "risk_1h_tags": tags_1h,
+        "triggers_yesterday": triggers_y,
+        "yesterday_trigger": len(triggers_y) > 0,
+        "last_hour_high": last_hour_high,
+    }

app/schedule_templates.py

@@ -190,3 +190,35 @@ KIND_LABELS: dict[str, str] = {
 
 def list_templates() -> list[dict[str, Any]]:
     return list(TEMPLATES)
+
+
+def template_by_id(template_id: str) -> dict[str, Any] | None:
+    for row in TEMPLATES:
+        if row["id"] == template_id:
+            return dict(row)
+    return None
+
+
+# Default clock slots for empty-day seed (P0 locked first).
+SEED_SLOTS: list[tuple[str, str, str]] = [
+    ("earn_one_ship", "09:00", "09:45"),
+    ("food_outside", "12:30", "13:15"),
+    ("stabilize_10", "15:00", "15:15"),
+    ("walk_new_route", "16:30", "16:50"),
+    ("sleep_wind", "22:00", "22:45"),
+]
+
+
+def seed_template_ids(*, capacity_hint: float) -> list[str]:
+    """Pick starter template ids under capacity (P0 always; cut P2 when low)."""
+
+    ids = ["food_outside", "sleep_wind"]
+    if capacity_hint >= 0.45:
+        ids.insert(0, "earn_one_ship")
+    if capacity_hint < 0.55:
+        ids.append("stabilize_10")
+    if capacity_hint >= 0.4:
+        ids.append("walk_new_route")
+    # Preserve SEED_SLOTS order
+    order = {tid: i for i, (tid, _, _) in enumerate(SEED_SLOTS)}
+    return sorted(set(ids), key=lambda t: order.get(t, 99))

docs/SCHEDULE.md

@@ -77,11 +77,14 @@ LLM must not invent `p_helped`, rank, or %.
 - `GET/PUT /api/plan/{date}`
 - `POST/PATCH/DELETE /api/plan/{date}/blocks[/{id}]`
 - `POST /api/plan/{date}/blocks/{id}/feedback`
+- `POST /api/plan/{date}/seed` — empty day → template starter (P0 locked; capacity cuts)
 - `GET /api/schedule/priors`
 - `GET /api/schedule/templates`
 - `POST /api/plan/{date}/reschedule` `{ "reason", "force" }`
 - `GET /api/plan/{date}/health`
 
+`GET /api/plan/{date}` overlays live `capacity_hint`, `operators`, `risk_1h`, `triggers_yesterday`.
+
 ## Agent API
 
 Set Space secret `AGENT_TOKEN`.

frontend/src/api.ts

@@ -489,3 +489,7 @@ export function reschedulePlan(
     body: JSON.stringify(payload),
   });
 }
+
+export function seedPlan(day: string): Promise<DayPlanView> {
+  return api(`/api/plan/${day}/seed`, { method: "POST", body: "{}" });
+}

frontend/src/components/BlockSheet.tsx

@@ -4,8 +4,10 @@ import { useEffect, useState } from "preact/hooks";
 import {
   addPlanBlock,
   deletePlanBlock,
+  getScheduleTemplates,
   postBlockFeedback,
   type ScheduledBlock,
+  type ScheduleTemplate,
   type TaskKind,
 } from "../api";
 import { Button } from "./Button";
@@ -27,6 +29,14 @@ const KIND_OPTIONS: { value: TaskKind; label: string }[] = [
   { value: "other", label: "Other" },
 ];
 
+function addMinutes(hhmm: string, mins: number): string {
+  const [h, m] = hhmm.split(":").map(Number);
+  const total = h * 60 + m + mins;
+  const nh = Math.floor(((total % (24 * 60)) + 24 * 60) % (24 * 60) / 60);
+  const nm = ((total % (24 * 60)) + 24 * 60) % (24 * 60) % 60;
+  return `${String(nh).padStart(2, "0")}:${String(nm).padStart(2, "0")}`;
+}
+
 type Props = {
   open: boolean;
   day: string;
@@ -48,6 +58,7 @@ export function BlockSheet({ open, day, block, mode, onClose, onChanged }: Props
   const [note, setNote] = useState("");
   const [money, setMoney] = useState("");
   const [busy, setBusy] = useState(false);
+  const [templates, setTemplates] = useState<ScheduleTemplate[]>([]);
 
   const [title, setTitle] = useState("New block");
   const [kind, setKind] = useState<TaskKind>("other");
@@ -58,6 +69,11 @@ export function BlockSheet({ open, day, block, mode, onClose, onChanged }: Props
 
   useEffect(() => {
     if (!open) return;
+    if (mode === "create") {
+      void getScheduleTemplates()
+        .then((r) => setTemplates(r.items || []))
+        .catch(() => setTemplates([]));
+    }
     if (mode === "view" && block) {
       setActualMin(block.planned_min || 30);
       setDid("done");
@@ -79,6 +95,21 @@ export function BlockSheet({ open, day, block, mode, onClose, onChanged }: Props
     }
   }, [open, mode, block?.id]);
 
+  const applyTemplate = (tmpl: ScheduleTemplate) => {
+    setTitle(tmpl.title);
+    setKind(tmpl.kind);
+    setPriority((tmpl.priority as "P0" | "P1" | "P2") || "P2");
+    setIntent(
+      (tmpl.intent as ScheduledBlock["intent"]) ||
+        (tmpl.kind === "explore"
+          ? "explore"
+          : tmpl.kind === "restore_fun"
+            ? "restore_fun"
+            : "duty"),
+    );
+    setEnd(addMinutes(start, tmpl.default_min || 30));
+  };
+
   const saveFeedback = async () => {
     if (!block) return;
     setBusy(true);
@@ -157,6 +188,22 @@ export function BlockSheet({ open, day, block, mode, onClose, onChanged }: Props
     >
       {mode === "create" ? (
         <div class="stack">
+          {templates.length > 0 && (
+            <>
+              <span class="field-label">From template</span>
+              <div class="choice-list">
+                {templates.slice(0, 8).map((tmpl) => (
+                  <Pressable
+                    key={tmpl.id}
+                    className="choice-item"
+                    onClick={() => applyTemplate(tmpl)}
+                  >
+                    {tmpl.title}
+                  </Pressable>
+                ))}
+              </div>
+            </>
+          )}
           <label class="field-label">
             Title
             <input class="field-input" value={title} onInput={(e) => setTitle((e.target as HTMLInputElement).value)} />
@@ -255,22 +302,18 @@ export function BlockSheet({ open, day, block, mode, onClose, onChanged }: Props
           )}
           <span class="field-label">Energy after</span>
           <div class="segment-row">
-            {[
-              [-2, "Worse"],
-              [0, "Same"],
-              [2, "Better"],
-            ].map(([v, label]) => (
+            {([-2, -1, 0, 1, 2] as const).map((v) => (
               <Pressable
                 key={String(v)}
                 className="segment"
                 ariaPressed={energy === v}
-                onClick={() => setEnergy(Number(v))}
+                onClick={() => setEnergy(v)}
               >
-                {label}
+                {v > 0 ? `+${v}` : String(v)}
               </Pressable>
             ))}
           </div>
-          {(block.intent === "explore" || block.intent === "restore_fun") && did !== "skipped" && (
+          {did !== "skipped" && (
             <>
               <span class="field-label">Would repeat?</span>
               <div class="segment-row">

frontend/src/pages/Plan.tsx

@@ -1,4 +1,4 @@
-/** Plan day view: iOS-like timeline, reschedule, add/complete blocks.
+/** Plan day view: iOS-like timeline, seed, reschedule, add/complete blocks.
 
 Nav IA: Home | Plan | (+) Log | Daily | Settings (History via Home).
 */
@@ -8,6 +8,7 @@ import { useEffect, useState } from "preact/hooks";
 import {
   getPlan,
   reschedulePlan,
+  seedPlan,
   type DayPlanView,
   type ScheduledBlock,
 } from "../api";
@@ -17,6 +18,7 @@ import { Pressable } from "../components/Pressable";
 import { Timeline } from "../components/Timeline";
 import { useToast } from "../components/Toast";
 import { isoDate } from "../dates";
+import { navigate } from "../router";
 
 function shiftDay(day: string, delta: number): string {
   const d = new Date(`${day}T00:00:00`);
@@ -49,8 +51,13 @@ export function Plan({ initialDate }: { initialDate?: string }) {
     }
   };
 
+  useEffect(() => {
+    if (initialDate && initialDate !== day) setDay(initialDate);
+  }, [initialDate]);
+
   useEffect(() => {
     void load(day);
+    navigate(`/plan/${day}`);
   }, [day]);
 
   const openBlock = (block: ScheduledBlock) => {
@@ -65,8 +72,20 @@ export function Plan({ initialDate }: { initialDate?: string }) {
     setSheetOpen(true);
   };
 
+  const onSeed = async () => {
+    setBusy(true);
+    try {
+      setPlan(await seedPlan(day));
+      toast.show("Starter day added");
+    } catch (e) {
+      toast.show(e instanceof Error ? e.message : "Seed failed", "error");
+    } finally {
+      setBusy(false);
+    }
+  };
+
   const onReschedule = async () => {
-    if (!confirm("Reschedule the rest of this day? Must-do blocks stay put.")) return;
+    if (!confirm("Reschedule the rest of this day? Locked blocks stay put.")) return;
     setBusy(true);
     try {
       const result = await reschedulePlan(day, { reason: "user", force: true });
@@ -81,6 +100,7 @@ export function Plan({ initialDate }: { initialDate?: string }) {
 
   const capacity = plan?.capacity_hint ?? 1;
   const health = plan?.health;
+  const empty = !plan?.blocks.length;
 
   return (
     <div class="app-shell">
@@ -126,14 +146,19 @@ export function Plan({ initialDate }: { initialDate?: string }) {
           </Button>
         </div>
 
-        {!plan?.blocks.length ? (
+        {empty ? (
           <section class="surface-card empty-card stack">
-            <p>No blocks yet. Add one, or Reschedule for a starter plan.</p>
-            <Button onClick={openCreate}>Add block</Button>
+            <p>No blocks yet. Seed a light starter day, or add one block.</p>
+            <Button disabled={busy} onClick={onSeed}>
+              Seed starter day
+            </Button>
+            <Button className="btn-secondary" disabled={busy} onClick={openCreate}>
+              Add block
+            </Button>
           </section>
         ) : (
           <section class="surface-card timeline-card">
-            <Timeline blocks={plan.blocks} onSelect={openBlock} />
+            <Timeline blocks={plan!.blocks} onSelect={openBlock} />
           </section>
         )}
       </main>

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-D3LLeLlA.js"></script>
+    <script type="module" crossorigin src="/assets/index-CsRld2Dr.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-6RturTFo.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-6RturTFo.css","/assets/index-D3LLeLlA.js","/assets/index-D3LLeLlA.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-6RturTFo.css","/assets/index-CsRld2Dr.js","/assets/index-CsRld2Dr.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_schedule_api.py

@@ -0,0 +1,95 @@
+"""API smoke tests for plan seed, feedback priors, agent auth, rules reschedule."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+from app.config import get_settings
+from app.schedule_math import ev_score
+from app.schedule_reschedule import seed_starter_blocks
+
+
+@pytest.fixture()
+def client(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> TestClient:
+    monkeypatch.setenv("DATA_ROOT", str(tmp_path / "data"))
+    monkeypatch.setenv("AGENT_TOKEN", "test-agent-token")
+    monkeypatch.setenv("APP_SECRET_KEY", "test-secret-key")
+    monkeypatch.setenv("APP_PASSWORD", "test-password")
+    monkeypatch.setenv("ENV", "dev")
+    get_settings.cache_clear()
+    from app.main import create_app
+
+    c = TestClient(create_app())
+    assert c.post("/api/auth/login", json={"password": "test-password"}).status_code == 200
+    return c
+
+
+def test_ev_score_locked_formula() -> None:
+    base = ev_score(p_done=0.8, utility=1.0, fun=0.5, d_hat_min=30, fse=0.2)
+    raised = ev_score(
+        p_done=0.8,
+        utility=1.0,
+        fun=0.5,
+        d_hat_min=30,
+        fse=0.2,
+        raise_eta=True,
+        raise_lambda_f=True,
+    )
+    assert isinstance(base, float) and isinstance(raised, float)
+
+
+def test_seed_starter_keeps_p0() -> None:
+    blocks = seed_starter_blocks("2026-07-19", capacity_hint=0.8)
+    kinds = {b.kind for b in blocks}
+    assert "food_out" in kinds and "sleep_window" in kinds
+    assert all(b.locked for b in blocks if b.priority == "P0")
+
+
+def test_plan_seed_and_feedback_priors(client: TestClient) -> None:
+    day = "2026-07-19"
+    r = client.post(f"/api/plan/{day}/seed")
+    assert r.status_code == 200, r.text
+    plan = r.json()["data"]
+    assert plan["blocks"]
+    assert "capacity_hint" in plan
+    bid = plan["blocks"][0]["id"]
+    fb = client.post(
+        f"/api/plan/{day}/blocks/{bid}/feedback",
+        json={
+            "did": "done",
+            "actual_min": 20,
+            "quality": 4,
+            "fun": 3,
+            "energy_after": 1,
+            "would_repeat": "yes",
+        },
+    )
+    assert fb.status_code == 200, fb.text
+    priors = client.get("/api/schedule/priors").json()["data"]["kinds"]
+    assert any(p.get("n", 0) >= 1 for p in priors)
+
+
+def test_agent_requires_token(client: TestClient) -> None:
+    bare = TestClient(client.app)
+    r = bare.get("/api/agent/context?day=2026-07-19")
+    assert r.status_code in (401, 403)
+    ok = bare.get(
+        "/api/agent/context?day=2026-07-19",
+        headers={"Authorization": "Bearer test-agent-token"},
+    )
+    assert ok.status_code == 200
+    assert ok.json()["data"]["constraints"]["scope"] == "P1_thin_loop"
+
+
+def test_reschedule_rules_source(client: TestClient) -> None:
+    day = "2026-07-20"
+    client.post(f"/api/plan/{day}/seed")
+    r = client.post(f"/api/plan/{day}/reschedule", json={"reason": "test", "force": True})
+    assert r.status_code == 200, r.text
+    body = r.json()["data"]
+    assert body["source"] in ("rules", "openrouter")
+    p0 = [b for b in body["plan"]["blocks"] if b["priority"] == "P0"]
+    assert p0