Skip to main content
Capstone review · current public capstone prototype

LAKANA SOS: Safety Without Surveillance

A full-stack, backend-linked civilian safety simulation for degraded infrastructure, bounded responder handoff, and public-safe evidence custody.

CreatorMarTaize Fails
ContextFull-stack capstone / research prototype
Project typeBackend-linked public simulation + evidence review layer
StatusPublic evaluation prototype deployed on Vercel — simulation-only, no field validation or emergency-service deployment
Submission status

Completion Dashboard

Counts below are read directly from the requirements, test, and scenario evidence on this page — not a separate hardcoded total.

Functional requirements
16
16 implemented of 16
Nonfunctional requirements
11
10 implemented of 11, with NFR-04 remaining partially verified
Documented tests
33
30 pass of 33
Proof Theater scenarios
7
Canonical scenario registry, live-run-engine.js
Professor scenarios
3
Flood/Hurricane, Structure Fire/Muster, Acoustic Emergency
Backend execution
Real
One backend POST per explicit run
Official receipt
Returned
Downloadable and independently verifiable
Responsive audit
Partially verified
0 overflow at 390–1920px; see Test Plan T-20–T-22
Accessibility audit
Partially verified
Manual keyboard pass complete; no independent third-party audit yet
Current submission status
Implemented and deployed
Public evaluation deployed; not a live emergency service or field-deployed local-first system
Choose your review depth

Review Mode

All three modes read the same preserved evidence. No mode deletes or permanently hides a section.

Highlights the mission brief, dashboard, console, live result, what was built, requirements/test summary, limitations, and submission snapshot. Every other section remains fully present and reachable.

Before you run it

Three-Step Professor Review

Choose the review path

Embedded professor console — single-run review: run one of three professor scenarios on this page, inspect the returned result, download the exact receipt, and verify its integrity/signature state.

Proof Theater — full flagship demonstration: open Flood/Hurricane, capture a baseline receipt, apply blackout stress, rerun, and compare the two completed receipts.

1

Choose a scenario and run depth

Select Flood/Hurricane, Structure Fire/Muster, or Acoustic Emergency Recognition. Then choose Full Evidence Run at 5,000 trials or Quick Professor Review at 600 trials.

  • Observe: the scenario objective, operating condition, and selected trial depth are shown before any request is made.
  • Does not happen automatically: changing the scenario or trial depth sends no request and creates no receipt.
2

Accept the acknowledgement

Check the simulation-only acknowledgement box. The Run button stays disabled until you do.

  • Observe: the Run button becomes enabled.
  • Does not happen automatically: no run starts before this explicit acceptance.
3

Run, inspect, download, and optionally verify

Run the simulation, review the result summary, download the exact official receipt, and optionally verify its integrity/signature state.

  • Observe: exactly one backend request per run.
  • Does not happen automatically: no result appears before the backend returns; no browser fallback result is ever created; download uses the exact captured receipt text; verification does not convert an imported receipt into a live run.
Primary academic review

Primary Academic Review

The following sections preserve the complete project objective, intended users, demonstration design, architecture, privacy boundary, emergency-management interpretation, and research alignment.

Project objective

What this capstone demonstrates

This capstone demonstrates a full-stack safety simulation prototype: public scenario controls, backend Monte Carlo execution, public-safe receipt generation, role-specific interpretation, consent-gated audio modeling, bounded responder handoff visualization, degraded-transport analysis, and stale-state protection.

The technical problem

Civilian safety software that watches continuously to be useful in an emergency becomes a permanent surveillance system the rest of the time. This project asks whether a safety architecture can stay bounded — minimizing what it collects and releases — while still behaving usefully when communications and power infrastructure degrade.

The public-safety problem

Flood, hurricane, and other large-area events routinely take out cell towers, cellular service, and home power at the same time a resident most needs a path out or a way to signal for help. A safety design that only works when the network is healthy is not tested against the conditions that matter most.

The privacy problem

Designing for degraded infrastructure tends to push systems toward more collection "just in case" — more location history, more always-on audio, more centralized storage. This capstone treats that as a design failure to avoid, not a tradeoff to accept, and evaluates a bounded, consent-gated, custody-aware alternative instead.

Why degraded infrastructure matters

The strongest evidence produced by the companion research is architecture-level and delivery/infrastructure-mediated: it shows up specifically when ordinary centralized transport is stressed, not in ordinary conditions. A capstone story built only around a calm-weather scenario would not exercise the part of the design doing the most work.

Primary user and use case

Who this is built to be evaluated for

Primary user

An isolated civilian, field-service worker, or community member operating during flood conditions and communications degradation — someone who needs a bounded, local-first safety layer when ordinary cellular, Wi-Fi, or cloud paths are unreliable.

Primary reviewer / customer context

  • University safety and research review.
  • Field-service safety programs.
  • Community resilience planning.
  • Emergency-management tabletop evaluation.

This capstone does not present live 911 service, operational public deployment, or agency integration as the primary user or use case. Those are future-work pathways described in the Limitations and Future Work sections below, not claims about the current prototype.

Flagship demonstration

Flood / Hurricane under communications and infrastructure degradation

The flagship demonstration runs the existing Flood / Hurricane preset through the real backend Monte Carlo twice, using only sliders that already exist in the Proof Theater, and compares the two completed public-safe receipts.

  1. Baseline run. Flood / Hurricane is selected and reset to its real preset defaults — severe weather with partial infrastructure still available. You accept the normal Run Access Agreement and manually start the backend Monte Carlo yourself. The completed receipt is stored as the baseline.
  2. Apply blackout stress. A single button configures existing, already backend-supported sliders — tower outage, RF/cellular degradation, route obstruction, evacuation-route viability, battery reserve, store-forward delay, Sovereign Home / wired-anchor availability, non-RF handoff capacity, and evidence/auth posture — to a documented degraded-communications configuration. This changes visible sliders only, marks the run stale, and consumes no backend run, no counter, and no receipt mutation.
  3. Blackout-stress run. You manually run the backend Monte Carlo again. The completed receipt is stored separately as the blackout-stress receipt. The page's normal "download latest receipt" behavior still points at whichever run completed most recently — the two capstone snapshots are stored and labeled separately from that.
  4. Compare. A compact, receipt-derived table compares only the fields that exist in both completed receipts — route obstruction, immediate-egress and blackout-risk scores, preservation score, primary/backup egress path, BFB handoff posture, TAB state, battery burden, evidence/auth posture, modeled scene-edge arrival and physical access windows, public access counters, run IDs, and Run Integrity state. Anything not returned by a receipt reads "Not returned by this receipt," never a fabricated value.

What changes between runs

Only the sliders listed above. Everything else — the scenario's flood depth and rain intensity, BFB/TAB enablement, and every other control — stays at the same preset value across both runs, so the comparison isolates the effect of communications/infrastructure degradation.

What remains controlled

The scenario, trial count, and every non-communications slider stay fixed. Both runs go through the same backend endpoint, the same trial cap, and the same receipt serialization path.

What the comparison can show

How the same modeled event's delivery-path, egress, and preservation reads change when ordinary transport is degraded and CivOS falls back to surviving permitted paths — the same architecture-level pattern the companion research reports under synthetic degraded-state stress.

What it cannot prove

This is not a controlled field experiment, an emergency-service validation, or a guarantee that a packet can leave when no physical transport path exists. When no route exists, SOS preserves the event locally and records non-delivery — it does not claim delivery happened anyway.

Open the Capstone Demonstration Mode in the Proof Theater
System architecture

Request → simulation → receipt → interpretation

Every run follows one linear, auditable path. Nothing about the diagram below implies a production emergency deployment — it documents the current public capstone prototype.

TAB (Tactical Audio Bridge) flow

Frontend vs. backend

Division of responsibility

Frontend responsibilities

  • Display the seven public presets.
  • Mount scenario and shared controls.
  • Validate interaction state (access agreement, stale runs).
  • Show changed-from-default status.
  • Show stale state after control changes.
  • Submit the public-safe request.
  • Display the backend receipt.
  • Render the graph and role-specific interpretation.
  • Support receipt download and sensitivity.

Backend responsibilities

  • Sanitize inputs.
  • Enforce the trial cap.
  • Execute the public Monte Carlo.
  • Enforce public access counters.
  • Serialize the public-safe receipt.
  • Apply TAB state.
  • Return bounded outputs only.

Evaluation implementation vs. target architecture

The capstone uses a serverless backend to make the public simulation reviewable, rate-limited, and reproducible. The modeled production architecture remains local-first: local-first device state, local evidence custody, degraded-transport handling, and device/hardware-adjacent execution. The cloud-hosted simulation service is an evaluation implementation, not the claimed final safety execution substrate.

Requirements traceability

Requirements Traceability Matrix

Every row reflects genuinely implemented behavior in the current production main build. Nothing here is marked complete unless it is real.

Functional requirements

IDRequirementImplementationEvidenceStatusBoundary
FR-01Select one of exactly seven scenarios.SCENARIOS array, live-run-enginePreset dropdown renders 7 optionsImplementedBackend math unchanged across all seven
FR-02Mount scenario-specific controls.slidersFor() / rebuildSliders()Sliders swap on scenario changeImplementedReal backend keys only, no invented sliders
FR-03Adjust public-safe shared controls.Universal substrate + degraded-egress groupsSliders visible, collapsible groupsImplementedPublic-safe estimates, not raw telemetry
FR-04Accept run-access agreement.isAccessAccepted() / #v21TermsRun button disabled until acceptedImplementedSession-scoped, not a legal record
FR-05Execute backend Monte Carlo.POST /api/sos/safety-simulation-labReal network request per runImplemented5,000-trial public cap
FR-06Generate a receipt-backed result.buildPublicSafeReceipt (backend)Receipt object returned per runImplementedProtected internals withheld by design
FR-07Display backend counters.publicAccessWindowHour/day/month/total usage shownImplementedDurable, atomic Upstash Redis enforcement using a privacy-preserving HMAC access identity; production fails closed if durable enforcement is unavailable
FR-08Mark results stale after control changes.markRerunRequired()#lkmcRerunFlag becomes visibleImplementedNo receipt mutation before rerun
FR-09Rerun through the same backend path.runSimulation()Same endpoint, same sanitizerImplementedNo local fallback result
FR-10Download the latest completed receipt.downloadReceipt()Always the most recent completed runImplementedNot the capstone baseline/blackout snapshots
FR-11Request and decide TAB.User tablet + TAB backend rerun bridgeAccept/deny dispatches real rerunImplementedNo-interaction path injects no fake state
FR-12Show BFB bounded handoff.BFB field console + receipt fieldsBounded responder packet renderedImplementedRoute hint/welfare/validity/audit only
FR-13Generate receipt-derived sensitivity.Quick Sensitivity BandsBands populate after a completed runImplementedNot protected Sobol/GSA validation
FR-14Render role-specific Reviewer Lens.Reviewer Lens (6 lenses)Deep-dive + questions per lensImplementedInterpretation only, not new metrics
FR-15Support baseline vs. blackout-stress capstone comparison.Capstone Demonstration ModeTwo-run comparison tableImplementedCompatible fields only, neutral for missing
FR-16Submit professor review feedback and produce a human-readable review report.Professor review form, durable review API, receipt reader, Word export, and print/PDF outputSuccessful API submission receipt, DOC generation, print layout, and imported-receipt verificationImplementedAcademic review workflow only; not an official OSU-OKC grading-system replacement

Nonfunctional requirements

IDRequirementImplementationEvidenceStatusBoundary
NFR-01Privacy minimization.Bounded release boundary, allow/deny listsReceipt releaseBoundary fieldImplementedNo raw audio/video/continuous location by default
NFR-02No raw trace exposure.Backend withholds protected constantsrawTracesWithheld: true on receiptImplementedReviewer-visible flag, not a formal audit
NFR-03Responsive mobile/tablet/desktop layout.Breakpoints across engine + review CSSTested 390/768/1024/1280/1440ImplementedSee Test Plan for viewport results
NFR-04Accessible keyboard operation.Native buttons/inputs, visible focus stylesManual keyboard pass on new pagesPartially verifiedNot independently audited by a third party
NFR-05Backend-authoritative results.No local fake Monte CarloEvery result traces to a POST responseImplementedErrors never fabricate a replacement result
NFR-06Duplicate-submit prevention.runToken guard + button disableRun button disabled while a request is in flightImplementedRate limit still enforced backend-side
NFR-07Public claim boundary.CLAIM_BOUNDARY_TEXT, claim-boundary sectionsRendered on Proof Theater and this pageImplementedRepeated at every relevant section, not just once
NFR-08Honest error state.errorMessageFor()Rate-limit/terms/5xx-specific copyImplementedNo stack traces or API internals shown
NFR-09Receipt integrity.receiptHash fieldHash present on every completed receiptImplementedIntegrity-style hash, not a cryptographic signature
NFR-10No dependency on continuous location display.Route hint / bounded proximity onlyNo live map or continuous coordinate feedImplementedModeled scene-edge/physical-access windows only
NFR-11Protect reviewer information and retain only bounded review evidence.Sanitization, consent notice, HMAC access identity, durable fail-closed storage, one-year retention, no raw IP persistencelib/sos/sos-capstone-review-store.js namespace/domain separation and review-record schemaImplementedNot a FERPA-certified student-record system and not a replacement for the institution's official LMS
Technology stack

What this is actually built with

HTMLStatic pages, semantic sections
CSSHand-written, no framework/utility library
JavaScriptVanilla JS, no frontend framework
Node-compatible serverless API/api/sos/safety-simulation-lab
Vercel deploymentStatic build + serverless function
JSON receiptsPublic-safe run receipts, no database row
Session-scoped browser statesessionStorage for access-agreement/session state
Monte Carlo simulationBackend-executed, trial-capped
jsdomUsed by existing non-browser validation scripts

Not used: React or another frontend framework, a database, WebRTC, native Android, a custom kernel, or deployed cryptographic hardware. If any of those are added later, this list should be updated alongside them.

State and data lifecycle

What exists, where, and for how long

Lives in the browser tab

  • Current slider state (until reset or reload).
  • Latest completed receipt (window.LAKANA_SOS_SIM_STATE).
  • Stale-preview flag after a control change.
  • Capstone baseline and blackout-stress receipt snapshots, held separately from the "latest receipt" pointer.

Lives in sessionStorage

  • Run-access-agreement acceptance for the current browser session.
  • A copy of the most recently upgraded receipt, for the current tab session only.

sessionStorage is browser tab storage, not a database. It clears when the tab closes and is never queried across users.

Leaves the browser

Only the sanitized public-safe request body (scenario key, slider values, trial count, seed) sent to the backend endpoint on each run. No raw audio, video, continuous location, or device identifiers are sent.

Server persistence boundary

Individual receipt payloads are not stored in a server-side run database after the response is returned. Public access counters are separately and atomically enforced through durable Upstash Redis using a privacy-preserving HMAC access identity; the production endpoint fails closed if durable enforcement is unavailable.

Real vs. simulated

What is genuinely real in this capstone

Real

  • Frontend and backend endpoint.
  • Request sanitizer.
  • Monte Carlo execution.
  • Run counters.
  • JSON receipt.
  • Stale-state behavior.
  • Scenario controls.
  • TAB accept/deny UI state.
  • BFB visualization.
  • Reviewer Lens.
  • Sensitivity.
  • Responsive layout.
  • Guided demonstration.
  • Two-run receipt comparison.

Simulated

  • The emergency event itself.
  • Actual dispatch.
  • Responder arrival.
  • Physical rescue.
  • Real agency integration.
  • Production local hardware.
  • Ring -1 behavior.
  • Kernel-adjacent behavior.
  • Field communications.
  • Emergency certification.

This prototype demonstrates system behavior, technical workflow, and evidence review. It is not live emergency dispatch, field validation, or guaranteed rescue.

Student authorship

What I Designed and Implemented

For this capstone, I designed and implemented the public evaluation prototype, backend-linked simulation workflow, receipt review interface, and validation package for the LAKANA SOS architecture.

Frontend

  • Professor-facing simulation console.
  • Scenario-selection interface.
  • Simulation acknowledgement.
  • Run-state handling.
  • Result presentation.
  • Receipt download.
  • Receipt verification interface.
  • Reviewer Lens.
  • Responsive and accessible review presentation.

Backend integration

  • Public-safe request construction.
  • Existing backend endpoint integration.
  • Idempotency handling.
  • Error-state handling.
  • Trial-limit compliance.
  • Official receipt capture.
  • Exact receipt preservation.

Evidence and validation

  • Requirements traceability.
  • Test matrix.
  • Current/stale-state protection.
  • Receipt-byte immutability checks.
  • Responsive audits.
  • Accessibility audits.
  • Claim-boundary validators.
  • Deployment verification.

Architecture presentation

  • BFB explanation.
  • TAB consent boundary.
  • NICOLE custody boundary.
  • CivOS degraded-operation explanation.
  • Architecture Evaluation.
  • Evidence dossier.

The underlying LAKANA SOS, CivOS, TSARO, NICOLE, BFB, and TAB architecture is pre-existing LAKANA background intellectual property. The capstone work is the public evaluation, implementation, review, and validation layer.

Student reflection

Engineering Decisions and Tradeoffs

Backend-authoritative results

Decision
Never create an official browser fallback result.
Tradeoff
The interface must show an honest error when the backend is unavailable.

Exact receipt preservation

Decision
Capture and serialize the returned official receipt once, then use that same text for download and verification.
Tradeoff
Presentation code cannot freely mutate or normalize the receipt object.

Idempotency

Decision
Use a stable request identity during safe retries.
Tradeoff
Certain error states require the user to deliberately start a new request.

Public-safe trial depth

Decision
Default the professor console to the endpoint's maximum public-safe 5,000-trial run while retaining a 600-trial Quick Professor Review option.
Tradeoff
The 5,000-trial mode reduces Monte Carlo sampling variability relative to 600 trials for the same modeled inputs, while the 600-trial mode remains faster for repeated interface review. Both remain public-safe simulations and are not the project's full research runs or field validation.

Privacy minimization

Decision
Show public-safe bounded state rather than raw audio, video, location history, or protected traces.
Tradeoff
The interface cannot expose every underlying research or production detail.

Local-first target vs. serverless evaluation

Decision
Use a serverless backend for the public academic evaluation.
Tradeoff
This public implementation is not the final local-first production substrate.

Stale-state protection

Decision
Mark results stale when inputs change.
Tradeoff
A user must explicitly rerun instead of seeing an instant locally projected result.

Progressive disclosure

Decision
Keep the professor first frame concise while preserving full technical evidence.
Tradeoff
Some technical evidence requires opening the appendix or disclosures.
Student reflection

Challenges Encountered

Frontend/receipt synchronization

Problem
Keeping frontend interpretation synchronized with receipt authority.
Why it mattered
A stale local interpretation could contradict the official receipt.
Resolution
Every interpretation function reads only receipt fields, never a separately computed value.
Remaining boundary
New receipt fields still require an explicit reader update.

Integrity vs. authenticity

Problem
Distinguishing digest integrity from signature authenticity.
Why it mattered
Conflating the two would overstate what an unsigned receipt proves.
Resolution
Digest and signature states are reported as two separate, explicitly worded fields.
Remaining boundary
Production signing is not enabled in this public evaluation.

Duplicate bindings and mounts

Problem
Preventing duplicate event bindings and repeated mounts.
Why it mattered
Duplicate handlers can fire a control's action multiple times per click.
Resolution
Every mount function checks for an existing node/binding flag before acting.
Remaining boundary
Verified by direct duplicate-event dispatch tests, not a formal static analyzer.

Presentation polling

Problem
Eliminating presentation polling.
Why it mattered
Timer-driven re-renders waste cycles and can fight user interaction mid-render.
Resolution
Rendering is event-driven with a render-signature guard instead of setInterval.
Remaining boundary
One long-standing loader interval remains elsewhere in the codebase, preserved under the zero-deletion covenant.

Node identity across state changes

Problem
Preserving node identity across scenario/state changes.
Why it mattered
Replacing a root node on every update resets scroll, focus, and open disclosures.
Resolution
Existing-node checks return the same element on every re-render.
Remaining boundary
Verified for the flows exercised in this branch's real-browser tests.

Grid-created dead space

Problem
Preventing grid-created dead space across responsive layouts.
Why it mattered
A shared CSS Grid row stretches to its tallest item regardless of alignment rules.
Resolution
Independent content lanes and align-items:start replaced shared-row layouts.
Remaining boundary
New sections must follow the same lane pattern to avoid reintroducing the defect.

Touch targets in dense controls

Problem
Maintaining 44×44 touch targets inside dense controls.
Why it mattered
Small interactive elements are hard or impossible to use on a touch device.
Resolution
A forensic tap-target audit fixed every sub-44px real touch target.
Remaining boundary
Not independently audited by a third party.

Civilian User Tablet preservation

Problem
Preserving the Civilian User Tablet and all modules while adding new review layers.
Why it mattered
New sections could accidentally reparent or reset an unrelated module.
Resolution
New mounts insert relative to stable anchors and never touch the tablet's own DOM.
Remaining boundary
Verified via protected-module regression checks in this branch's flows.

Commercial-reference framing

Problem
Keeping commercial-reference profiles from becoming vendor-performance claims.
Why it mattered
A topology sensitivity could be misread as a named-vendor benchmark.
Resolution
Every profile card carries an explicit "not a vendor benchmark" label and comparability boundary.
Remaining boundary
Public documentation coverage of vendor architectures is necessarily incomplete.

BFB/TAB claim boundary

Problem
Separating modeled BFB/TAB stages from real dispatch or responder outcomes.
Why it mattered
A bounded operational picture could be mistaken for actual responder arrival.
Resolution
Every BFB/TAB surface states explicitly that it is not dispatch, arrival, or physical access.
Remaining boundary
No real responder or agency has used this interface.

Exact bytes vs. readable summaries

Problem
Preserving exact receipt bytes while still presenting readable summaries.
Why it mattered
A summary that silently changed the underlying object would break verification.
Resolution
Summaries read from the receipt; they never write back to it.
Remaining boundary
Verified by byte-comparison checks across every real-browser flow in this branch.

Honest error and retry states

Problem
Supporting useful error and retry states without fabricating a result.
Why it mattered
A generic error message can be mistaken for a completed run.
Resolution
Rate-limit, terms, and server errors show specific, honest copy with no invented result.
Remaining boundary
Not independently load-tested at scale.
Student reflection

What I Learned and Would Improve

What I learned

  • Backend authority is a product-design decision, not only an API decision.
  • Honest missing-state presentation matters as much as successful-state presentation.
  • Accessibility failures often come from layout ownership and effective target area, not only color contrast.
  • Responsive design must be validated through real browser geometry.
  • Security and privacy claims require explicit boundaries.
  • Receipt provenance, integrity, and authenticity are separate concepts.
  • Simulation evidence must not be presented as field evidence.
  • Complex technical systems need role-specific explanations.

What I would improve next

  • Independent accessibility audit.
  • External code/security review.
  • Emergency-management tabletop review.
  • Human-factors testing.
  • Degraded-communications bench testing.
  • Controlled partner pilot.
  • Local hardware prototype.
  • Field calibration after governance approval.
  • More formal automated end-to-end coverage.
  • Submission/deployment automation.
Privacy and security design

How the boundary is enforced

Data minimization & bounded disclosure

The allowed payload is limited to welfare state, route hint, validity, and audit fields. Denied-by-default fields — raw audio, raw video, continuous location — are named explicitly on every receipt's release boundary.

Consent-gated TAB, non-recording default

The Tactical Audio Bridge only enters an accepted state after an explicit user decision. Recording remains off by default, and no-interaction never injects a fake accepted/denied override.

BFB packet boundary

The Blue Force Bridge responder packet is minimized to route hint, welfare, validity, and audit — never a continuous location feed or raw evidence vault access.

Raw trace withholding & denied-path audit

Protected constants, private thresholds, and raw traces are withheld by design. Denied or failed transport is not silently dropped — it is recorded in the event timeline.

Stale-state protection

Once any control changes after a completed run, the result is marked stale and a rerun is required before the receipt is treated as current — the interface never quietly keeps showing a result that no longer matches the visible controls.

Browser permission posture

The public demo does not request microphone, camera, or continuous geolocation permissions. TAB and BFB flows are modeled UI state, not live WebRTC sessions.

Not claimed: perfect privacy, "unhackable" or "surveillance-proof" status, formal certification, or legal compliance in any specific jurisdiction.

Emergency-management interpretation

Reading this as an EM practitioner

Scene-edge arrival vs. physical access

A responder reaching the general area (scene-edge arrival) is not the same as reaching the specific person (physical access). The gap between the two — the access gap — is the operationally decisive quantity under blocked roads, floodwater, debris, smoke, or crowd compression.

Route obstruction, floodwater, and debris

Route obstruction is modeled explicitly and feeds both the egress-path read and the modeled access-gap estimate, rather than being folded silently into a single opaque score.

Communications degradation

Tower outage, RF degradation, and cellular degradation are modeled as independent, adjustable pressures, matching how large-area events typically fail: partially, unevenly, and often for the exact routes people are trying to use.

Preservation vs. delivery

When no permitted path exists, the model's answer is to preserve the event locally, not to claim delivery anyway. Preservation and delivery are reported as separate scores for this reason.

Local relay & store-and-forward

When immediate egress is blocked, the model evaluates whether a nearby peer, relay, or store-and-forward path can carry the event once a route returns, rather than treating "no immediate delivery" as final failure.

Bounded responder packet

The BFB packet a responder would see is deliberately minimized — this is dispatch-adjacent situational awareness, not a dispatch replacement, and not incident-command authority. It is designed to support incident response, not direct it.

Testing and evaluation evidence

Capstone Test Matrix

Results below reflect the current production build's manual and scripted verification. Where independent testing has not occurred, that is stated directly rather than implied.

Test IDDescriptionExpected resultCurrent evidenceResult
T-01Buildnpm run build completes without errorStatic build logPass
T-02Preset countExactly seven presets in the scenario dropdownscripts/validate-sos-capstone.jsPass
T-03Backend requestRun dispatches a real POST to the safety-simulation-lab endpointManual Playwright network capturePass
T-04Trial capRequested trials above 5,000 are rejected or clampedBackend sanitizer code pathNot independently load-tested
T-05Duplicate submissionA second click while a run is in flight does not fire a second requestRun button disable + runToken guardPass
T-06Receipt generationA completed run returns a full public-safe receipt objectassets/sos-sample-public-receipt.jsonPass
T-07Latest receipt downloadDownload always reflects the most recently completed runManual verification across rerunsPass
T-08Counter sourceAccess counters come only from the backend responsepublicAccessWindow field inspectionPass
T-09Stale stateAny slider change after a completed run shows the stale/rerun indicatorManual + scripted checkPass
T-10TAB no interactionNo accepted/denied override is injected without a real user decisionDirect event-dispatch testPass
T-11TAB acceptedAccepting TAB and rerunning records an accepted state on the receiptDirect event-dispatch testPass
T-12TAB deniedDenying TAB and rerunning records a denied state on the receiptDirect event-dispatch testPass
T-13Sensitivity receipt connectionSensitivity bands populate from the completed receipt, not a static previewManual verificationPass
T-14Guided demoThe existing Guided Demo opens/closes and consumes no runScripted Playwright checkPass
T-15Reset presetReset Preset restores real defaults and marks the run staleScripted Playwright checkPass
T-16Changed-from-default indicatorsIndicators reflect real slider deltas onlyScripted Playwright checkPass
T-17Baseline / blackout comparisonComparison table renders from two stored completed receipts, with neutral text for missing fieldsManual verification, this branchPass
T-18Error statesRate-limit/terms/5xx errors show safe copy, no stack traces, no fake resultManual + code reviewPass
T-19Copy/claim scanNo forbidden claim phrases appear in changed filesscripts/validate-sos-capstone.jsPass
T-20Mobile layoutNo horizontal overflow at 390×844Playwright viewport checkPass
T-21Tablet layoutNo horizontal overflow at 768×1024Playwright viewport checkPass
T-22Desktop layoutNo horizontal overflow at 1024–1920 widthsPlaywright viewport checkPass
T-23Keyboard navigationAll interactive controls reachable and operable by keyboardManual tab-order pass on new pagesNot yet independently tested
T-24200% zoomNo lost content or broken layout at 200% browser zoomManual visual check on new pagesNot yet independently tested
T-25Console errorsNo uncaught console errors during the flagship workflowPlaywright pageerror capturePass
T-26Professor review form submissionA valid submission returns a reviewId, timestamp, and integrity digestReal POST to /api/sos/capstone-review against the local backend harnessPass
T-27Review idempotency and rate limitingSame key/body replays the same response; different body conflicts; excess submissions are rate-limitedScripted retry/conflict/rate-limit harnessPass
T-28Imported receipt verificationAn unsigned valid receipt reports "Digest integrity verified; receipt unsigned."Manual + scripted verification against importOfficialReceiptPass
T-29Human-readable DOC reportDownloaded .doc file contains readable review and receipt-summary textManual DOC content inspectionPass
T-30Print / Save PDF layoutPrint view shows the complete review report with no clipped sectionsManual print-preview inspectionPass
T-31Zero simulation POST from review workflowOpening the form, importing a receipt, and generating DOC/PDF never call the simulation endpointPlaywright network capturePass
T-32Review privacy and retention boundaryStored record excludes raw IP and the exact receipt JSON; retains only the bounded summaryDirect inspection of the stored review record schemaPass
T-33Owner endpoint authenticationMissing/incorrect/query-string tokens are rejected; a valid bearer token succeedsScripted auth harness against api/sos/capstone-review-admin.jsPass
Research alignment

Companion technical research — available for quantitative review

You do not need to read the companion research to understand this capstone. This section summarizes it conservatively for reference.

Scope

Monte Carlo evaluation of a civilian safety architecture under separated comparison suites and synthetic degraded-state stress. 250,000 nominal trials; 500,000 synthetic degraded-state trials. Simulation-only — no field validation, no emergency-service certification, no empirically calibrated human-safety claim, no real-world attacker-resistance claim, no clinical survival claim. "Survivability" is a simulator-defined protected-outcome variable, not mortality or percent alive.

Headline architecture results (nominal, n = 250,000)

  • LAKANA + CivOS: 0.954636
  • LAKANA without CivOS: 0.949616
  • Industry comparator: 0.947172

Shared-detector degraded-state stress

  • LAKANA + CivOS: 0.950753
  • Industry comparator: 0.782674

The strongest evidence is architecture-level and delivery/infrastructure-mediated under the modeled degraded-state regime — the comparator's dependence on centralized transport is the dominant failure mechanism in that diagnostic.

Detector burden–sensitivity trade-space

Detector behavior is reported as a burden–sensitivity trade-space: higher raw recall can also raise false-positive and escalation burden. This research does not claim universal detector superiority or empirical calibration.

Companion technical research — available for quantitative review
Evidence ladder

Where this project sits today

  1. 1. Architecture and problem definitionComplete
  2. 2. Backend-linked public prototypeCurrent stage
  3. 3. Simulation evidenceCurrent stage
  4. 4. Tabletop and human-factors reviewNot yet started
  5. 5. Controlled partner pilotNot yet started
  6. 6. Field evaluation after governance and safety reviewNot yet started

This project is at stages 2–3. Stages 4–6 are future work, not completed milestones.

Requirements and test summary

Requirements and Test Summary

16Functional requirements
11Nonfunctional requirements
33Documented tests

"Implemented" means present in the current project. "Pass" means supported by the evidence listed in the table. "Partially verified" does not mean failed. Passing scripted tests does not establish field safety or certification.

Limitations

What this prototype does not establish

  • Public browser trial cap (5,000 trials per run).
  • Synthetic scenarios, not field-collected events.
  • No empirical field calibration.
  • No live dispatch.
  • No real responder integration.
  • No live WebRTC audio.
  • No medical diagnosis.
  • No independent security certification.
  • No field validation.
  • Target local-first substrate not yet deployed.
  • No claim that delivery is possible without a physical route.
Submission snapshot

Submission Snapshot

Project
LAKANA SOS Emergency Management & Civil Safety Infrastructure Lab
Creator
MarTaize Fails
Project type
Full-stack capstone / research prototype
Submission surface
Professor-facing Capstone Review + Proof Theater
Backend
Existing public-safe SOS simulation endpoint
Professor scenarios
3
Functional requirements
16
Nonfunctional requirements
11
Documented tests
33
Receipt capability
Run, download exact official receipt, verify integrity/signature state
Current evidence stage
Architecture + prototype + simulation evidence
Current boundary
Public evaluation prototype deployed on Vercel. No field validation, live dispatch, emergency-service certification, operational agency integration, or field-deployed local-first substrate.
Source repository
Private repository. Request controlled review access.
Primary Capstone implementation
PR #77 — Phases 0–6 Capstone implementation (private repository — request access to review).
Trial-depth finalization
PR #78 — 5,000 / 600 professor run-depth modes — merged into main (private repository — request access to review).
Current production source
main branch — PR #78 merged and deployed.
Live deployment
Vercel production deployment built from the current main commit. This is the public evaluation deployment, not a live emergency-service deployment.
Current commit
The exact deployed commit is recorded in GitHub main history, Vercel deployment metadata, and each production receipt's modelBuildCommit field.
Live scenario
Not returned by this receipt.
Live completion timestamp
Not returned by this receipt.
Live verification state
Not yet verified.
Selected run depth
Full Evidence Run · 5,000 trials
Official receipt trials
Not returned by this receipt.

No live receipt generated yet in this session.

This snapshot reads the professor console's own receipt and state directly. The public evaluation page is deployed, but the modeled emergency-service and local-first production system are not field deployed or certified.

Professor review submission

Professor Review Submission

Use this form to submit academic feedback on the LAKANA SOS Capstone. You may attach the current simulation receipt or import a previously downloaded official receipt JSON file. A human-readable copy can be downloaded after submission.

Review Form

Used only for confirmation/follow-up. Never displayed publicly.
Receipt attachment

Receipt Reader and Human-Readable Report

Future work

Priority order

  1. Emergency-management tabletop exercise.
  2. Degraded-communications bench testing.
  3. Privacy and consent review.
  4. Human-factors testing.
  5. External code / security review.
  6. Partner-supervised non-emergency pilot.
  7. Local hardware prototype.
  8. Field measurements for transport and route models.
Capstone demonstration checklist

A professor's walkthrough

For a short review, complete the embedded single-run professor console first. For the full flagship workflow, continue to the Proof Theater baseline-versus-blackout comparison below.

  1. Open Capstone Review (this page).
  2. Read the project objective.
  3. Open the Proof Theater.
  4. Start the Flood/Hurricane capstone demonstration.
  5. Run the baseline.
  6. Apply blackout stress.
  7. Rerun.
  8. Compare receipts.
  9. Inspect Run Integrity.
  10. Open the Reviewer Lens (Capstone Professor / Emergency Management lens).
  11. Download the final receipt.
  12. Review Real vs. Simulated on this page.
  13. Submit the professor review and download a human-readable copy.
Commercialization relevance (secondary)

Potential controlled validation contexts

  • Field-service safety.
  • Community resilience.
  • University safety research.
  • Emergency-management training.
  • Campus safety.
  • Rural response planning.

No revenue projection, adoption claim, or agency endorsement is made here. These are potential controlled-validation contexts, not commitments.