# Pending / Done — recording a sales-flow contact

Part of the [Sales flow chart](/docs/modules_handbook/shared/sales-flow-chart/readMe.md). This file is the ONE home
of the write path behind every human box; the Funnel Journey, My Work and Leads handbooks link here.

## What it does

A colleague contacts a customer and records **what happened** against one precise obligation —
*lead · funnel · Session · Project · responsibility queue* — whether or not a task exists for it. Owner decisions
of 2026-10-08:

- **D3** — a recorded contact on a *suggestion* with no agreed next date returns as a suggestion after
  `config('funnel_journey.recontact_after_days')` days (env `FUNNEL_RECONTACT_AFTER_DAYS`, default 30). An agreed
  date is a follow-up task on that date. "Not closed" never returns.
- **D4** — every human box records a contact, including paid service steps and every Stage 3 step. On a service step
  a contact **never completes the step**; it shows as **Last contact**; the step completes when its real record exists
  (consent / WhoPay saved, Zoom booked, deal closed). **D4b** — Stage 3's unpaid contact stores a closing decision on
  the outcome; since 2026-10-14 the buttons never post one, so a **Done** there records *Still following up* by
  itself, and **Not closed + reason is recorded only in Sales Projects** (deal → Lost + reason), never on the call.
- **D5** — the lead's account manager, the opportunity's sales owner, a holder of the task and super admins may
  record; whoever records it, everyone's My Work and every board treat the obligation as recorded.
- **One click (owner + Shawn, 2026-10-14).** Every sales-flow call is recorded with ONE click — **Pending** (tried,
  no answer → `result: no_answer`, the task stays open) or **Done** (sorted → `result: reached`, the task closes).
  No questions, no note, no date: the "How did the call go?" form (`HandoffOutcomeModal`) is gone. The outcome
  record (`lead_action_item_outcomes`, `HandoffOutcome`, `FunnelFollowUpState`) stays — it is how *Last contact*,
  Help team and the boards know someone called. See [The buttons](#the-buttons--pending--done).
- **D6 (owner, 2026-10-11) — Stage 1 is open.** Leads still get an account manager by the company round robin, but
  **any sales admin** who can see the lead may record a **Stage 1** step — `preview_invite` or `preview_call` (the
  queues `MyWorkResponsibilities::QUEUES` puts in stage `'1'`; NOT every `preview_*`) — of a customer who is **still
  in Stage 1**. Stage 2 and 3 keep D5. Colleagues find the ones who need help — overdue calls, and new customers
  nobody has contacted for 3 days (whose button is this invitation) — on My Work's **Help team** list (D10, see the
  [My Work handbook](/docs/modules_handbook/manage/my-work/readMe.md)).

Two entry points, one recorder (`HandoffOutcome::record()`):

| Path | Routes | Used for |
|---|---|---|
| **Task** | `GET` / `POST /manage/leads/{lead}/action-items/{item}/outcome` — `manage.leads.action-items.outcome.form` / `.outcome.store` → `ActionItemsController::outcomeForm()` / `outcome()`, `OutcomeRequest` | an existing open sales-flow task (an automation hand-off, a recorded "No answer", an agreed follow-up, the REP's Zoom task) — the item's `work.outcome_url` |
| **Context** | `GET` / `POST /manage/leads/{lead}/funnel-follow-up` — `manage.leads.funnel-follow-up.show` / `.store` → `FunnelFollowUpController`, `FollowUpContextRequest` / `FollowUpOutcomeRequest`, `FunnelFollowUpRepository` | a suggestion with no task, a customer without a journey, a paid service step — the item's `action_context` |

Both route groups require `permission:viewLeadsAny`; everything else is checked in the controller and again under
lock in the repository.

## How it works

### Queues

`Src\Lead\LeadActionItem` holds the lists; `MyWorkResponsibilities::QUEUES` gives each queue its image stage, title,
instructions and completion line.

| Constant | Queues | Meaning |
|---|---|---|
| `CONTACT_QUEUES` | `preview_invite` · `preview_call` · `preview_no_show` · `preview_unpaid` · `preview_after_call` · `project_invite` · `project_call` · `project_no_show` · `project_unpaid` · `project_after_call` | a human contact around a Session |
| `SERVICE_QUEUES` | `member_preparation` · `member_zoom` · `member_meeting` · `project_handoff` · `project_preparation` · `project_zoom` · `project_meeting` · `project_close` | a paid service step; completes only from its real record |
| `FOLLOW_UP_QUEUES` | both of the above | finished through a recorded outcome, never ticked |
| `SUGGESTION_QUEUES` | `preview_invite` · `preview_no_show` · `preview_unpaid` · `project_invite` · `project_no_show` · `project_unpaid` | a recorded outcome suppresses the suggestion until the D3 window passes |
| `CLOSING_DECISION_QUEUES` | `project_no_show` · `project_unpaid` · `project_after_call` | the outcome carries a closing decision (D4b) — a Done records *Still following up*; Not closed is recorded in Sales Projects |

### The buttons — Pending / Done

`Components/Leads/FunnelFollowUpButton.vue` renders two buttons wherever a salesperson records a sales-flow call (the
roster's Work cell, My Work's Sales steps and Action Item rows, the lead's Action items panel):

| Button | Posts | Effect | Toast |
|---|---|---|---|
| **Pending** (outline, amber text) | `{ result: 'no_answer' }` | the task stays open, rescheduled for another try | "Marked Pending. Call again later." |
| **Done** (solid emerald) | `{ result: 'reached' }` | the task closes ("Spoke to them" in the outcome record) | "Marked Done." |

- Nothing else is posted on the task path; the context path adds the context fields and a fresh `submission_uuid`
  per click. No `note`, `answers`, `appointment_at` or `closing_decision` — both endpoints accept that
  (`OutcomeRequest`; `FollowUpOutcomeRequest`'s note is optional since 2026-10-14). *Cannot be reached*
  (`unreachable`) is no longer offered by any button; the endpoints still accept it.
- Both buttons are disabled while one saves. A refusal (409 already done, 422, 403) is an error toast with the
  server's message, and nothing reloads.
- Accessible names are `Pending: <item title>` / `Done: <item title>`. `size` — `'sm'` (default, compact, for table
  cells) or `'md'` (44px touch target, for My Work rows and the lead page).
- Paid service steps (`member_*`, `project_handoff` / `_preparation` / `_zoom` / `_meeting` / `_close`) still record a
  contact through the same buttons, but a contact never completes them (D4).

### Who may record (D5 + D6)

ONE rule, `Src\Lead\Support\FollowUpAccess::canRecord($viewer, $lead, $salesOwnerId, $queue)` — every button and
both endpoints go through it, so a button never leads to a 403:

- **Super admin** — always.
- **D5** — the lead's account manager (`leads.assigned_admin_id`) or the paid opportunity's sales owner
  (`LeadActionItem::salesOwnerOf()`: `zoom_closer_id`, else the closer assignment), on any step, while they can see
  the lead (`LeadVisibility::allows`).
- **D6** — anyone else only when ALL of these hold:
  1. they are a **sales admin** (`FollowUpAccess::isSalesAdmin()`: active, a manage role, `sales-execution` — the
     round robin's "sales staff" marker; a super admin counts);
  2. the step is a **Stage 1 step** (`isOpenQueue()`: `QUEUES[$q][0] === '1'` → `preview_invite`, `preview_call`);
  3. they can **see the lead** (`LeadVisibility::allows`) — so a viewer who cannot see it never gets a button;
  4. the customer is **still in Stage 1** (`inStageOne()` / batch `stageOneLeadIds()`, primed for a page with
     `rememberStageOne()`): no attended Session in a Preview funnel, no registration in a Project funnel, no Membership
     or Project fee ever paid (active or refunded). A **missed** Preview ends Stage 1 only while it is the customer's
     LATEST registration in that funnel — re-booked on a later Session they owe the Stage 1 call again, the same rule
     as `PreviewJourneyBoard::contexts()`. An open deal does **not** count — one opens at a customer's first project enquiry (e.g. an inbound
     WhatsApp), which would close Stage 1 to the team for most new leads.
- **`$queue` is always the step as the SERVER derived it**, never a request's queue name: a board fact
  (`queueForFact()`), a task's frozen step (`LeadActionItem::followUpQueue()` = its `responsibility_queue`, else
  `JourneyWorkQueue::queueForTask()` of its journey; null without either), or — on the context path — the posted step
  re-checked by `JourneyWorkQueue::owedOpenQueue()`: the context's Stage 1 step counts only when the customer owes it
  **right now** on that Preview funnel, from the same `PreviewJourneyBoard::population()` + `contexts()` the boards and
  My Work build their buttons from (same Session; a `webinar` context owes nothing). Why both checks: `preview_invite`
  needs no Session, so a queue-name rule would let anyone record an "invite" on a Stage 3 customer (blocked by 4.), and
  a Stage 1 customer already registered for a Session owes no invitation (blocked by `owedOpenQueue()`). A closure
  may be passed for `$queue`; it is resolved only when D6 is reached (a task's step can cost a journey read), and a
  task first asks `LeadActionItem::mayBeOpenStage()` (no query: a named non-Stage-1 step, a Zoom, paid or
  after-webinar task never is), so the journey is read only when it could matter. The Closing board passes the step
  it already knows.
- A task: `LeadActionItem::canRecordOutcomeFor($viewer, $lead, $queue = null)` = a holder of the task, else
  `canRecord()` with the opportunity frozen on the task — and D6 only while the task is **OPEN**. It gates the task
  path's POST and the lead's Action items panel (`can_toggle`, via `canRecordAsResponsible()`, which now resolves the
  signed-in viewer and applies the same rule). It also gates **done / reopen** of a sales-flow task
  (`ActionItemsController::guardGeneratedChecklistAssignee()`): done is refused for every sales-flow task anyway, and a
  closed task opens to nobody new, so **reopen stays D5**. Ordinary tasks keep `canToggleFor()` — unchanged.
- The boards, My Work (incl. Help team and a leader's *Tasks nobody holds*, `MyWorkBoard::taskRows()`) only send an
  `action_context` / `outcome_url` to someone these rules allow; the endpoints re-check (403), the context path again
  under the lock in `FunnelFollowUpRepository::record()`.
- **What a colleague's record does NOT do:** it never hands the lead over (`assignees_become_reps => false`), sends no
  phone notification and moves no account manager. The account manager sees it as the step's **Last contact … by
  <name>** (`FunnelFollowUpState`) on My Work — on a fact item and, since 2026-10-11, on a task item they hold — and as
  the "📞 电话回报" Discussion line on the lead (Spoke to them / Cannot be reached). Gap: a **No answer** on an
  automation hand-off task is not a "recorded contact" in `FunnelFollowUpState` (only a closed one with a human result
  is), so it shows only in that task's attempts and the lead's Action items — unless another task on the same
  obligation key is recorded: then *Last contact* is the newest human result across ALL tasks of that key, this No
  answer included.
- **Done is refused for every sales-flow task** (`LeadActionItem::hasFunnelOutcome()`): `POST …/action-items/{item}/done`
  answers "Record the contact outcome to finish this follow-up." (409 for plain AJAX, flash + back for Inertia), and
  My Work offers `outcome_url` instead of `done_url`.

### Context path — resolving the context

`FunnelFollowUpController::context()` re-reads every id from the current records; a chart payload is never trusted.
Input: `queue`, `funnel_uuid`, `event_uuid`, `project_uuid`, `engagement_uuid`.

- **Lead** — by uuid, not staff, visible to the viewer (403).
- **Funnel** — required except for the paid Project service queues (`FollowUpContextRequest::projectServiceQueues()`),
  which **ignore** a sent funnel. It must be live (a merged funnel 404s) and of the queue's kind: `project_*` → a
  Project funnel, `preview_*` / `member_*` → a Preview funnel (422).
- **`member_*`** — needs an active Membership purchase (422). No Session or Project.
- **Project service** — `project_uuid` required, inside the viewer's `GroupScope`; needs an active Project fee for
  that Project (422). The opportunity is the named one (it must be this customer's for that Project, 422), else the
  canonical oldest.
- **Contact queues** — `event_uuid` must be a Session of that funnel (an unknown Session, or one of another funnel, is
  a 404) the customer is registered on (no registration → 422). Every queue but `*_invite` needs a Session; `*_no_show` needs a no-show registration, `*_unpaid` an attended one; the
  after-webinar queues (`*_no_show`, `*_unpaid`, `*_after_call`) refuse a Session still upcoming or live. An optional
  `project_uuid` is refused on `preview_*`, and must be on the Session's offer (its own offer snapshot, else its
  Slot's active offer) or paid at that Session; a named `engagement_uuid` must be this customer's for that Project.
- **Access** — `FollowUpAccess::canRecord()` with the opportunity's sales owner and, for D6, the posted step only as
  `JourneyWorkQueue::owedOpenQueue()` confirms it (403).

The stored context (`lead_action_items.handoff_context`) is `funnel_id`, `event_id`, `event_series_id`,
`registration_id`, `project_id`, `engagement_id`, `responsibility_queue` and `phase` —
`FunnelQuestionSet::MOMENT_PAID` for service queues, `MOMENT_AFTER` for the after-webinar queues, else
`MOMENT_BEFORE`.

### The definition (GET)

Nothing shows a form any more. The button reads this definition only **after a Done on a registering queue**, to offer
the agreed Session (see below). `HandoffOutcome::followUpForm()` = the hand-off definition plus the step's guidance:

```
{ results: [{value, label, hint, color, closes}],      // reached · no_answer · unreachable (system results never offered)
  questions: [...], data_point: {code, name, moment} | null,
  closing: { enabled, default: 'following', decisions: [{value, label}], reasons: [{value, label}] },
  attempts: [...], session: {title, starts_at, can_mute, is_muted} | null,
  queue, instructions, completion,                      // MyWorkResponsibilities::QUEUES
  note_required,                                        // legacy: the context path still says true, but no note is
                                                        // required since 2026-10-14 and nothing reads it
  can_register, register_reason, sessions: [{uuid, title, starts_at, slot, funnel_uuid, funnel_name}] }
```

The task path returns the same extras when the task's queue — its explicit `responsibility_queue`, else
`JourneyWorkQueue::queueForTask()` of its frozen Session and phase — is a `FOLLOW_UP_QUEUES` queue; any other
hand-off gets the plain `HandoffOutcome::form()`.

Questions (`HandoffQuestions::for()`): the Session's Slot question set for the moment, else that Slot's AI-profile
fields (`aiQuestions()` — on a Preview funnel supplemented by the Stage 1 Needs pack, and always filtered and ordered by
`funnel_journey.outcome_fields`; a paid moment WITH a Slot falls back to these too). Without a Session: a Preview
contact → the Stage 1 Needs pack; a Project contact or a paid-moment contact (every service step) → none — the note is
the record.

### Recording (POST)

Body: `result` (`reached` · `no_answer` · `unreachable`), `answers{}`, `join_next_time`, `appointment_at` (today or
later), `note`, `closing_decision` (`following` · `not_closed` — only after `reached`, only on a closing-decision
queue), `lost_reason_code` (an `Engagement::LOST_REASONS` key; required with `not_closed`, refused otherwise). An
agreed `appointment_at` is refused together with `not_closed`. The context path also posts the context fields and a
`submission_uuid` (the button mints a fresh one per click). Every field but `result` (and the context path's context +
`submission_uuid`) is optional on both paths — the one-click buttons post only those.

`FunnelFollowUpRepository::record()`, in one transaction:

1. Lock the customer's journey on that funnel (if any), then the lead; re-check visibility and access (the same
   `canRecord()` + `owedOpenQueue()` as the controller).
2. **Replay** — a task on this lead already carrying the same `submission_uuid`: the actor must hold it (403) and
   every context key must match (409 "This submission belongs to a different follow-up."); its first outcome is
   returned and nothing new is written. A double submit records once.
3. **A paid service step with an OPEN recorded task** (an earlier "No answer", or an agreed follow-up — a task whose
   own `responsibility_queue` is this step, under the same obligation key) — the outcome is recorded **on that task**
   (`openServiceTask()`), when `canRecordOutcomeFor()` allows the actor; nothing new is created (2026-10-13 — each
   "No answer" used to leave one more open task). The REP's automation "book the Zoom" task has no queue and is never
   used. ⚠️ The submission is not stored on a continued task, so a retried submission there is not de-duplicated.
4. **Conflicts** — below.
5. Otherwise create ONE task: assigned to the actor only and `assignees_become_reps => false` (recording never hands
   the lead over), body = the queue's title and instructions, a Call due today, topic Relationship,
   `funnel_journey_id` = the customer's journey on that funnel — none for service queues, without a funnel, or
   **without a Session** (an invitation: linked to the journey, its outcome read as "about the journey's current
   Session" and could move a *With a colleague* journey to *Colleague called* while the real call task stayed open;
   its answers still file against the funnel), `handoff_kind = call`, `handoff_context` = the context +
   `submission_uuid`.
6. `HandoffOutcome::record()` on it — the same recorder as the task path:
   - **Spoke to them** (the Done button) / **Cannot be reached** close the task; a closing result posts the "📞 电话回报" Discussion line and
     fires the usual `actionItemDone` hook (the journey's box guard decides whether it moves).
   - **No answer** (the Pending button) keeps the task open, rescheduled to tomorrow (today when the webinar is within a day): the
     obligation is now RETRY and is continued on that task.
   - An agreed `appointment_at` creates a follow-up task for the actor on that date with the same context plus
     `followup_at` — no Calendar or Zoom record.
   - "Join next time" mutes that Session's reminders while it is still ahead.
   - The closing decision is stored on the outcome row (`closing_decision`, `lost_reason_code`); without one, a reached
     contact on a closing-decision queue stores `CLOSING_FOLLOWING`.

The response is JSON `{message, closed}`; the flash is set **only for a non-AJAX request** (2026-10-13).
`FunnelFollowUpButton` posts BOTH paths with `X-Requested-With: XMLHttpRequest` and shows its own toast (the global
`petav3:toast` event) — the fixed words of the clicked button, or the server's message on a refusal; a flash as well
would repeat it after My Work's full reload. The task path's `outcome()` answers a plain XHR with **204** and refuses a
task closed meanwhile with **409** "This task is already done."; an Inertia visit gets a flash and `back()` instead
(`ActionItemsController::isPlainAjax()`). It calls the same recorder.

### Conflict rules (`FunnelFollowUpRepository::guardConflict()`)

- **Service queues never conflict.** A contact never completes a service step, so an open REP "book the Zoom" task
  does not block another contact and is left untouched; an earlier No answer is continued (step 3 above), not
  refused.
- **Any other queue:** an OPEN sales-flow task under the same obligation key — a recorded one, or the automation's
  hand-off keyed by its frozen Session and phase — or under the Project-less key → 409 "This follow-up already has an
  open task. Open that task and record the outcome there." **A record without a Project** is about every Project of
  its Session, so an open task of the same lead / funnel / Session / step on **any** Project blocks it too
  (2026-10-13; before, only the Project-less key was checked and a second task was written beside the open Project
  one). The surfaces offer that task's `outcome_url` instead — on a Stage 1 step to any sales admin too (D6), so a
  colleague's "No answer" can be continued by the next colleague.
- Nothing claims a customer while somebody is calling: `preview_call` is not a suggestion queue, so once a record is
  closed another colleague's record is accepted (a second task, outcome and Discussion line). Only the records are
  de-duplicated.
- **`SUGGESTION_QUEUES`:** an active recorded contact (D3) → 409 "…can be recorded again after N days, or on the agreed
  follow-up"; a recorded Not closed → 409 with its own message.
- The other contact queues (`preview_call`, `preview_after_call`, `project_call`, `project_after_call`) may be recorded
  again once nothing is open. On `project_after_call` (a closing-decision queue that is not a suggestion queue) a later
  explicit **Still following up** can therefore reopen a recorded **Not closed**: `FunnelFollowUpState` reads the
  newest outcome carrying a closing decision, so the newest decision wins. Only a **Spoke to them** carries a decision
  (`HandoffOutcome::record()`), so a No answer or Cannot be reached never reopens it.

### `FunnelFollowUpState` — what the boards and My Work read

`Src\Lead\Services\FunnelFollowUpState::forLeads($leadIds)` (ids or a sub-query) returns recorded human work keyed by
obligation:

- **Key** `lead:funnel:event:project:queue` (missing ids = 0). Member service is per customer (`lead:0:0:0:queue`);
  paid Project service is per Project (`lead:0:0:project:queue`). `find()` reads the exact key, then the Project-less
  one: a task without a Project covers every Project of its Session.
- **Tasks read** — every task with a `responsibility_queue` or a `funnel_journey_id`, open or closed. Recorded tasks
  key by their context; automation hand-offs key by `JourneyWorkQueue::queueForTask()` on their frozen Session. An
  automation task counts as recorded only when DONE with a reached / unreachable outcome; nobody recorded → no state.
- **Value** — `state` DONE (reached) · SCHEDULED (open, e.g. an agreed follow-up) · RETRY (open after No answer) ·
  REVIEW (unreachable and the rest); `active`; `task` (the open one, else the latest); `outcome`; `label`
  (`Not closed · {reason}` when not closed); `last_contact` = `{result, result_label, at, by, next_at, note (≤160
  chars), closing}` from the latest human result on the key; `closing` = `{decision: 'not_closed', reason_code,
  reason_label}` or null.
- **`active` (D3)** — true while a task is open, a Not closed is recorded, or an agreed next contact is in the future;
  otherwise the latest outcome must be younger than `recontact_after_days` (at least 1).

How the surfaces apply it (`JourneyWorkQueue::recordedExtra()`, `MyWorkResponsibilities`):

- an active record replaces the suggestion with the recorded state and drops its `action_context`;
- a lapsed record on a suggestion queue brings the suggestion back, carrying its `last_contact`;
- a service step only gains `last_contact`; a closed recorded service task never shows as a completed step;
- an open task somebody else left on the obligation gives an `outcome_url` to anyone `canRecordOutcomeFor()` allows
  (D5; D6 on a Stage 1 step);
- who recorded it does not matter: the key has no person in it.

### Agreed-Session registration after the call

`Src\Event\Support\WorkflowSessions`:

- `registersFor()` — `preview_invite`, `preview_no_show`, `preview_unpaid`, `preview_after_call`, `project_invite`,
  `project_no_show`, `project_unpaid`, `project_after_call`; service steps never.
- `funnelsFor()` — the contact's own funnel (of the queue's kind); after a Preview (`preview_no_show` / `_unpaid` /
  `_after_call`) also the Project funnels this Preview feeds (`candidate_source_funnel_id`, live, Project kind) — the
  image's "reminds the lead to join the Project webinar".
- `eligibleSessions()` — active, unmerged funnels; scheduled Sessions dated today or later that start in the future
  and are still upcoming, on an active Session-type Slot of the same funnel; the customer is not registered there and
  was not removed from it; funnels where they already hold an upcoming registration are skipped (no doubled reminders).
- `can_register` = the queue registers, the viewer has `manage-events`, the contact has a live funnel, and a Session
  is offered; otherwise `register_reason` says why.

After **Done** on a registering queue (the context's `queue`; a task path that does not name its queue always asks),
`FunnelFollowUpButton` GETs the definition above and, when it offers a Session (`can_register` with `sessions`),
opens `FunnelSessionRegistrationModal`: the Sessions grouped by funnel, plus a required "the customer agreed" tick.
The person may close it ("Not now"); the page then reloads once. When no Session is offered (or the read fails — the
call is already recorded) it just reloads; the `register_reason` is no longer shown (2026-10-14). It posts `POST /manage/events/registrations` with `{event, lead_uuid,
workflow_funnel_uuid: the chosen Session's funnel, customer_agreed: true}`. `RegistrationStoreRequest`'s workflow
variant needs `manage-events`, a visible non-staff lead, and re-validates the Session with `WorkflowSessions`.
`RegistrationsController::store()` registers as `SOURCE_ADMIN` with `restoreRemoved: false` (a removed registration
is never silently restored — that stays the Session's explicit **Add lead**), sends the ticket, logs
`{source: 'workflow', agreed: true, funnel_uuid, event_uuid}` on the activity trail and syncs Zoom. **It starts no
automation (D2)**: no journey, no AI call, no task — the customer waits in the R1 box.

### Answers without a journey → readiness

Most context-path customers have no automation journey (historical registrants, invitations, member service).
`HandoffQuestions::journeyForTask()` builds an unsaved journey projection from the context's funnel, Session and phase,
so the form asks the right questions and `FunnelJourneyAnswerRepository` files the answers with `funnel_journey_id =
null` and `event_funnel_id` = the funnel — migration `2026_10_08_191000_allow_funnel_journey_answers_without_journey`
(existing rows copy their journey's funnel). Readiness reads answers by `lead_id`
(`ReadinessColumns::answered()`), so they are amber evidence like any DATA answer, and a reached colleague call is
Relationship evidence. A context with no funnel (paid Project service) has no questions and files nothing; the note
and the Discussion line are the record.

## Reference usage

`Components/Leads/JourneyWorkCell.vue` (a roster row's Work cell) is the canonical caller: it mounts
`FunnelFollowUpButton` with the row's `lead`, `:context="item.action_context"`, `:task="item.work"` (its
`outcome_url`), `:item-title="item.title"` and the board's `reload-only`. The button builds the URL from
`task.outcome_url`, else from a context with a `queue` and a `funnel_uuid` or `project_uuid`; renders nothing without
one; posts through the item's own path; then opens the registration modal or reloads only the board prop (it emits
`saved` first). My Work's `ResponsibilityItem.vue` uses it the same way. A plain task needs only its URL —
`:task="{ outcome_url }"`, as My Work's Action Item tab and the lead's `ActionItemsPanel.vue` pass it (`size="sm"`; the
panel also refreshes the lead quick-view modal on `saved`); add `queue` to the task when known to save the definition
read after a Done. `size="md"` for a row read on a phone. The `label` prop is still accepted and ignored. Never build an
`action_context` in the browser.

## Related files

- Backend: `app/Http/Controllers/Manage/Leads/{FunnelFollowUpController,ActionItemsController}.php`,
  `app/Http/Requests/Manage/Leads/ActionItems/{FollowUpContextRequest,FollowUpOutcomeRequest,OutcomeRequest}.php`,
  `src/Lead/Repositories/FunnelFollowUpRepository.php`, `src/Lead/Journey/HandoffOutcome.php`,
  `src/Lead/Journey/Support/HandoffQuestions.php`, `src/Lead/Services/FunnelFollowUpState.php`,
  `src/Lead/Support/FollowUpAccess.php` (the rule, D5 + D6), `src/Lead/Journey/JourneyWorkQueue.php` (`owedOpenQueue()`,
  `actionContext()`), `src/Lead/{LeadActionItem,LeadActionItemOutcome}.php`,
  `src/Event/Support/WorkflowSessions.php`, `app/Http/Requests/Manage/Events/RegistrationStoreRequest.php`,
  `app/Http/Controllers/Manage/Events/RegistrationsController.php` (`store`),
  `src/Lead/Journey/Repositories/FunnelJourneyAnswerRepository.php`, `config/funnel_journey.php` (`recontact_after_days`).
- Frontend: `resources/js/Components/Leads/{FunnelFollowUpButton,FunnelSessionRegistrationModal,LastContactLine}.vue`
  (`HandoffOutcomeModal.vue` — the "How did the call go?" form — was deleted 2026-10-14),
  `resources/js/Pages/Manage/MyWork/Index.vue` (Action Item tab),
  `resources/js/Pages/Manage/Leads/Partials/Tabs/ActionItemsPanel.vue`.
- Migrations: `2026_10_08_190000_add_closing_decision_to_lead_action_item_outcomes.php`,
  `2026_10_08_191000_allow_funnel_journey_answers_without_journey.php` (and `2026_10_08_150000_add_handoff_context_to_lead_action_items.php`).
- Routes: `manage.leads.funnel-follow-up.{show,store}`, `manage.leads.action-items.outcome.{form,store}`,
  `manage.events.registrations.store`.
- Tests: `tests/Feature/Lead/FunnelFollowUpTest.php` (D6: `test_any_sales_admin_records_a_stage_one_contact_but_only_for_a_customer_still_in_stage_one`,
  `test_a_colleague_continues_a_stage_one_no_answer_and_the_account_manager_sees_who_called`; 2026-10-13:
  `test_an_invitation_without_a_session_never_moves_the_customers_journey`,
  `test_a_record_without_a_project_waits_for_an_open_task_on_any_project_of_the_session`,
  `test_a_second_contact_on_a_paid_service_step_continues_its_open_task`; 2026-10-14:
  `test_one_click_pending_and_done_record_a_contact_without_a_note`),
  `tests/Feature/Manage/MyWorkTest.php` (Help team), `tests/Feature/Event/WorkflowSessionRegistrationTest.php`,
  `tests/Unit/Lead/ActionItemCompletionAuthorizationTest.php` (Stage 2 stays D5), vitest `Components/Leads/FunnelFollowUpButton.test.js`.
