# Sales flow chart

**Nav:** **My Workspace** (code name My Work) → **Sales flow guide** → **Live flow & actions**
(`/manage/my-work/sales-flow?guide=live`, the company view) and **How the three stages work** (`?guide=flow`, the same charts without counts); Events → Funnels →
a Sales-flow funnel → **Journey** tab (`/manage/events/funnels/{uuid}?tab=journey`, that funnel's own board).

Sub-docs in this folder:

- [Closing board](/docs/modules_handbook/shared/sales-flow-chart/closing.md) — Stage 3's paid branch (paid Project
  opportunities) and how the unpaid branch ends in Not closed.
- [Pending / Done (record contact)](/docs/modules_handbook/shared/sales-flow-chart/record-contact.md) — the one write path behind
  every human box: endpoint, who may record, queues, conflicts, re-contact window.

## What it does

The owner's three flowcharts (owner decision **D1, 2026-10-08**) drawn box for box, with a live count on every box,
and the customers behind any count listed with exactly what to do next and one **Pending / Done** pair per row (the
call recorded with one click, 2026-10-14).
The source is the owner's own page, `storage/app/workflow/PropertyLab Flow.html` (git-ignored by `storage/app/.gitignore`,
so it exists only where it was copied — Shawn's VM); the three images the owner sent are screenshots of it, and
`salesFlowOperations.js` is the committed copy of its boxes, messages and cards.

| Image stage | Name (`BUSINESS_STAGES`, My Work uses the same words) | What the image shows |
|---|---|---|
| **1** | Registration → Preview webinar | "Invite to a Preview" (human, above the landing) · landing registration → AI-call opt-in → M1 → AI call / M2 → missed-call M3 → **Human Call / Zoom (DATA 2)** → R1 reminders → Preview webinar → R2 |
| **2** | After Preview → Project webinar | Attended? → Paid (Membership)? → payment WA → auto-assign REP (DATA 3+4) → Human Zoom → R1; unpaid / no-show → WA → AI call → DATA 3 → **Human Call / Zoom (DATA 4)** → R1 → Project webinar |
| **3** | After Project webinar → Closing | Attended? → Paid (Project fee)? → payment WA → auto-assign REP (DATA 5) → Human Zoom → Closing; unpaid / no-show → WA → AI → DATA 3 → **Human Call / Zoom (DATA 4)** → Closing → Won / Not closed (+ reason) |

Rules the chart encodes (all owner decisions; see the [Funnel Journey handbook](/docs/modules_handbook/manage/leads/funnel-journey/readMe.md)):

- Every answered AI call still needs a colleague's human contact (owner, 2026-10-08 morning).
- A customer a **colleague** registered (agreed-Session form, From Preview, admin add, CSV import) starts **no
  automation**: no AI call, no M2, no automatic task, no M1 — except **From Preview**, which still sends the
  Session's own welcome WhatsApp with the Zoom link. They wait in the R1 box and are **not** human work (D2).
- Every human box can record a contact; on a paid **service** step a contact never completes the step — only the
  real record does (D4). Stage 3's unpaid contact ends in a **closing decision** (D4b).
- Viewing, filtering and paging never create a task, a journey, a message or a call.

## How it works

### Image stages vs data boards

The image stages are the **presentation**. The counts come from three read-only **data boards**, which keep their
own names and classes:

| Board key | Class | Population |
|---|---|---|
| `preview` | `Src\Lead\Journey\PreviewJourneyBoard` | the company lead population, positioned in ONE Preview funnel |
| `project` | `Src\Lead\Journey\ProjectJourneyBoard` (+ `ProjectJourneyContexts`) | customer × Project contexts of ONE Project funnel |
| `closing` | `Src\Lead\Journey\ClosingJourneyBoard` | company-wide paid Project opportunities (no funnel needed) — [closing.md](/docs/modules_handbook/shared/sales-flow-chart/closing.md) |

| Image stage | Company page boards (roster default first) | Preview funnel's Journey tab | Project funnel's Journey tab |
|---|---|---|---|
| 1 | `preview` | yes (its `preview` board) | link to the company page |
| 2 | `project`, `preview` | yes (`preview` chips only) | yes (`project` chips only) |
| 3 | `closing`, `project` | link to the company page | yes (`project` chips; `closing` boxes link out) |

A funnel page loads only its own board; a box whose counts live on another board, and the stage it does not feed,
link to `/manage/my-work/sales-flow?guide=live&jstage=N` (plus `jproject` from a Project funnel).

The company page picks the Project funnel named by `jproject` (any non-merged one; default: the first **active**
non-merged Project funnel, else the first non-merged one) and **only** its `candidate_source_funnel_id` as the
Preview funnel (`MyWorkController::salesFlow()`) — a Project funnel with no candidate source has no `preview` board.
A board whose funnel does not exist is `null`, and a stage none of whose boards exists falls back to the first
available stage (`flowBoard.stage`). The page draws that fallback: the URL's `jstage` is used only when one of its
boards loaded (`BUSINESS_STAGES[].boards`), else `board.stage` — never an empty Stage 1 — and the next load writes
the fallback into the URL.

Do not confuse the image stage with `FunnelJourney::flowStage()`: that number is a journey's own position and only
routes DATA points (`FunnelJourneyAnswer::pointFor()`). The image stage is which chart a box sits on.

### URL contract

| Param | Values | Notes |
|---|---|---|
| `jstage` | `1` · `2` · `3` | legacy `preview` · `project` · `closing` map to 1 · 2 · 3; anything else, or a stage with no board on the company page → the first available stage (`board.stage`), which the page then shows |
| `jboard` | `preview` · `project` · `closing` | company page only; must be one of the stage's boards, else the stage's own board |
| `jnode` | a node or reference key of that board, or `all` | **absent, empty or unknown → no roster is built (counts only)**. An unknown key (a typo, a retired node in an old link) is ignored like a missing one (2026-10-13; it used to build the whole `all` roster, the most expensive path) |
| `jpage` | ≥ 1 | 25 rows per page (`PreviewJourneyBoard::PAGE_SIZE`, shared) |
| `jduration` | `240_plus` · `120_239` · `60_119` · `under_60` · `unknown` | preview `ready` only |
| `jreadiness` | a `ReadinessColumns::AREAS` key | narrows the roster to customers missing that area |
| `jreadiness_counts` | `1` | compute the seven gap counts (otherwise only when an area is chosen) |
| `jwork` | `overdue` · `today` · `unassigned` · `suggested` | work filter, see below |
| `jowner` | a user uuid | owner filter (closing: sales owner, falling back to the account manager). An unknown uuid is ignored (`filters.owner` = `null`); the page then shows "All accessible owners", never "Selected owner" over company-wide counts |
| `jproject` | a Project funnel uuid | company page only. The filters' **Reset** clears it with the others, back to the default Project funnel (2026-10-13; it used to keep the chosen funnel) |
| `jsession` · `jfrom` · `jto` | Session uuid · `Y-m-d` | funnel page only (`FunnelsController::journeyBoard()`) |

A value sent as an array reads as "not given", never as an error page. Every filter lives in the URL, so a shared
link opens the same view; the frontend preserves `suite` on every link (`withSuite()`).

### Counts-only first paint

Both props are `Inertia::optional`: company `flowBoard`, funnel `journeyBoard`. When the prop is absent the
workspace's first request (on mount) reloads it with the URL's own j* params plus `jstage`, and **replaces** the
history entry — it only fills in this entry, so Back leaves the page instead of landing on a board-less entry that
would load and push again. Opened without `jnode` (the strip tab, My Workspace's links, a funnel's Journey tab),
every board is built with `counts_only`: nodes, references, totals, owners and Sessions are returned, but
**`roster`, `work` and `readiness` are `null`** — `JourneyWorkQueue::build()`, the readiness cohort and row
building are skipped. A URL that already has `jnode` (a shared link, a refresh) builds that roster in the first
request. Per-node open-task counts (`JourneyWorkQueue::countsForCohorts()`; closing:
`taskCounts()`) stay, because they are cheap. Counts-only is not free: the population, the Preview board's member
purchases, financial preparation and consultations, and the task counts are still read for every visible customer,
and the company page rebuilds all three boards on every `flowBoard` reload, whatever the stage.

**Memory.** The Preview and Project boards hold every customer of their funnel and every registration of its
Sessions in memory. After the legacy webinars were filed under the two sales-flow funnels
(`zoom:import-legacy-webinars`, 2026-10-14: ~10,000 registrations each) one company `flowBoard` request peaked at
~240 MB (~9 s) — past PHP-FPM's 128 MB default. Production showed "Could not count the customers" on every load
(2026-10-16); dev reproduced the failure at a 128 MB limit with the same data (prod's own log was not read). Both boards' `population()` now call `Support\BoardMemory::ensure()`, which raises
`memory_limit` to `BoardMemory::LIMIT` (512M) for that request when it is finite and lower; this covers the company
page, a funnel's Journey tab, My Workspace and the lead's Journey. If the boards outgrow it, make the population
lighter (fewer hydrated models) rather than raising the limit again.

Clicking a count chip reloads only that prop with `jstage`, `jboard` (company), `jnode`, `jpage=1` and clears
`jwork` / `jreadiness` / `jduration`; on the company page only the board named by `jboard` gets the roster filters,
the others stay counts-only. The page then scrolls to the list.

A failed load — a validation error (`onError`), a 500 or gateway timeout (`onHttpException`) or a dropped
connection (`onNetworkError`) — shows "Could not refresh the flow…" (or, before any board arrived, "Could not
count the customers…") in place of Inertia's raw error dialog; the header's Refresh tries again. Opening
**Readiness gaps** while a load is in flight asks for the gap counts as soon as that load lands. Switching stage
in place, and the stage cards' links, are built from the address bar (`window.location`), so the params written
with `replaceState` only — the lead modal's `?lead=` — survive.

```
flowBoard    = { stage: '1'|'2'|'3', board: 'preview'|'project'|'closing', filters: { owner },
                 preview_funnel: {uuid,name}|null, project_funnel: {uuid,name}|null,
                 preview: Board|null, project: Board|null, closing: Board }
journeyBoard = Board + { stage, filters: { session, owner } }
```

### Count chips

A box lists its live counts as chips (`salesFlowOperations.js`, `chips: [{ board, node, label }]`). The count key
is **`${board}:${node}`** (`countKey()`); `boardCounts()` builds the map from each loaded board's `nodes`,
`references` and `all` (the board total — `closing:all` is every active paid opportunity). A chip of a board the
page did not load is hidden, and the box shows a link to the company flow instead (`hints`); a stage's "Also in
this stage" extra chips of an unloaded board are simply hidden (no link). Chips overlap — one customer can sit in
several boxes for different Sessions or Projects — so never add them.

| Board | Nodes | References |
|---|---|---|
| `preview` | `registered` · `welcome` · `offer` (M2 sent, waiting for the click) · `ai` · `missed` · `callback` · `human` (a pending colleague call BEFORE the Preview webinar; after it a missed Preview sits in `no_show`, and only an after-webinar hand-off with no attendance verdict stays `human`) · `webinar` (registered and waiting, incl. every colleague registration) · `no_show` · `review` · `paused` · `ready` (attended any Session) · `staff` (accounts) | `ready_unpaid` · `membership_paid` · `consent_pending` · `questionnaire_pending` · `report_pending` · `consultation_pending` · `consultation_booked` · `consultation_review` · `consultation_done` |
| `project` | `eligible` · `welcome` · `ai` · `human` (a pending colleague call BEFORE the Project webinar; after it, the call sits in `attended` / `no_show`; an after-webinar hand-off with no attendance verdict stays `human`, queue `project_after_call`) · `webinar` · `no_show` · `attended` · `paid` (ends Stage 2 → Stage 3) · `won` (a deal Booked / Converted while the customer has **no** active Project fee for that Project — owner, 2026-10-13) · `lost` (a recorded Not closed, a Lost deal or a stopped journey) · `swung` (every deal on the Project ended with a Swing — owner, 2026-10-13: not a loss) · `review` | `source_ready` · `from_preview` · `direct` |
| `closing` (unit: opportunities) | `handoff` · `preparation` · `booking` · `meeting` · `closing` · `booked` · `converted` · `lost` · `swung` · `review` | `refunded` |

Where the chips sit (box → chips):

- **Stage 1** — Invite: `preview:registered` · M1: `welcome` · M2: `offer` · AI call: `ai`, `callback` · M3:
  `missed` · Human Call / Zoom: `human` · R1: `webinar` · extras: `review`, `paused`, `staff`.
  **AI 2 Rounds (2026-10-16):** the registration call is AI 2 Rounds' round 1, so the AI part reads *AI Call · Round
  1* → Picked up? → *Auto-record call notes* (+ "AI drafts an answer", DATA 1) → **Approve the answer** (HUMAN, the
  account manager on [2 Rounds AI Call](/docs/modules_handbook/manage/my-work/ai-rounds.md); not done in 6 h →
  Human Call) → **AI Call · Round 2** (explains the answer, books a time) → *Time agreed* → Human Call / Zoom. The two
  new boxes have no chips: a journey waiting for call 2 is still `ai_call_answered`, so it is counted on the AI Call
  box's `ai` chip ("AI call 1 or 2 under way") until the hand-off moves it to `human`. Newer than the owner's page.
- **Stage 2** — Payment received: `preview:membership_paid` · REP: `consent_pending`, `questionnaire_pending`,
  `report_pending`, `consultation_pending` · Human Zoom: `consultation_booked`, `consultation_review`,
  `consultation_done` · Human Call / Zoom: `preview:no_show`, `preview:ready_unpaid`, `project:eligible`,
  `project:human` · R1: `project:welcome`, `project:ai`, `project:webinar` · extras: `project:direct`,
  `preview:ready`, `project:source_ready`, `project:from_preview`, `project:review`.
- **Stage 3** — Payment received: `closing:all`, `project:paid` · REP: `closing:handoff`, `closing:preparation` ·
  Human Zoom: `closing:booking`, `closing:meeting` · Human Call / Zoom: `project:no_show`, `project:attended` ·
  Closing: `closing:closing` · Won: `closing:booked`, `closing:converted`, `project:won` ("Booked · no Project
  fee") · Not closed: `closing:lost` ("Paid · not closed"), `project:lost` ("Unpaid · not closed") · extras:
  `project:review`, `closing:swung` ("Paid · moved to another project"), `project:swung` ("Unpaid · moved to another
  project"), `closing:review`, `closing:refunded`.

**Won and Swing (owner, 2026-10-13).** A deal Booked or Converted while the customer has no active Project fee for
that Project counts as Won (`project:won`); a context WITH such a fee is `paid` (attributed to this funnel) or `review`
(paid through another funnel), and its deal is counted by the Closing board only, so nothing is counted twice. A deal that moved to another project (Engagement Swing) is never "Not closed": both boards
show it beside the Not closed box, as its own chip. Before, the Project board put a Swing under `project:lost` and a
fee-less win under `project:review`.

`project:review` is labelled **Check records** on both Stage 2 and Stage 3: it is the same count, and it holds
paid-elsewhere, unmapped and muted contexts as well as unpaid ones.

Units: preview and project count distinct **customers** (`staff` counts accounts); closing counts
**opportunities** and carries each node's distinct `customers` beside it.

### Rosters, rows and items

A roster row is one customer (closing: one opportunity, keyed `engagement:{uuid}` or `pending:{lead}:{project}`).
Every row carries `items[]` — every open task and every Session / Project obligation the customer still has on that
board — and **`items[0]` is the row's primary item**: the item for the work the row is listed under (the selected
node's context, the task a work filter picked, the first suggestion under `suggested`, a member reference's step),
else the first actionable item (it has an `action_context` or a `work.outcome_url`), else the first unfinished one
(`JourneyWorkQueue::primaryFirst()`). **`row.work` is `items[0].work`** (`primaryWork()` only appends a selected
readiness gap to its reason), so the row's one button and its text always describe the same obligation.

```
item = { key, queue, title, state, state_label, source ('task'|'record'|'candidate'), context, session, project,
         owner, due_label, work: {kind, label, href, reason, due_label, priority, task_uuid, assignee, outcome_url},
         action_context: {funnel_uuid, event_uuid, queue, project_uuid, engagement_uuid} | null,
         last_contact: {result, result_label, at, by, next_at, note, closing} | null, task_uuid, node?, outcome? }
```

- **Task items** (`JourneyWorkQueue::taskItems()`; closing: `taskItem()`) record through the task's own form:
  `work.outcome_url` is set while the task is open and the viewer holds it or may record for it
  (`LeadActionItem::canRecordOutcomeFor()`: D5, and D6 — any sales admin on a Stage 1 step of a customer still in
  Stage 1 — see [Pending / Done](/docs/modules_handbook/shared/sales-flow-chart/record-contact.md)). Their
  `action_context` is always `null`.
- **Context items** (`JourneyWorkQueue::contextItem()`) carry `action_context` only for a
  `LeadActionItem::FOLLOW_UP_QUEUES` queue and a viewer `FollowUpAccess::canRecord()` allows (D5, or D6 on a Stage 1
  step — so on the company board every sales admin sees Pending / Done on colleagues' Stage 1 customers); on the preview and
  project boards' Session / Project contexts only while the state is a suggestion, waiting or to-do (a paid member's
  preparation step keeps it only while it is the current unfinished step, `member_zoom` / `member_meeting` until the
  consultation is held; the closing record item hides its button once the step is done). A standing recorded contact replaces the suggestion and nulls the
  context (`recordedExtra()`); a lapsed one (D3) brings the suggestion back with its `last_contact`. A recorded
  **Spoke to them** or **Cannot be reached** reads done for the D3 window (2026-10-13: Cannot be reached closes the
  contact too); only system results stay "Check the recorded result".
- An open task of the same Session (and Project) covers the matching context (`coveringItem()`; a task without a
  Project covers every Project of its Session; a `human` fact is covered by any contact task of that Session).
- A `webinar` context owes no item (D2). A project `paid` context is a pointer to Stage 3, not a contact; a `won` or
  `swung` context is finished (done, badged "Won" / "Moved to another project", no Pending / Done); a `lost`
  context shows its recorded reason; `review` contexts are records to read.
- A paid member's Preview row adds the member service items: the three preparation steps (only the current one
  carries the `member_preparation` context) and then `member_zoom` / `member_meeting` — that item appears once
  preparation is complete, or earlier when a consultation record already exists.
- A closing row is its open tasks plus one **record item** for the opportunity's current step (`SERVICE_QUEUE`) —
  see [closing.md](/docs/modules_handbook/shared/sales-flow-chart/closing.md).

Fact → queue is ONE map, `JourneyWorkQueue::queueForFact()`: `registered` / `eligible` → `{prefix}_invite`;
`welcome` · `offer` · `ai` · `missed` · `callback` → `{prefix}_call`; `human` → `{prefix}_call`, or
`{prefix}_after_call` after the webinar; `no_show` → `{prefix}_no_show`; `ready` / `attended` → `{prefix}_unpaid`;
`webinar` and the rest → none. `stateForFact()` gives the state: suggestion nodes → `candidates`, tracked automation
nodes → `waiting` (untracked → `review`), `human` → `todo`, `paid` → `done` (badge "In Stage 3", only the *Continue in
Stage 3* link), `won` / `swung` → `done` (badges "Won" / "Moved to another project"), `webinar` → `waiting` (My Work
omits it).

### Work filters

`jwork` narrows the selected node's roster before pagination. `work.counts` / `customer_counts` are distinct
customers — except on the closing board, where `counts` (= `opportunity_counts`) are **opportunities** and
`customer_counts` the distinct customers behind them; `work.task_counts` are task rows for `overdue` · `today` · `unassigned` only —
a suggestion is not a task. Filters overlap. **Unassigned** = no active assignee who can still see the lead.
**Suggested** = a context that calls for contact (invite / eligible, With a colleague, no-show, Ready / attended)
with no active recorded contact (D3) and no open task covering it; on the closing board, an opportunity at a service
step with no task of its own. Only open tasks
of this funnel count: `funnel_journey_id` on this funnel's journey, or `handoff_context.funnel_id` = this funnel
(closing: tasks frozen to the opportunity, or to an unambiguous lead/Project pair).

### Pending / Done (record contact)

The row's buttons are `FunnelFollowUpButton` acting on `items[0]`: **Pending** (no answer — `result: no_answer`, the
task stays open) or **Done** (sorted — `result: reached`, it closes); nothing else to fill in (2026-10-14, it replaced
the "How did the call go?" form). A task posts to its `work.outcome_url`; a suggestion or service step posts its
`action_context` to `manage.leads.funnel-follow-up.store`. After **Done** on a contact that can end in an agreed
Session, the definition is read and, when it offers a Session, the registration modal opens. On Stage 3's unpaid
contact a Done records *Still following up*; Not closed + reason is recorded in Sales Projects (deal → Lost). Both
paths post as a plain XHR (`X-Requested-With`), so the server answers with a status — JSON `{message, closed}` on the
context path, 204 on the task path, 409 / 403 / 422 with a message the button toasts as an error — never a flash and
a redirect; the button toasts the result itself (the client `petav3:toast` event) and then reloads only the board
prop. The agreed-Session registration reloads the board prop
**and `flash`**, so "Lead added to the session." shows. Full contract:
[record-contact.md](/docs/modules_handbook/shared/sales-flow-chart/record-contact.md).

### Open in My Workspace

A human box's `queue` names the My Workspace step its "Open in My Workspace" link opens (side panel, hover / click
card, guide): `myWorkPath()` → `/manage/my-work?tab=workflow&rstage=N&rqueue=<step>[&rview=<view>][&person=<jowner>]`
(`person` only on a live board filtered to an owner). My Workspace shows all three stages on one page and **ignores
`rstage`** (kept for old links); `rqueue` selects the step. A box several steps meet in opens its **first** step —
the others sit right beside it in the Steps list:

| Box | `rqueue` |
|---|---|
| Stage 1 Invite to a Preview | `preview_invite` + **`rview=optional`** (invites are suggestions: they wait under Extra) |
| Stage 1 Human Call / Zoom | `preview_call` |
| Stage 1 Approve the answer | none — the box's `page` opens `/manage/my-work/ai-rounds` (`?person=` when filtered) |
| Stage 2 REP | `member_preparation` (then `member_zoom`) |
| Stage 2 Human Zoom | `member_meeting` |
| Stage 2 Human Call / Zoom | `preview_no_show` (then `preview_unpaid`, `preview_after_call`, `project_invite`, `project_call`) |
| Stage 3 REP | `project_handoff` (then `project_preparation`) |
| Stage 3 Human Zoom | `project_zoom` (then `project_meeting`) |
| Stage 3 Human Call / Zoom | `project_no_show` (then `project_unpaid`, `project_after_call`) |
| Stage 3 Closing | `project_close` |

### Readiness and shared preparation

The seven readiness-gap filters (`jreadiness`) apply to the selected node and duration group. Expanding a row shows
`ReadinessSummary` with the shared financial preparation; consent, financial answers and WhoPay follow the customer
across stages. Its three FPA steps open the customer's Property Portal → Financial Report tab in the lead modal
(`EngagementProgressCell` `fpa-in-place` → `open-fpa` → `leadModalTarget()`), never the lead page. See [Journey and readiness](/docs/modules_handbook/manage/leads/funnel-journey/readiness.md) and
[ReadinessSummary](/docs/modules_handbook/shared/readiness-summary/readMe.md).

### Renderer file map

All under `resources/js/Pages/Manage/MyWork/Partials/` unless noted.

| File | Role |
|---|---|
| `salesFlowOperations.js` | The three flows box for box (`STAGE1_FLOW` · `STAGE2_FLOW` · `STAGE3_FLOW`, `STAGE_FLOWS`), `BUSINESS_STAGES` (each with its data `boards`), the detail cards (`DETAILS`: M1–M4, R1/R2, AI / human / REP cards), `countKey()`, `boardCounts()`, `stageChips()`, `normalizeStage()`, `describeNode()`, `myWorkPath()`. A box: `id, kind, who, tag, title, subs, at [col,row], code, data, det, chips, queue, page, view, entry, action, completion` (`page`: a My Workspace page of its own the box opens instead of a step). |
| `salesFlowLayout.js` | Pure geometry: grid placement from `at`, right-angle edge routing between named ports, pinned detail cards in Details view. |
| `salesFlowSkin.js` | The owner page's colour tokens as whole Tailwind classes (`SKIN`, `WHO_SKIN`, `skinOf`, `LEGEND`, edge / canvas tokens), plus the stage and view tones My Workspace's Sales steps use (`STAGE_SKIN` / `stageSkin`, `VIEW_SKIN` / `viewZero`). |
| `SalesFlowNode.vue` | One box: tag, code, DATA badge, count chips (`select`), ⓘ (`inspect`), hints to the company flow. |
| `SalesFlowCanvas.vue` | One stage on its dotted canvas: SVG arrows, boxes, pinned cards; measures boxes so nothing is cut. |
| `SalesFlowMap.vue` | The stages with intro / caption / extras, the Overview · Details toggle and zoom; emits `select({board,node,id,stage})` and `inspect`. Used by the live boards and the guide tab. Hover shows a box's card in Overview only; a click / ⓘ opens it with its help (Who is here · What you do · Open in My Workspace) in both views. |
| `SalesFlowDetailCard.vue` | A box's card (message bubble, timetable, call card) — hover card, pinned card and side panel. |
| `SalesFlowStepPanel.vue` | The live board's side panel: card + Who is here · What you do · How the customer moves on + "Open in My Workspace" (`myWorkPath()`, see above; `person=<jowner>` when filtered). Drawer on a phone. |
| `SalesFlowStageCards.vue` | The three stage cards used as the stage rail; a stage this page lacks is a link. |
| `SalesJourneyWorkspace.vue` | The live workspace: stage rail → map with counts → roster (`DataTable`), filters, work filters, readiness, paging; owns `load()` (`router.reload` of the one prop). |
| `SalesOperationsBoard.vue` | Company wrapper (`company`, `flowBoard`, `flowFunnels`). |
| `Events/Funnels/Partials/Tabs/{JourneyBoardTab,FunnelJourneyWorkspace}.vue` | Funnel Journey tab wrapper (`funnel`, `journeyBoard`). |
| `Components/Leads/{JourneyContactCell,JourneyWorkCell,LastContactLine,WhatToDo}.vue` | Row cells — [Journey work cells](/docs/modules_handbook/shared/journey-work/readMe.md). |
| `Components/Leads/{FunnelFollowUpButton,FunnelSessionRegistrationModal}.vue` | Pending / Done (record contact) — [record-contact.md](/docs/modules_handbook/shared/sales-flow-chart/record-contact.md). |

The per-lead chart on a lead's Sales → Journey tab is **not** this renderer: it still draws the older dagre
`SalesFlowChart.vue` from `FLOW_CHART` in `salesFlowGuide.js`, painted by `SalesFlowChartPath` (see the
[Funnel Journey handbook](/docs/modules_handbook/manage/leads/funnel-journey/readMe.md) §6). Moving it onto the image
renderer is an open item.

### Permissions and scope

- `LeadVisibility` scopes every count and row; `GroupScope` scopes Projects. `jowner` narrows inside the viewer's
  visibility, never widens it.
- Event links need an Events permission; the conversion-notification shortcut needs `view-leads-all`,
  `view-integrations` and `manage-integrations`.
- Write targets come only from the server (`action_context`, `outcome_url`); the backend re-checks everything
  ([record-contact.md](/docs/modules_handbook/shared/sales-flow-chart/record-contact.md)).

## Reference usage

The funnel Journey tab is the canonical consumer: `Events/Funnels/Partials/Tabs/FunnelJourneyWorkspace.vue` mounts
`SalesJourneyWorkspace` with `funnel` and the optional `journeyBoard` prop, and the controller side is
`FunnelsController::journeyBoard()` (filters → `PreviewJourneyBoard` / `ProjectJourneyBoard` `build()`). The company
page does the same through `SalesOperationsBoard.vue` + `MyWorkController::salesFlow()`.

- Pass the server board; never derive a count from a paginated roster.
- A new box goes in `salesFlowOperations.js`, and its chips must name existing board keys (`${board}:${node}`).
  Attendance, payment, task ownership and opportunity classification stay in the PHP boards.
- A new human queue needs `LeadActionItem::*_QUEUES`, `MyWorkResponsibilities::QUEUES` and
  `JourneyWorkQueue::queueForFact()` together; the button never guesses a write target from a box.

## Related files

- Backend: `src/Lead/Journey/{PreviewJourneyBoard,ProjectJourneyBoard,ProjectJourneyContexts,ClosingJourneyBoard,JourneyWorkQueue,JourneyReadiness}.php`,
  `src/Lead/Journey/Support/BoardMemory.php` (the per-request memory raise),
  `src/Lead/Services/FunnelFollowUpState.php`, `src/Lead/Support/FollowUpAccess.php`,
  `app/Http/Controllers/Manage/MyWorkController.php` (`salesFlow`),
  `app/Http/Controllers/Manage/Events/FunnelsController.php` (`journeyBoard`).
- Frontend: the renderer file map above; `resources/js/Pages/Manage/MyWork/SalesFlow.vue` (guide tabs).
- Tests: `tests/Feature/Lead/{PreviewJourneyBoardTest,ProjectJourneyBoardTest,ClosingJourneyBoardTest,JourneyWorkQueueTest,FunnelFollowUpTest}.php`,
  `tests/Feature/Manage/SalesFlowScopeTest.php`, `tests/Unit/Lead/SalesFlowChartPathTest.php` (pins `FLOW_CHART`'s
  ids / bands / edges); vitest `MyWork/Partials/SalesOperationsBoard.test.js`, `MyWork/Partials/SalesFlowChart.test.js`
  (the per-lead chart and `SalesFlowMap`: stage drawing, chips, elsewhere hints, Details view),
  `Events/Funnels/Partials/Tabs/FunnelJourneyWorkspace.test.js`, `Components/Leads/FunnelFollowUpButton.test.js`.
- Routes: `manage.my-work.sales-flow`, `manage.events.funnels.show`, `manage.leads.funnel-follow-up.{show,store}`.
