`, favicon, and body of `Root()` to\nmatch your app's existing `index.html`, and stamp anything else your shell\nreferences directly (images, css) with `immutableFileUrl()`.\n\n1. Create `frontend/root.tsx`:\n\n```tsx\n/** @jsxImportSource npm:hono@4/jsx */\nimport { raw } from \"npm:hono@4/html\";\nimport { immutableFileUrl } from \"https://esm.town/v/std/utils/index.ts\";\n\n// The HTML shell for the app. It is never cached, so immutableFileUrl can stamp\n// the current val version into each asset URL — the browser caches those\n// immutably, and publishing the val changes the URLs, refetching exactly once.\nexport function Root() {\n return (\n <>\n {raw(\"<!DOCTYPE html>\")}\n <html lang=\"en\">\n <head>\n <meta charSet=\"UTF-8\" />\n <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n <title>React Hono Val Town Starter

[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_328":329,"_330":331},"routes/_app.x.$handle.$name",{"_11":12,"_13":14,"_15":-7,"_18":19,"_17":-7,"_244":-5,"_20":245,"_22":246,"_247":248,"_249":250,"_26":251,"_24":252,"_253":254,"_255":256,"_257":51,"_258":259,"_260":71,"_261":-5,"_262":-5,"_263":264},"routes/_app.x.$handle.$name.code.$",{"_11":12,"_13":14,"_15":16,"_17":-7,"_18":19,"_20":21,"_22":23,"_24":25,"_26":27,"_28":29,"_30":-5,"_31":32,"_33":34,"_35":-5},"handle","wakawaka1","name","Register","branchName","main","version","path","frontend/components/review.tsx","project",{"_36":196,"_13":14,"_38":197,"_49":-5,"_198":51,"_52":53,"_199":53,"_200":-5,"_201":202,"_203":204,"_205":90,"_206":71,"_207":-5,"_208":-5,"_209":34,"_56":210,"_211":212,"_213":214,"_215":216,"_217":-5,"_218":219,"_220":219,"_221":222,"_223":222,"_224":222,"_225":219,"_226":219,"_227":228,"_229":230,"_231":232,"_50":51},"tree",[83,84,85,86,87],"file",{"_36":60,"_13":61,"_62":63,"_64":65,"_66":67,"_68":69,"_70":71,"_38":72,"_17":73,"_74":75,"_76":77,"_78":51,"_79":-5,"_18":80},"contents",[],"upstream",{"_36":37,"_38":39,"_40":41,"_13":16,"_42":43,"_17":44,"_45":-5,"_46":-5,"_47":48,"_49":-5,"_50":51,"_52":53,"_54":55,"_56":57,"_58":59},"pull","ahead",36,"behind",0,"envVars","id","961078ea-f528-11ef-aa68-569c3dd06744","createdAt",["D",1740674013689],"updatedAt",["D",1785420707976],"projectId","96102714-f528-11ef-aa68-569c3dd06744",91,"forkedBranchId","forkedBranchVersion","lockfileKey","1785420708123-esm.town_v_templates_react-hono-starter@91-main","deletedAt","isOwned",false,"privacy","public","userHandle","templates","orgId","019aa807-52c2-709c-928b-2029bae9a558","projectName","react-hono-starter","7fdc30a2-0936-4cb3-b38e-c3aeb02376d6","review.tsx","fileId","6b115e38-aa59-11f1-a1d5-1607ee4eb77e","parentId","019fb508-534b-72f8-ae6b-5c9134b15841","branchId","77aeb2e4-2684-499f-b0b5-734576b3c68b","branchVersion",34,"latest",true,["D",1788745310914],3,"fileType","script","content","/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport {\n forwardRef,\n useEffect,\n useRef,\n useState,\n} from \"https://esm.sh/react@18.2.0\";\nimport {\n api,\n Area,\n Btn,\n Field,\n fileToBase64,\n fmt,\n Label,\n Panel,\n PROOF,\n proofLabel,\n Stat,\n T,\n} from \"./ui.tsx\";\n\n// frontend/components/review.tsx — the weekly review passes and the card.\n\n// ───────────────────────────────────────────────────────── passes\n\nfunction PassClose({ state, next }: any) {\n const open = state.open_week;\n const ids: string[] = JSON.parse(open.required_json);\n const items = ids.map((i) => state.backlog.find((b: any) => b.id === i))\n .filter(Boolean);\n const [busy, setBusy] = useState(false);\n const [err, setErr] = useState(null);\n\n return (\n

\n pass 1 — verdict\n \n Read-only. These were verified live during the week.\n

\n {items.map((it: any) => (\n \n \n {it.title}\n \n \n {it.done_week === open.iso_week ? \"verified\" : \"outstanding\"}\n \n

\n ))}\n\n {!state.can_close && (\n \n The week's still running and something's outstanding. Finish it, or\n come back Sunday.\n

\n )}\n {err && (\n \n {err}\n

\n )}\n\n

\n {\n setBusy(true);\n setErr(null);\n try {\n const v = await api(\"/week/close\", { iso_week: open.iso_week });\n next({ verdict: v });\n } catch (e: any) {\n setErr(e.message);\n }\n setBusy(false);\n }}\n >\n {busy ? \"…\" : \"Close the week\"}\n \n

\n \n );\n}\n\nfunction PassInbox({ state, next, reload }: any) {\n const [queue, setQueue] = useState(state.inbox_pending);\n const [title, setTitle] = useState(\"\");\n const [ptype, setPtype] = useState(\"artifact_photo\");\n const [pdesc, setPdesc] = useState(\"\");\n const [busy, setBusy] = useState(false);\n const [think, setThink] = useState(false);\n const cur = queue[0];\n\n useEffect(() => {\n setTitle(cur ? cur.raw : \"\");\n setPdesc(\"\");\n setPtype(\"artifact_photo\");\n }, [cur?.id]);\n\n if (!cur) {\n return (\n

\n pass 2 — inbox\n \n {state.inbox_pending.length > 0\n ? \"Left for next time.\"\n : \"Inbox empty.\"}\n

\n {\n await reload();\n next({});\n }}\n >\n Continue\n \n

\n );\n }\n\n return (\n

\n \n pass 2 — inbox · {queue.length} left\n {\n await reload();\n next({});\n }}\n style={{\n background: \"none\",\n border: \"none\",\n padding: 0,\n cursor: \"pointer\",\n fontFamily: T.mono,\n fontSize: 11,\n color: T.faint,\n }}\n >\n skip the rest →\n \n

\n \n \n {cur.raw}\n

\n \n captured {new Date(cur.captured_at).toLocaleDateString(\"en-NZ\")}\n

\n \n\n one action\n setTitle(e.target.value)} />\n

\n proof type\n \n {PROOF.map((p) => (\n setPtype(p.v)}\n style={{ padding: \"7px 11px\", fontSize: 13 }}\n >\n {p.label}\n \n ))}\n

\n what the photo shows\n setPdesc(e.target.value)}\n placeholder=\"a booking confirmation from the gym\"\n />\n\n

\n {\n setBusy(true);\n try {\n await api(\"/backlog\", {\n from_inbox: [cur.id],\n title: title.trim(),\n proof_type: ptype,\n proof_description: pdesc.trim(),\n });\n setQueue((q) => q.slice(1));\n } catch (e: any) {\n alert(e.message);\n }\n setBusy(false);\n }}\n >\n File it\n \n {\n setThink(true);\n try {\n const p = await api(\"/ai/promote\", { raw: cur.raw });\n if (p.title) setTitle(p.title);\n if (p.proof_type) setPtype(p.proof_type);\n if (p.proof_description) setPdesc(p.proof_description);\n } catch {}\n setThink(false);\n }}\n >\n {think ? \"…\" : \"Suggest\"}\n \n {\n setBusy(true);\n await api(\"/inbox/discard\", { ids: [cur.id] });\n setQueue((q) => q.slice(1));\n setBusy(false);\n }}\n >\n Bin it\n \n setQueue((q) => q.slice(1))}>Later\n

\n {pdesc.trim().length < 10 && (\n \n No describable photo means it isn't an action yet. Shrink it until you\n can name the image.\n

\n )}\n \n );\n}\n\n// Confession must never be expensive, or you'll start confessing one small\n// thing a week. Only the worst becomes mandatory; the rest get a short fuse.\nfunction PassLoopholes({ next, reload }: any) {\n const [qs, setQs] = useState(null);\n const [answers, setAnswers] = useState(\"\");\n const [props, setProps] = useState(null);\n // Tracked by identity, not list position — dropping a row above the chosen\n // one would otherwise move the amber dot onto a different item silently.\n const [worst, setWorst] = useState(null);\n const [busy, setBusy] = useState(false);\n\n return (\n

\n pass 3 — loopholes\n {!qs && (\n <>\n \n Where did your laziness find a way round the system this week?\n

\n {\n setBusy(true);\n const r = await api(\"/ai/interrogate\", {});\n setQs(r.questions);\n setBusy(false);\n }}\n >\n {busy ? \"…\" : \"Interrogate me\"}\n \n next({})}>Skip\n

\n \n )}\n\n {qs && !props && (\n <>\n {qs.map((q, i) => (\n \n {q}\n

\n ))}\n

\n setAnswers(e.target.value)}\n placeholder=\"Answer honestly. Confessing more costs you nothing.\"\n />\n

\n {\n setBusy(true);\n const r = await api(\"/ai/interrogate\", {\n questions: qs,\n answers,\n });\n const list = (r.proposals || []).map((x: any, i: number) => ({\n ...x,\n _id: \"p\" + i,\n }));\n setProps(list);\n setWorst(list.length ? list[0]._id : null);\n setBusy(false);\n }}\n >\n {busy ? \"…\" : \"Turn into actions\"}\n \n next({})}>Skip\n

\n \n )}\n\n {props && (\n <>\n \n Pick the worst one. That closes next week, guaranteed. The rest go\n to the backlog on a two-week fuse.\n

\n {props.length === 0 && (\n \n All dropped. Nothing to file.\n

\n )}\n {props.map((p: any) => (\n \n setWorst(p._id)}\n style={{\n flexShrink: 0,\n width: 20,\n height: 20,\n borderRadius: 10,\n marginTop: 3,\n border: \"1px solid \" + (worst === p._id ? T.owed : T.line),\n background: worst === p._id ? T.owed : \"transparent\",\n cursor: \"pointer\",\n }}\n />\n setWorst(p._id)}\n style={{ flex: 1, cursor: \"pointer\" }}\n >\n \n {p.title}\n

\n \n {proofLabel(p.proof_type)} — {p.proof_description}\n

\n \n setProps((list: any) => {\n const kept = list.filter((x: any) => x._id !== p._id);\n if (worst === p._id) {\n setWorst(kept.length ? kept[0]._id : null);\n }\n return kept;\n })}\n style={{\n background: \"none\",\n border: \"none\",\n padding: \"0 0 0 8px\",\n cursor: \"pointer\",\n fontFamily: T.mono,\n fontSize: 11,\n color: T.faint,\n alignSelf: \"flex-start\",\n flexShrink: 0,\n }}\n >\n drop\n \n

\n ))}\n

\n {\n setBusy(true);\n const forced: string[] = [];\n for (const p of props as any[]) {\n try {\n const r = await api(\"/backlog\", {\n from_inbox: [],\n title: p.title,\n proof_type: p.proof_type,\n proof_description: p.proof_description,\n origin: \"loophole\",\n });\n if (p._id === worst) forced.push(r.id);\n } catch {}\n }\n await reload();\n next({ forced });\n setBusy(false);\n }}\n >\n {busy ? \"…\" : \"File \" + props.length}\n \n next({})}>\n {props.length ? \"Skip\" : \"Continue\"}\n \n

\n \n )}\n \n );\n}\n\nfunction PassAged({ state, next, reload }: any) {\n const flagged = state.backlog.filter(\n (b: any) => (b.needs_decision || b.needs_reshape) && !b.mandatory,\n );\n const [forced, setForced] = useState([]);\n const [editing, setEditing] = useState(null);\n const [t, setT] = useState(\"\");\n const [d, setD] = useState(\"\");\n const [busy, setBusy] = useState(false);\n\n if (!flagged.length) {\n return (\n

\n pass 4 — forced decisions\n \n Nothing overdue or repeatedly failed.\n

\n next({})}>Continue\n

\n );\n }\n\n return (\n

\n pass 4 — forced decisions\n \n Carried too long, or failed three times. Require it, reshape it, or kill\n it.\n

\n {flagged.map((b: any) => (\n \n \n \n {b.title}\n

\n \n {b.needs_reshape\n ? \"failed \" + b.fail_count + \"x\"\n : b.age_weeks + \"w\"}\n {b.mention_count > 0 ? \" · said \" + b.mention_count + \"x\" : \"\"}\n \n

\n\n {editing === b.id\n ? (\n

\n setT(e.target.value)}\n placeholder=\"smaller title\"\n />\n

\n setD(e.target.value)}\n placeholder=\"what the photo shows\"\n />\n

\n {\n setBusy(true);\n await api(\"/backlog/reshape\", {\n id: b.id,\n title: t,\n proof_description: d,\n });\n await reload();\n setEditing(null);\n setBusy(false);\n }}\n >\n Save\n \n setEditing(null)}\n >\n Cancel\n \n

\n )\n : (\n \n \n setForced((f) =>\n f.includes(b.id)\n ? f.filter((x) => x !== b.id)\n : [...f, b.id]\n )}\n >\n Require\n \n {\n setEditing(b.id);\n setT(b.title);\n setD(b.proof_description);\n }}\n >\n Reshape\n \n {\n setBusy(true);\n try {\n await api(\"/backlog/kill\", { id: b.id });\n await reload();\n } catch (e: any) {\n alert(e.message);\n }\n setBusy(false);\n }}\n >\n Kill\n \n

\n )}\n \n ))}\n

\n next({ forced })}>\n Continue\n \n

\n \n );\n}\n\n// Commit. The proof description is refined and frozen here — frozen so it can't\n// be loosened later to fit whatever photo you happened to take.\nfunction PassCommit({ state, next, locked, mode }: any) {\n const adding = mode === \"add\";\n const options = adding\n ? state.backlog.filter((b: any) => b.state !== \"required\")\n : state.backlog;\n const mandatory = adding ? [] : [\n ...state.backlog.filter((b: any) => b.mandatory).map((b: any) => b.id),\n ...(locked || []),\n ];\n const [picked, setPicked] = useState(\n [...new Set(mandatory)] as string[],\n );\n const [proofs, setProofs] = useState(() => {\n const o: any = {};\n for (const b of state.backlog) o[b.id] = b.proof_description;\n return o;\n });\n const [busyId, setBusyId] = useState(null);\n const [busy, setBusy] = useState(false);\n const [when, setWhen] = useState(\"next\");\n const [err, setErr] = useState(null);\n\n return (\n

\n {adding ? \"add to this week\" : \"pass 5 — commit\"}\n \n {adding\n ? \"These join the week already running, on the same deadline. You can add, never remove.\"\n : \"Minimum one. Write each proof line as loosely as you can while it still means you did it — it's frozen once you commit.\"}\n

\n\n {!adding && (\n

\n setWhen(\"next\")}\n style={{ padding: \"7px 11px\", fontSize: 13 }}\n >\n starts Monday\n \n setWhen(\"now\")}\n style={{ padding: \"7px 11px\", fontSize: 13 }}\n >\n due this Sunday\n \n

\n )}\n\n {options.map((b: any) => {\n const on = picked.includes(b.id);\n const isLocked = mandatory.includes(b.id);\n return (\n \n {\n if (isLocked) return;\n setPicked((p) =>\n on ? p.filter((x) => x !== b.id) : [...p, b.id]\n );\n }}\n style={{\n display: \"flex\",\n gap: 12,\n cursor: isLocked ? \"default\" : \"pointer\",\n }}\n >\n \n {on ? \"✓\" : \"\"}\n

\n \n {b.title}\n

\n \n {b.age_weeks}w · {proofLabel(b.proof_type)}\n {isLocked ? \" · mandatory\" : \"\"}\n {b.fail_count > 0 ? \" · failed \" + b.fail_count + \"x\" : \"\"}\n {b.mention_count > 0\n ? \" · said \" + b.mention_count + \"x\"\n : \"\"}\n

\n \n\n {on && (\n

\n \n setProofs({ ...proofs, [b.id]: e.target.value })}\n />\n

\n {\n setBusyId(b.id);\n try {\n const r = await api(\"/ai/freeze\", {\n title: b.title,\n proof_description: proofs[b.id],\n });\n setProofs((p: any) => ({\n ...p,\n [b.id]: r.frozen_proof,\n }));\n } catch {}\n setBusyId(null);\n }}\n >\n {busyId === b.id ? \"…\" : \"Loosen it\"}\n \n

\n )}\n \n );\n })}\n\n {err && (\n \n {err}\n

\n )}\n

\n {\n setBusy(true);\n setErr(null);\n try {\n const payload = {\n items: picked.map((id) => ({ id, frozen_proof: proofs[id] })),\n };\n if (adding) await api(\"/week/add\", payload);\n else await api(\"/week\", { when, ...payload });\n next({ added: adding });\n } catch (e: any) {\n setErr(e.message);\n }\n setBusy(false);\n }}\n >\n {busy ? \"…\" : (adding ? \"Add \" : \"Commit \") + picked.length}\n \n

\n \n );\n}\n\nfunction CardView({ card }: any) {\n if (!card) return null;\n return (\n

\n proof\n \n Screenshot this and submit it to Vouch.\n

\n \n \n \n Weekly review\n \n \n {fmt(card.reviewed_at)}\n \n

\n \n \n {card.cleared === null\n ? \"first review — no prior week\"\n : card.cleared\n ? \"last week cleared\"\n : card.failed_count + \" missed · now mandatory\"}\n \n \n {card.cleared_count}/{card.closed_count} weeks\n \n \n

\n required · {card.week}\n {card.required.map((r: any, i: number) => (\n

\n \n {i + 1}\n \n

\n \n {r.title}\n

\n \n {r.frozen_proof}\n

\n ))}\n

\n \n \n backlog {card.backlog_count}\n {card.oldest_weeks ? \" · oldest \" + card.oldest_weeks + \"w\" : \"\"}\n \n \n {card.session}\n \n \n {card.build_outstanding && (\n \n building: {card.build_outstanding}\n

\n )}\n \n \n );\n}\n\n// ───────────────────────────────────────────────────────── review\n\n// A card exited before it was screenshotted is not recoverable from anywhere\n// else — the weekly review only builds it once — so every past card stays\n// reachable here.\nfunction CardHistory({ onBack }: any) {\n const [list, setList] = useState(null);\n const [card, setCard] = useState(null);\n const [err, setErr] = useState(null);\n\n useEffect(() => {\n api(\"/cards\")\n .then((r: any) => setList(r.cards ?? []))\n .catch(() => setErr(\"could not load the list\"));\n }, []);\n\n async function open(week: string) {\n setErr(null);\n try {\n const r = await api(\"/card?week=\" + encodeURIComponent(week));\n if (r.card) setCard(r.card);\n else setErr(\"no card for \" + week);\n } catch {\n setErr(\"could not load \" + week);\n }\n }\n\n if (card) {\n return (\n

\n \n

\n setCard(null)}>Back to the list\n

\n );\n }\n\n return (\n

\n past cards\n {err && (\n \n {err}\n

\n )}\n {list === null && !err && (\n

\n loading…\n

\n )}\n {list?.length === 0 && (\n

\n No cards yet — the first one appears once you commit a week.\n

\n )}\n {list?.map((c: any) => (\n open(c.week)}\n style={{\n display: \"block\",\n width: \"100%\",\n textAlign: \"left\",\n background: T.panel,\n border: \"1px solid \" + T.line,\n borderRadius: 6,\n padding: \"12px 14px\",\n marginBottom: 8,\n cursor: \"pointer\",\n }}\n >\n

\n {c.week}\n

\n \n {fmt(c.reviewed_at)} · {c.session} ·{\" \"}\n {c.outcome === null\n ? \"running\"\n : c.outcome\n ? \"cleared\"\n : \"missed\"}\n

\n \n ))}\n

\n Back to the review\n

\n \n );\n}\n\nfunction Review({ state, reload }: any) {\n const [step, setStep] = useState(0);\n const [acc, setAcc] = useState({});\n const [card, setCard] = useState(null);\n const [added, setAdded] = useState(false);\n const [history, setHistory] = useState(false);\n\n // A week that's running but not yet finishable can't be closed — but the rest\n // of the review still works, and pass 5 adds to it rather than committing the\n // next one.\n const running = !!state.open_week && !state.can_close;\n const steps: string[] = [];\n if (state.open_week && state.can_close) steps.push(\"close\");\n steps.push(\"inbox\", \"loopholes\", \"aged\", \"commit\");\n\n async function advance(data: any) {\n const merged = { ...acc, ...data };\n setAcc(merged);\n if (steps[step] === \"commit\") {\n if (data?.added) {\n setAdded(true);\n await reload();\n return;\n }\n const r = await api(\"/card\");\n setCard(r.card);\n } else {\n setStep(step + 1);\n }\n }\n\n if (added) {\n return (\n

\n added\n \n They're on this week's list. No new card — the one you submitted on\n Sunday still stands.\n

\n {\n await reload();\n setAdded(false);\n setStep(0);\n setAcc({});\n }}\n >\n Done\n \n

\n );\n }\n\n if (card) {\n return (\n

\n \n

\n {\n await reload();\n setCard(null);\n setStep(0);\n setAcc({});\n }}\n >\n Back to the review\n \n

\n );\n }\n\n if (history) return setHistory(false)} />;\n\n const name = steps[step];\n return (\n

\n \n setHistory(true)}\n style={{\n background: \"none\",\n border: \"none\",\n padding: 0,\n cursor: \"pointer\",\n fontFamily: T.mono,\n fontSize: 11,\n color: T.dim,\n textDecoration: \"underline\",\n }}\n >\n past cards\n \n

\n {steps.map((s, i) => (\n \n ))}\n

\n {name === \"close\" && }\n {name === \"inbox\" && (\n \n )}\n {name === \"loopholes\" && }\n {name === \"aged\" && (\n \n )}\n {name === \"commit\" && (\n \n )}\n \n );\n}\n\nexport { CardView, Review };","deleted","label",[81,82,61],"frontend","components",{"_36":122,"_13":81,"_62":123,"_64":-5,"_66":67,"_68":110,"_70":71,"_38":124,"_17":34,"_74":125,"_76":-5,"_78":51,"_79":-5,"_96":126,"_18":127},{"_36":115,"_13":116,"_62":117,"_64":-5,"_66":67,"_68":110,"_70":71,"_38":118,"_17":34,"_74":24,"_76":119,"_78":51,"_79":-5,"_96":120,"_18":121},{"_36":107,"_13":108,"_62":109,"_64":-5,"_66":67,"_68":110,"_70":71,"_38":111,"_17":34,"_74":24,"_76":112,"_78":51,"_79":-5,"_96":113,"_18":114},{"_36":99,"_13":100,"_62":101,"_64":-5,"_66":67,"_68":32,"_70":71,"_38":102,"_17":103,"_74":75,"_76":104,"_78":51,"_79":-5,"_96":105,"_18":106},{"_36":88,"_13":89,"_62":90,"_64":-5,"_66":67,"_68":91,"_70":71,"_38":92,"_17":93,"_74":94,"_76":95,"_78":51,"_79":-5,"_96":97,"_18":98},"9368fe7b-2b17-44ce-94c5-66d20c575044","index.ts","019fb508-534b-72f8-ae6b-7b2519b376d1",6,["D",1785449322682],2,"http","import {\n parseVal,\n serveImmutableFile,\n} from \"https://esm.town/v/std/utils/index.ts\";\nimport { Hono } from \"npm:hono\";\nimport { Root } from \"./frontend/root.tsx\";\nimport api from \"./api.ts\";\n\nconst app = new Hono();\napp.route(\"/api\", api);\n\n// Serve the (never-cached) HTML shell at the root /\napp.get(\"/\", (c) => c.html(Root()));\n\n// Serve frontend files at the version-addressed URLs Root() stamps, cached immutably\napp.get(\"/__immutable/*\", (c) => serveImmutableFile(c.req.path));\n\n// View source redirect\napp.get(\"/source\", (c) => c.redirect(parseVal().links.self.val));\n\n// Add your API routes here\n// app.get(\"/api/data\", c => c.json({ hello: \"world\" }));\n\n// Unwrap and rethrow Hono errors as the original error\n// If you delete this, all errors will be \"Internal Server Error\"\napp.onError((err) => Promise.reject(err));\n\n// HTTP vals expect an exported \"fetch handler\"\n// This is how you \"run the server\" in Val Town with Hono\nexport default app.fetch;","children",[],[89],"5af444ea-70d6-4ca5-b240-94c3ccfcb64a","api.ts","0b87d8ac-8c63-11f1-850c-1607ee4eb77e",["D",1788746693211],10,"// api.ts — the register: capture, backlog, live proof verification, weekly review.\n// Mounted into the template's index.ts with: app.route(\"/api\", api)\n//\n// Env vars: REGISTER_PIN, ANTHROPIC_API_KEY\n\nimport { Hono } from \"npm:hono\";\nimport { getCookie, setCookie } from \"npm:hono/cookie\";\nimport { sqlite } from \"https://esm.town/v/std/sqlite/main.ts\";\n\nconst PIN = Deno.env.get(\"REGISTER_PIN\");\nconst AGE_FUSE_DEFAULT = 6; // weeks before an item forces a decision\nconst AGE_FUSE_LOOPHOLE = 2; // loophole closures burn faster\nconst RESHAPE_AT_FAILS = 3; // repeated failure means the item is misshapen\nconst YAP_MIN_WORDS = 150; // below this a note can't count toward the goal\nconst YAPS_PER_WEEK = 2; // the floor, not a target\nconst BUILD_CYCLE_DAYS = 14; // how often you look at the system itself\nconst DRIFT_WINDOW_DAYS = 56; // how far back the numbers read — longer, or it's noise\nconst PROOF_TYPES = [\n \"before_after\",\n \"timelapse\",\n \"artifact_photo\",\n \"acquisition_photo\",\n];\n\n// ───────────────────────────────────────────────────────── schema\n\nlet ready = false;\n\nasync function init() {\n if (ready) return;\n await sqlite.batch([\n `CREATE TABLE IF NOT EXISTS inbox (\n id TEXT PRIMARY KEY, captured_at TEXT NOT NULL, source TEXT NOT NULL,\n raw TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'pending', promoted_to TEXT)`,\n `CREATE TABLE IF NOT EXISTS backlog (\n id TEXT PRIMARY KEY, title TEXT NOT NULL, proof_type TEXT NOT NULL,\n proof_description TEXT NOT NULL, state TEXT NOT NULL DEFAULT 'backlog',\n fail_count INTEGER NOT NULL DEFAULT 0, first_captured_at TEXT NOT NULL,\n forced_until_week TEXT, killed_at TEXT)`,\n `CREATE TABLE IF NOT EXISTS backlog_inbox (\n backlog_id TEXT NOT NULL, inbox_id TEXT NOT NULL,\n PRIMARY KEY (backlog_id, inbox_id))`,\n `CREATE TABLE IF NOT EXISTS weeks (\n iso_week TEXT PRIMARY KEY, reviewed_at TEXT NOT NULL, required_json TEXT NOT NULL,\n cleared INTEGER, closed_at TEXT, card_session TEXT NOT NULL, verdict_json TEXT)`,\n `CREATE TABLE IF NOT EXISTS proofs (\n id TEXT PRIMARY KEY, backlog_id TEXT NOT NULL, iso_week TEXT NOT NULL,\n submitted_at TEXT NOT NULL, verdict TEXT NOT NULL,\n appealed INTEGER NOT NULL DEFAULT 0, note TEXT, message TEXT)`,\n `CREATE TABLE IF NOT EXISTS notes (\n id TEXT PRIMARY KEY, created_at TEXT NOT NULL, source TEXT NOT NULL,\n text TEXT NOT NULL, word_count INTEGER NOT NULL, summary TEXT)`,\n `CREATE TABLE IF NOT EXISTS note_mentions (\n note_id TEXT NOT NULL, backlog_id TEXT NOT NULL,\n PRIMARY KEY (note_id, backlog_id))`,\n `CREATE TABLE IF NOT EXISTS ideas (\n id TEXT PRIMARY KEY, created_at TEXT NOT NULL, text TEXT NOT NULL,\n status TEXT NOT NULL DEFAULT 'open', proof_description TEXT,\n committed_at TEXT, shipped_at TEXT, shipped_note TEXT)`,\n `CREATE TABLE IF NOT EXISTS build_cycles (\n id TEXT PRIMARY KEY, reviewed_at TEXT NOT NULL, verdict TEXT NOT NULL,\n note TEXT, idea_id TEXT, card_session TEXT NOT NULL)`,\n ]);\n // Columns added after the first deploy. SQLite has no IF NOT EXISTS for\n // columns, so each is attempted and its \"duplicate column\" error ignored.\n for (\n const col of [\n \"frozen_proof TEXT\",\n \"verified_at TEXT\",\n \"done_week TEXT\",\n \"appeal_count INTEGER NOT NULL DEFAULT 0\",\n \"fuse_weeks INTEGER NOT NULL DEFAULT 6\",\n \"origin TEXT NOT NULL DEFAULT 'capture'\",\n \"mention_count INTEGER NOT NULL DEFAULT 0\",\n \"last_mentioned_at TEXT\",\n ]\n ) {\n try {\n await sqlite.execute(`ALTER TABLE backlog ADD COLUMN ${col}`);\n } catch { /* exists */ }\n }\n // Cards are the artifacts submitted as proof, so each is frozen when its\n // review finishes and re-served verbatim afterwards.\n for (const table of [\"weeks\", \"build_cycles\"]) {\n try {\n await sqlite.execute(`ALTER TABLE ${table} ADD COLUMN card_json TEXT`);\n } catch { /* exists */ }\n }\n ready = true;\n}\n\n// ───────────────────────────────────────────────────────── helpers\n\nconst nid = () => crypto.randomUUID().slice(0, 8);\nconst now = () => new Date().toISOString();\n\n// Weeks must roll over at the user's Sunday midnight, not UTC's — otherwise a\n// NZ week ends around midday Monday.\nfunction nzNow(): Date {\n return new Date(\n new Date().toLocaleString(\"en-US\", { timeZone: \"Pacific/Auckland\" }),\n );\n}\n\nconst isSunday = () => nzNow().getDay() === 0;\n\nfunction isoWeek(d = nzNow()): string {\n const t = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));\n const day = t.getUTCDay() || 7;\n t.setUTCDate(t.getUTCDate() + 4 - day);\n const start = new Date(Date.UTC(t.getUTCFullYear(), 0, 1));\n const week = Math.ceil(((t.getTime() - start.getTime()) / 86400000 + 1) / 7);\n return `${t.getUTCFullYear()}-W${String(week).padStart(2, \"0\")}`;\n}\n\nfunction nextIsoWeek(): string {\n const d = nzNow();\n d.setDate(d.getDate() + 7);\n return isoWeek(d);\n}\n\nconst weeksSince = (iso: string) =>\n Math.floor((Date.now() - new Date(iso).getTime()) / (7 * 86400000));\n\nasync function rows(sql: string, args: unknown[] = []) {\n const r = await sqlite.execute({ sql, args });\n return r.rows.map((row) =>\n Object.fromEntries(r.columns.map((c, i) => [c, (row as any)[i]]))\n ) as Record[];\n}\n\nconst inList = (n: number) => Array(n).fill(\"?\").join(\",\");\n\nasync function anthropic(body: any) {\n const res = await fetch(\"https://api.anthropic.com/v1/messages\", {\n method: \"POST\",\n headers: {\n \"content-type\": \"application/json\",\n \"x-api-key\": Deno.env.get(\"ANTHROPIC_API_KEY\") ?? \"\",\n \"anthropic-version\": \"2023-06-01\",\n },\n body: JSON.stringify({\n model: \"claude-sonnet-4-6\",\n max_tokens: 1000,\n ...body,\n }),\n });\n const data = await res.json();\n return (data.content ?? [])\n .filter((b: any) => b.type === \"text\")\n .map((b: any) => b.text)\n .join(\"\\n\");\n}\n\nconst claude = (system: string, prompt: string) =>\n anthropic({ system, messages: [{ role: \"user\", content: prompt }] });\n\nfunction parseJson(text: string) {\n const clean = text.replace(/```json/g, \"\").replace(/```/g, \"\").trim();\n const at = [clean.indexOf(\"[\"), clean.indexOf(\"{\")].filter((i) => i >= 0);\n return JSON.parse(clean.slice(Math.min(...at)));\n}\n\n// ───────────────────────────────────────────────────────── auth\n\nconst api = new Hono();\n\napi.post(\"/login\", async (c) => {\n const { pin } = await c.req.json().catch(() => ({}));\n if (!PIN || String(pin) !== PIN) return c.json({ error: \"wrong pin\" }, 401);\n setCookie(c, \"register\", PIN, {\n httpOnly: true,\n secure: true,\n sameSite: \"Lax\",\n maxAge: 60 * 60 * 24 * 365,\n });\n return c.json({ ok: true });\n});\n\napi.use(\"*\", async (c, next) => {\n if (c.req.path.endsWith(\"/login\")) return next();\n if (!PIN || getCookie(c, \"register\") !== PIN) {\n return c.json({ error: \"locked\" }, 401);\n }\n await init();\n return next();\n});\n\n// ───────────────────────────────────────────────────────── capture\n\n// The only endpoint with no constraint beyond non-empty text — every gate lives\n// at promotion, so nothing slows down an 11pm thought. Newlines split (explicit\n// intent); commas don't, since \"milk, eggs and bread\" is one errand.\napi.post(\"/inbox\", async (c) => {\n const b = await c.req.json();\n const source = [\"web\", \"voice\", \"shortcut\", \"review\"].includes(b.source)\n ? b.source\n : \"web\";\n const lines = String(b.raw ?? \"\").split(\"\\n\").map((l) => l.trim()).filter(\n Boolean,\n );\n if (!lines.length) return c.json({ error: \"empty\" }, 400);\n\n const base = Date.now();\n const entries = lines.map((raw, i) => ({\n id: nid(),\n captured_at: new Date(base + i).toISOString(),\n source,\n raw,\n }));\n await sqlite.batch(entries.map((e) => ({\n sql: `INSERT INTO inbox (id, captured_at, source, raw) VALUES (?, ?, ?, ?)`,\n args: [e.id, e.captured_at, e.source, e.raw],\n })));\n return c.json({ ok: true, count: entries.length });\n});\n\napi.post(\"/inbox/discard\", async (c) => {\n const { ids } = await c.req.json();\n if (!Array.isArray(ids) || !ids.length) {\n return c.json({ error: \"no ids\" }, 400);\n }\n await sqlite.execute({\n sql: `UPDATE inbox SET status='discarded' WHERE id IN (${\n inList(ids.length)\n })`,\n args: ids,\n });\n return c.json({ ok: true });\n});\n\n// ───────────────────────────────────────────────────────── backlog\n\napi.post(\"/backlog\", async (c) => {\n const b = await c.req.json();\n const from: string[] = Array.isArray(b.from_inbox) ? b.from_inbox : [];\n const title = String(b.title ?? \"\").trim();\n const desc = String(b.proof_description ?? \"\").trim();\n const origin = b.origin === \"loophole\" ? \"loophole\" : \"capture\";\n\n if (!title) return c.json({ error: \"title required\" }, 400);\n if (!PROOF_TYPES.includes(b.proof_type)) {\n return c.json({ error: \"bad proof_type\" }, 400);\n }\n // The vagueness gate: no describable photo means it isn't an action yet.\n if (desc.length < 10) {\n return c.json({ error: \"proof_description too vague\" }, 400);\n }\n\n let firstCaptured = now();\n if (from.length) {\n const linked = await rows(\n `SELECT captured_at FROM inbox WHERE id IN (${inList(from.length)})\n ORDER BY captured_at ASC LIMIT 1`,\n from,\n );\n // Age clock reads the earliest linked capture, so re-promoting an item\n // cannot launder how long it has actually been carried.\n if (linked.length) firstCaptured = linked[0].captured_at;\n }\n\n const id = nid();\n const batch: any[] = [{\n sql: `INSERT INTO backlog\n (id, title, proof_type, proof_description, first_captured_at, fuse_weeks, origin)\n VALUES (?, ?, ?, ?, ?, ?, ?)`,\n args: [\n id,\n title,\n b.proof_type,\n desc,\n firstCaptured,\n origin === \"loophole\" ? AGE_FUSE_LOOPHOLE : AGE_FUSE_DEFAULT,\n origin,\n ],\n }];\n for (const inboxId of from) {\n batch.push({\n sql:\n `INSERT OR IGNORE INTO backlog_inbox (backlog_id, inbox_id) VALUES (?, ?)`,\n args: [id, inboxId],\n });\n batch.push({\n sql: `UPDATE inbox SET status='promoted', promoted_to=? WHERE id=?`,\n args: [id, inboxId],\n });\n }\n await sqlite.batch(batch);\n return c.json({ ok: true, id });\n});\n\n// Kill, with purgatory. An item that failed while required owes one more forced\n// week — otherwise the rollover threat is escapable by simply deleting it.\napi.post(\"/backlog/kill\", async (c) => {\n const { id } = await c.req.json();\n const found = await rows(`SELECT * FROM backlog WHERE id=?`, [id]);\n if (!found.length) return c.json({ error: \"not found\" }, 404);\n if (found[0].forced_until_week && found[0].forced_until_week >= isoWeek()) {\n return c.json(\n { error: \"in purgatory until \" + found[0].forced_until_week },\n 409,\n );\n }\n await sqlite.execute({\n sql: `UPDATE backlog SET state='killed', killed_at=? WHERE id=?`,\n args: [now(), id],\n });\n return c.json({ ok: true });\n});\n\n// Three failures usually means the item is too big, not that you're lazy.\n// Reshaping resets the fail count; the age clock deliberately survives.\napi.post(\"/backlog/reshape\", async (c) => {\n const { id, title, proof_description } = await c.req.json();\n if (\n !String(title ?? \"\").trim() ||\n String(proof_description ?? \"\").trim().length < 10\n ) {\n return c.json(\n { error: \"needs a smaller title and a describable proof\" },\n 400,\n );\n }\n await sqlite.execute({\n sql:\n `UPDATE backlog SET title=?, proof_description=?, fail_count=0 WHERE id=?`,\n args: [String(title).trim(), String(proof_description).trim(), id],\n });\n return c.json({ ok: true });\n});\n\n// ───────────────────────────────────────────────────────── week\n\n// Commit. Each item freezes the proof description it will be judged against,\n// frozen so it can't be loosened later to fit whatever photo you happened to\n// take. The appeal flow is the release valve instead.\napi.post(\"/week\", async (c) => {\n const { items, when } = await c.req.json();\n if (!Array.isArray(items) || items.length < 1) {\n return c.json({ error: \"commit at least one item\" }, 400);\n }\n for (const it of items) {\n if (!it.id || String(it.frozen_proof ?? \"\").trim().length < 10) {\n return c.json(\n { error: \"every item needs a frozen proof description\" },\n 400,\n );\n }\n }\n\n // Default is the week starting Monday. \"now\" opens the current week instead,\n // but only once — otherwise you could reopen mid-week and swap out an item\n // you were about to miss.\n const week = when === \"now\" ? isoWeek() : nextIsoWeek();\n if (when === \"now\") {\n const existing = await rows(`SELECT iso_week FROM weeks WHERE iso_week=?`, [\n week,\n ]);\n if (existing.length) {\n return c.json({ error: \"this week is already open\" }, 409);\n }\n }\n\n const session = crypto.randomUUID().slice(0, 4);\n const ids = items.map((i: any) => i.id);\n\n const batch: any[] = [{\n sql:\n `INSERT OR REPLACE INTO weeks (iso_week, reviewed_at, required_json, card_session)\n VALUES (?, ?, ?, ?)`,\n args: [week, now(), JSON.stringify(ids), session],\n }];\n for (const it of items) {\n batch.push({\n sql:\n `UPDATE backlog SET state='required', frozen_proof=?, verified_at=NULL,\n done_week=NULL WHERE id=?`,\n args: [String(it.frozen_proof).trim(), it.id],\n });\n }\n await sqlite.batch(batch);\n\n // Frozen here rather than on first view: the card is screenshotted as proof,\n // so re-opening it later has to show what was submitted, not today's numbers.\n const committed = await rows(`SELECT * FROM weeks WHERE iso_week=?`, [week]);\n if (committed.length) {\n await sqlite.execute({\n sql: `UPDATE weeks SET card_json=? WHERE iso_week=?`,\n args: [JSON.stringify(await buildCard(committed[0])), week],\n });\n }\n\n return c.json({ ok: true, iso_week: week, card_session: session });\n});\n\n// Close is a report, not a judgement — items were verified live during the\n// week, so nothing here is self-reported.\n// Adding to a live week is safe in a way that removing never would be: it only\n// ever increases what you owe, so there's no version of this that gets you off\n// the hook for something you were about to miss.\napi.post(\"/week/add\", async (c) => {\n const { items } = await c.req.json();\n if (!Array.isArray(items) || !items.length) {\n return c.json({ error: \"nothing to add\" }, 400);\n }\n for (const it of items) {\n if (!it.id || String(it.frozen_proof ?? \"\").trim().length < 10) {\n return c.json(\n { error: \"every item needs a frozen proof description\" },\n 400,\n );\n }\n }\n\n const week = isoWeek();\n const found = await rows(`SELECT * FROM weeks WHERE iso_week=?`, [week]);\n if (!found.length) {\n return c.json({ error: \"no week running — commit one first\" }, 404);\n }\n if (found[0].cleared !== null) {\n return c.json({ error: \"this week is already closed\" }, 409);\n }\n\n const existing: string[] = JSON.parse(found[0].required_json);\n const fresh = items.filter((i: any) => !existing.includes(i.id));\n if (!fresh.length) {\n return c.json({ error: \"already required this week\" }, 400);\n }\n\n const batch: any[] = [{\n sql: `UPDATE weeks SET required_json=? WHERE iso_week=?`,\n args: [JSON.stringify([...existing, ...fresh.map((f: any) => f.id)]), week],\n }];\n for (const it of fresh) {\n batch.push({\n sql:\n `UPDATE backlog SET state='required', frozen_proof=?, verified_at=NULL,\n done_week=NULL WHERE id=?`,\n args: [String(it.frozen_proof).trim(), it.id],\n });\n }\n await sqlite.batch(batch);\n return c.json({\n ok: true,\n added: fresh.length,\n total: existing.length + fresh.length,\n });\n});\n\napi.post(\"/week/close\", async (c) => {\n const b = await c.req.json();\n const week = String(b.iso_week ?? isoWeek());\n const found = await rows(`SELECT * FROM weeks WHERE iso_week=?`, [week]);\n if (!found.length) return c.json({ error: \"no such week\" }, 404);\n if (found[0].cleared !== null) {\n return c.json({ ok: true, already: true, cleared: !!found[0].cleared });\n }\n\n const required: string[] = JSON.parse(found[0].required_json);\n const items = required.length\n ? await rows(\n `SELECT * FROM backlog WHERE id IN (${inList(required.length)})`,\n required,\n )\n : [];\n const done = items.filter((i) => i.done_week === week).map((i) => i.id);\n const failed = required.filter((r) => !done.includes(r));\n const cleared = failed.length === 0;\n\n // Closing a week that's still running is only allowed once everything is\n // verified — otherwise a Wednesday review would bank failures for items you\n // still had four days to finish.\n if (week === isoWeek() && !cleared && !isSunday()) {\n return c.json({\n error: failed.length + \" still outstanding — the week isn't over yet\",\n }, 409);\n }\n\n const purgatory = nextIsoWeek();\n\n const batch: any[] = [{\n sql:\n `UPDATE weeks SET cleared=?, closed_at=?, verdict_json=? WHERE iso_week=?`,\n args: [cleared ? 1 : 0, now(), JSON.stringify({ done, failed }), week],\n }];\n if (done.length) {\n batch.push({\n sql: `UPDATE backlog SET state='done' WHERE id IN (${\n inList(done.length)\n })`,\n args: done,\n });\n }\n // Failures roll forward as mandatory, so a bad week makes the next one\n // heavier rather than leaving the rest of this week unstaked.\n for (const f of failed) {\n batch.push({\n sql: `UPDATE backlog SET state='backlog', fail_count=fail_count+1,\n forced_until_week=?, frozen_proof=NULL WHERE id=?`,\n args: [purgatory, f],\n });\n }\n await sqlite.batch(batch);\n return c.json({\n ok: true,\n cleared,\n award_vouch_point: cleared,\n failed,\n done,\n });\n});\n\n// ───────────────────────────────────────────────────────── verification\n\n// Follows the OPEN week, not the calendar week. A week stays open until it is\n// closed at review, so items committed in W36 must stay visible and completable\n// in W37 — otherwise rolling over the calendar hides work you still intend to do.\napi.get(\"/active\", async (c) => {\n const week = isoWeek();\n const weeks = await rows(\n `SELECT * FROM weeks WHERE cleared IS NULL ORDER BY iso_week ASC LIMIT 1`,\n );\n if (!weeks.length) return c.json({ week, items: [], open: false });\n\n const openWeek = weeks[0].iso_week;\n const ids: string[] = JSON.parse(weeks[0].required_json);\n const items = ids.length\n ? await rows(\n `SELECT * FROM backlog WHERE id IN (${inList(ids.length)})`,\n ids,\n )\n : [];\n return c.json({\n week: openWeek,\n current_week: week,\n open: true,\n overdue: openWeek < week,\n upcoming: openWeek > week,\n items: items.map((i) => ({\n id: i.id,\n title: i.title,\n frozen_proof: i.frozen_proof,\n proof_type: i.proof_type,\n verified: i.done_week === openWeek,\n verified_at: i.verified_at,\n appeal_count: i.appeal_count,\n })),\n });\n});\n\n// Vision check, framed permissively on purpose: a false accept only fools you,\n// and you know it. A false reject costs money and your trust in the whole\n// system, so the asymmetry is deliberate.\napi.post(\"/verify\", async (c) => {\n const { id, image, media_type, note } = await c.req.json();\n // Credit the open week, not today's. The deadline that matters is when the\n // week gets closed at review; being late to close already costs the weekly\n // review goal, so it doesn't need punishing twice.\n const openWeeks = await rows(\n `SELECT iso_week FROM weeks WHERE cleared IS NULL ORDER BY iso_week ASC LIMIT 1`,\n );\n const week = openWeeks[0]?.iso_week ?? isoWeek();\n const found = await rows(`SELECT * FROM backlog WHERE id=?`, [id]);\n if (!found.length) return c.json({ error: \"not found\" }, 404);\n const item = found[0];\n if (item.state !== \"required\") {\n return c.json({ error: \"not active this week\" }, 409);\n }\n if (!image) return c.json({ error: \"no image\" }, 400);\n\n const out = await anthropic({\n system:\n 'You verify that a task was completed, from a photo. Accept if the image is CONSISTENT with having done it — accept variants, near-matches, different naming, and partial views. Class names, product names and wording routinely differ from what was written in advance; that alone is never grounds for rejection. Reject ONLY if the image is clearly unrelated to the task, or clearly shows it was not done. If you are unsure, or one detail conflicts, return unclear with a single specific question rather than rejecting. False rejections are far more costly than false acceptances. Reply with JSON only: {\"verdict\":\"accept|unclear|reject\",\"message\":\"one short sentence\"}',\n messages: [{\n role: \"user\",\n content: [\n {\n type: \"image\",\n source: {\n type: \"base64\",\n media_type: media_type || \"image/jpeg\",\n data: image,\n },\n },\n {\n type: \"text\",\n text: \"Task: \" + item.title +\n \"\\nProof required: \" +\n (item.frozen_proof || item.proof_description) +\n (note ? \"\\n\\nTheir explanation of this image: \" + note : \"\"),\n },\n ],\n }],\n });\n\n let parsed: any;\n try {\n parsed = parseJson(out);\n } catch {\n parsed = {\n verdict: \"unclear\",\n message: \"Couldn't read that one — try again?\",\n };\n }\n\n const appealed = note ? 1 : 0;\n const batch: any[] = [{\n sql:\n `INSERT INTO proofs (id, backlog_id, iso_week, submitted_at, verdict, appealed, note, message)\n VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,\n args: [\n nid(),\n id,\n week,\n now(),\n parsed.verdict,\n appealed,\n note ?? null,\n parsed.message ?? null,\n ],\n }];\n if (parsed.verdict === \"accept\") {\n batch.push({\n sql:\n `UPDATE backlog SET verified_at=?, done_week=?, appeal_count=appeal_count+? WHERE id=?`,\n args: [now(), week, appealed, id],\n });\n }\n await sqlite.batch(batch);\n return c.json({ verdict: parsed.verdict, message: parsed.message });\n});\n\n// ───────────────────────────────────────────────────────── state\n\napi.get(\"/state\", async (c) => {\n const week = isoWeek();\n const pending = await rows(\n `SELECT * FROM inbox WHERE status='pending' ORDER BY captured_at ASC`,\n );\n const backlog = await rows(\n `SELECT * FROM backlog WHERE state IN ('backlog','required')\n ORDER BY first_captured_at ASC`,\n );\n const weeks = await rows(\n `SELECT * FROM weeks ORDER BY iso_week DESC LIMIT 8`,\n );\n\n const enriched = backlog.map((b) => {\n const age = weeksSince(b.first_captured_at);\n return {\n ...b,\n age_weeks: age,\n needs_decision: age >= (b.fuse_weeks ?? AGE_FUSE_DEFAULT),\n needs_reshape: b.fail_count >= RESHAPE_AT_FAILS,\n mandatory: !!b.forced_until_week && b.forced_until_week >= week,\n };\n });\n\n const closed = weeks.filter((w) => w.cleared !== null);\n // A week committed for next Monday is not \"open\" — otherwise running the\n // review twice would offer to close a week that hasn't started.\n const open = weeks.find((w) => w.cleared === null && w.iso_week <= week) ??\n null;\n let canClose = false;\n if (open) {\n const ids: string[] = JSON.parse(open.required_json);\n const done = enriched.filter((b) =>\n ids.includes(b.id) && b.done_week === open.iso_week\n ).length;\n canClose = open.iso_week < week || isSunday() || done === ids.length;\n }\n\n return c.json({\n current_week: week,\n inbox_pending: pending,\n backlog: enriched,\n mandatory_next_week: enriched.filter((b) => b.mandatory).map((b) => b.id),\n open_week: open,\n can_close: canClose,\n committed_next: weeks.find((w) =>\n w.cleared === null && w.iso_week > week\n ) ?? null,\n cleared_count: closed.filter((w) => w.cleared).length,\n closed_count: closed.length,\n });\n});\n\nasync function buildCard(week: Record) {\n const ids: string[] = JSON.parse(week.required_json);\n const items = ids.length\n ? await rows(\n `SELECT title, frozen_proof FROM backlog WHERE id IN (${\n inList(ids.length)\n })`,\n ids,\n )\n : [];\n const backlog = await rows(\n `SELECT first_captured_at FROM backlog WHERE state='backlog'`,\n );\n // Anchored strictly before this card's own week: a card reports the verdict\n // of the week it closed, never its own.\n const scope = await rows(\n `SELECT * FROM weeks WHERE iso_week < ? ORDER BY iso_week DESC LIMIT 8`,\n [week.iso_week],\n );\n const closed = scope.filter((w) => w.cleared !== null);\n const prev = closed[0] ?? null;\n const verdict = prev?.verdict_json ? JSON.parse(prev.verdict_json) : null;\n // Display-only on the weekly card so a committed improvement can't sit\n // invisible for a fortnight. Deliberately not counted — the moment system\n // work affects cleared weeks, that number stops describing real-world output.\n const buildOutstanding = await rows(\n `SELECT text FROM ideas WHERE status='committed' LIMIT 1`,\n );\n\n return {\n week: week.iso_week,\n session: week.card_session,\n reviewed_at: week.reviewed_at,\n required: items,\n backlog_count: backlog.length,\n oldest_weeks: backlog.length\n ? Math.max(...backlog.map((b) => weeksSince(b.first_captured_at)))\n : 0,\n cleared: prev ? !!prev.cleared : null,\n failed_count: verdict ? verdict.failed.length : 0,\n cleared_count: closed.filter((w) => w.cleared).length,\n closed_count: closed.length,\n build_outstanding: buildOutstanding[0]?.text ?? null,\n };\n}\n\n// Weeks committed before card_json existed have no snapshot; they are rebuilt\n// once, on first view, and frozen from then on.\nasync function cardFor(week: Record) {\n if (week.card_json) {\n try {\n return JSON.parse(week.card_json);\n } catch { /* unreadable snapshot — rebuild below */ }\n }\n const card = await buildCard(week);\n await sqlite.execute({\n sql: `UPDATE weeks SET card_json=? WHERE iso_week=?`,\n args: [JSON.stringify(card), week.iso_week],\n });\n return card;\n}\n\n// No ?week= gives the card for the week currently committed — the one the\n// review just produced. With ?week= it gives any past card, so a card exited\n// before it was screenshotted can still be submitted.\napi.get(\"/card\", async (c) => {\n const wanted = c.req.query(\"week\");\n const found = wanted\n ? await rows(`SELECT * FROM weeks WHERE iso_week=?`, [wanted])\n : await rows(\n `SELECT * FROM weeks WHERE cleared IS NULL ORDER BY iso_week DESC LIMIT 1`,\n );\n if (!found.length) return c.json({ card: null });\n return c.json({ card: await cardFor(found[0]) });\n});\n\napi.get(\"/cards\", async (c) => {\n const weeks = await rows(\n `SELECT iso_week, reviewed_at, cleared, card_session FROM weeks\n ORDER BY iso_week DESC LIMIT 26`,\n );\n return c.json({\n cards: weeks.map((w) => ({\n week: w.iso_week,\n reviewed_at: w.reviewed_at,\n session: w.card_session,\n outcome: w.cleared === null ? null : !!w.cleared,\n })),\n });\n});\n\n// ───────────────────────────────────────────────────────── ai\n\napi.post(\"/ai/promote\", async (c) => {\n const { raw } = await c.req.json();\n const out = await claude(\n 'You convert a vague captured note into ONE concrete physical action that can be photographed. Reply with JSON only: {\"title\":\"...\",\"proof_type\":\"before_after|timelapse|artifact_photo|acquisition_photo\",\"proof_description\":\"what the photo must show\"}. The title must be doable in a single sitting; if the note is really a multi-step project, make the title only its first step. Write the proof_description as PERMISSIVELY as possible while still meaning the task was done — real names, class titles and wording routinely differ from what was written in advance, so allow for that explicitly.',\n \"Captured note: \" + String(raw ?? \"\"),\n );\n try {\n return c.json(parseJson(out));\n } catch {\n return c.json({ error: \"could not parse\" }, 502);\n }\n});\n\napi.post(\"/ai/freeze\", async (c) => {\n const { title, proof_description } = await c.req.json();\n const out = await claude(\n 'Rewrite a proof requirement to be as permissive as possible while still meaning the task was genuinely done. Anticipate that real-world names, class titles, product names and wording will differ from what was written in advance, and allow for it explicitly. Reply with JSON only: {\"frozen_proof\":\"...\"}. One sentence.',\n \"Task: \" + title + \"\\nDraft proof requirement: \" + proof_description,\n );\n try {\n return c.json(parseJson(out));\n } catch {\n return c.json({ frozen_proof: proof_description });\n }\n});\n\n// The interrogation runs on evidence the system has collected — appeals used,\n// items missed, items quietly passed over — not on a generic prompt.\napi.post(\"/ai/interrogate\", async (c) => {\n const { answers, questions } = await c.req.json();\n\n if (!answers) {\n const appeals = await rows(\n `SELECT b.title, p.note FROM proofs p JOIN backlog b ON b.id = p.backlog_id\n WHERE p.appealed = 1 ORDER BY p.submitted_at DESC LIMIT 5`,\n );\n const failing = await rows(\n `SELECT title, fail_count FROM backlog WHERE fail_count > 0\n ORDER BY fail_count DESC LIMIT 5`,\n );\n const stale = await rows(\n `SELECT title, first_captured_at, mention_count FROM backlog WHERE state='backlog'\n ORDER BY mention_count DESC, first_captured_at ASC LIMIT 5`,\n );\n const notes = await rows(\n `SELECT created_at, summary FROM notes WHERE summary IS NOT NULL\n ORDER BY created_at DESC LIMIT 6`,\n );\n\n const evidence = [\n appeals.length\n ? \"Talked the verifier into accepting: \" +\n appeals.map((a) => a.title + \" (\" + (a.note ?? \"\") + \")\").join(\"; \")\n : null,\n failing.length\n ? \"Committed then missed: \" +\n failing.map((f) => f.title + \" x\" + f.fail_count).join(\"; \")\n : null,\n stale.length\n ? \"Sitting untouched in the backlog: \" +\n stale.map((s) =>\n s.title + \" (\" + weeksSince(s.first_captured_at) + \"w\" +\n (s.mention_count ? \", talked about \" + s.mention_count + \"x\" : \"\") +\n \")\"\n ).join(\"; \")\n : null,\n notes.length\n ? \"What they've been talking about lately:\\n\" +\n notes.map((n) =>\n new Date(n.created_at).toISOString().slice(0, 10) + \" — \" +\n n.summary\n ).join(\"\\n\")\n : null,\n ].filter(Boolean).join(\"\\n\");\n\n const out = await claude(\n \"You interrogate someone about how they have been dodging their own commitment system. Use the evidence given to ask exactly three short, pointed, specific questions — quote their actual items rather than speaking generally. An item they keep talking about but never choose is the strongest material you have; so is anything their recent notes contradict. If the evidence is thin, ask about what they have avoided choosing, and why. No preamble, no numbering, one question per line. Direct rather than gentle.\",\n \"Evidence from their register:\\n\" + (evidence || \"No history yet.\") +\n \"\\n\\nA known past loophole: they blocked YouTube on their laptop, then started watching it on their phone instead.\",\n );\n return c.json({\n questions: out.split(\"\\n\").filter((l: string) => l.trim()).slice(0, 3),\n });\n }\n\n const out = await claude(\n 'Turn confessed loopholes into concrete closure actions that can be photographed. Reply with JSON only: an array of {\"title\":\"...\",\"proof_type\":\"before_after|timelapse|artifact_photo|acquisition_photo\",\"proof_description\":\"...\"}. One action per loophole, each doable in a single sitting, ordered with the MOST DAMAGING loophole first. Write each proof_description permissively. Maximum four.',\n \"Questions asked:\\n\" + (questions || []).join(\"\\n\") +\n \"\\n\\nTheir answers:\\n\" + answers,\n );\n try {\n return c.json({ proposals: parseJson(out) });\n } catch {\n return c.json({ proposals: [] });\n }\n});\n\n// ───────────────────────────────────────────────────────── loopholes\n\n// A loophole raised here is mandatory for the running week, unlike the softer\n// pass-3 interrogation where only the worst confession is forced. The reasoning:\n// deliberately opening this tab means naming a live corruption of the system's\n// own numbers, and a system whose numbers are lying is worth more than a week\n// of convenience.\napi.post(\"/loopholes/raise\", async (c) => {\n const b = await c.req.json();\n const text = String(b.text ?? \"\").trim();\n if (text.length < 8) return c.json({ error: \"describe the loophole\" }, 400);\n\n let title = String(b.title ?? \"\").trim();\n let ptype = PROOF_TYPES.includes(b.proof_type)\n ? b.proof_type\n : \"artifact_photo\";\n let desc = String(b.proof_description ?? \"\").trim();\n\n if (!title || desc.length < 10) {\n const out = await claude(\n 'Someone has confessed a way they are cheating their own accountability system. Turn it into ONE concrete closure action that can be photographed, doable in a single sitting. Prefer structural fixes that remove the ability to cheat over promises to behave. Reply with JSON only: {\"title\":\"...\",\"proof_type\":\"before_after|timelapse|artifact_photo|acquisition_photo\",\"proof_description\":\"what the photo must show\"}. Write proof_description permissively — real wording and app names differ from expectations.',\n \"The loophole: \" + text,\n );\n try {\n const p = parseJson(out);\n title = title || p.title;\n ptype = PROOF_TYPES.includes(p.proof_type) ? p.proof_type : ptype;\n desc = desc.length >= 10 ? desc : p.proof_description;\n } catch { /* fall through to the raw confession */ }\n }\n if (!title) title = \"Close: \" + text.slice(0, 60);\n if (!desc || desc.length < 10) {\n desc = \"photo or screenshot showing the loophole is closed\";\n }\n\n const id = nid();\n const week = isoWeek();\n const openWeeks = await rows(\n `SELECT * FROM weeks WHERE cleared IS NULL ORDER BY iso_week ASC LIMIT 1`,\n );\n const running = openWeeks[0] ?? null;\n\n const batch: any[] = [{\n sql: `INSERT INTO backlog\n (id, title, proof_type, proof_description, first_captured_at, fuse_weeks, origin,\n frozen_proof, state, forced_until_week)\n VALUES (?, ?, ?, ?, ?, ?, 'loophole', ?, ?, ?)`,\n args: [\n id,\n title,\n ptype,\n desc,\n now(),\n AGE_FUSE_LOOPHOLE,\n desc,\n running ? \"required\" : \"backlog\",\n nextIsoWeek(),\n ],\n }];\n\n if (running) {\n const ids: string[] = JSON.parse(running.required_json);\n batch.push({\n sql: `UPDATE weeks SET required_json=? WHERE iso_week=?`,\n args: [JSON.stringify([...ids, id]), running.iso_week],\n });\n }\n await sqlite.batch(batch);\n\n return c.json({\n ok: true,\n id,\n title,\n proof_description: desc,\n required_now: !!running,\n week: running ? running.iso_week : week,\n });\n});\n\napi.get(\"/loopholes\", async (c) => {\n const openItems = await rows(\n `SELECT * FROM backlog WHERE origin='loophole' AND state IN ('backlog','required')\n ORDER BY first_captured_at DESC`,\n );\n const closed = await rows(\n `SELECT * FROM backlog WHERE origin='loophole' AND state='done'\n ORDER BY verified_at DESC LIMIT 15`,\n );\n const openWeeks = await rows(\n `SELECT iso_week FROM weeks WHERE cleared IS NULL ORDER BY iso_week ASC LIMIT 1`,\n );\n const openWeek = openWeeks[0]?.iso_week ?? null;\n\n return c.json({\n open_week: openWeek,\n open: openItems.map((b) => ({\n id: b.id,\n title: b.title,\n frozen_proof: b.frozen_proof || b.proof_description,\n state: b.state,\n fail_count: b.fail_count,\n verified: !!openWeek && b.done_week === openWeek,\n age_weeks: weeksSince(b.first_captured_at),\n })),\n closed: closed.map((b) => ({\n id: b.id,\n title: b.title,\n verified_at: b.verified_at,\n })),\n closed_total: closed.length,\n });\n});\n\n// ───────────────────────────────────────────────────────── notes\n\n// Extraction deliberately matches against what's already tracked instead of\n// always creating new items. A thing mentioned eleven times and never chosen is\n// the sharpest signal the system can produce, and it only exists if repeats\n// increment a counter rather than piling up as duplicates.\napi.post(\"/notes\", async (c) => {\n const b = await c.req.json();\n const text = String(b.text ?? \"\").trim();\n if (text.length < 20) return c.json({ error: \"too short\" }, 400);\n const words = text.split(/\\s+/).filter(Boolean).length;\n const source = b.source === \"dictation\" ? \"dictation\" : \"typed\";\n\n const open = await rows(\n `SELECT id, title FROM backlog WHERE state IN ('backlog','required')`,\n );\n const pending = await rows(\n `SELECT id, raw FROM inbox WHERE status='pending'`,\n );\n const known = [\n ...open.map((o) => ({ id: o.id, label: o.title })),\n ...pending.map((p) => ({ id: \"inbox:\" + p.id, label: p.raw })),\n ];\n\n const out = await claude(\n 'You read a personal voice-note transcript and pull out ONLY explicit intentions — things the speaker says they should, need, want, or keep meaning to do. Ignore observations, feelings, context and musings entirely; under-extracting is much better than over-extracting, because every extra item costs them time in a weekly review. Match each intention against the existing items given, by meaning rather than wording. Reply with JSON only: {\"summary\":\"one sentence on what this note was about\",\"intentions\":[{\"text\":\"the intention, phrased as an action\",\"matches_id\":\"\"}]}',\n \"Existing tracked items:\\n\" +\n (known.length\n ? known.map((k) => k.id + \" :: \" + k.label).join(\"\\n\")\n : \"(none)\") +\n \"\\n\\nTranscript:\\n\" + text,\n );\n\n let parsed: any;\n try {\n parsed = parseJson(out);\n } catch {\n parsed = { summary: null, intentions: [] };\n }\n\n const noteId = nid();\n const batch: any[] = [{\n sql: `INSERT INTO notes (id, created_at, source, text, word_count, summary)\n VALUES (?, ?, ?, ?, ?, ?)`,\n args: [noteId, now(), source, text, words, parsed.summary ?? null],\n }];\n\n let matched = 0, created = 0;\n const base = Date.now();\n for (const it of (parsed.intentions ?? [])) {\n const m = it.matches_id;\n if (m && !String(m).startsWith(\"inbox:\") && open.some((o) => o.id === m)) {\n matched++;\n batch.push({\n sql:\n `UPDATE backlog SET mention_count = mention_count + 1, last_mentioned_at = ?\n WHERE id = ?`,\n args: [now(), m],\n });\n batch.push({\n sql:\n `INSERT OR IGNORE INTO note_mentions (note_id, backlog_id) VALUES (?, ?)`,\n args: [noteId, m],\n });\n } else if (m && String(m).startsWith(\"inbox:\")) {\n matched++; // already waiting in the inbox — don't duplicate it\n } else if (it.text) {\n created++;\n batch.push({\n sql:\n `INSERT INTO inbox (id, captured_at, source, raw) VALUES (?, ?, ?, ?)`,\n args: [\n nid(),\n new Date(base + created).toISOString(),\n \"voice\",\n String(it.text).trim(),\n ],\n });\n }\n }\n await sqlite.batch(batch);\n\n return c.json({\n ok: true,\n id: noteId,\n word_count: words,\n summary: parsed.summary,\n matched,\n created,\n counts_toward_goal: words >= YAP_MIN_WORDS,\n });\n});\n\n// Day-complete page for Vouch. Only renders as passable once the note is\n// substantial — otherwise \"uh, testing\" would clear the goal and the mention\n// counts, which are the valuable part, would fill with filler.\napi.get(\"/notes/card\", async (c) => {\n const week = isoWeek();\n const recent = await rows(\n `SELECT * FROM notes ORDER BY created_at DESC LIMIT 20`,\n );\n if (!recent.length) return c.json({ card: null });\n\n const latest = recent[0];\n const since = new Date(nzNow());\n since.setDate(since.getDate() - 7);\n const thisWeek = recent.filter((n) => new Date(n.created_at) >= since);\n\n return c.json({\n card: {\n created_at: latest.created_at,\n word_count: latest.word_count,\n summary: latest.summary,\n week_count: thisWeek.length,\n target: YAPS_PER_WEEK,\n total: recent.length,\n passable: latest.word_count >= YAP_MIN_WORDS,\n week,\n },\n });\n});\n\napi.get(\"/notes/recent\", async (c) => {\n const recent = await rows(\n `SELECT id, created_at, word_count, summary FROM notes ORDER BY created_at DESC LIMIT 10`,\n );\n return c.json({ notes: recent });\n});\n\n// ───────────────────────────────────────────────────────── build track\n\n// Kept in its own tables, not in the backlog. That's what makes system work\n// structurally invisible to the cleared-weeks metric — not a filter someone has\n// to remember to apply, but a different place entirely.\n\nasync function drift() {\n const cutoff = new Date(Date.now() - DRIFT_WINDOW_DAYS * 86400000)\n .toISOString();\n const monthAgo = new Date(Date.now() - 28 * 86400000).toISOString();\n\n const weeks = await rows(\n `SELECT cleared FROM weeks WHERE cleared IS NOT NULL ORDER BY iso_week DESC LIMIT 8`,\n );\n const proofs = await rows(\n `SELECT verdict, appealed FROM proofs WHERE submitted_at >= ?`,\n [cutoff],\n );\n const captures = await rows(\n `SELECT captured_at FROM inbox WHERE captured_at >= ?`,\n [monthAgo],\n );\n const notes = await rows(`SELECT id FROM notes WHERE created_at >= ?`, [\n monthAgo,\n ]);\n const backlog = await rows(\n `SELECT first_captured_at FROM backlog WHERE state IN ('backlog','required')`,\n );\n const killed = await rows(`SELECT id FROM backlog WHERE killed_at >= ?`, [\n cutoff,\n ]);\n\n // Captures spread across many days means the letterbox is being used as\n // intended; captures bunched onto a couple of days means friction is pushing\n // you into batching them at review time.\n const days = new Set(captures.map((c) => String(c.captured_at).slice(0, 10)));\n\n return {\n weeks_closed: weeks.length,\n weeks_cleared: weeks.filter((w) => w.cleared).length,\n proof_submissions: proofs.length,\n rejections: proofs.filter((p) => p.verdict === \"reject\").length,\n appeals: proofs.filter((p) => p.appealed).length,\n captures_28d: captures.length,\n capture_days_28d: days.size,\n yaps_28d: notes.length,\n backlog_size: backlog.length,\n backlog_oldest_weeks: backlog.length\n ? Math.max(...backlog.map((b) => weeksSince(b.first_captured_at)))\n : 0,\n killed_recently: killed.length,\n };\n}\n\napi.post(\"/build/ideas\", async (c) => {\n const { text } = await c.req.json();\n const lines = String(text ?? \"\").split(\"\\n\").map((l) => l.trim()).filter(\n Boolean,\n );\n if (!lines.length) return c.json({ error: \"empty\" }, 400);\n const base = Date.now();\n await sqlite.batch(lines.map((t, i) => ({\n sql: `INSERT INTO ideas (id, created_at, text) VALUES (?, ?, ?)`,\n args: [nid(), new Date(base + i).toISOString(), t],\n })));\n return c.json({ ok: true, count: lines.length });\n});\n\napi.post(\"/build/ideas/drop\", async (c) => {\n const { id } = await c.req.json();\n await sqlite.execute({\n sql: `UPDATE ideas SET status='dropped' WHERE id=? AND status='open'`,\n args: [id],\n });\n return c.json({ ok: true });\n});\n\napi.get(\"/build/state\", async (c) => {\n const ideas = await rows(\n `SELECT * FROM ideas WHERE status IN ('open','committed') ORDER BY created_at ASC`,\n );\n const cycles = await rows(\n `SELECT * FROM build_cycles ORDER BY reviewed_at DESC LIMIT 20`,\n );\n\n const outstanding = ideas.find((i) => i.status === \"committed\") ?? null;\n const last = cycles[0] ?? null;\n const dueAt = last\n ? new Date(\n new Date(last.reviewed_at).getTime() + BUILD_CYCLE_DAYS * 86400000,\n ).toISOString()\n : null;\n\n let passes = 0;\n for (const cy of cycles) {\n if (cy.verdict === \"pass\") passes++;\n else break;\n }\n\n return c.json({\n ideas: ideas.filter((i) => i.status === \"open\"),\n outstanding,\n last_reviewed_at: last?.reviewed_at ?? null,\n due_at: dueAt,\n due: !dueAt || new Date(dueAt) <= new Date(),\n consecutive_passes: passes,\n cycle_count: cycles.length,\n drift: await drift(),\n });\n});\n\napi.post(\"/build/ship\", async (c) => {\n const { id, note } = await c.req.json();\n const found = await rows(`SELECT * FROM ideas WHERE id=?`, [id]);\n if (!found.length) return c.json({ error: \"not found\" }, 404);\n await sqlite.execute({\n sql:\n `UPDATE ideas SET status='shipped', shipped_at=?, shipped_note=? WHERE id=?`,\n args: [now(), String(note ?? \"\").trim() || null, id],\n });\n return c.json({ ok: true });\n});\n\n// Engagement is mandatory, committing is not. \"Nothing worth changing\" passes —\n// but it has to be a stated verdict rather than a shrug, because looking at\n// numbers that might say you're declining is the part that gets avoided.\napi.post(\"/build/review\", async (c) => {\n const { verdict, note, idea_id, proof_description } = await c.req.json();\n const reason = String(note ?? \"\").trim();\n if (reason.length < 10) return c.json({ error: \"say why, in one line\" }, 400);\n\n const committed = await rows(\n `SELECT * FROM ideas WHERE status='committed' LIMIT 1`,\n );\n if (committed.length) {\n return c.json({\n error: 'ship \"' + committed[0].text + \"\\\" first — it's still outstanding\",\n }, 409);\n }\n\n const batch: any[] = [];\n let ideaId: string | null = null;\n\n if (verdict === \"commit\") {\n if (!idea_id) return c.json({ error: \"pick an idea\" }, 400);\n if (String(proof_description ?? \"\").trim().length < 10) {\n return c.json({\n error: \"describe what the screenshot shows when it's done\",\n }, 400);\n }\n ideaId = idea_id;\n batch.push({\n sql:\n `UPDATE ideas SET status='committed', committed_at=?, proof_description=? WHERE id=?`,\n args: [now(), String(proof_description).trim(), idea_id],\n });\n }\n\n const session = crypto.randomUUID().slice(0, 4);\n const cycleId = nid();\n batch.push({\n sql:\n `INSERT INTO build_cycles (id, reviewed_at, verdict, note, idea_id, card_session)\n VALUES (?, ?, ?, ?, ?, ?)`,\n args: [\n cycleId,\n now(),\n verdict === \"commit\" ? \"commit\" : \"pass\",\n reason,\n ideaId,\n session,\n ],\n });\n await sqlite.batch(batch);\n\n // Frozen for the same reason the weekly card is: the drift numbers on it move\n // continuously, and a card already screenshotted as proof must not change.\n const written = await rows(`SELECT * FROM build_cycles WHERE id=?`, [cycleId]);\n if (written.length) {\n await sqlite.execute({\n sql: `UPDATE build_cycles SET card_json=? WHERE id=?`,\n args: [JSON.stringify(await buildCycleCard(written[0])), cycleId],\n });\n }\n\n return c.json({ ok: true, card_session: session, card_id: cycleId });\n});\n\nasync function buildCycleCard(cycle: Record) {\n // Counted up to this cycle rather than up to now, so an older card still\n // reports the streak and review number it was made with.\n const upto = await rows(\n `SELECT * FROM build_cycles WHERE reviewed_at <= ?\n ORDER BY reviewed_at DESC LIMIT 20`,\n [cycle.reviewed_at],\n );\n\n let passes = 0;\n for (const cy of upto) {\n if (cy.verdict === \"pass\") passes++;\n else break;\n }\n\n let committedText: string | null = null;\n if (cycle.idea_id) {\n const i = await rows(`SELECT text FROM ideas WHERE id=?`, [cycle.idea_id]);\n committedText = i[0]?.text ?? null;\n }\n\n return {\n id: cycle.id,\n reviewed_at: cycle.reviewed_at,\n verdict: cycle.verdict,\n note: cycle.note,\n committed: committedText,\n consecutive_passes: passes,\n cycle_count: upto.length,\n session: cycle.card_session,\n drift: await drift(),\n };\n}\n\n// Cycles reviewed before card_json existed have no snapshot; they are rebuilt\n// once, on first view, and frozen from then on.\nasync function buildCardFor(cycle: Record) {\n if (cycle.card_json) {\n try {\n return JSON.parse(cycle.card_json);\n } catch { /* unreadable snapshot — rebuild below */ }\n }\n const card = await buildCycleCard(cycle);\n await sqlite.execute({\n sql: `UPDATE build_cycles SET card_json=? WHERE id=?`,\n args: [JSON.stringify(card), cycle.id],\n });\n return card;\n}\n\n// No ?id= gives the most recent improvement review's card. With ?id= it gives\n// any past one, so a card dismissed before it was screenshotted still counts.\napi.get(\"/build/card\", async (c) => {\n const wanted = c.req.query(\"id\");\n const found = wanted\n ? await rows(`SELECT * FROM build_cycles WHERE id=?`, [wanted])\n : await rows(\n `SELECT * FROM build_cycles ORDER BY reviewed_at DESC LIMIT 1`,\n );\n if (!found.length) return c.json({ card: null });\n return c.json({ card: await buildCardFor(found[0]) });\n});\n\napi.get(\"/build/cards\", async (c) => {\n const cycles = await rows(\n `SELECT id, reviewed_at, verdict, card_session FROM build_cycles\n ORDER BY reviewed_at DESC LIMIT 26`,\n );\n return c.json({\n cards: cycles.map((cy) => ({\n id: cy.id,\n reviewed_at: cy.reviewed_at,\n session: cy.card_session,\n verdict: cy.verdict,\n })),\n });\n});\n\nexport default api;",[],[100],"61a5ee95-de07-479e-af80-d53a114ac8db","README.md","019fb508-534b-72f8-ae6b-77805693e0dc",1,["D",1785448649481],"# React + Hono Starter\n\nA minimal starter template for building client-side React apps with a Hono\nbackend on Val Town. Click **Remix** to get your own copy.\n\n## Picking a starter\n\n| Starter | When to pick it |\n| --- | --- |\n| [`basic-html-starter`](https://www.val.town/x/templates/basic-html-starter) | Static HTML pages. Sprinkle of vanilla JS. No server-side rendering. |\n| [`hono-jsx-starter`](https://www.val.town/x/templates/hono-jsx-starter) | Dynamic server-rendered HTML with JSX. API routes. No React, no SPA. |\n| **[`react-hono-starter`](https://www.val.town/x/templates/react-hono-starter)** *(you're here)* | Client-side React SPA with a Hono API backend. |\n\n**Want to build UI?** Start writing React components in\n[`frontend/components/`](/frontend/components/). Import them into `App.tsx` and\nyou're good to go. Styling is [Twind](https://twind.style/) — just use Tailwind\nutility classes, zero config.\n\n**Want to add an API?** Add routes in [`index.ts`](/index.ts) (there's a\ncommented-out example). Fetch them from your React components.\n\n## Architecture\n\n```mermaid\ngraph LR\n Browser -->|\"GET /\"| Hono[\"index.ts
(Hono server)\"]\n Hono -->|serves| HTML[\"root.tsx\"]\n HTML -->|loads| Entry[\"index.tsx\"]\n Entry -->|renders| App[\"App.tsx\"]\n App -->|renders| Counter[\"Counter.tsx\"]\n```\n\n## File structure\n\n```\nindex.ts ← Hono backend (serves frontend + API routes)\nfrontend/\n root.tsx ← HTML shell (stamps immutable asset URLs)\n index.tsx ← React entrypoint (mounts )\n favicon.svg ← App icon\n components/\n App.tsx ← Root component (layout + view source link)\n Counter.tsx ← Example component with state\n```\n\n## How it works\n\n1. **`index.ts`** is the HTTP entrypoint — a Hono server that serves the\n frontend and any API routes you add.\n2. **`frontend/root.tsx`** is the HTML shell — it loads Twind and stamps\n immutable asset URLs for the favicon and React entrypoint.\n3. **`frontend/index.tsx`** mounts the React app.\n4. **`frontend/components/App.tsx`** is the root layout — add new components\n alongside it.\n5. **`frontend/components/Counter.tsx`** is an example stateful component —\n replace it with your own!\n\n## Next steps\n\n- Add API routes in `index.ts`\n- Add new components in `frontend/components/`\n- Add a SQLite database — see the\n [React Hono Example](https://www.val.town/x/stevekrouse/reactHonoExample) for\n a full-stack example with database, queries, and shared types\n\nTemplate updates and upgrade paths for existing remixes: [CHANGELOG.md](/CHANGELOG.md)\n",[],[108],"0a3f50aa-4135-40be-80cf-fe9d9a6f3138","CHANGELOG.md","019fb508-534b-72f8-ae6b-70d7a94155bc",["D",1785448649481],"# Changelog\n\n## 2026-07-30 — Immutable asset caching\n\nFrontend files are now served at version-addressed URLs\n(`/__immutable/45/frontend/index.tsx`) with\n`Cache-Control: public, max-age=31536000, immutable`, so repeat visits load the\nwhole client graph from the browser cache — roughly 3× faster (~665ms → ~157ms\nmeasured). Publishing your val bumps its version, which changes every URL, so\ncaches invalidate automatically. Old-version URLs return 404 after a publish\n(like Next.js build assets); a reload picks up the new version.\n\nWhat changed in the template:\n\n- `frontend/index.html` → [`frontend/root.tsx`](/frontend/root.tsx): the HTML\n shell is now JSX and stamps asset URLs with `immutableFileUrl()`\n- [`index.ts`](/index.ts): serves `Root()` at `/`, and one\n `app.get(\"/__immutable/*\", (c) => serveImmutableFile(c.req.path))` route\n serves all frontend files\n\n### Upgrading an existing remix\n\nYour copy of this template doesn't update automatically. Two options:\n\n**Minimal (most of the benefit):** point both routes at `serveImmutableFile` —\nyour existing bare URLs redirect into versioned space, the new route serves\nthem, and the whole module graph gets cached (costs one redirect per page view):\n\n```ts\nimport { serveImmutableFile } from \"https://esm.town/v/std/utils/index.ts\";\n\napp.get(\"/__immutable/*\", (c) => serveImmutableFile(c.req.path));\napp.get(\"/frontend/**/*\", (c) => serveImmutableFile(c.req.path)); // was serveFile\n```\n\n**Full upgrade (also removes the redirect):** three self-contained steps —\nno other files needed. Adjust the ``, favicon, and body of `Root()` to\nmatch your app's existing `index.html`, and stamp anything else your shell\nreferences directly (images, css) with `immutableFileUrl()`.\n\n1. Create `frontend/root.tsx`:\n\n```tsx\n/** @jsxImportSource npm:hono@4/jsx */\nimport { raw } from \"npm:hono@4/html\";\nimport { immutableFileUrl } from \"https://esm.town/v/std/utils/index.ts\";\n\n// The HTML shell for the app. It is never cached, so immutableFileUrl can stamp\n// the current val version into each asset URL — the browser caches those\n// immutably, and publishing the val changes the URLs, refetching exactly once.\nexport function Root() {\n return (\n <>\n {raw(\"<!DOCTYPE html>\")}\n <html lang=\"en\">\n <head>\n <meta charSet=\"UTF-8\" />\n <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n <title>React Hono Val Town Starter\n