> ## Documentation Index
> Fetch the complete documentation index at: https://docs.vinmake.com/llms.txt
> Use this file to discover all available pages before exploring further.
# RFQ to Quote Lifecycle
> The full RFQ → quotation lifecycle as diagrams — what AI does, where humans approve, and why we build agents instead of wrapping a chatbot
# RFQ to Quote Lifecycle
This page documents the full client-RFQ to quote-sent lifecycle as a series of paired flowcharts + sequence diagrams. Each stage of the workflow has both a structural view (decisions, branches, data stores) and an interaction view (HTTP calls, table writes, LLM invocations).
The source of truth for these diagrams is [`vinmaketeam/brain-contracts/LIFECYCLE.mmd`](https://github.com/vinmaketeam/brain-contracts/blob/main/LIFECYCLE.mmd). This page renders them.
**Color legend.** Across every diagram: blue = AI step, yellow = human action, amber = human approval gate, green = data store, gray = external system, purple = input artifact.
## Why we build an agent, not a thin wrapper
A pure model (ChatGPT.com, Claude.ai) applied to VinMake's work is like sending a baby to do a merchandiser's job. Smart on a single turn, useless across a hundred. We need professionals — consistent, dependable, accurate, high-agency.
The four traits a merchandiser must have, and a thin wrapper never does:
| Trait | What it means | Why it breaks with a thin wrapper |
| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Consistent** | Same input pattern → same output pattern, every time | Pure models vary turn to turn. Monday's BOM and Friday's BOM don't match for the same tech pack. |
| **Dependable** | Always reaches the workflow's end OR fails into a known, recoverable error | Thin wrappers hand back half-finished answers that cost an hour to debug. |
| **Accurate** | Per-line confidence with provenance | Mai needs to know which page of which tech pack produced "shell: 100% cotton 280gsm" so she can correct it in 30 seconds. Wrappers give prose, not auditable facts. |
| **High agency** | Decides when to ask, when to act, when to wait. Picks the right tool, threads provenance, retries failures, defers blocking actions to humans | Wrappers wait to be told. |
The agent route costs more engineering up front. What we get back is a system that grows from baby-grade to professional-grade over weeks — and stays there because the harness, contracts, and eval loop keep it there.
### Baby → Professional
```mermaid theme={null}
flowchart LR
classDef baby fill:#fee2e2,stroke:#991b1b,color:#7f1d1d
classDef pro fill:#dcfce7,stroke:#166534,color:#14532d
classDef bridge fill:#e0e7ff,stroke:#3730a3,color:#312e81
Baby["BABY — thin wrapper
(ChatGPT / Claude.ai)
• different output each turn
• forgets prior context
• plausible-sounding prose
• waits to be told what next
• no provenance, no audit
• hallucinates confidently
• one prompt at a time"]:::baby
Bridge["What gets us from baby to pro
1. Structured contracts (Pydantic)
2. State + idempotency per step
3. Tool calls, not just prose
4. Provenance threaded through
5. Eval harness + correction log
6. Human-in-the-loop gates"]:::bridge
Pro["PROFESSIONAL — agent + harness
(Brain + BOM + KG)
• consistent across turns
• state + memory in the loop
• per-line confidence + sources
• picks tool + asks when stuck
• provenance on every artifact
• reconfirms when guessing
• runs the whole workflow"]:::pro
Baby -- "where VinMake is today
with ad-hoc Claude / ChatGPT use" --> Bridge
Bridge -- "what Phase 1 ships:
three services + contracts" --> Pro
```
### LangGraph workflows, not just .md skills
Inside the Baby → Pro bridge, "structured contracts" and "state per step" pull a specific weight: about **70% of Brain framework's work lives in explicit LangGraph + Pydantic AI workflows**, not in `.md` skill files inside a system prompt.
Skill files are fine for single-prompt deterministic operations — summarize a style, find duplicates, classify an email. But they break consistency the moment a workflow needs state, retries, idempotency, typed handoffs between steps, or human approval gates in the middle.
A BOM generation expressed as *"you are a BOM extraction assistant…"* in a system prompt produces a different shape every run. The same workflow expressed as LangGraph nodes with Pydantic outputs produces the same shape every run — and the eval harness can grade it.
**Rule of thumb.** If the work needs to look the same on Monday and Friday, it goes in a LangGraph node. If it's a one-shot transformation with no downstream consumers, a `.md` skill is fine.
| Type | Location | Share | When to use | Examples |
| --------------------------- | ---------------------- | --------- | -------------------------------------------------------------------------- | --------------------------------------------------- |
| `.md` skill | Inside main agent | \~15% | Single-prompt, deterministic, no state | `/summarize-style`, `/find-duplicates` |
| **LangGraph + Pydantic AI** | **Inside main agent** | **\~70%** | **Long-running, consistency-critical, typed I/O, mid-flow approval gates** | `/generate-bom`, `/draft-true-cost`, `/draft-quote` |
| LangGraph + Pydantic AI | Outside (microservice) | \~10% | Own lifecycle, scaling, or ownership | BOM agent, KG service |
| `.md` multi-agent | Outside | \~5% | LLM-as-a-judge / adversarial; must be uncorrelated with what it judges | Eval grader for BOM output |
```mermaid theme={null}
flowchart TB
classDef md fill:#fef3c7,stroke:#b45309,color:#7c2d12
classDef lg fill:#dbeafe,stroke:#1e40af,color:#1e3a8a
classDef title fill:#e0e7ff,stroke:#3730a3,color:#312e81
Title["IMPLEMENTATION POV
where each skill / workflow lives"]:::title
subgraph Inside ["INSIDE main agent (Brain framework)"]
direction TB
InsideMD["~15% — .md skill file
simple deterministic prompts
e.g. /summarize-style,
/find-duplicates
cheap + fast
but no state, no retries,
output shape drifts run-to-run"]:::md
InsideLG["~70% — LangGraph + Pydantic AI
explicit workflow with state
e.g. /generate-bom,
/draft-true-cost, /draft-quote
USE WHEN
• long-running task
• consistency across prompts
• typed inputs and outputs
• human approval gates mid-flow"]:::lg
end
subgraph Outside ["OUTSIDE main agent"]
direction TB
OutsideMD["~5% — multi-agent .md
LLM-as-a-judge / adversarial
e.g. eval grader scoring
BOM agent output
must be uncorrelated with
the agent being judged"]:::md
OutsideLG["~10% — microservice
multi-repo, separate host
e.g. BOM agent (Ku Kue),
KG service (Andy)
when service has its own
lifecycle, scaling, ownership"]:::lg
end
Title --> Inside
Title --> Outside
```
### Measuring consistency
You cannot ship a professional you cannot measure. Two axes split the measurement problem cleanly: **debug** (what just happened?) vs **judge** (was it any good?). Both have a NOW tool and a LATER tool — pick the cheap one until prod traffic justifies the spend.
```mermaid theme={null}
flowchart TB
classDef now fill:#dbeafe,stroke:#1e40af,color:#1e3a8a
classDef later fill:#f3f4f6,stroke:#4b5563,color:#1f2937
classDef header fill:#fef3c7,stroke:#b45309,color:#7c2d12
classDef techniques fill:#fce7f3,stroke:#9d174d,color:#831843
Title["MEASURING CONSISTENCY"]:::header
HDebug["DEBUG — observability
what just happened?"]:::header
HJudge["JUDGE — evaluation
was it any good?"]:::header
Title --> HDebug
Title --> HJudge
NowDebug["NOW — LangSmith
full trace per workflow_run
X-Session-Id propagates
across Brain / BOM / KG
(zero cost, already wired
in deer-flow)"]:::now
LaterDebug["LATER — Arize Phoenix
self-host once data-
residency clause lands
or merchandiser #3 onboards
(months out, not weeks)"]:::later
NowJudge["NOW — code-defined evals
JSONL ground-truth files +
Python runner per service
(BOM: 5 tech packs
KG: 20 emails)"]:::now
LaterJudge["LATER — Braintrust
continuous eval at prod
regression catching +
shipped quality dashboard
(month 2-3, when traffic
justifies)"]:::later
HDebug --> NowDebug
HDebug --> LaterDebug
HJudge --> NowJudge
HJudge --> LaterJudge
Techniques["EVAL TECHNIQUES — be creative
1. Predefined eval set
(BOM v0: 5 ground-truth tech packs,
1 Jaspal + 2 Lulus + 2 ASOS)
2. Passively collect human corrections
(Brain correction log in Supabase →
yesterday's edits become tomorrow's eval)
3. Adversarial judgement
(LLM-as-a-judge, second model grades the first)
4. AI proposes hard cases + human curates
(Claude generates edge-case scenarios,
Mai / Zean approve into the eval set)"]:::techniques
NowJudge -.- Techniques
LaterJudge -.- Techniques
```
## Lifecycle overview
Six stages, three services, two humans, one client. The sequence diagram is the narrative view; the tree is the branching view.
### Sequence
```mermaid theme={null}
sequenceDiagram
autonumber
actor C as Client
participant G as Gmail
participant KG as "KG service (Andy)"
participant B as "Brain framework (Thai)"
participant BOM as "BOM agent (Ku Kue)"
participant CM as CutMake DB
actor M as Mai
actor Z as Zean
Note over C,Z: STAGE 1 — Email intake
C->>G: RFQ email + tech pack +
POM + measurement
KG->>G: poll history cursor
every 30s, lag ≤ 90s
KG->>KG: dedupe + OCR + chunk + embed
build provenance_ids
KG-->>B: GET /v0/emails (since cursor)
B->>B: classify as RFQ
extract client + style_ref
B->>M: Inbox card + Task
M->>B: confirm RFQ
Note over C,Z: STAGE 2 — Style record
B->>KG: fetch email body + attachments
B->>B: regex + LLM extract fields
B->>CM: SELECT clients WHERE domain=...
B->>M: Style record draft
M->>B: edits + approve
B->>CM: INSERT styles row
Note over C,Z: STAGE 3 — BOM
B->>BOM: POST /v0/generate-bom
style_id, urls, request_id
BOM->>BOM: pdfplumber + pdf2image
vision per page, cost-metered
category template fill
BOM-->>B: BomGenerationResponse
lines + confidence + provenance
B->>M: render BOM, flag LOW conf
loop reconfirm low-confidence lines
B->>M: AI is guessing — is X right?
M->>B: confirm or correct
end
M->>B: approve full BOM
B->>CM: INSERT bom_lines rows
Note over C,Z: STAGE 4 — True cost
B->>CM: read materials, fx_rates, moq
B->>B: per-line cost + overheads
anomaly check vs history
B->>Z: cost breakdown + flags
Z->>B: adjustments + approve
B->>CM: INSERT true_costs row
Note over C,Z: STAGE 5 — Quotation
B->>CM: read client markup rules
B->>B: apply markup
render quotation PDF
diff vs past quotes
B->>Z: quotation + delta from history
Z->>B: edits + approve
B->>CM: INSERT quotations row
Note over C,Z: STAGE 6 — Reply email
B->>KG: POST /v0/retrieve
scope: thread + style
B->>B: detect tone
draft reply
attach quotation PDF
B->>M: email draft + diff vs past replies
M->>B: edits + approve
B->>G: send via Gmail API
on original thread
G->>C: deliver
KG->>G: re-index outbound message
Note over C,Z: Lifecycle complete — awaiting client response
```
### Tree
```mermaid theme={null}
flowchart TD
classDef ai fill:#dbeafe,stroke:#1e40af,color:#1e3a8a
classDef human fill:#fef3c7,stroke:#b45309,color:#7c2d12
classDef gate fill:#fde68a,stroke:#92400e,color:#7c2d12
classDef store fill:#d1fae5,stroke:#047857,color:#064e3b
classDef ext fill:#f3f4f6,stroke:#4b5563,color:#1f2937
Client((Client)):::ext
Gmail[Gmail mailbox]:::ext
Client -- "RFQ + tech pack +
POM + measurement" --> Gmail
Gmail --> S1
subgraph S1 ["Stage 1 — Email intake"]
direction TB
I1[AI KG: pull + dedupe + index
build provenance IDs]:::ai
I2[AI Brain: classify RFQ
extract client + style_ref]:::ai
I3[AI Brain: Inbox card + Task]:::ai
I1 --> I2 --> I3
end
S1 --> G1{Mai: is this an RFQ?}:::gate
G1 -- "file only" --> FileOnly[AI Brain: file
no action]:::ai
G1 -- "spam" --> Drop[AI Brain: drop]:::ai
G1 -- "yes" --> S2
subgraph S2 ["Stage 2 — Style record"]
direction TB
T1[AI Brain: regex + LLM
extract fields]:::ai
T2[AI Brain: lookup client
+ draft Style]:::ai
T1 --> T2
end
S2 --> G2{Mai: approve style?}:::gate
G2 -- "edits" --> S2
G2 -- "approve" --> S3
subgraph S3 ["Stage 3 — BOM generation"]
direction TB
B1[AI BOM: parse PDF + images]:::ai
B2[AI BOM: vision —
visible BOM]:::ai
B3[AI BOM: template —
invisible BOM]:::ai
B4[AI BOM: aggregate +
per-line confidence]:::ai
B1 --> B2 --> B4
B1 --> B3 --> B4
end
S3 --> G3{"Mai: approve BOM?
reconfirm LOW conf lines"}:::gate
G3 -- "edits / reconfirms" --> S3
G3 -- "approve" --> S4
subgraph S4 ["Stage 4 — True cost"]
direction TB
C1[AI Brain: match supplier
prices per line]:::ai
C2[AI Brain: per-garment cost
+ labor + freight + duty]:::ai
C1 --> C2
end
S4 --> G4{Zean: approve cost?}:::gate
G4 -- "adjust" --> S4
G4 -- "approve" --> S5
subgraph S5 ["Stage 5 — Quotation"]
direction TB
Q1[AI Brain: apply client
markup rule]:::ai
Q2[AI Brain: render PDF +
sanity check vs history]:::ai
Q1 --> Q2
end
S5 --> G5{Zean: approve quote?}:::gate
G5 -- "adjust" --> S5
G5 -- "approve" --> S6
subgraph S6 ["Stage 6 — Reply email"]
direction TB
E1[AI KG: pull thread context]:::ai
E2[AI Brain: draft reply +
attach quote PDF]:::ai
E1 --> E2
end
S6 --> G6{Mai: approve + send?}:::gate
G6 -- "edits" --> S6
G6 -- "send" --> Sent[AI Brain: send via
Gmail API]:::ai
Sent --> ClientEnd((Client)):::ext
```
## Stage 1 — Email intake
KG service polls Gmail every 30s, dedupes by `gmail_message_id`, downloads attachments to a Supabase bucket, runs OCR/embedding/entity-extraction. Brain framework pulls indexed emails, classifies (heuristic → LLM fallback), posts an Inbox card. Mai's gate decides Task vs File vs Spam.
**Task vs File.** A *Task* is a blocking action that writes to CutMake (e.g. create Style row). A *File* is an indexed-but-no-action archive — still retrievable, no human gate.
### Flowchart
```mermaid theme={null}
flowchart LR
classDef ai fill:#dbeafe,stroke:#1e40af
classDef human fill:#fef3c7,stroke:#b45309
classDef gate fill:#fde68a,stroke:#92400e
classDef store fill:#d1fae5,stroke:#047857
classDef ext fill:#f3f4f6,stroke:#4b5563
Mai[Mai]:::human
Zean[Zean]:::human
MB["mai@vinmake.com"]:::ext
ZB["zean@vinmake.com"]:::ext
Mai --> MB
Zean --> ZB
MB --> Poll
ZB --> Poll
Poll["AI KG: Gmail poll
users.history.list
cursor=last_historyId
every 30s"]:::ai
Poll --> Fetch["AI KG: fetch full message
users.messages.get
format=full"]:::ai
Fetch --> Dedup["AI KG: dedupe by
gmail_message_id
SELECT messages_indexed"]:::ai
Dedup --> Skip{Already
indexed?}:::gate
Skip -- "yes" --> Done1[Skip, advance cursor]:::ai
Skip -- "no" --> Attach
Attach["AI KG: extract attachments
download base64 → bucket
sha256 each blob"]:::ai
Attach --> Buck[(Supabase Storage
bucket: rfq_attachments)]:::store
Attach --> ProvIDs["AI KG: assign provenance_ids
email:gmail-msg-{id}
pdf:sha256-{hex}
xlsx:sha256-{hex}
image:sha256-{hex}"]:::ai
ProvIDs --> Artifacts[(artifacts table
provenance_id PK)]:::store
Attach --> Text["AI KG: extract text
pdfplumber → PDF text
openpyxl → xlsx
tesseract → image OCR"]:::ai
Text --> Chunk["AI KG: chunk text
≈512 token windows
64 token overlap
preserve page boundaries"]:::ai
Chunk --> Embed["AI KG: embed
text-embedding-3-large
3072 dim"]:::ai
Embed --> VStore[(pgvector chunks table
ivfflat index, cos sim)]:::store
Text --> Ents["AI KG: entity extract
LLM tool-use:
Person, Client, Style,
Thread, Attachment"]:::ai
Ents --> KGStore[(KG nodes + edges:
Email-FROM-Person
Email-ABOUT-Style
Style-FOR-Client)]:::store
ProvIDs -.-> MarkIndexed
VStore -.-> MarkIndexed
KGStore -.-> MarkIndexed
MarkIndexed["AI KG: mark indexed
INSERT messages_indexed
UPDATE ingest cursor"]:::ai
MarkIndexed --> Events[(ingestion_events queue
indexed event)]:::store
Events --> BPoll
BPoll["AI Brain: subscribe to
GET /v0/emails
since=last_seen"]:::ai
BPoll --> Heur["AI Brain: heuristic classify
sender domain in clients?
subject ∈ rfq|quote|inquiry?
tech pack attached?
has style_ref pattern?"]:::ai
Heur --> Conf{heuristic
confidence ≥ 0.8?}:::gate
Conf -- "no" --> LLMClass["AI Brain: LLM classify
Claude Sonnet, tool-use
output: rfq|followup|
internal|spam"]:::ai
Conf -- "yes" --> Extract
LLMClass --> Extract
Extract["AI Brain: extract fields
client_id, style_ref,
requested_qty, due_date,
incoterms hints"]:::ai
Extract --> Lookup[(SELECT clients
WHERE domain or fuzzy_name)]:::store
Lookup --> Card["AI Brain: post Inbox card
structured summary +
open Task affordance +
provenance link to email"]:::ai
Card --> Gate{Mai: classification
correct?}:::gate
Gate -- "yes — RFQ" --> Task["Create Task workflow_run
idempotent on gmail_message_id
blocking: writes Style row"]:::ai
Gate -- "no — file only" --> File["AI Brain: file
indexed only, no workflow"]:::ai
Gate -- "no — spam" --> Drop["AI Brain: drop
mark thread mute
propagate to KG"]:::ai
Gate -- "wrong fields" --> Override["AI Brain: re-extract
with override hint"]:::ai
Override --> Card
Task --> Trigger["Trigger Stage 2:
Style record draft
workflow_run_id propagates"]:::ai
```
### Sequence
```mermaid theme={null}
sequenceDiagram
autonumber
actor C as Client
participant G as Gmail API
participant KG as "KG service (Andy)"
participant V as "pgvector (Supabase)"
participant KGDB as "KG tables (Supabase)"
participant Buck as "Storage bucket"
participant A as "Anthropic API"
participant B as "Brain framework (Thai)"
actor M as Mai
Note over C,M: Polling loop (every 30s)
KG->>G: users.history.list
?startHistoryId=cursor
G-->>KG: history entries + new IDs
loop per new gmail_message_id
KG->>G: users.messages.get
?format=full&id={id}
G-->>KG: message + attachments (base64)
KG->>KGDB: SELECT FROM messages_indexed
WHERE gmail_message_id={id}
alt already indexed
KGDB-->>KG: hit (skip)
else new
KGDB-->>KG: miss
KG->>KG: extract attachments,
sha256 each blob
KG->>Buck: PUT rfq_attachments/{sha}
KG->>KG: assign provenance_ids
email:gmail-msg-{id}
pdf:sha256-{hex}
KG->>KGDB: INSERT artifacts rows
KG->>KG: extract text via
pdfplumber / openpyxl / OCR
KG->>KG: chunk at 512 tokens
w/ 64 overlap
KG->>A: POST /v1/embeddings
model=text-embedding-3-large
A-->>KG: 3072-dim vectors
KG->>V: INSERT chunks (vector + metadata)
KG->>A: messages.create
tool: extract_entities
model=claude-sonnet-4-6
A-->>KG: Person, Client, Style,
Thread, Attachment
KG->>KGDB: INSERT nodes + edges
KG->>KGDB: INSERT messages_indexed
UPDATE ingest cursor
KG->>KGDB: INSERT indexing_events
(type=indexed)
end
end
Note over C,M: Brain pickup
B->>KG: GET /v0/emails?since={cursor}
X-Session-Id={trace}
KG-->>B: IndexedEmailResponse
(emails, indexing_lag_seconds)
loop per IndexedEmail
B->>B: heuristic classify
sender + subject + attachments
alt heuristic conf < 0.8
B->>A: messages.create
tool: classify_email
model=claude-sonnet-4-6
A-->>B: classification + confidence
end
B->>B: extract client_id, style_ref,
qty, due_date, incoterms
B->>B: render Inbox card payload
B->>M: push Inbox card via SSE
end
M->>B: confirm RFQ / file / spam
(workflow_action POST)
alt confirmed RFQ
B->>B: create Task workflow_run
(idempotent on gmail_message_id)
B-->>B: emit stage_2_trigger event
else file only
B->>KGDB: UPDATE threads SET state='filed'
else spam
B->>KGDB: UPDATE threads SET state='muted'
B->>KG: PUT /v0/threads/{id}/mute
end
```
## Stage 2 — Style record creation
Brain extracts fields via regex (hard refs) and LLM tool-use (prose), matches the client (exact domain → fuzzy name → past style\_refs), drafts a Style record, asks Mai for any missing pieces, then writes to CutMake on approval. Brain owns this stage end to end; KG is read-only.
### Flowchart
```mermaid theme={null}
flowchart LR
classDef ai fill:#dbeafe,stroke:#1e40af
classDef human fill:#fef3c7,stroke:#b45309
classDef gate fill:#fde68a,stroke:#92400e
classDef store fill:#d1fae5,stroke:#047857
classDef io fill:#e0e7ff,stroke:#3730a3
Task["Task from Stage 1:
new RFQ for client X
workflow_run_id"]:::ai
Task --> Fetch["AI Brain: fetch via
GET /v0/emails/{id}
+ attachments list"]:::ai
Fetch --> KGRead[("KG service:
IndexedEmail +
Provenance refs")]:::store
KGRead --> Rule["AI Brain: regex extract
style_ref: [A-Z]{2,3}[0-9]{3,6}
dates: ISO + natural
qty: numeric + units"]:::ai
KGRead --> LLM["AI Brain: LLM extract
Claude Sonnet, tool-use
fabric mentions, special notes,
shipping address, incoterms,
special instructions"]:::ai
Rule --> Merge["AI Brain: merge fields
regex wins on hard refs
LLM wins on prose"]:::ai
LLM --> Merge
Merge --> CMLookup
CMLookup["AI Brain: client lookup
1. SELECT WHERE domain=sender_domain
2. fuzzy match on display_name
3. fuzzy match on past style_refs"]:::ai
CMLookup --> ClientTbl[(CutMake.clients
id, domain, name, aliases)]:::store
ClientTbl --> Match{Client
matched?}:::gate
Match -- "yes — exact" --> AssignClient["AI Brain: assign client_id"]:::ai
Match -- "yes — fuzzy" --> ConfirmClient{"Mai: confirm
client = X?"}:::gate
Match -- "no" --> NewClient["AI Brain: stage new client
(pending Mai approval)"]:::ai
ConfirmClient -- "yes" --> AssignClient
ConfirmClient -- "no — pick" --> PickClient["Mai: search + pick
or create new"]:::ai
PickClient --> AssignClient
NewClient --> AssignClient
AssignClient --> StyleDraft["AI Brain: Style record draft
style_ref, season, qty range,
category_hint, due_date,
special_notes, provenance_ids"]:::ai
StyleDraft --> MissingCheck{All required
fields populated?}:::gate
MissingCheck -- "no — missing tech pack" --> AskTP["AI Brain: ask Mai
do you have the tech pack?
upload or skip"]:::ai
MissingCheck -- "no — missing qty" --> AskQty["AI Brain: ask Mai for qty"]:::ai
MissingCheck -- "yes" --> Render
AskTP --> Upload["Mai: upload tech pack
or confirm skip"]:::ai
Upload --> KGIndex["AI KG: index uploaded
tech pack (out-of-band)"]:::ai
KGIndex --> StyleDraft
AskQty --> StyleDraft
Render["AI Brain: render Style draft
in chat with edit affordance"]:::ai
Render --> Approval{Mai: approve
or edit?}:::gate
Approval -- "edits" --> StyleDraft
Approval -- "wrong client" --> CMLookup
Approval -- "approve" --> Validate["AI Brain: pydantic validate
vs Style schema"]:::ai
Validate --> Write[("CutMake DB:
INSERT styles row
style_id returned")]:::store
Write --> Link["AI Brain: link email →
style_id in KG"]:::ai
Link --> LinkKG[("KG: INSERT
Email-ABOUT-Style edge")]:::store
Link --> Trigger["Trigger Stage 3:
BOM generation
(workflow_run_id propagates)"]:::ai
```
### Sequence
```mermaid theme={null}
sequenceDiagram
autonumber
participant B as "Brain framework (Thai)"
participant KG as "KG service (Andy)"
participant A as "Anthropic API"
participant CM as "CutMake DB"
actor M as Mai
Note over B,M: Triggered by Stage 1 Task confirmation
B->>KG: GET /v0/emails/{id}
+ provenance refs
KG-->>B: IndexedEmail + attachments
Note over B,M: Field extraction (parallel)
par regex pass
B->>B: regex extract
style_ref, dates, qty
and LLM pass
B->>A: messages.create
tool: extract_style_fields
model=claude-sonnet-4-6
A-->>B: structured fields
end
B->>B: merge regex + LLM
Note over B,M: Client matching
B->>CM: SELECT clients WHERE domain=...
CM-->>B: candidates
B->>B: fuzzy match if no exact hit
alt fuzzy match found
B->>M: confirm client = X?
M-->>B: yes / pick another / new
else no match
B->>M: client unknown — pick or create
M-->>B: selection
end
Note over B,M: Style draft + missing-data loop
B->>B: assemble Style record draft
alt tech pack missing
B->>M: do you have the tech pack?
M-->>B: upload file
B->>KG: POST /v0/ingest
(out-of-band upload)
KG-->>B: provenance_id
end
B->>M: render Style draft in chat
loop until approved
M-->>B: edits / approve
alt edits
B->>B: re-render with edits
else approve
B->>B: pydantic validate vs Style schema
end
end
B->>CM: INSERT styles row
CM-->>B: style_id
B->>KG: PUT /v0/edges
Email-ABOUT-Style {style_id}
B-->>B: emit stage_3_trigger event
```
## Stage 3 — BOM generation
This is the workflow with the most LLM-heavy reasoning and the tightest cost discipline. BOM agent owns the work; Brain orchestrates and runs Mai's reconfirm loop.
**Hard cost cap.** BOM agent enforces a per-request vision budget (default \$2.00). Pathological PDFs with hundreds of images return `partial: true` with `skipped_pages` populated rather than running away with cost. Brain renders the partial BOM and asks Mai to fill the gaps.
**Reconfirm rule.** Every LOW-confidence line gates on Mai before the BOM can be approved. HIGH and MEDIUM lines do not gate. "If AI is guessing → always reconfirm" is a hard rule, not a heuristic.
### Flowchart
```mermaid theme={null}
flowchart LR
classDef ai fill:#dbeafe,stroke:#1e40af
classDef human fill:#fef3c7,stroke:#b45309
classDef gate fill:#fde68a,stroke:#92400e
classDef store fill:#d1fae5,stroke:#047857
classDef io fill:#e0e7ff,stroke:#3730a3
Style["Approved Style record:
style_id, style_ref,
category_hint, attachments"]:::ai
TP[/Tech pack PDF/]:::io
POM[/POM xlsx/]:::io
Meas[/Measurement PDF/]:::io
Style --> TP
Style --> POM
Style --> Meas
Style --> Request["AI Brain: build
BomGenerationRequest
+ request_id (idempotency)"]:::ai
Request --> IdmpCache{"BOM agent:
request_id in cache?"}:::gate
IdmpCache -- "yes" --> Cached[Return cached
BomGenerationResponse]:::ai
IdmpCache -- "no" --> Parse
Parse["AI BOM: parse PDFs
pdfplumber → text per page
pdf2image → 150dpi page images"]:::ai
Parse --> ParseX["AI BOM: parse POM xlsx
openpyxl
POM table → dict"]:::ai
Parse --> ParseM["AI BOM: parse measurement
pdfplumber → measurement
chart"]:::ai
ParseX --> Visible
ParseM --> Visible
Parse --> Prio["AI BOM: prioritize pages
first N + pages with
detected garment images"]:::ai
Prio --> Budget1{"Vision budget
remaining?"}:::gate
Budget1 -- "yes" --> Vision
Budget1 -- "no, hit cap" --> SkipPage[Skip page,
record in skipped_pages]:::ai
SkipPage --> NextPage{More
pages?}:::gate
NextPage -- "yes" --> Budget1
NextPage -- "no" --> Visible
Vision["AI BOM: per-page vision call
Anthropic SDK
model=claude-sonnet-4-6
cost meter wraps each call"]:::ai
Vision --> CostMeter["AI BOM: cost meter
accumulate USD per request
raises BudgetExceeded at cap"]:::ai
CostMeter --> NextPage
Vision --> Garment["AI BOM: classify garment
jacket / pants / dress /
shirt / skirt / blazer"]:::ai
Vision --> Visible["AI BOM: extract visible BOM
shell, lining, buttons, zipper,
contrast, trims, embellishments"]:::ai
Garment --> TemplLookup
TemplLookup["AI BOM: look up category template
e.g. blazer_v0.3
(template_version recorded)"]:::ai
TemplLookup --> TemplStore[(category templates
blazer, jacket, pants,
dress, shirt)]:::store
Style --> Client["Client record from Style"]:::ai
Client --> Pack["AI BOM: client packaging
conventions
(if known)"]:::ai
TemplLookup --> Hidden["AI BOM: fill invisible BOM
interlining, fusing, thread,
main label, care label,
price tag, polybag, carton"]:::ai
Pack --> Hidden
Visible --> Score["AI BOM: per-line confidence
HIGH if direct text match
MED if vision-extracted
LOW if template-guessed or
image-inferred"]:::ai
Hidden --> Score
Score --> Prov["AI BOM: assign provenance_id
per line
(point into KG: pdf:sha-{hex}#page{N})"]:::ai
Prov --> Aggregate["AI BOM: aggregate BOM
lines + cost_usd +
template_version + partial flag"]:::ai
Aggregate --> Response["BomGenerationResponse
(see brain_contracts/bom_agent.py)"]:::ai
Response --> WriteIdmp[("AI BOM: write to
idempotency cache
{request_id: response}")]:::store
Response --> RenderUI["AI Brain: render BOM in chat
group by visible/invisible
color by confidence"]:::ai
Cached --> RenderUI
RenderUI --> LowConfCheck{Any LOW conf
lines?}:::gate
LowConfCheck -- "yes" --> Reconfirm["AI Brain: per LOW line
show source page (provenance) +
ask: is X correct?"]:::ai
Reconfirm --> MaiReply{Mai: confirm,
correct, or skip}:::gate
MaiReply -- "confirm" --> UpdateConf["AI Brain: mark line
confidence=HIGH (Mai approved)"]:::ai
MaiReply -- "correct" --> EditLine["AI Brain: apply edit
(material, qty, consumption)"]:::ai
MaiReply -- "skip line" --> Skip2[AI Brain: drop line,
flag for manual add]:::ai
UpdateConf --> RenderUI
EditLine --> RenderUI
Skip2 --> RenderUI
LowConfCheck -- "no" --> Final{Mai: approve
full BOM?}:::gate
Final -- "edit" --> EditLine
Final -- "regenerate" --> Request
Final -- "approve" --> Validate["AI Brain: pydantic-ai
validate vs BomLine schema
(strict)"]:::ai
Validate --> ValidOK{Valid?}:::gate
ValidOK -- "no" --> Manual["AI Brain: surface error,
Mai fixes inline"]:::ai
Manual --> RenderUI
ValidOK -- "yes" --> Event["AI Brain: emit
BOM_APPROVED event
workflow_run_id, style_id, lines"]:::ai
Event --> WriteBOM[("CutMake DB:
INSERT bom_lines rows
style_id FK")]:::store
WriteBOM --> Trigger["Trigger Stage 4:
True cost computation"]:::ai
```
### Sequence
```mermaid theme={null}
sequenceDiagram
autonumber
participant B as "Brain framework (Thai)"
participant BOM as "BOM agent (Ku Kue)"
participant A as "Anthropic API"
participant KG as "KG service (Andy)"
participant CM as "CutMake DB"
actor M as Mai
Note over B,M: Triggered by Stage 2 Style approval
B->>B: build BomGenerationRequest
(style_id, urls, request_id,
vision_budget_usd=2.0)
B->>BOM: POST /v0/generate-bom
X-Session-Id={trace}
BOM->>BOM: SELECT idempotency cache
WHERE request_id=...
alt cache hit
BOM-->>B: cached BomGenerationResponse
else cache miss
BOM->>BOM: pdfplumber text per page
pdf2image @ 150dpi
openpyxl POM
BOM->>BOM: prioritize pages by
garment image detector
loop per prioritized page (budget-gated)
BOM->>BOM: cost_meter.remaining()?
alt remaining > page_cost_estimate
BOM->>A: messages.create (vision)
model=claude-sonnet-4-6
image + extraction prompt
A-->>BOM: visible parts JSON
BOM->>BOM: cost_meter.add(usd)
else budget hit
BOM->>BOM: add to skipped_pages
end
end
BOM->>BOM: classify garment category
BOM->>BOM: lookup category template
(blazer_v0.3 etc.)
BOM->>BOM: fill invisible BOM
+ client packaging conventions
BOM->>BOM: per-line confidence score
BOM->>BOM: assign provenance_id
pdf:sha-{hex}#page{N}
BOM->>BOM: pydantic-validate response
BOM->>BOM: write to idempotency cache
BOM-->>B: BomGenerationResponse
(lines, cost_usd, partial,
template_version)
end
Note over B,M: Brain renders + reconfirm loop
B->>B: group lines by visible/invisible
color by confidence
B->>M: render BOM with source links
loop while LOW-conf lines remain
B->>KG: GET /v0/provenance/lookup
{provenance_ids: [...]}
KG-->>B: Provenance refs (URL + snippet)
B->>M: per LOW line: show source +
"is X correct?"
M-->>B: confirm / correct / skip
alt confirm
B->>B: mark line confidence=HIGH
else correct
B->>B: apply edit
else skip
B->>B: drop line + flag manual
end
end
M-->>B: approve full BOM
B->>B: pydantic-ai validate strict
alt validation fails
B->>M: surface error inline
M-->>B: fix
else valid
B->>CM: INSERT bom_lines rows
CM-->>B: bom_line_ids
B-->>B: emit BOM_APPROVED event
trigger Stage 4
end
```
## Stage 4 — True cost computation
Brain matches each BOM line to a supplier price (exact code → fuzzy on type/color/gsm), converts to base currency, adds MOQ surcharges, layers in overheads (labor SAM, freight zone, HS-code duty, defect allowance), then runs an anomaly check vs the prior 50 styles in the same category for the same client. Zean reviews.
### Flowchart
```mermaid theme={null}
flowchart LR
classDef ai fill:#dbeafe,stroke:#1e40af
classDef human fill:#fef3c7,stroke:#b45309
classDef gate fill:#fde68a,stroke:#92400e
classDef store fill:#d1fae5,stroke:#047857
BOM["Approved BOM lines
from Stage 3"]:::ai
Qty["Order quantity +
size breakdown
from Style"]:::ai
BOM --> Match["AI Brain: match each BOM line
to supplier price entry
by material code or fuzzy
on (type, color, gsm)"]:::ai
Match --> Materials[(materials price book
CutMake.materials
supplier_id, currency, price)]:::store
Match --> MatchResult{All lines
matched?}:::gate
MatchResult -- "no — unmatched" --> Stage["AI Brain: stage unmatched
lines as MED conf cost
(uses category average)"]:::ai
MatchResult -- "yes" --> Calc1
Stage --> Calc1
Calc1["AI Brain: per-line raw cost
= unit_price × consumption × qty
(unit-aware, e.g. m, kg, pc)"]:::ai
Calc1 --> FX[(fx_rates table
quoted_currency → THB/USD)]:::store
FX --> Calc2["AI Brain: convert to base currency
USD or THB per company config"]:::ai
Calc1 --> Calc2
Calc2 --> MOQ[(moq_table
per material
moq, lead_time_days)]:::store
MOQ --> Surcharge["AI Brain: MOQ surcharge
if order_qty < material_moq
add (moq - order_qty)
× unit_price"]:::ai
Calc2 --> Surcharge
Surcharge --> Overhead["AI Brain: add overheads
labor (per minute SAM × rate)
freight (per kg, lookup zone)
duty (per HS code)
defect allowance (% of materials)"]:::ai
Overhead --> Overheads[(overheads config
labor_rate, freight_zones,
hs_duty_table)]:::store
Overhead --> Total["AI Brain: per-garment true cost
+ line-level breakdown
+ percentage attribution"]:::ai
Total --> Anom["AI Brain: anomaly detection
z-score vs prior 50 styles
same category + client"]:::ai
Anom --> History[(historical_costs
same category + client)]:::store
Anom --> Flags["AI Brain: flag lines with
z > 2 (high) or z < -2 (low)
+ explain delta vs prior"]:::ai
Flags --> Render["AI Brain: render cost
breakdown to Zean
line-level + total +
anomaly flags + explanations"]:::ai
Render --> Gate{Zean: approve
cost?}:::gate
Gate -- "adjust line cost" --> EditLine["Zean: edit line
(unit_price, consumption,
or material swap)"]:::ai
Gate -- "swap supplier" --> SwapSup["Zean: pick alternate
supplier from price book"]:::ai
Gate -- "change qty" --> Qty
Gate -- "explain flag" --> Explain["AI Brain: show prior
styles + price history"]:::ai
Gate -- "approve" --> Validate["AI Brain: pydantic validate
vs TrueCost schema"]:::ai
EditLine --> Calc1
SwapSup --> Match
Explain --> Render
Validate --> Write[("CutMake DB:
INSERT true_costs row
+ true_cost_lines rows")]:::store
Write --> Event["AI Brain: emit
COST_APPROVED event"]:::ai
Event --> Trigger["Trigger Stage 5:
Quotation drafting"]:::ai
```
### Sequence
```mermaid theme={null}
sequenceDiagram
autonumber
participant B as "Brain framework (Thai)"
participant CM as "CutMake DB"
participant A as "Anthropic API"
actor Z as Zean
Note over B,Z: Triggered by Stage 3 BOM approval
B->>CM: SELECT bom_lines
WHERE style_id=...
CM-->>B: BOM lines
Note over B,Z: Match + price
loop per BOM line
B->>CM: SELECT materials
WHERE code=line.material_code
OR fuzzy match on (type, color, gsm)
CM-->>B: candidates
alt no match
B->>A: tool: fuzzy_material_match
A-->>B: best candidate or null
B->>B: stage as MED conf
(category avg if null)
end
end
B->>CM: SELECT fx_rates
WHERE quoted_currency IN (...)
CM-->>B: rates
B->>B: convert to base currency
B->>CM: SELECT moq_table
WHERE material_id IN (...)
CM-->>B: moq + lead_time
B->>B: compute MOQ surcharge
B->>CM: SELECT overheads_config
CM-->>B: labor_rate, freight, duty
B->>B: add overheads to total
Note over B,Z: Anomaly check
B->>CM: SELECT historical_costs
WHERE category=... AND client_id=...
ORDER BY created_at DESC LIMIT 50
CM-->>B: prior costs
B->>B: compute z-score per line
flag |z| > 2
B->>Z: render cost breakdown +
anomaly flags
loop until approved
Z-->>B: adjust / swap / qty / approve
alt adjust line
B->>B: recompute affected lines
else swap supplier
B->>CM: SELECT materials WHERE supplier_id=...
B->>B: re-match + recompute
else explain flag
B->>Z: show prior styles + history
else approve
B->>B: pydantic-validate vs TrueCost
end
end
B->>CM: INSERT true_costs +
true_cost_lines
CM-->>B: true_cost_id
B-->>B: emit COST_APPROVED event
trigger Stage 5
```
## Stage 5 — Quotation drafting
Brain applies the client's markup rule, fills terms (incoterms, payment, lead time, validity), renders the quotation PDF via Jinja+WeasyPrint, sanity-checks the unit price against the past 12 months of quotations to the same client. Zean reviews.
### Flowchart
```mermaid theme={null}
flowchart LR
classDef ai fill:#dbeafe,stroke:#1e40af
classDef human fill:#fef3c7,stroke:#b45309
classDef gate fill:#fde68a,stroke:#92400e
classDef store fill:#d1fae5,stroke:#047857
Cost["Approved true cost
from Stage 4"]:::ai
Client["Client record"]:::ai
Cost --> Rules["AI Brain: load markup rule
per client + category
(default: target_margin %)"]:::ai
Client --> Rules
Rules --> RulesTbl[(markup_rules
client_id, category,
margin_pct, currency)]:::store
Rules --> Markup["AI Brain: apply markup
quote_unit_price =
cost / (1 - margin)"]:::ai
Markup --> Terms["AI Brain: fill terms
incoterms (default FOB),
payment (30% deposit + 70% BL),
lead time (from MOQ table),
validity (30 days)"]:::ai
Client --> Terms
Markup --> Render["AI Brain: render quotation
weasyprint or reportlab
template: quote_v1.html"]:::ai
Terms --> Render
Render --> Templ[(quotation templates
jinja2 + CSS)]:::store
Render --> Past[(past quotations
same client + category
last 12 months)]:::store
Past --> Sanity["AI Brain: sanity check
compare to median past unit_price
flag if delta > ±15%"]:::ai
Render --> Sanity
Sanity --> Explain["AI Brain: if flagged,
generate explanation
(cost driver vs prior)"]:::ai
Render --> RenderUI["AI Brain: show to Zean
PDF preview + cost-to-quote diff +
sanity flags + explanation"]:::ai
Explain --> RenderUI
RenderUI --> Gate{Zean: approve
price + terms?}:::gate
Gate -- "adjust margin" --> Rules
Gate -- "edit terms" --> Terms
Gate -- "edit line price" --> EditLine["Zean: override
specific line price"]:::ai
Gate -- "approve" --> Validate["AI Brain: pydantic validate
vs Quotation schema"]:::ai
EditLine --> Markup
Validate --> Write[("CutMake DB:
INSERT quotations row
+ quotation_lines rows")]:::store
Write --> StorePDF[(Storage bucket:
quotations/{quote_id}.pdf)]:::store
Write --> Event["AI Brain: emit
QUOTE_APPROVED event"]:::ai
Event --> Trigger["Trigger Stage 6:
Reply email drafting"]:::ai
```
### Sequence
```mermaid theme={null}
sequenceDiagram
autonumber
participant B as "Brain framework (Thai)"
participant CM as "CutMake DB"
participant Buck as "Storage bucket"
actor Z as Zean
Note over B,Z: Triggered by Stage 4 cost approval
B->>CM: SELECT true_costs WHERE id=...
CM-->>B: true cost + lines
B->>CM: SELECT markup_rules
WHERE client_id AND category
CM-->>B: margin_pct
B->>B: apply markup
quote_price = cost / (1 - margin)
B->>CM: SELECT clients WHERE id=...
CM-->>B: incoterms, payment_terms,
default_lead_time
B->>B: fill quotation terms
B->>B: render via jinja2 + weasyprint
B->>Buck: PUT quotations/{id}.pdf (preview)
B->>CM: SELECT quotations
WHERE client_id AND category
AND created_at > now() - 365d
CM-->>B: past quotations
B->>B: compute delta vs median
flag if > ±15%
B->>Z: render PDF preview + diff + flags
loop until approved
Z-->>B: adjust / edit / approve
alt adjust margin
B->>B: recompute quote_price
else edit terms
B->>B: re-render PDF
else edit line price
B->>B: override + re-render
else approve
B->>B: pydantic-validate vs Quotation schema
end
end
B->>CM: INSERT quotations + quotation_lines
CM-->>B: quote_id
B->>Buck: PUT quotations/{quote_id}.pdf (final)
B-->>B: emit QUOTE_APPROVED event
trigger Stage 6
```
## Stage 6 — Client reply email
Brain pulls recent thread context via KG retrieval, detects tone (formal / casual / urgent), composes the reply with anchors the client used (style\_ref, dates, specific questions), attaches the quote, shows Mai a draft. On send, Gmail outbound is re-indexed and linked to the RFQ thread.
### Flowchart
```mermaid theme={null}
flowchart LR
classDef ai fill:#dbeafe,stroke:#1e40af
classDef human fill:#fef3c7,stroke:#b45309
classDef gate fill:#fde68a,stroke:#92400e
classDef store fill:#d1fae5,stroke:#047857
classDef ext fill:#f3f4f6,stroke:#4b5563
Quote["Approved quotation PDF
from Stage 5"]:::ai
Thread["Original RFQ thread
(gmail thread_id)"]:::ai
Thread --> Retrieve["AI Brain: POST /v0/retrieve
scope: thread_id + style_id
max_results=20"]:::ai
Retrieve --> KGRet[(KG: cross-source retrieval
prior emails, prior quotes,
past replies same client)]:::store
KGRet --> Tone["AI Brain: LLM detect tone
formal / casual / urgent
output: tone label + signals"]:::ai
KGRet --> Anchors["AI Brain: extract anchors
style_ref, qty, dates,
specific questions client asked"]:::ai
Quote --> Compose["AI Brain: draft email body
structured prompt:
greet by name (anchor) +
reference style_ref +
state quote price + lead time +
answer asked questions +
close in detected tone"]:::ai
Tone --> Compose
Anchors --> Compose
Compose --> Templ[(reply templates
per language: en, th, vi)]:::store
Templ --> Compose
Compose --> Attach["AI Brain: bind attachments
quotation PDF + addenda
(size chart, fabric swatches
if previously discussed)"]:::ai
Quote --> Attach
Attach --> DiffPast["AI Brain: diff vs
past replies to same client
(structure + phrasing only)"]:::ai
KGRet --> DiffPast
DiffPast --> RenderUI["AI Brain: show draft to Mai
body + attachments + diff +
To/Cc auto-filled from thread"]:::ai
RenderUI --> Gate{Mai: approve
+ send?}:::gate
Gate -- "edit body" --> EditBody["Mai: edit prose
or regenerate"]:::ai
Gate -- "edit recipients" --> EditTo["Mai: add/remove
To/Cc"]:::ai
Gate -- "different attachment" --> Attach
Gate -- "regenerate" --> Compose
Gate -- "send" --> Send["AI Brain: send via
users.messages.send
threadId={thread_id}
In-Reply-To header set"]:::ai
EditBody --> RenderUI
EditTo --> RenderUI
Send --> Gmail[(Gmail API)]:::ext
Gmail --> Client((Client)):::ext
Send --> KGReindex["AI KG: re-index outbound
(picked up on next poll)
link to RFQ thread"]:::ai
KGReindex --> KGUpdate[(KG: Email-REPLY_TO-Email
edge added)]:::store
Send --> Write[("CutMake DB:
INSERT email_sent row
quote_id FK")]:::store
Write --> Event["AI Brain: emit
QUOTE_SENT event"]:::ai
Event --> Done([Lifecycle complete —
workflow_run state = QUOTED
awaiting client response]):::ai
```
### Sequence
```mermaid theme={null}
sequenceDiagram
autonumber
participant B as "Brain framework (Thai)"
participant KG as "KG service (Andy)"
participant A as "Anthropic API"
participant G as "Gmail API"
participant CM as "CutMake DB"
actor M as Mai
actor C as Client
Note over B,C: Triggered by Stage 5 Quote approval
B->>KG: POST /v0/retrieve
{question: "what did client
previously ask?",
scope: {thread_id, style_id,
max_results: 20}}
KG-->>B: RetrievalResponse
(prior emails, quotes, replies)
par tone detection
B->>A: messages.create
tool: detect_tone
input: thread history
A-->>B: tone label + signals
and anchor extraction
B->>A: messages.create
tool: extract_anchors
input: original RFQ
A-->>B: style_ref, qty, dates,
questions asked
end
B->>B: select reply template
by language (en/th/vi)
B->>A: messages.create
tool: compose_reply
input: tone + anchors +
quote_summary + template
A-->>B: drafted email body
B->>B: bind attachments
(quotation PDF + addenda)
B->>KG: retrieve past replies to same
client for structure diff
KG-->>B: 3-5 past replies
B->>B: compute diff (structural)
B->>M: render draft +
attachments + diff + To/Cc
loop until approved
M-->>B: edit / regenerate / approve
alt edit body
B->>B: apply Mai edits
else regenerate
B->>A: re-compose with feedback
A-->>B: new draft
else edit recipients
B->>B: update To/Cc
else approve
B->>B: pydantic-validate Email schema
end
end
B->>G: users.messages.send
threadId={thread_id}
In-Reply-To: {message_id}
G-->>B: sent message_id
G->>C: deliver email
B->>CM: INSERT email_sent +
UPDATE workflow_runs
SET state='QUOTED'
B-->>B: emit QUOTE_SENT event
Note over KG,G: Outbound re-indexed
KG->>G: users.history.list (next poll)
G-->>KG: outbound message picked up
KG->>KG: index + link to thread
Email-REPLY_TO-Email edge
Note over B,C: Lifecycle complete — awaiting client response
```
## Related
* [Aggregator + Workflow Registry](/brain/staging/architecture/aggregator-and-workflows) — how chat, slash, and Inbox clicks all route to the workflows in this lifecycle
* [Implementation Tiers](/brain/staging/architecture/tiers) — when each stage is a skill, workflow, or full agent
* [Observability](/brain/staging/architecture/observability) — the LangSmith → Langfuse migration and the correction log
* [Data Integration](/brain/staging/architecture/data-integration) — Brain Supabase vs CutMake Supabase boundary