Commissioning State Machine

In a dairy factory, equipment doesn't just appear. It progresses: idea → spec → P&ID → procurement → in transit → in store → mechanically in place → electrically wired → controls proven → operating system. Each state has evidence. Each transition is deterministic. The commissioning engineer knows exactly where every piece stands.

Why would software be different?

The Job​

When a venture has many data tables and no compass — scores plateau, interpretation is manual, and gaps never route to tasks — help it know where every table stands, detect gaps automatically, and route those gaps to executable work.

The job: "I need to know where every data table stands — and have gaps turn into tasks automatically."

The hidden objection: "What if the algorithm is wrong?" The answer: the algorithm stays pure — no side effects, deterministic transitions, schema changes through migration workflow. The constitution protects the signal.

The Factory Metaphor​

Matt's dairy factory experience maps directly. Equipment progresses through discrete states. Same model applies to every data table.

Every table. Every venture. Same progression. The Factory Control Room shows the state of the whole system.

The 10-State Machine​

Constitution: The algorithm must remain pure — no side effects. State transitions are deterministic. Schema changes flow through the migration workflow. The state machine observes; it does not mutate.

Gap Detection → Task Automation​

The value isn't the state. It's what happens when a gap is detected.

Gap Detected → Algorithm Identifies Missing Evidence → Task Generated → Task Assigned → Gap Closed

Target: 80% of gaps route to tasks automatically. No manual interpretation. No "someone should fix that" — the system produces the task.

Capability Commissioning Table​

A second entity — parallel to but distinct from the 10-state data table machine. This tracks product features (the commissioning dashboard) at L0-L4 maturity.

Write rule: All writes via Drizzle ORM + repository pattern only. The outer loop agent reads via Supabase MCP or REST endpoint — never writes directly.

// commissioning_capabilities — Drizzle schema
{
  id:               uuid PK
  slug:             text UNIQUE  // kebab-case, matches dashboard row
  feature_name:     text
  capability_enabled: text
  prd_slug:         text         // links to PRD
  claimed_level:    enum         // L0 | L1 | L2 | L3 | L4
  evidence:         jsonb        // { receipts: [], test_results: [], usage: {} }
  last_verified:    timestamp
  verified_by:      text         // agent name or human
  updated_at:       timestamp
}

Endpoint: GET /api/commissioning/status — machine-readable, LLM-friendly, A2A-compatible. The dashboard feature-matrix.md is the spec. This table is the reality. The diff is the work queue.

A2A path: This endpoint is the HTTP stub. When the A2A protocol is live, commissioning/status becomes a first-class agent task — any agent can query and post evidence through the same protocol.

Feature / Function / Outcome​

Business Dev​

This is a Mycelium capability — it doesn't sell directly. It sells by making every venture's data maturity visible and actionable.

Commissioning​

Metrics​

Risks + Kill Signal​

Kill signal: 0 tables reaching state 7+ after 90 days. If the system can't move tables through the progression, the state machine is theory, not tool. Kill and simplify.

Mycelium Capability​

This is the progressive maturity automation that ensures every data table reaches operational readiness. Any mushroom cap venture benefits from commissioned data.

When commissioning works, every venture knows where its data stands. When it doesn't, every venture reinvents maturity tracking. This is the highest-leverage Mycelium primitive for data readiness.

Context​

• Jobs To Be Done — Demand-side thinking: what progress, not what features
• Validate Demand — Awareness levels and kill signals
• Shape Up — Fixed time, variable scope
• Standards — Protocol, standard, glue — how repeatable outcomes emerge
• Process Optimisation — Plan, Do, Check, Act — the Deming loop commissioning embodies
• Flow Engineering — Maps that produce code artifacts
• Type-First Development — Schema-driven build approach
• Phygital Mycelium — The capability network this PRD belongs to
• The Factory — Spec → Build → Commission — why builder ≠ commissioner
• ETL Data Tool — State 7 depends on this pipeline
• Data Interface — State 8 depends on this interface
• Mushroom Caps — The ventures that benefit from commissioned data

Questions​

What is the single most important thing that must be true for commissioning to succeed — and how would you know if it weren't?

• Which user struggle does this PRD solve most directly — and is that the same struggle that would drive adoption?
• What is the minimum viable version of this feature that would still produce the core outcome?
• If this PRD were never built, what would users do instead — and is that workaround good enough?