Files
OKF_Vault/mission/plan.md
T
2026-11-13 20:14:32 +01:00

11 KiB
Raw Blame History

Plan — Saturday 07:00 to Sunday 13:00

The real clock

Time What Hard?
Fri 13 Nov, evening SKE access, data, repo skeleton, decisions Yes — do this today
Sat 14 Nov, 07:00 Build starts —
Sat 10:00 Gate 1: public HTTPS hello-world on SKE Yes
Sat 13:00 Gate 2: data pipeline + API contract + app shell Soft
Sat 18:00 Gate 3: end-to-end core on SKE, 3 phones Yes
Sat 23:00 Feature freeze Yes
Sun 15 Nov, 06:00 Deploy freeze Yes
Sun 07:00–09:00 Rehearse, record fallback, pack Yes
Sun 10:00 Preselection demo Yes
Sun 13:00 Submit presentation + code Yes
Sun 14:00 Final pitch (if selected) Stretch

You said "24 hours from 07:00." The actual submission deadline is 30 hours later, but only ~24 of those are usable build time. Use the extra 6 hours for rehearsal and submission, not features.

Friday evening (today) — 2–3 hours, not 6

  • Request SKE access (expected today; namespace-only).
  • Namespace access verified: no Ingress, no Jobs/CronJobs, no cert-manager, no quota. Use Cloudflare Tunnel and build-time batch. See friday-blockers.md.
  • Create a Gitea package token; push a hello-world to git.noelsabia.dev; create gitea-regcred; verify the cluster pulls it.
  • Download the PAX CSV (done; see data.md); keep it out of git.
  • Decide Q1 (hero use case) and the Q1.1–Q1.3 follow-ups in mvp.md.
  • Create the app repo/folder skeleton: api/, web/, ml/, deploy/, Makefile, README.md.
  • Verify Nuxt SSR + Onyx build (done; see friday-blockers.md). Do not design the UI yet.
  • Sleep. Tomorrow is the long day.

Saturday

Time Human Data/ML agent Go agent Nuxt agent Infra/QA agent
07:00–08:00 Stand-up, confirm namespace, assign Verify CSV, write parser API skeleton, health Nuxt SSR shell Namespace smoke test, Gitea pull
08:00–10:00 Unblock, deploy hello-world Hourly aggregation, features Contract endpoints Layout, mock data Cloudflare Tunnel, Gate 1
10:00–13:00 Integrate, review Baseline model, FastAPI skeleton Sensors/series/forecast Map + time series Build/push all three images
13:00–16:00 Gate 2, integrate Weather join, scenario grid Staffing endpoint, SSE, cache Staffing view, scenario controls Deploy web/api/ml, smoke test
16:00–19:00 Test on phones, cut FastAPI fallback test, model card Load test 120 SSE Mobile polish, live view SSE through Tunnel, Gate 3
19:00–22:00 Demo rehearsal #1 Fix data/API edge cases Fix API/SSE bugs Fix UI bugs, empty states Load test, rollback drill
22:00–23:00 Freeze, tag, deploy Freeze model/JSON Freeze binary Freeze build Freeze manifests
23:00–23:30 Feature freeze. Write down what is cut. — — — —
23:30–04:30 Sleep (yes, really) — — — —

If Gate 1 slips past 10:00, stop feature work and fix deployment. If it slips past 12:00, escalate to the mentors and switch to the fallback. Do not build a beautiful app that is not on SKE.

Sunday

Time What
04:30–06:00 Final verification. Fix only a demo blocker; re-deploy the frozen image; verify health.
06:00–07:00 Deploy freeze. No cluster changes.
07:00–08:30 Rehearse the 5-minute preselection demo and the 8-minute final; record a backup video.
08:30–09:00 Pack: laptop, charger, 3 phones, hotspot, QR slide, backup video, USB stick.
10:00 Preselection. Demo. Explain. Do not debug on stage.
13:00 Submit presentation + code.
14:00 Final pitch if selected.

Workstreams and agent contracts

The human owns decisions, integration, deployment, and the demo. Agents own code in isolated folders. Do not let agents deploy to SKE without review.

1. Human — architect / integrator / presenter

  • Owns mission/, deploy/, the final demo, and every merge.
  • Writes the API contract before agents start.
  • Runs the 10:00 / 13:00 / 18:00 / 23:00 checkpoints.
  • Cuts scope without debate when a gate slips.
  • Does not write frontend CSS at 02:00.

2. Data/ML agent — ml/

  • Owns ml/, data/ (git-ignored raw), generated JSON, the FastAPI service.
  • Delivers: batch pipeline (make data), sensors.json, series.json, forecasts.json, metrics.json, model_card.md, FastAPI /predict and /simulate with /healthz and /readyz.
  • Must not touch web/ or api/ code.
  • Definition of done: reproducible batch run; time-based validation; baseline comparison; no leakage; FastAPI starts with the baked model; JSON schema matches the contract; Go cache fallback tested.
  • Prompt: "Read mission/README.md, mission/data.md and mission/architecture.md. Build the batch pipeline and FastAPI service. Do not tune for more than 2 hours. Report MAE/WAPE vs seasonal naive and the exact JSON/API schema."

3. Go agent — api/

  • Owns api/.
  • Delivers: health/ready, sensors, series, forecast, staffing, scenario POST, SSE stream, FastAPI client, cached fallback, tests for the SSE hub and handlers.
  • Must not touch web/ or ml/.
  • Definition of done: go test ./...; runs with the generated JSON; works when FastAPI is down; 120 concurrent SSE clients; graceful shutdown.
  • Prompt: "Read mission/architecture.md. Implement the API contract exactly. Use the JSON fixtures in api/testdata/. Cache FastAPI responses and fall back to baked JSON. Do not add a database, a framework, or auth beyond the control token."

4. Nuxt agent — web/

  • Owns web/.
  • Delivers: app shell, pulse map, time-series chart, forecast + staffing view, scenario controls, /live mobile view, /stage big-screen view, /control token page, empty/error states.
  • Must not touch api/ or ml/.
  • Definition of done: builds with nuxt build (SSR); works with mock JSON before the API exists; responsive at 390 px and 1440 px; no console errors; browser-only map/chart wrappers; Onyx components where sensible.
  • Prompt: "Read mission/README.md and mission/architecture.md. Build the screens against the mock data in web/mock/. Use @sit-onyx/nuxt with SSR. Wrap MapLibre and SSE in client-only components. Keep the map dependency replaceable with a static image."

5. Infra/QA agent — deploy/

  • Owns deploy/, Dockerfiles, Makefile, smoke tests, load test.
  • Delivers: multi-stage Dockerfiles for web/api/ml, namespace-only k8s manifests, Cloudflare Tunnel Deployment, imagePullSecret, PSA-compliant securityContext, make deploy, make smoke, make load.
  • Must not change app logic or install cluster-scoped resources.
  • Definition of done: a fresh namespace deploys all three images plus cloudflared; HTTPS works; /api/healthz and FastAPI /healthz pass; 120 SSE clients for 5 minutes; rollback documented.
  • Prompt: "Read mission/architecture.md and mission/friday-blockers.md. Produce namespace-only manifests, a Cloudflare Tunnel Deployment, and a smoke test. Do not install cert-manager, external-dns, an ingress controller, Jobs/CronJobs or any CRD. Use the Gitea registry."

Integration cadence

Every checkpoint: build, deploy, open on a phone, update the README, write down what broke.

Checkpoint Demoable outcome If missing
Sat 10:00 Public HTTPS hello-world Stop features; fix deployment.
Sat 13:00 Real data in API; app shell on SKE Cut map polish; keep data + shell.
Sat 18:00 Forecast + staffing + scenario on 3 phones Cut audience view and poll.
Sat 23:00 Frozen demo, 5-minute run-through Cut to 3 screens: map, forecast, staffing.

Effort budget

Area Share Why
Frontend + SSR integration 35% The long pole. Map, charts, responsive, scenario UI, hydration, empty states.
Data/ML + FastAPI 20% Batch baseline is proven; FastAPI, caching and fallback add work.
Go API + SSE 15% Straightforward, but cache fallback and 120-client load testing take time.
Infra + deployment 20% Namespace-only, Gitea registry, Cloudflare Tunnel, three services, smoke tests.
Demo + docs 10% High leverage for judging; do not leave it to the last hour.

If you are solo, cut the audience view, the poll, the custom domain, and the battery panel. Keep the map, forecast, staffing, scenario, SSE, and SKE deployment.

Risks

Risk Likelihood Impact Mitigation
SKE access late Medium Blocks the requirement Access requested, expected today; namespace smoke test; escalate Saturday 09:00; manifests ready.
Namespace quota too small Medium Three pods do not fit Check quota first; degradation ladder: 2 pods or 1 pod.
Gitea pull fails Medium No images Test hello-world pull; check gitea-regcred, DNS, NetworkPolicy; public registry fallback.
Cloudflare Tunnel unavailable Medium No public HTTPS Check outbound 443; use a temporary local tunnel; escalate.
Frontend scope explodes High Misses freeze Three screens only; mock data first; cut P1 at 18:00.
Over-engineering High Wastes the day Three services maximum; no DB, no extra platform, no CI beyond build/push.
FastAPI is a single point of failure Medium Blank demo Go caches forecasts; FastAPI optional at runtime; test the fallback.
Venue network fails Medium Demo dies Mobile data; local build; recorded video.
Onyx/Nuxt SSR integration Low UI delay SSR tested; wrap browser-only components; fall back to SPA.
Model/data leakage Medium Credibility Time-based split; no future features; show baseline.
Single API pod restarts Low Brief outage Probes, small image, Recreate, local fallback.
Agent integration conflicts Medium Merge pain Four worktrees, folder ownership, API contract, human review.
No sleep Medium Bad pitch Sleep 4–5 h; storytelling is 30% of the final score.

Friday-night checklist

  • SKE access requested (namespace-only).
  • Namespace access verified: no Ingress, no Jobs/CronJobs, no cert-manager, no quota. Cloudflare Tunnel is the exposure path.
  • Gitea token created; hello-world pushed; gitea-regcred created; cluster pull verified.
  • Hero use case chosen (Q1.1–Q1.3).
  • Realtime meaning chosen (Q4: a + c).
  • Nuxt SSR + Onyx hello-world builds (verified).
  • Repo skeleton + API contract written.
  • Raw CSV downloaded and git-ignored.
  • Alarm set for 06:30.

Sunday-morning checklist

  • Deployed URL opens on a phone on mobile data.
  • /api/healthz, /api/readyz and FastAPI /healthz return 200.
  • Scenario change reaches the phone in under 2 seconds.
  • FastAPI down test: app still serves the cached forecast.
  • 120 SSE clients for 5 minutes.
  • Audience QR opens /live without login.
  • Backup video plays offline.
  • Pitch deck PDF on a USB stick and in the cloud.
  • Code and presentation submitted before 13:00.