From 651205e49edfcb3964fa8a50ce7454f091b56a5a Mon Sep 17 00:00:00 2001 From: orchestration-renewed Date: Wed, 18 Nov 2026 15:21:58 +0100 Subject: [PATCH] feat(schema): bring-up step tables, stage rows, records and query bringup-chain Declares bringup_stages, bringup_steps, bringup_step_edges and step_status (decision 2026-11-18-bringup-steps-generic-in-docs-status-in-each-base). The stage list is rows (bringup-stage), not an enum, so it changes without a schema change. bringup-edge refuses a cycle; bringup-chain orders by depth, stage, ord and computes ready/waits. step_status is declared only: a feed fills it. Co-Authored-By: Claude Opus 5.5 --- data/backlog.json | 2 +- docs/backlog.md | 4 +- docs/bringup_stages.md | 3 + docs/bringup_step_edges.md | 3 + docs/bringup_steps.md | 3 + docs/index.md | 4 + docs/step_status.md | 3 + queries/bringup-chain.sql | 32 ++++++ records/bringup-edge.sql | 15 +++ records/bringup-stage.sql | 9 ++ records/bringup-step.sql | 22 ++++ tables.toml | 218 +++++++++++++++++++++++++++++++++++++ 12 files changed, 315 insertions(+), 3 deletions(-) create mode 100644 docs/bringup_stages.md create mode 100644 docs/bringup_step_edges.md create mode 100644 docs/bringup_steps.md create mode 100644 docs/step_status.md create mode 100644 queries/bringup-chain.sql create mode 100644 records/bringup-edge.sql create mode 100644 records/bringup-stage.sql create mode 100644 records/bringup-step.sql diff --git a/data/backlog.json b/data/backlog.json index 6415bc5..5778eef 100644 --- a/data/backlog.json +++ b/data/backlog.json @@ -181,7 +181,7 @@ {"project":"linux-phone-oco/surya-lab","id":"surya-follows-template","title":"surya-lab follows device-template's release: its copy of the list gone, check.yml and tests/health/README.md taken, the pin a release","status":"open","note":"Migration for decision 2026-11-18-device-template-follows-by-release; no phone. Measured drift today: generic copy 5 entries behind, check.yml without xargs -r, tests/health/README.md missing, devicebase.toml template = 2026-11-17. AGENTS.md outside the idealkb part stays its own until the template:begin part exists, then the general conventions come from the template.","opened":"2026-11-18","waits":null,"blocked_by":"template-releases","hardware":null,"needs":"build","device":"xiaomi-surya","proof":"docs research/device-template/2026-11-18/template-drift.sh device-template ideal-knowledge-base surya-lab: every surya-lab line says ok","rank":null,"about":"device-template"} {"project":"linux-phone-oco/google-walleye-lab","id":"walleye-follows-template","title":"google-walleye-lab follows device-template's release: its copy of the list gone, its rust job in its own workflow, the pin a release, stale PR 208 closed","status":"open","note":"Migration for decision 2026-11-18-device-template-follows-by-release; no phone. Measured drift today: generic copy 5 entries behind, ffs-acm-rs job inside the template's check.yml, devicebase.toml template = 2026-11-17, PR #208 (the template's #15 by hand) open though main has it.","opened":"2026-11-18","waits":null,"blocked_by":"template-releases","hardware":null,"needs":"build","device":"google-walleye","proof":"docs research/device-template/2026-11-18/template-drift.sh device-template ideal-knowledge-base google-walleye-lab: every google-walleye-lab line says ok","rank":null,"about":"device-template"} {"project":"linux-phone-oco/docs","id":"bringup-steps","title":"Bring-up steps as data: every step that makes Linux run on a machine, generic in docs, each device's status claimed in its own base, a guidebook and helpers made from it","status":"open","note":"Decided 2026-11-18-bringup-steps-generic-in-docs-status-in-each-base (research bringup-steps-landscape). The pieces are the items about bringup-steps, unranked for the author.","opened":"2026-11-18","waits":null,"blocked_by":"bringup-steps-schema,bringup-steps-seed,feed-device-steps,walleye-steps-claimed","hardware":null,"needs":null,"device":null,"proof":"research/bringup-steps/2026-11-18/bringup-chain-walleye.sh passes in docs: tad q bringup-chain --device google-walleye lists walleye's steps in order, each proven one with its proof and run, none unknown (fails today: no query bringup-chain)","rank":null,"about":"commons-only"} -{"project":"linux-phone-oco/docs","id":"bringup-steps-schema","title":"The bring-up step tables in docs: bringup_steps, bringup_step_edges, step_status, the records bringup-step and bringup-edge, and the query bringup-chain","status":"open","note":"Ready to land as drafted in research/bringup-steps/2026-11-18 (schema.toml, records/, queries/): tried in a scratch clone at 3596bb3. The owner's to land (AGENTS.md: schema, records, queries).","opened":"2026-11-18","waits":null,"blocked_by":null,"hardware":null,"needs":null,"device":null,"proof":"tad check passes with the three tables; tad r bringup-edge refuses an edge that closes a cycle; tad q bringup-chain answers with no device (every status unknown)","rank":null,"about":"bringup-steps"} +{"project":"linux-phone-oco/docs","id":"bringup-steps-schema","title":"The bring-up step tables in docs: bringup_steps, bringup_step_edges, step_status, the records bringup-step and bringup-edge, and the query bringup-chain","status":"done","note":"Landed: tables bringup_stages (the stage list as rows, so it changes with ikb bringup-stage and no schema change), bringup_steps, bringup_step_edges, step_status (declared only; a feed fills it); records bringup-step, bringup-edge (refuses a cycle, a self-edge, a group mixing hard and soft), bringup-stage; query bringup-chain [--device] with a computed ready/waits. Reviewed by the programmer subagent (group-name collision, UNION for the depth walk, stage tie, device guard fixed). tad check: 37 tables; make verify twice clean. Test research/bringup-steps/2026-11-18/bringup-chain-walleye.sh: was 'no query bringup-chain'; with the schema and seed it gets 26 steps in order and fails only for lack of claims (walleye kernel-reaches-init is unknown, not done): walleye-steps-claimed and feed-device-steps make it pass.","opened":"2026-11-18","waits":null,"blocked_by":null,"hardware":null,"needs":null,"device":null,"proof":"tad check passes with the three tables; tad r bringup-edge refuses an edge that closes a cycle; tad q bringup-chain answers with no device (every status unknown)","rank":null,"about":"bringup-steps"} {"project":"linux-phone-oco/docs","id":"bringup-steps-seed","title":"Seed the generic steps: 26 steps and 37 edges from walleye's real chain, surya's road checked against it","status":"open","note":"sh research/bringup-steps/2026-11-18/seed.sh in docs, through the records","opened":"2026-11-18","waits":null,"blocked_by":"bringup-steps-schema","hardware":null,"needs":null,"device":null,"proof":"tad q bringup-chain lists 26 steps, bootloader and stock steps at depth 0, health-suite-runs last; tad check passes","rank":null,"about":"bringup-steps"} {"project":"linux-phone-oco/device-template","id":"steps-contract","title":"The steps contract in the template: a steps table, the record step, contract steps = 1 in devicebase.toml, data/steps.json empty, in the template's followed files","status":"open","note":"Reaches labs by the template release (decision 2026-11-18-device-template-follows-by-release), never by hand. A new device starts with no claim: every step not known yet.","opened":"2026-11-18","waits":null,"blocked_by":"bringup-steps-schema,template-releases","hardware":null,"needs":null,"device":null,"proof":"in the template, tad check passes with an empty steps table; tad r step --step shell-on-console --status done --proof X --run Y writes one row and refuses a status outside the six","rank":null,"about":"bringup-steps"} {"project":"linux-phone-oco/docs","id":"feed-device-steps","title":"Pull each device base's steps into step_status: records/feed-device-steps.sql and a device-steps-unknown fallback in bin/run-feeds.sh","status":"open","note":"As feed-device-parts: read devicebase.toml (steps = 1) and data/steps.json from the base on main; a step not claimed is unknown, not known yet; a claim of a step docs does not know is dropped and named.","opened":"2026-11-18","waits":null,"blocked_by":"bringup-steps-schema,steps-contract","hardware":null,"needs":null,"device":null,"proof":"run against a base without steps = 1, every step of that device is unknown with the reason; against google-walleye-lab after its claims, research/bringup-steps/2026-11-18/bringup-chain-walleye.sh passes","rank":null,"about":"bringup-steps"} diff --git a/docs/backlog.md b/docs/backlog.md index 95af843..6049bb6 100644 --- a/docs/backlog.md +++ b/docs/backlog.md @@ -4556,10 +4556,10 @@ Project : linux-phone-oco/docs Status -: open +: done Note -: Ready to land as drafted in research/bringup-steps/2026-11-18 (schema.toml, records/, queries/): tried in a scratch clone at 3596bb3. The owner's to land (AGENTS.md: schema, records, queries). +: Landed: tables bringup_stages (the stage list as rows, so it changes with ikb bringup-stage and no schema change), bringup_steps, bringup_step_edges, step_status (declared only; a feed fills it); records bringup-step, bringup-edge (refuses a cycle, a self-edge, a group mixing hard and soft), bringup-stage; query bringup-chain [--device] with a computed ready/waits. Reviewed by the programmer subagent (group-name collision, UNION for the depth walk, stage tie, device guard fixed). tad check: 37 tables; make verify twice clean. Test research/bringup-steps/2026-11-18/bringup-chain-walleye.sh: was 'no query bringup-chain'; with the schema and seed it gets 26 steps in order and fails only for lack of claims (walleye kernel-reaches-init is unknown, not done): walleye-steps-claimed and feed-device-steps make it pass. Opened : 2026-11-18 diff --git a/docs/bringup_stages.md b/docs/bringup_stages.md new file mode 100644 index 0000000..1b1036b --- /dev/null +++ b/docs/bringup_stages.md @@ -0,0 +1,3 @@ + + +# Bringup Stages diff --git a/docs/bringup_step_edges.md b/docs/bringup_step_edges.md new file mode 100644 index 0000000..40811b1 --- /dev/null +++ b/docs/bringup_step_edges.md @@ -0,0 +1,3 @@ + + +# Bringup Step Edges diff --git a/docs/bringup_steps.md b/docs/bringup_steps.md new file mode 100644 index 0000000..62842ba --- /dev/null +++ b/docs/bringup_steps.md @@ -0,0 +1,3 @@ + + +# Bringup Steps diff --git a/docs/index.md b/docs/index.md index a8a9df9..237a081 100644 --- a/docs/index.md +++ b/docs/index.md @@ -5,6 +5,9 @@ The memory of linux-phone-oco, whose goal is Linux phones as good as Android for everyday use, and better: which phone supports which hardware, how we know, why decisions were made, and what is next. Plain versioned data; see AGENTS.md. The plan, and where Linux phones stand against Android and iOS: [the grand picture](picture.md), and the main screen, [features against Android and iOS](feature_support.md). - [Backlog](backlog.md): 194 +- [Bringup Stages](bringup_stages.md): 0 +- [Bringup Step Edges](bringup_step_edges.md): 0 +- [Bringup Steps](bringup_steps.md): 0 - [Components](components.md): 21 - [Concepts](concepts.md): 10 - [Decisions](decisions.md): 72 @@ -25,6 +28,7 @@ The memory of linux-phone-oco, whose goal is Linux phones as good as Android for - [Session Log](session_log.md): 120 - [Shell Releases](shell_releases.md): 2 - [Sources](sources.md): 259 +- [Step Status](step_status.md): 0 - [Summaries](summaries.md): 9 - [Support Status](support_status.md): 63 - [Test Results](test_results.md): 0 diff --git a/docs/step_status.md b/docs/step_status.md new file mode 100644 index 0000000..ba25899 --- /dev/null +++ b/docs/step_status.md @@ -0,0 +1,3 @@ + + +# Step Status diff --git a/queries/bringup-chain.sql b/queries/bringup-chain.sql new file mode 100644 index 0000000..cd4531c --- /dev/null +++ b/queries/bringup-chain.sql @@ -0,0 +1,32 @@ +-- A device's bring-up, step by step in the order the steps need each other: each step's depth (the longest +-- chain of needs under it, soft ones too: they order the guide), its stage, its status on the device with the +-- proof and the run, what it needs, and whether it is ready (every hard need done, or one of each group). +-- Without --device: the generic chain, every status unknown - the guidebook's order. A step the device's base +-- never claimed is unknown. In needs, ~ marks a soft need and |G the alternatives group it is one of. Within a +-- depth the steps go by stage (bringup_stages.ord), then their own ord. +-- --device string? the device (devices id); omitted: the generic chain +WITH RECURSIVE depth(id, d) AS ( + SELECT id, 0 FROM bringup_steps WHERE id NOT IN (SELECT step FROM bringup_step_edges) + UNION + SELECT e.step, depth.d + 1 FROM bringup_step_edges e JOIN depth ON e.requires = depth.id +), +lvl AS (SELECT id, max(d) AS depth FROM depth GROUP BY id), +st AS ( + SELECT s.id, coalesce(ss.status, 'unknown') AS status, ss.proof, ss.run, ss.proven_on, ss.updated + FROM bringup_steps s LEFT JOIN step_status ss ON ss.step_id = s.id AND ss.device_id = $device +), +need AS ( + SELECT e.step, e.requires, e.kind, e."group", coalesce('g:' || e."group", 'r:' || e.requires) AS g, st.status = 'done' OR st.status = 'not-needed' AS met + FROM bringup_step_edges e JOIN st ON st.id = e.requires +), +ready AS ( + SELECT step, bool_and(gmet) AS ok FROM (SELECT step, g, bool_or(met) AS gmet FROM need WHERE kind = 'hard' GROUP BY step, g) GROUP BY step +) +SELECT row_number() OVER (ORDER BY l.depth, sg.ord, sg.id, s.ord, s.id) AS n, + s.id AS step, s.stage, l.depth, st.status, + coalesce(st.proof, s.proof) AS proof, st.run, st.updated, + (SELECT string_agg(requires || CASE WHEN kind = 'soft' THEN '~' ELSE '' END || coalesce('|' || "group", ''), ' ' ORDER BY requires) FROM need WHERE need.step = s.id) AS needs, + CASE WHEN st.status IN ('done', 'not-needed') THEN '' WHEN coalesce(r.ok, true) THEN 'ready' ELSE 'waits' END AS next +FROM bringup_steps s JOIN bringup_stages sg ON sg.id = s.stage JOIN lvl l ON l.id = s.id JOIN st ON st.id = s.id LEFT JOIN ready r ON r.step = s.id +WHERE CASE WHEN $device IS NOT NULL AND $device NOT IN (SELECT id FROM devices) THEN error('no device ' || $device || ' (tad q coverage names them)') ELSE true END +ORDER BY n; diff --git a/records/bringup-edge.sql b/records/bringup-edge.sql new file mode 100644 index 0000000..31071d1 --- /dev/null +++ b/records/bringup-edge.sql @@ -0,0 +1,15 @@ +-- What a step needs before it (an edge of that pair is replaced). hard: it cannot be done first; soft: it can, +-- but blind or at much greater cost. Edges of one step sharing a group are alternatives: one done is enough. +-- --step string the step +-- --requires string the step it needs +-- --kind string hard or soft +-- --group string? the alternatives it is one of (console: UART or the USB gadget) +-- --why string why, in a line - the record that showed it, when one did +SELECT CASE WHEN $step = $requires THEN error('a step cannot require itself') END; +SELECT CASE WHEN EXISTS ( + WITH RECURSIVE up(id) AS (SELECT $requires UNION SELECT e.requires FROM bringup_step_edges e JOIN up ON e.step = up.id) + SELECT 1 FROM up WHERE id = $step) THEN error('this edge makes a cycle: ' || $requires || ' already needs ' || $step) END; +SELECT CASE WHEN $group IS NOT NULL AND EXISTS (SELECT 1 FROM bringup_step_edges e WHERE e.step = $step AND e."group" = $group AND e.kind <> $kind AND e.requires <> $requires) + THEN error('the group ' || $group || ' of ' || $step || ' mixes hard and soft: alternatives are all of one kind') END; +DELETE FROM bringup_step_edges WHERE step = $step AND requires = $requires; +INSERT INTO bringup_step_edges (step, requires, kind, "group", why) VALUES ($step, $requires, $kind, $group, $why); diff --git a/records/bringup-stage.sql b/records/bringup-stage.sql new file mode 100644 index 0000000..b585243 --- /dev/null +++ b/records/bringup-stage.sql @@ -0,0 +1,9 @@ +-- A phase of bringing Linux up on a machine, in the order one meets them: a chapter of the guidebook (a stage of +-- that id is replaced). The list is data, so it changes with this record: a stage added, split, renamed or moved +-- (its ord), with no schema change. A step names its stage (bringup-step --stage). +-- --id string a-short-name: prepare, boot, console ... +-- --ord integer its place among the stages: the order of the chapters (a tie goes by id) +-- --title string the chapter's name +-- --what string what the stage is for, in a line or two +DELETE FROM bringup_stages WHERE id = $id; +INSERT INTO bringup_stages (id, ord, title, what) VALUES ($id, $ord, $title, $what); diff --git a/records/bringup-step.sql b/records/bringup-step.sql new file mode 100644 index 0000000..97e35d9 --- /dev/null +++ b/records/bringup-step.sql @@ -0,0 +1,22 @@ +-- A step of bringing Linux up on a machine, for every machine it applies to (a step of that id is replaced). +-- Generic: what the step is, when it is done and how that is proven - never one device's state, which its own +-- base claims (its steps table) and docs pulls into step_status. What it needs goes in bringup-edge. +-- --id string a-short-name: kernel-reaches-init, shell-on-console ... +-- --title string what it is, in a few words +-- --stage string its stage: the id of a stage (tad sql "SELECT id FROM bringup_stages ORDER BY ord") +-- --ord integer its place in the stage, where the edges leave two steps unordered +-- --applies string = any any, or the class it holds for: boot:android, boot:uefi, usb:gadget, soc:qcom ... +-- --done-when string what done means, checkably +-- --proof string the test that proves it (a tests id, or the check a device's test must make) +-- --proof-kind string host-check, phone-suite, build-check, witness or research +-- --helper string? the lpoco command that does it; none yet is the gap a helper fills +-- --component string? the part of the catalogue whose first light it is +-- --guide string how it is done, and the traps met so far with the records that met them +-- --sources string? ids of the sources, comma-separated +-- --checked-on date = today when its text was last checked +SELECT CASE WHEN $sources IS NOT NULL AND EXISTS (SELECT 1 FROM unnest(string_split($sources, ',')) AS t(x) WHERE trim(t.x) NOT IN (SELECT id FROM sources)) + THEN error('sources names no source of this base: ' || (SELECT string_agg(trim(t.x), ', ') FROM unnest(string_split($sources, ',')) AS t(x) WHERE trim(t.x) NOT IN (SELECT id FROM sources)) || ' (tad r source records one)') END; +SELECT CASE WHEN $stage NOT IN (SELECT id FROM bringup_stages) THEN error('no stage ' || $stage || ' (ikb bringup-stage records one)') END; +DELETE FROM bringup_steps WHERE id = $id; +INSERT INTO bringup_steps (id, title, stage, ord, applies, done_when, proof, proof_kind, helper, component, guide, sources, checked_on) +VALUES ($id, $title, $stage, $ord, $applies, $done_when, $proof, $proof_kind, $helper, $component, $guide, $sources, $checked_on); diff --git a/tables.toml b/tables.toml index 49cab57..734aaa8 100644 --- a/tables.toml +++ b/tables.toml @@ -1485,3 +1485,221 @@ required = true [[rules.references]] field = "hardware.about" to = ["components", "features", "milestones", "devices", "backlog", "concepts"] + +# The phases of a bring-up, in the order one meets them: the guidebook's chapters. Held as rows, not as an enum +# of bringup_steps.stage, so the list can change (a stage added, split, renamed or moved) with +# `ikb bringup-stage`, never with a schema change; a step names its stage (a reference), and a stage a step +# still names cannot be removed. +[tables.bringup_stages] +key = ["id"] + +[[tables.bringup_stages.fields]] +name = "id" +type = "string" +required = true +pattern = "^[a-z0-9]+(-[a-z0-9]+)*$" + +# its place among the stages: the order of the chapters +[[tables.bringup_stages.fields]] +name = "ord" +type = "integer" +required = true +minimum = 1.0 + +[[tables.bringup_stages.fields]] +name = "title" +type = "string" +required = true + +# what the stage is for, in a line or two: the chapter's opening +[[tables.bringup_stages.fields]] +name = "what" +type = "string" +required = true + + +# Bring-up steps (decision 2026-11-18-bringup-steps-generic-in-docs-status-in-each-base): every small step that +# makes Linux run on a machine, once for all machines, in the commons. A device never writes here: its own base +# claims each step (the steps table, contract steps = 1 in devicebase.toml) and docs pulls the claims into +# step_status, as it pulls parts into support_status. A step a base never claimed is not known yet. +[tables.bringup_steps] +key = ["id"] + +[[tables.bringup_steps.fields]] +name = "id" +type = "string" +required = true +pattern = "^[a-z0-9]+(-[a-z0-9]+)*$" + +# what the step is, in a few words +[[tables.bringup_steps.fields]] +name = "title" +type = "string" +required = true + +# the phase it belongs to: a row of bringup_stages, which orders the guidebook's chapters +[[tables.bringup_steps.fields]] +name = "stage" +type = "string" +required = true + +# its place within the stage when the edges leave two steps unordered (the guidebook's tie-break) +[[tables.bringup_steps.fields]] +name = "ord" +type = "integer" +required = true +minimum = 1.0 + +# which machines it holds for: any, or a class - boot:android (an Android bootloader), boot:uefi, usb:gadget, +# soc:qcom, power:battery ... A device whose class does not match records not-needed, with why. +[[tables.bringup_steps.fields]] +name = "applies" +type = "string" +required = true +pattern = "^(any|[a-z]+:[a-z0-9-]+)$" + +# what done means, checkably: the sentence the proof tests +[[tables.bringup_steps.fields]] +name = "done_when" +type = "string" +required = true + +# the generic proof: a tests id, or the check a device's own test must make (named, to write) +[[tables.bringup_steps.fields]] +name = "proof" +type = "string" +required = true + +# how the proof is had: a host-side check on what the phone printed, the phone's own suite, a build check, +# a person's witness, or a research row (a reading that is not a test) +[[tables.bringup_steps.fields]] +name = "proof_kind" +type = "string" +required = true +enum = ["host-check", "phone-suite", "build-check", "witness", "research"] + +# the lpoco command that does the step or most of it; none yet = the gap a helper fills +[[tables.bringup_steps.fields]] +name = "helper" +type = "string" + +# the part of docs' catalogue whose first light this step is, when it is one +[[tables.bringup_steps.fields]] +name = "component" +type = "string" + +# the guidebook's paragraph: how it is done, and the traps met so far with the records that met them +[[tables.bringup_steps.fields]] +name = "guide" +type = "string" +required = true + +# the sources, comma-separated ids +[[tables.bringup_steps.fields]] +name = "sources" +type = "string" + +[[tables.bringup_steps.fields]] +name = "checked_on" +type = "date" +required = true + +# What a step needs before it. hard: it cannot be done before the other is done; soft: it can, but blind or +# at much greater cost (a crash window before the first kernel). Edges sharing a group are alternatives: one +# done is enough (a console over UART or over the USB gadget). +[tables.bringup_step_edges] +key = ["step", "requires"] + +[[tables.bringup_step_edges.fields]] +name = "step" +type = "string" +required = true + +[[tables.bringup_step_edges.fields]] +name = "requires" +type = "string" +required = true + +[[tables.bringup_step_edges.fields]] +name = "kind" +type = "string" +required = true +enum = ["hard", "soft"] + +[[tables.bringup_step_edges.fields]] +name = "group" +type = "string" + +[[tables.bringup_step_edges.fields]] +name = "why" +type = "string" +required = true + +# Each device's steps as its own base claims them: filled by a feed (feed-device-steps, to come), never typed here. +# The feed will give every step x every registered device a row; what a base does not claim is unknown, "not known yet". +[tables.step_status] +key = ["device_id", "step_id"] + +[[tables.step_status.fields]] +name = "device_id" +type = "string" +required = true + +[[tables.step_status.fields]] +name = "step_id" +type = "string" +required = true + +[[tables.step_status.fields]] +name = "status" +type = "string" +required = true +enum = ["done", "partial", "failing", "open", "not-needed", "unknown"] + +# the test or check that proved it on this device (a tests id, or the base's own script) +[[tables.step_status.fields]] +name = "proof" +type = "string" + +# where the proof ran: a test_runs id, a research row, a pull request +[[tables.step_status.fields]] +name = "run" +type = "string" + +# what it was proven on: the image, kernel or dtb (its hash), so a later change can be told from it +[[tables.step_status.fields]] +name = "proven_on" +type = "string" + +[[tables.step_status.fields]] +name = "notes" +type = "string" + +[[tables.step_status.fields]] +name = "updated" +type = "date" +required = true + +[[rules.references]] +field = "bringup_step_edges.step" +to = ["bringup_steps"] + +[[rules.references]] +field = "bringup_step_edges.requires" +to = ["bringup_steps"] + +[[rules.references]] +field = "bringup_steps.component" +to = ["components"] + +[[rules.references]] +field = "step_status.device_id" +to = ["devices"] + +[[rules.references]] +field = "step_status.step_id" +to = ["bringup_steps"] + +[[rules.references]] +field = "bringup_steps.stage" +to = ["bringup_stages"]