A handoff. Read this once before changing anything; the deeper reasoning lives in ARCHITECTURE.md (invariants) and RUNBOOK.md (operating it).
Half Life is a ten-week hardware programme. Participants design five projects and then build all five, journalling as they go; approved work mints coins, and coins buy a 3D printer at the end. The backend's job is to hold that economy honestly.
Next.js 16 App Router, Postgres via Prisma 8, Cloudflare R2 for media, better-auth against Hack Club Auth. One repo, four worlds:
| Route group | What it is |
|---|---|
(site) |
The marketing page. Own root layout and stylesheet. |
(platform)/(app) |
The logged-in product: trail, projects, shop, feed. |
(platform)/(ops) |
Admin and review. Carries ops.css, the earlier design system. |
(handoff) |
One public page: the phone upload a QR code opens. |
proxy.ts redirects / to /dashboard when a session cookie is present, so a stranger gets the landing page and a participant lands on the trail, which has its own URL. That cookie check is optimistic and decides nothing – (app) runs requireSessionPage().
There are no server actions. Every write goes through src/app/api/**, which means every write has one auditable entry point with a Zod schema on it.
src/lib/config/ every tunable number – tiers, printers, themes, weeks
src/lib/queries/ read paths (one per surface)
src/lib/*.ts domain: currency, hours, review, shop, feed, handoff, streak
src/lib/schemas/ Zod, one per API area
src/app/api/ every write
prisma/contract.prisma
The trail derives its entire shape – how many nodes a week has, where the progress reels fall, which node is live, what is locked and why – from one pure function, curriculum.checkpointsFor(), applied to one map of checkpoint states.
lib/queries/store.ts builds that map by reading the projects, sessions, posts and submissions that already exist. lib/store.tsx hands it to the UI through useStore().
There is deliberately no checkpoint table. It would be a second source of truth for "has this week had its idea reel", and the first time the two disagreed the trail would lie to someone about work they had really done.
Reels bind to their node by Post.checkpointKey, not by counting posts of a kind: the 5h and 15h reels are both PROGRESS, so counting would tick the 15h node the moment the 10h one landed.
The ledger is append-only. reconcileGrant reads a running sum and writes the delta, so re-approving something converges instead of double-paying. It sums by kind – so a new bucket needs a new kind, not the same kind with a different bucket, or the two halves reconcile against each other's totals forever.
Two pots. SPENDABLE buys anything; BANKED is the printer fund and buys a printer only. spendableFor() is the only thing that decides which applies.
Banking is paced by the printer, not the tier. A tier decides how many of a design week's hours the project itself eats (fundingHours); everything above that banks at the rate the chosen machine needs (goal.bankedHours). Every tier banks the same for the same printer. lib/config/printers.ts is the budget spreadsheet transcribed – the season must land on each price, and verify:ledger checks all eight machines.
Hours have one implementation. rollUpHours() decides what a phase is worth and both the trail and the reviewer call it. Journal and Hackatime hours are additive; timelapse duration is not (it is a recording of hours already claimed). Ari does not share that model – it adds a journal's minutes and the duration of every Lapse clip under a Hackatime project the ship names, from any of the maker's weeks – so the ship does two things: journalTime() takes each entry's own clips off its claim, and distributeJournalMinutes() takes the rest of that pool off the journals in proportion, rounding every entry together so the total lands on the minute rather than drifting a little per entry. That is what keeps Ari's number on Half Life's. The remainder the journals cannot absorb is sent as meta.hours.timelapse_unabsorbed_seconds, and clips nothing could attribute to a project as timelapse_unattributed_seconds, so a reviewer can see why Ari may read high even after the journals have given up all they can. verify:ari-hours names any open hand-in whose two totals still disagree.
Uploads store keys, never URLs, minted at read time so the bucket can move. Keys are <folder>/<userId>/<uuid>.<ext> and are not secrets – the feed returns a full video URL for every reel. Anywhere a client hands a key back, check isOwnedKey(), or a stranger's timelapse becomes evidence for hours nobody worked.
Nobody reviews their own work, and a build cannot be approved before its design.
The submit gate is server-side. submitPhase re-runs checkRepo rather than trusting the submit sheet: a missing README, too little text or too few photos, or a missing required file blocks, while the README BOM table is only a warning. The CAD source list accepts editable files from accepted tools only – Tinkercad, OpenSCAD, Blender and STL-only fail – and a starter project still carrying the starter's own description is refused. See docs/ARCHITECTURE.md.
Ari (ari.hackclub.com, @hackclub/ari) is the review surface. Half Life sends each submitted (project, phase) as a ship and receives the decisions back as signed webhooks; the in-house /review console still exists and still works – whichever decision lands first wins, because both go through finalizeReview and it refuses an already-resolved submission.
lib/ari.tsis the whole integration.lib/ari-id.tsholds the two pure helpers (ariExternalId/parseAriExternalId) soverify:contractscan pin the format.- One ship per (project, phase).
external_idis<themeProjectId>:designor:build, so design and build get independent decisions. The Airtable row is found by the record id kept in the audit log; when that id is unknown, the write adopts a row matching (email, project name, stage) under an advisory lock, because the table has no Half-Life ID column. - Outbound happens in the submit/unsubmit
afterhooks, like the Airtable write, and no-ops when theARI_*secrets are unset. A failed send logs anARI_SYNC_FAILUREaudit row and is replayed byari-retry, or by hand from/admin/program. - Inbound is
POST /api/integrations/ari/webhook, verified withARI_WEBHOOK_SECRET.ARI_WEBHOOK_SECRETis not the signing secret; the SDK treats them as different credentials. - Decisions are applied through
finalizeReview, attributed to no Half Life user (SubmissionReview.reviewerIdis nullable) and with reviewer identity in the audit row. Ari'sapproved_hours/approved_minutesbecome the hours override, so the payout matches what Ari approved. - A design approval needs a tier. Half Life's design approval is also the funding decision, and Ari reviews the work rather than the money, so the tier is the maker's
requestedTier(falling back to an assignedtier). A design approval with neither is logged asARI_WEBHOOK_IGNOREDand left for a human rather than invented. - Idempotent. The
delivery_idis checked first and recorded only after the work succeeds, so Ari's retries are safe and a failed delivery is retried.review.requeuedundoes the local status and credit and puts the same ship back in front of reviewers;review.reverteddoes the same but leaves the phase onupdate_requested, because the ship is terminal at Ari and only a fresh hand-in can be reviewed.review.fraudflags the maker on a failed verdict;ship.updatedand unknown events are recorded and ignored. - A 409
already_queuedis an answer, not a failure. Ari refuses to replace an open ship but names the ship it found, sosendSubmissionToArirecords that id on the hand-in instead of retrying forever. This is the recovery for a create whose response was lost, and it stops a ship Ari already has from being invisible to every local count. - The admin ring counts projects, one state each.
getProjectReviewStatusesgives every project the single state its card shows (projectReviewState: rejected > needs changes > pending > approved) and counts it once, so the ring's total is the number of projects that have been submitted and a project cannot appear in two slices. The ship-level count still exists for the queue:countAriShipsbacks the admin pending figure andari-review-countsmirrors Ari's own board, so the ring and Ari's board answer different questions. - A delivery can be lost, so decisions are also pulled. The webhook is fire-and-forget: a delivery sent while the endpoint was unregistered, misconfigured or briefly unreachable is gone, and the hand-in sits decided at Ari while Half Life still shows it pending – the admin pending figure then reads hundreds of hand-ins more pending than Ari's own board.
reconcileAriDecisions(lib/ari.ts) asksari.ships.statusfor each open hand-in and applies any standing decision through the samefinalizeReviewthe webhook calls; a ship Ari reports asrevertedis reset from there too, because a lost revert leaves the phase looking pending forever.ari-retryruns a bounded pass every hour, andbun run reviews:backfill-ari(dry run;--commitwrites) drains a backlog in one go.statuscarries the decision and nothing else –id,external_id,version,phase,decision– so a replayed decision has no note to store and is recorded with Ari's generic sentence; the approved hours are likewise reconstructed from Half Life's own roll-up, so check the few approvals rather than trusting them blind. Makers are not notified by a bulk replay by default (--announceopts in) – mirror the row afterwards withairtable:backfill-review. - The phases before a decision are silent, so they are polled. Ari sends no webhook when a first-pass decision is held for a second pass, nor when a second pass returns it to the queue. The same status pass stores
phaseonPhaseSubmission.ariStatus/ariStatusAtand mirrors it toAri - Review phase,Ari - Review phase atandAri - Second pass sinceon the Airtable row.secondPassandsecondPassReturnedin the job summary count what the poll saw. The confirming organizer is still not exposed: the status response names the phase, not who confirmed or returned the held decision. - A pulled decision gets its reviewer's words back from the webhook. The note an Ari decision carries travels only in the outbound delivery, so a status pass cannot show it. A decision resent from Ari's review screen arrives as an ordinary delivery, and
adoptStatusPlaceholder(lib/ari.ts) rewrites the placeholder it finds instead of refusing it as already-decided. If the status response is extended to return the final review,bun run reviews:repair-ari(dry run;--commitwrites) reads each placeholder back from Ari and rewrites the review row, the audit reason, the reviewer and the project's standing comment in one pass; until then it reports every placeholder asquiet.
The Ire platform can run beside Ari as a read-only shadow. The initial integration does not change who decides: Ari still owns every decision, every grant and every maker notice.
lib/ire-platform.tsspeaks Ire's Ari-compatible edge directly. It signstimestamp.body(the delivery id is not in the inbound signature) and sends the nestedmeta.bom,meta.hours,meta.prior_reviews,meta.requested_tierandmeta.grant_cap_centsthat the Ari SDK refuses.lib/review-ship.tsbuilds one ship;toAriShipInputflattens it back to exactly Ari's payload. The two providers cannot drift into different answers to "what was handed in".lib/ire-shadow.tsowns the lifecycle.IreShipis a separate row keyed by(themeProjectId, phase)becauseunsubmitPhasedeletes the local submission; the mapping has to survive that. A resubmission withdraws the stale Ire copy and creates the next version.ire-retrycloses copies whose phase has left review, so the shadow queue cannot fill with ships Ari has already decided.- Read-only. Ire runs with
IRE_SHADOW=1: claim, heartbeat, release, draft, decision and send-back return409 shadow_mode, and no outbox row is written. Half Life's Ire client never callsfinalizeReview, so an Ire event cannot move credit, Airtable or a maker notification. - Inbound.
POST /api/integrations/ire/webhookverifiesIRE_WEBHOOK_SECRETand records every delivery asARI_WEBHOOK_IGNOREDwithprovider: "ire"; it is a shadow receiver, not a decision path. The admin panel shows the URL for the later live phase. - Failures. A shadow failure is an audit row (
IRE_SYNC_FAILURE) and anIreShip.lastError, not a participant-visible problem. It is replayed byPOST /api/integrations/ire-retryor the admin Retry button. - Parity.
bun run ire:paritycompares the open queues, claimed hours, BOM totals and check summaries through Ire's machine parity feed.bun run ire:backfill --commitcopies the currently open queue once.
Fabricate's review UI, running on Half Life's review backend. It sits beside the /review console rather than replacing it, and both decide through the same routes, so whichever decision lands first wins – the same rule as with Ari.
- Its own world.
app/(review)is a fourth root layout, drawn in Fabricate's design system:app/(review)/stylesis a verbatim copy of Fabricate's stylesheets (Biome skips it),half-life.cssbeside it holds the few additions the port needed. Links into it from the rest of the app go throughHardLink, because crossing root layouts must be a full page load. - No new decision logic. Claims, per-entry deflation, Hackatime hours, decisions, reversals and dispute replies all go through the console's existing routes (
/api/review/*,/api/admin/theme-projects/[id]/override,/api/admin/disputes/*), so every rule those routes enforce holds here – nobody reviews their own work, a reviewer cannot raise a tier past the request or set a grant without MANAGE_CREDIT, a live claim locks out everyone else. The one change to them is that approvals now accepttechnicalFeatures, whichfinalizeReviewalready stored for Ari. - Reads are
lib/review-platform/queries.ts. What a viewer sees follows the console's lines (lib/review-platform/viewer.ts): contact details for ADMIN and AUDITOR, risk flags and internal notes for those and for REVIEW_HOURS holders. An Ari decision stores its reviewer's address as a name, so that is shown as "Ari" to anyone without contact access. - Left out of the port, because Half Life has nothing they could run on: every AI check (Robert, Spork, cart, README, follow-up and experience checks, image reuse), the repo checklist, Slack threads, scraps and the early kit, staff notes and flags, review telemetry, reviewer pledges, the Unified T2 queue and the YSWS justification composer – Half Life writes that record itself from the decision.
- The Files tab is Fabricate's repository viewer (
components/review/hurt), copied whole. It is type-checked under Fabricate's own compiler settings (tsconfig.hurt.json, run bybun run typecheck), excluded from the main tsconfig and the linters, and reached through the@review/hurtalias (turbopack.resolveAlias). Its GitHub reads go throughforgeGet– the gh-proxy pool – in/api/reviews/[id]/files/*; the browser fetches file bodies from raw.githubusercontent.com itself. WebAssembly and pdf.js data are served from the installed packages by/api/reviews/assets/*, an allowlist. STEP/IGES/BREP models too big for the browser are converted on the server, as in Fabricate:lib/review-platform/model-conversion.tshas FART (FART_URL, hackclub/fart, which runs OpenCascade for Fabricate too) convert them, one at a time, authenticated withFART_TOKEN, and keeps the GLB on local disk keyed by repo, commit and path. Nothing heavy runs in this app's pod. FART's README lists the endpoints this depends on. The@tracespace/plotterfix Fabricate applies in a postinstall script is abun patchhere (patches/), which is why the Dockerfile copies that folder before installing. - Images. README pictures live on GitHub, so
/reviewsgets GitHub's image hosts in its CSP (REVIEW_PLATFORM_HOSTSinlib/csp.ts). Only there: the platform is staff-only, and every participant-facing page keeps the narrower policy. - Offline reviews (
/reviews/offline,components/review/offline), Fabricate's offline reviews on Half Life's screen. "Save for offline" on the queue hands that page's pending rows to/reviews/offline, which downloads each into Cache Storage: the screen's data (/api/reviews/[id]/offline,getReviewDetailplus the time it was read), the Files tab's tree, commits, compare presets and raw files (the viewer's own size caps; big models converted on FART first), the Airtable preview, Lapse's answers and videos, and journal pictures. Half Life's bucket sends no CORS headers, so its pictures come through/api/reviews/media, which only reads Hack Club's asset hosts (isProxiedMediaUrl). A service worker (public/review-offline-worker.js, scope/reviews/offlineonly, so online reviewing never goes through it) keeps the page and the build's files (/api/reviews/offline-assets) and answers the page's requests from the downloads. Reviewing offline isShipReviewitself on an offlineReviewRuntime(components/review/runtime.tsx): writes go to an outbox (Cache Storage, mirrored in localStorage) and moves stay on the page. Videos play from/reviews/offline/media?url=…, because Firefox never sends a cross-origin<video>request through a service worker. Sending checks each review against the submission as it is now (GET /api/review/submissions/[id]): decided since, or claimed by someone else, is refused; a journal entry added or changed since the download is shown and sent only on "Send anyway". Then it claims, saves the hours and decides through the usual routes.
Setting IRE_MODE=live makes Ire own review: submit, unsubmit, dispute requeues and warm-up imports send to Ire exclusively, and POST /api/integrations/ire/webhook applies decisions through the same finalizeReview Ari uses, attributed to Ire (decidedBy: "ire", "Approved by Ire." fallback). ire-retry additionally reconciles standing Ire decisions the webhook never delivered, quietly. A build approved before its design is deferred – the webhook rethrows for redelivery and the reconcile applies it once the design lands. Send failures notify the maker once per stuck hand-in through the existing shipError marker. Decisions are mirrored into the ari* columns on PhaseSubmission so admin counts, Airtable and audit queries keep working until those columns are renamed; IreShip remains the source of truth for which remote ship a phase holds.
Cutover: run ire:parity until queue counts match, ire:backfill --commit for the open queue, ire:backfill-reviewed --commit for decided history, point Ire at the webhook URL with IRE_SHADOW=0, then set IRE_MODE=live. Rollback is setting it back to shadow – Ari still holds every ship it was sent while dual-sending.
ProgramSettings.payoutSource decides who pays. Under AIRTABLE, approval mints coins and freezes grantUsd, and the Design row Half Life writes to YSWS Project Submission is what the payout team pays from. Under HCB, Airtable stays the submission and Loops surface but its Requested funding column is written as zero, and /admin/grants issues HCB card grants instead. The Airtable pipeline must be paused before the source changes; two payers is a double payment.
/admin/grants issues one HCB card grant per approved design, for the BOM total (bomTotalUsd, including tax and shipping), not grantUsd. It needs MANAGE_CREDIT.
- the preview and the batch are the same query; a SHA-256 fingerprint over
projectId:amountCents:emailmeans a stale confirmation cannot issue a different set; HcbGrantCardhas a partial unique index on(themeProjectId, phase)forPENDING,ISSUEDandAMBIGUOUS, so two batches or two tabs cannot create two live grants;- a row is claimed with a compare-and-set before HCB is called, and each request processes a small chunk;
- a lost response is reconciled against
GET /organizations/{slug}/card_grantsby email, amount and the constant purpose. Only a known absence may retry; - an owner mismatch cancels the grant and leaves it
AMBIGUOUS; a reconciliation with several matches does the same; - every issue writes
ADMIN_ISSUE_GRANT_CARDwith the HCB grant id in the same transaction as theISSUEDrow; - un-approving a design is refused while a live card grant exists; cancel it first.
The legacy /admin/users/[id] "Send grant" top-up (lib/grants.ts, HcbGrantTopUp) remains as history and is refused whenever the payout source is HCB. Under AIRTABLE it is still the old manual fallback, with the same approved-design, identity and owner checks.
- The HCB v3 API is read-only. Grants go through the authenticated v4 API. Set
HCB_ORG_SLUGplus either a staticHCB_ACCESS_TOKENor the OAuth application's client credentials, then authorise the application once (next bullet). - Authorising the app is what stores the token. HCB spends a refresh token when it is used and returns a new one, so the token is never typed into an env var: sign in as a Half Life admin and press Connect HCB on
/admin/grants. That admin-only POST mints astateand a PKCE verifier into__Host-cookies and sends the browser to HCB's authorise page; HCB redirects to/api/integrations/hcb/callback, and that route checks the state, the verifier, a signed-in admin and a top-level navigation before exchanging the code and storing the replacement encrypted inhcb_credential(keyed fromBETTER_AUTH_SECRETwith its own HKDF info). Every later refresh rewrites the row. Reconnecting from the same page is the recovery path, and asks for confirmation first because it replaces a working credential;HCB_REFRESH_TOKENexists only to seed a headless deployment. Opening the authorise link by hand can no longer complete anything – the state and verifier it lacks are what stop a captured code from being replayed by a journal image or any other page. Concurrent refreshes are serialised to one exchange. A refresh failure includes HCB'serrorbody and is logged, so a spent token is distinguishable from a bad client secret. - The registered redirect URI is
/api/integrations/hcb/callback. That route both reserves the path and completes the exchange, so setHCB_REDIRECT_URIto the same absolute URL the application is registered with – on production,https://halflife.hackclub.com/api/integrations/hcb/callback. - Scopes the client actually uses:
card_grants:readandcard_grants:write(create, top up, cancel, reconcile),organizations:read(balance preflight) andtransactions:write(the memo on a top-up's transaction). Addrestrictedto make HCB enforce them; without it the granular scopes are not checked. Reading another user's email needspiiplusadmin:writeon an HCB admin's token, which an ordinary org manager cannot get, so the owner check normally runs withHCB_VERIFY_GRANT_OWNER=falseor should read the card grant's ownemailfield instead. - Without API credentials,
/admin/grantsstill has a no-API path. The HCB CSV import panel writes the same ready projects into the organisation's bulk-import template (card_grants_template.csv:email, amount_cents, purpose, instructions, one_time_use, pre_authorization_required, invite_messageand the empty lock/banned columns —src/lib/grant-card-csv.ts), and the admin uploads it to HCB to create the cards. The file is frozen intoHcbCardGrantExportBatch+HcbCardGrantExportRow(fingerprint + atomic rows, audited asADMIN_CREATE_GRANT_CARD_EXPORT), is re-downloadable from the Generated CSV files history, and a project in it drops out of future previews, so a second file cannot pay it again. The preview-level checks still apply: onlypayoutSource === HCB, and top-up or card-grant-paid projects never appear. - Only unified projects are paid. A project whose design row's
Automation - First Submitted Atis empty was never put in the unified database by the pipeline, so it is excluded from the preview with "Not in the unified database" and the fingerprint does not include it. The check reads the YSWS table live, and it fails closed: when the read cannot run, every ready project is excluded with "Could not check the unified database" rather than paid unverified. A deployment with no Airtable reads at all skips the check, because without the integration no project can be in the base either way. - The token has to be able to read the maker's email. The owner check compares the card's owner with the maker's address. HCB renders another account's email only to a token carrying
piiandadmin:write, authorised by an HCB admin – an ordinary organisation manager cannot satisfy that, soHCB_VERIFY_GRANT_OWNER=truerefuses every grant on such a token with "HCB would not say who that grant belongs to". Either keep the check off withHCB_VERIFY_GRANT_OWNER=false(the audit row then records that nobody checked whose card it was) or compare against the card grant's own top-levelemail, which HCB returns unconditionally.
./dev.sh # Postgres in Docker, migrated, seeded, then next dev
bun run typecheck && bun run lint && bun run buildLocal scripts need DATABASE_URL in .env – every package.json script assumes it, and without it Prisma silently falls back to a database named after your shell user.
Schema changes: edit prisma/contract.prisma, then
bun run db:generate
bun run db:plan --name <what_changed>Review the planned operations, fill any data-transform placeholders, and apply with bun run db:migrate. Verify with bun run db:verify. The signed marker in migrations/app/refs/db.json records which contract hash the database is at; prisma db sign adopts a database whose schema already matches.
Restart bun run dev after generating a new contract. The ORM reads contract.json when the process starts, so a running dev server keeps the old field list until it restarts and answers with errors such as Model "ShopOrder" has no field "cancellationReason" even though the migration is applied.
Eleven suites. The DB-backed ones write to whatever DATABASE_URL points at and clean up after themselves – point them at a scratch database, never production.
verify:ledger |
the economy: two pots, and every printer reachable |
verify:store |
the database-to-trail mapping |
verify:contracts |
client calls match route methods and schemas (no DB needed) |
verify:pii |
nothing private reaches a browser; staff surfaces refuse participants |
verify:onboarding |
the first checkpoint cannot be skipped |
verify:feed |
moderation actually removes things |
verify:handoff |
the QR upload token is single-use, through both the direct and form paths |
verify:uploads |
R2 round trip, public read, and the direct-upload CORS rule |
verify:forge-write |
the forge write path's retries and status classification (no DB) |
verify:loops |
the Loops Signups-row join (no network, no DB) |
verify:loops-entries |
audit Loops - halfLifeLastEntryAt against the devlog rule (read-only unless --clear) |
verify:pii and verify:contracts exist because the compiler cannot see either problem: an RSC serialises whatever it hands a client component into the HTML, so a field nobody renders still ships; and a wrong HTTP method is a 405 that looks identical to "the click did nothing".
ok()returns the payload itself – there is nodataenvelope. Onlyfail()wraps, in{ error: { code, message } }. Three clients assumed symmetry and threw on their first call.tsconfighasnoUncheckedIndexedAccess. Index access isT | undefined. Where the real invariant is a fixed arity, write it as a tuple.- Prisma 7 moved things.
migrate diff --from-migrationsneeds a shadow database;db executeno longer takes--url(it readsprisma.config.ts). - The Docker image ships
scripts/andsrc/. The runner stage copies both (Dockerfile, runner stage), so a script runs in a pod withbun --conditions=react-server scripts/<name>.tsfrom/app. .env.examplecomments live above values, not beside them – a trailing comment gets copy-pasted into a deployment and a 32-character R2 key becomes 59.- Asset URLs stored in journals have two possible key layouts. Before the S3 client stopped putting the bucket name in the path, an object landed at
<bucket>/<key>and its URL was<origin>/<bucket>/<key>. Both that and the current<origin>/<key>are valid, sobun run uploads:backfill-urlslists the bucket once before rewriting anything rather than assuming one layout. Objects themselves are the other half:bun run uploads:migrate-legacycopies every legacy<bucket>/<key>object to<key>server-side, which is what makes the keys rows already hold resolve. It leaves the legacy copies unless--delete-legacyis passed; run the URL backfill first if those are to go, because a journal may still name the legacy URL, and let mirrored projects syncJOURNAL.mdonce more before deleting. - Coins are minted at review approval, not when hours are logged. The trail moves immediately because the node is the entry, not the payment.
- R2 is public-read. Anything uploaded is fetchable by URL, by anyone. Reels, journal photos, timelapses.
/explorepublishes journal bodies to every participant. Written for a reviewer, read by peers./admin/feedis post-only – no way to unpin or remove an announcement without the moderation route.- Deadlines are soft by design. A late joiner has to be able to finish, so almost nothing on the trail is hard-locked; the one real gate is that a build cannot be approved before its design.