Speed + UX: trim scored schema, cache prompt, lighter ctx, live status

App-only deploy to the Space. Same app changes as origin commit 6408b42 but
without the demo/ video tooling (and its font binary, which HF rejects and the
running app never uses).

- PARSE schema trimmed to ranker-only fields (~20-35% fewer output tokens)
- Why column derived from score.explain (deterministic, zero tokens)
- cache_prompt: reuse system-prompt KV between calls
- llama-server ctx 8192 -> 4096
- prioritize() streams an instant status so CPU inference isn't a frozen wait

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

app.py

@@ -37,6 +37,35 @@ Two scores compete and the higher one shows:
 DF_HEADERS = ["#", "Task", "Score", "Due", "Flag", "Why", "I", "R", "Eff·h"]
 DF_DATATYPES = ["number", "str", "str", "str", "str", "str", "number", "number", "number"]
 
+# ── Branding, borrowed from the full what-first.com app ───────────────────────
+# Indigo → blue gradient, slate/ink text, Roboto — the palette the marketing
+# site and the demo video (demo/compose.py) share.
+INDIGO, BLUE = "#4F46E5", "#2563EB"
+SLATE, INK, MUTED = "#1E293B", "#111827", "#5A6473"
+
+THEME = gr.themes.Soft(
+    primary_hue=gr.themes.colors.indigo,
+    secondary_hue=gr.themes.colors.blue,
+    neutral_hue=gr.themes.colors.slate,
+    font=[gr.themes.GoogleFont("Roboto"), "system-ui", "sans-serif"],
+).set(
+    button_primary_background_fill=f"linear-gradient(90deg, {INDIGO}, {BLUE})",
+    button_primary_background_fill_hover=f"linear-gradient(90deg, {BLUE}, {INDIGO})",
+    button_primary_text_color="white",
+    block_title_text_weight="600",
+)
+
+CSS = f"""
+#wf-hero {{
+  background: linear-gradient(120deg, {INDIGO}, {BLUE});
+  color: #fff; border-radius: 16px; padding: 26px 30px; margin-bottom: 8px;
+}}
+#wf-hero h1 {{ margin: 0 0 6px; font-weight: 700; letter-spacing: -0.5px; }}
+#wf-hero p {{ margin: 0; opacity: 0.92; font-size: 1.02em; line-height: 1.5; }}
+#wf-hero a {{ color: #fff; text-decoration: underline; }}
+#wf-first {{ color: {SLATE}; font-weight: 600; }}
+"""
+
 
 def _label(t: dict) -> str:
     return f"{t['id']} · {t['title']}"
@@ -59,19 +88,30 @@ def render(tasks: list[dict]):
             score.format_score(c["display"]),
             score.due_label(t.get("due_date"), now) if t.get("due_date") else "—",
             flag,
-            t.get("reason", "") or "",
+            score.explain(t, now) + (" · edited" if t.get("edited") else ""),
             round(c["I"]),
             round(c["R"]),
             round(t["effort_hours"], 2),
         ])
     top = ranked[0]
-    header = f"### ▶ Do this first: **{top['title']}**  ·  score {score.format_score(score.priority(top))}"
+    header = (
+        f"### <span id='wf-first'>▶ Do this first: {top['title']}</span>"
+        f"  ·  score {score.format_score(score.priority(top))}"
+    )
     return header, rows, [_label(t) for t in ranked]
 
 
 def prioritize(text, image, tasks):
+    # A generator: the first yield lands instantly so the ~60s CPU inference
+    # doesn't look like a frozen app. Gradio streams each yield to the UI.
     if not llm.is_ready():
-        return tasks, "### ⏳ The local model is still loading — give it a moment and try again.", [], gr.update()
+        yield tasks, "### ⏳ The local model is still loading — give it a moment and try again.", [], gr.update()
+        return
+    hint = ""
+    if text and text.strip():
+        n = len([ln for ln in text.splitlines() if ln.strip()])
+        hint = f" ~{n} item{'s' if n != 1 else ''}"
+    yield tasks, f"### ⏳ Reading and scoring{hint} on the local model… (~60s on free CPU)", [], gr.update()
     collected = []
     if text and text.strip():
         collected += llm.parse_braindump(text)
@@ -80,9 +120,10 @@ def prioritize(text, image, tasks):
     for i, t in enumerate(collected):
         t["id"] = f"t{i}"
     if not collected:
-        return collected, "### Nothing actionable found — try a different dump or photo.", [], gr.update(choices=[], value=None)
+        yield collected, "### Nothing actionable found — try a different dump or photo.", [], gr.update(choices=[], value=None)
+        return
     header, rows, choices = render(collected)
-    return collected, header, rows, gr.update(choices=choices, value=(choices[0] if choices else None))
+    yield collected, header, rows, gr.update(choices=choices, value=(choices[0] if choices else None))
 
 
 def load_task(sel, tasks):
@@ -98,7 +139,7 @@ def apply_edit(sel, impact, readiness, effort, tasks):
         t["impact"] = int(impact)
         t["readiness"] = int(readiness)
         t["effort_hours"] = float(effort)
-        t["reason"] = (t.get("reason") or "").split(" · edited")[0] + " · edited"
+        t["edited"] = True
     header, rows, choices = render(tasks)
     keep = sel if sel in choices else (choices[0] if choices else None)
     return tasks, header, rows, gr.update(choices=choices, value=keep)
@@ -121,12 +162,16 @@ def _find(sel, tasks):
     return next((x for x in tasks if x["id"] == tid), None)
 
 
-with gr.Blocks(title="whatfirst-small", theme=gr.themes.Soft()) as demo:
-    gr.Markdown(
-        "# whatfirst · small\n"
-        "Dump everything on your mind — or snap a photo of your to-do list — and a "
-        "**small local model** turns it into structured tasks. A **transparent scoring "
-        "engine** then tells you what to do *first*, and shows its work. No cloud, no API keys."
+with gr.Blocks(title="whatfirst-small", theme=THEME, css=CSS) as demo:
+    gr.HTML(
+        "<div id='wf-hero'>"
+        "<h1>whatfirst · small</h1>"
+        "<p>Dump everything on your mind — or snap a photo of your to-do list — and a "
+        "<strong>small local model</strong> turns it into structured tasks. A "
+        "<strong>transparent scoring engine</strong> then tells you what to do <em>first</em>, "
+        "and shows its work. No cloud, no API keys. &nbsp;The full app lives at "
+        "<a href='https://what-first.com'>what-first.com</a>.</p>"
+        "</div>"
     )
     tasks_state = gr.State([])
 
@@ -141,7 +186,10 @@ with gr.Blocks(title="whatfirst-small", theme=gr.themes.Soft()) as demo:
                 go = gr.Button("Prioritize", variant="primary")
                 sample = gr.Button("Try a sample")
         with gr.Column(scale=3):
-            header = gr.Markdown("### Add a brain-dump or a photo, then hit **Prioritize**.")
+            header = gr.Markdown(
+                "### Add a brain-dump or a photo, then hit **Prioritize**.",
+                sanitize_html=False,
+            )
             table = gr.Dataframe(
                 headers=DF_HEADERS, datatype=DF_DATATYPES, interactive=False,
                 wrap=True, label="Ranked",

llm.py

@@ -63,6 +63,10 @@ def _chat(system: str, user_content, max_tokens: int) -> str:
         "top_p": 0.9,
         "stream": False,
         "response_format": {"type": "json_object"},
+        # Keep the (identical, ~400-token) system-prompt prefix in the server's
+        # KV cache between calls, so repeated requests — the image flow's two
+        # passes, per-task re-suggest, back-to-back demos — skip re-processing it.
+        "cache_prompt": True,
     }
     r = requests.post(CHAT_URL, json=payload, timeout=REQUEST_TIMEOUT)
     r.raise_for_status()

prompts.py

@@ -23,18 +23,15 @@ effort_hours: realistic focused time. 0.25 = 15 minutes, 1 = an hour, 8 = a day.
 
 PARSE_SYSTEM_PROMPT = f"""You turn a messy brain-dump into a prioritized task list for a personal productivity app. The text is one person listing things they need to do; it may ramble, run several tasks together, or include filler.
 
-Output a JSON object: {{ "items": [ {{ "title": string, "category": string | null, "notes": string | null, "due_date": string | null, "due_time": string | null, "impact": integer, "readiness": integer, "effort_hours": number, "reason": string }} ] }}
+Output a JSON object: {{ "items": [ {{ "title": string, "due_date": string | null, "due_time": string | null, "impact": integer, "readiness": integer, "effort_hours": number }} ] }}
 
 {SCALE_GUIDE}
 
 Rules:
 - title is a short imperative phrase, sentence case, no trailing period, under 90 characters. Prefer the person's own words.
-- category is a 1-2 word project name if obvious (e.g. "Work", "Home", "Errands"); otherwise null.
-- notes is a clarifying detail that won't fit in the title; otherwise null.
 - due_date: if a day, date, or deadline is named ("Friday", "tomorrow", "by the 5th", "end of week"), resolve it to YYYY-MM-DD relative to the current date given below. Otherwise null.
 - due_time: if a clock time is named ("at 11pm", "by 9am", "noon"), resolve it to 24-hour HH:MM. If a day but no clock time, null. Never invent a time.
 - impact, readiness, effort_hours: always score every task using the scale above. If importance is stated ("really important", "no rush"), let it guide impact.
-- reason: one short lowercase sentence, no exclamations, under 14 words, explaining the scores.
 - Split distinct tasks into separate items. Skip greetings, filler, and self-talk that isn't a task.
 - Return at most 25 items. Drop near-duplicates.
 - If there are no actionable tasks, return {{ "items": [] }}.

score.py

@@ -22,10 +22,6 @@ PREP_BIAS = 0.7    # action bias on the prep branch (<1)
 SCORE_CAP = 1000   # backstop guard, above the formula's natural max
 TIE_BAND = 0.10    # value-closeness band (log-bucketed for transitivity)
 
-# Quick-win lens: a short, ready-to-start task for a spare moment.
-QUICK_WIN_MAX_EFFORT_HOURS = 0.25  # 15 minutes
-QUICK_WIN_MIN_READINESS = 7
-
 
 def clamp(x: float, lo: float, hi: float) -> float:
     return max(lo, min(hi, x))
@@ -66,13 +62,6 @@ def comp_urgency(d: float, e_hours: float) -> float:
     return min(30, base + accel)
 
 
-def urgency(due_date, effort_hours) -> float:
-    if not due_date:
-        return 2
-    d = days_to_due_raw(due_date)
-    return max(cal_urgency(d), comp_urgency(d, effort_hours or 0.05))
-
-
 # -- Core score ---------------------------------------------------------------
 
 def score_components(t: dict) -> dict:
@@ -115,24 +104,6 @@ def value_bucket(v: float) -> int:
     return math.floor(math.log(max(v, 0.1)) / math.log(1 + TIE_BAND))
 
 
-# -- Assignment (collapses to "always mine" with no teams) --------------------
-
-def assignee_ids(task: dict) -> list:
-    ids = task.get("assignee_user_ids")
-    if isinstance(ids, list):
-        return ids
-    if task.get("assignee_user_id") is not None:
-        return [task["assignee_user_id"]]
-    return []
-
-
-def mine_to_do(task: dict, current_user_id=None) -> bool:
-    if current_user_id is None:
-        return True
-    ids = assignee_ids(task)
-    return len(ids) == 0 or current_user_id in ids
-
-
 # -- Dates --------------------------------------------------------------------
 
 def normalize_iso(due_date):
@@ -180,7 +151,7 @@ def deadline_status(task: dict, now: datetime | None = None):
 
 # -- Ranking ------------------------------------------------------------------
 
-def deadline_risk_map(sorted_active: list, now: datetime | None = None, current_user_id=None) -> dict:
+def deadline_risk_map(sorted_active: list, now: datetime | None = None) -> dict:
     """Walk the queue in priority order, accumulate effort, and flag any task
     whose projected wall-clock finish lands past its deadline. Returns
     {id: 'at-risk' | 'tight'}."""
@@ -190,8 +161,6 @@ def deadline_risk_map(sorted_active: list, now: datetime | None = None, current_
     for t in sorted_active:
         if not t or t.get("completed"):
             continue
-        if not mine_to_do(t, current_user_id):
-            continue
         E = max(t.get("effort_hours") or 0, 0)
         acc += E
         if not t.get("due_date"):
@@ -210,7 +179,7 @@ def deadline_risk_map(sorted_active: list, now: datetime | None = None, current_
     return out
 
 
-def rank_active(tasks: list, now: datetime | None = None, current_user_id=None) -> list:
+def rank_active(tasks: list, now: datetime | None = None) -> list:
     """Rank with deadlines as a constraint, not a blended term. Three tiers:
     0 overdue (EDF), 1 binding/at-risk (EDF, lifted above the value pack),
     2 value pack (value bucket, then sooner due breaks near-ties)."""
@@ -219,11 +188,9 @@ def rank_active(tasks: list, now: datetime | None = None, current_user_id=None)
     V = {t["id"]: priority(t) for t in active}
     D = {t["id"]: days_to_due_raw(t.get("due_date"), now) for t in active}
     by_value = sorted(active, key=lambda t: V[t["id"]], reverse=True)
-    risk = deadline_risk_map(by_value, now, current_user_id)
+    risk = deadline_risk_map(by_value, now)
 
     def tier_of(t):
-        if not mine_to_do(t, current_user_id):
-            return 2
         if t.get("due_date") and D[t["id"]] <= 0:
             return 0
         return 1 if risk.get(t["id"]) == "at-risk" else 2
@@ -239,25 +206,6 @@ def rank_active(tasks: list, now: datetime | None = None, current_user_id=None)
     return sorted(by_value, key=sort_key)
 
 
-# -- Quick-win lens -----------------------------------------------------------
-
-def is_quick_win(task: dict) -> bool:
-    if not task or task.get("completed"):
-        return False
-    e = task.get("effort_hours")
-    if not isinstance(e, (int, float)) or not math.isfinite(e) or e <= 0 or e > QUICK_WIN_MAX_EFFORT_HOURS:
-        return False
-    return readiness_of(task) >= QUICK_WIN_MIN_READINESS or bool(task.get("execute_anyway"))
-
-
-def quick_wins(tasks: list) -> list:
-    """Quick wins, shortest first, ties by priority desc."""
-    return sorted(
-        (t for t in tasks if is_quick_win(t)),
-        key=lambda t: (t["effort_hours"], -priority(t)),
-    )
-
-
 # -- Display helpers ----------------------------------------------------------
 
 def format_score(n: float) -> str:
@@ -265,6 +213,33 @@ def format_score(n: float) -> str:
     return str(int(rounded)) if rounded == int(rounded) else f"{rounded:.1f}"
 
 
+def explain(t: dict, now: datetime | None = None) -> str:
+    """A short, deterministic 'why it ranks here' phrase, read off the same
+    components that drive the score. This replaces a model-written reason: it
+    costs the model no tokens to produce and can never drift from the math the
+    way an LLM sentence can."""
+    now = now or datetime.now()
+    c = score_components(t)
+    I, R, E = c["I"], c["R"], c["E"]
+    status = deadline_status(t, now)
+    if status == "overdue":
+        return "overdue — start now"
+    if c["prep_wins"]:
+        return ("high-value but not ready — de-risk first" if I >= 5
+                else "not ready — needs a first step")
+    if status in ("today", "tomorrow"):
+        return f"due {status} — time-sensitive"
+    if E <= 1 and R >= 7:
+        return "quick win — short and ready"
+    if R <= 3:
+        return "blocked — next step unclear"
+    if I >= 8:
+        return "high-impact work"
+    if I <= 3:
+        return "minor — low impact"
+    return "steady priority"
+
+
 def due_label(due_date, now: datetime | None = None) -> str:
     """Compact relative deadline label ('now', '3h', 'tomorrow', '2d', '5d late')."""
     if not due_date:

start.sh

@@ -14,7 +14,7 @@ echo "[start] launching llama-server"
   --model "${MODEL_DIR}/${MODEL_FILE}" \
   --mmproj "${MODEL_DIR}/${MMPROJ_FILE}" \
   --host 127.0.0.1 --port 8080 \
-  --ctx-size 8192 \
+  --ctx-size 4096 \
   --threads "$(nproc)" &
 
 # 3. Start the Gradio app (foreground). is_ready() polls the server's /health,

test_score.py

@@ -123,19 +123,6 @@ def test_completed_tasks_excluded():
     assert order == ["live"]
 
 
-# -- Quick wins ---------------------------------------------------------------
-
-def test_quick_win_filter_and_order():
-    tasks = [
-        {"id": "a", "impact": 5, "readiness": 9, "effort_hours": 0.1},   # qualifies
-        {"id": "b", "impact": 9, "readiness": 9, "effort_hours": 0.05},  # qualifies, shorter
-        {"id": "c", "impact": 5, "readiness": 3, "effort_hours": 0.1},   # too unready
-        {"id": "d", "impact": 5, "readiness": 9, "effort_hours": 2},     # too long
-    ]
-    order = [t["id"] for t in s.quick_wins(tasks)]
-    assert order == ["b", "a"], order  # shortest first
-
-
 def test_due_label():
     assert s.due_label("2026-06-08T12:00:00", NOW) == "tomorrow"
     assert s.due_label("2026-06-12T12:00:00", NOW) == "5d"