Onboarding

Jzero

19 cards ~ 2.3 h Foundational

Foundational walk through the jzero project. Read top to bottom if you're new; no prior context assumed.

More about this project on the Jzero hub.

junction-zerorun
  1. jzero beginner 5 min

    Junction Zero topology: console, run, fun, brand, and why jzero.run is the one that matters here

    Use when: orienting in the junction-zero org for the first time; deciding which of the four repos a change belongs in; someone says 'the junction-zero repo' and you need to know which one they mean

  2. jzero intermediate 7 min

    jzero.run cannot write to petrova, and writes to GitHub one way: the three tripwires and their enumerated exemptions

    Use when: asking what jzero.run can change in the estate, and through which single path; being tempted to add a button, a form, a fetch with a body, or a new GitHub write to the panel; configuring the panel's environment and choosing which petrova bearer to set

  3. jzero intermediate 7 min

    Getting in: Airlock handoff, the __jzero_session cookie, the sealed __jzero_gh signing token, and the four /denied reasons

    Use when: an operator lands on /denied and you need to read the reason code; wiring a second apex onto Airlock and wanting the reference shape; auditing which jzero.run paths are reachable without a session; an operator is bounced to GitHub when opening a decision record, or sees a NOT SIGNED banner on /approvals

  4. jzero intermediate 7 min

    The RPC client: twelve read methods against petrova.host /api/rpc, one retry, and a vendored integer

    Use when: adding a page that needs estate data and choosing which petrova method to call; a page shows write_scope_required or unauthorized and you need the failure taxonomy; checking whether jzero.run's stale threshold still matches petrova's

  5. jzero advanced 9 min

    Frozen source and vacuity: Observation<T>, SOURCE FROZEN, and why a pass nobody can date is not a pass

    Use when: every row on jzero.run says UNKNOWN and you need to know whether that is the panel, the sweep, or the bundle; designing any status surface that must not report more confidence than its source supports; reading the SOURCE FROZEN banner and deciding what to do about it

  6. jzero intermediate 7 min

    / the estate table: one row per repo, the ?state= filter, the slug-conflict banners, and three drift watches that are still stubs

    Use when: opening jzero.run and needing to read the home table cold; asking why the contract column is always erased; checking whether drift watches A-1..A-3 are evaluated (they are not)

  7. jzero intermediate 5 min

    /estate/[slug]: one repo in depth, with integrations split into declared (intent) and observed (fact)

    Use when: drilling from the estate grid into one repository; reading whether ares, traceo, crumb, rocky or eva is wired for a repo; explaining why 'not applicable' and 'unknown' are different glyphs

  8. jzero intermediate 6 min

    /gates and /gates/[slug]: the sweep-machinery anchor, and why every per-repo gate hangs off it

    Use when: reading the gates route and needing to know why every row went UNKNOWN at once; deep-linking a colleague to one gate on one repo; reasoning about which gate kinds exist and what evidence dates them

  9. jzero intermediate 6 min

    /cupel: red-before-green trace status per registered repo, read structurally and never as a substitute for CI

    Use when: checking whether a repo's CUPEL criteria have both a RED and a GREEN run and a citing merge; understanding why /cupel is slow and off the sub-second critical path; being tempted to treat a clean /cupel row as proof a repo's lint passed

  10. jzero advanced 9 min

    /approvals: the countersign queue over every org the App reaches, sourced from git not petrova, and now signable one record at a time

    Use when: asking 'what is waiting on my signature across the estate' (with /next, the nearest thing to a today-list on jzero.run); a decision record is missing from the queue and you need to know which reason applies; a record shows in the queue but its page says NOT READ or NOTHING TO SIGN HERE

  11. jzero intermediate 6 min

    /installations: which orgs panto-observer reaches, and why App reach is not estate coverage

    Use when: a decision record is missing from /approvals and you suspect the org is simply not reachable; reading the PARTIAL COVERAGE row and the 'days' column correctly; being asked 'how many orgs carry an App' and needing to know which question that is

  12. jzero intermediate 7 min

    /health: the config table, per-method latency probes, and the guard-rail check that calls a mutating verb on purpose

    Use when: telling a jzero.run config fault from an estate fault; reading a red /health row and deciding whether the panel manufactured it; verifying that the deployed bearer really is read-only

  13. jzero beginner 5 min

    /fleet and /ledger: two declared placeholders, and the firmware update host that must never be a jzero.run route

    Use when: opening /fleet or /ledger and wondering whether the empty table is a bug; being asked to 'wire cycle data into /fleet' (do not; wrong subsystem); planning the updates.jzero.run deployment and its manifest endpoint

  14. jzero beginner 6 min

    What an operator can actually do on jzero.run: sixteen key bindings, ten routes, filters, one signature, and nothing that writes to petrova

    Use when: learning the panel's keyboard vocabulary before a 2am fault; answering 'can I trigger / approve / fix X from jzero.run' (only approve, one record at a time); explaining why every state on the panel is a URL

  15. jzero advanced 10 min

    Where jzero.run sits in the MARY-led panto and petrova cycles: still the viewport, now also the countersign surface every cycle ends at

    Use when: someone says 'the PETROVA-PANTO-MARY-EVA cycle' and you need the actual written shape; deciding whether jzero.run is a control surface for the automation loop (it is the human end of it, not a driver); planning the /cycles route and knowing what it is blocked on

  16. jzero advanced 11 min

    T1 countersign: one record, one commit, as the operator, through seven refusing gates

    Use when: signing a decision record from jzero.run and wanting to know exactly what the click does; a countersign was refused and the banner names a reason you need to trace; adding a repository whose governance needs SSH-signed, fast-forward ratifications; being asked whether jzero.run signatures are non-repudiable (they are not; T3 is)

  17. jzero advanced 10 min

    /path and its unblock views: every org's gates to revenue, derived from .petrova/gates.yaml, never read as state

    Use when: asking what stands between a product and revenue, across every org, and who it waits on; a gate shows INVALID, blocked or ready and you need to know how that state was computed; an operator act (a ruling or a group of config values) needs its question, evidence and next step on one page

  18. jzero intermediate 8 min

    /next: one card at a time across every org, built from gates files and wizard records, and no platform token anywhere

    Use when: you have ten minutes and want the single most useful thing to do toward revenue, picked for you; a card will not go away after you ran its wizard; someone proposes giving jzero.run a Vercel, Railway or Polar token so it can check config itself

  19. jzero advanced 8 min

    Two caches, two rules: /approvals' shared stale-while-revalidate over Runtime Cache, and /path's per-instance map

    Use when: /approvals or /path is slow, or shows an age stamp, and you need to know what is cached and for how long; a record you just signed still shows as awaiting somewhere; adding a cache to another jzero.run route and choosing between the two patterns