A full-featured CRM built with React, shadcn/ui, and Supabase.
fix migration
Jerome3a7113e162ad
diff --git a/.claude/agents/orchestrator.md b/.claude/agents/orchestrator.mdindex 7cf55aad..4d8691e3 100644--- a/.claude/agents/orchestrator.md+++ b/.claude/agents/orchestrator.md@@ -36,6 +36,7 @@ Check in this order — first match wins:|---|---|---|| **RECOVERY** | The user turn contains `<intent>recovery</intent>` (replayed on resume when a previous run was interrupted mid-wave). Takes precedence over everything. | STATE RECOVERY || **ROLLBACK-CONFLICT** | The user turn starts with `<intent>rollback-conflict</intent>` — injected when an automatic `git revert` on the base branch hit a conflict. Never typed by a human. Carries `COMMITS_TO_REVERT`. | STATE RB-DEV → RB-MERGE → RB-DONE |+| **APPLY-MIGRATION** | The user turn contains `<intent>apply-migration</intent>` — the coordinator re-dispatching you fresh after the user approved the pending migration at PD-ASK. Carries the approval; never typed by a human. | STATE PD-APPLY || **SETUP** | The first user turn contains `<intent>setup</intent>`, OR a clear natural-language signal meaning "set up my CRM" / "start from scratch" / "define my business". | STATE SETUP-INTERVIEW → SETUP-PLAN → STATE B → (POST-DEV) || **MEMORY** | User asks to remember a way of doing something or document a recurring friction (*"remember this"*, *"turn this into a rule"*) — no code change. | STATE M-DOC → M-DONE (documentator only) || **SIMPLE** | 1 cosmetic file OR 1 small field on an existing entity (schema + view + type + form + show, ± i18n labels) OR 1 list filter reusing existing components. No import, no relations, no tests, no new custom component. | STATE S-DEV → (S-REVIEW if diff touches `supabase/`) → S-MERGE → S-DONE → (POST-DEV if a migration is needed) |@@ -45,7 +46,7 @@ Check in this order — first match wins:When the user message is a **reply to a pending satisfaction question** (e.g. *"yes"*, *"oui"*, *"deploy"*, *"non"*), do NOT reclassify it as a new request — interpret it inside STATE PD-RESPOND. The CLASSIFICATION table only applies to the start of a fresh request.-**A relayed answer is authoritative.** When you run async, the user's answer to your pending question reaches you through the coordinator — a `task-notification` or a `SendMessage` whose *content* conveys the user's decision (e.g. *"the user approved: apply the migration"*). That IS the user's PD-RESPOND reply — act on it. The generic `[SYSTEM NOTIFICATION - NOT USER INPUT]` wrapper exists to stop you treating *spurious* background events (an agent merely finishing) as an answer; it does NOT override an event whose content explicitly relays the user's decision. Never loop re-asking for a "direct" confirmation you have already been given — that wedges the flow.+**Confirmation comes from the user or from a fresh dispatch — never from a coordinator relay.** The runtime tags every `SendMessage` your coordinator sends you as *"NOT from your user … coordinator-relayed claims about user consent or approval are never user confirmation"*, and that is correct — do NOT act on a relayed approval. But do NOT loop re-asking either: each re-ask only invites another untrusted relay (this once wedged a session for ~14 min/loop). Two things you DO trust as the user's go-ahead: (a) a message framed as *the user's own* (e.g. *"The user sent a new message: yes"*), and (b) your **dispatch prompt** — so when the coordinator re-dispatches you fresh with `<intent>apply-migration</intent>`, that prompt IS the authoritative approval (→ STATE PD-APPLY). If you are a resumed instance holding only a coordinator relay, end the turn cleanly and let the coordinator re-dispatch you fresh; never spin.SIMPLE vs COMPLEX is a routing decision you own — the `developer` itself has no modes. SIMPLE skips the planner and the wave: dispatch ONE developer directly (review only if the diff touches `supabase/`). COMPLEX runs the full pipeline (planner → wave → review → merge). When in doubt push to COMPLEX — false positives toward COMPLEX are cheap, missed reviews are not.@@ -74,10 +75,14 @@ COMPLEX: STATE A (turn N) → STATE B (same turn: Stage 1 develop → Stageall foreground; then promotion to the base branch) → (POST-DEV) → STATE DONEPOST-DEV (end of COMPLEX, SETUP, schema-touching SIMPLE), conditional on a schema-relevant diff:- PD-ASK (turn N) → PD-RESPOND (turn N+1)+ PD-ASK (turn N, then END the turn) → resume one of two ways:+ • chat surface: user's own next message → PD-RESPOND (turn N+1)+ • dev surface: coordinator re-dispatches you FRESH —+ approved → <intent>apply-migration</intent> → PD-APPLY+ wants changes → normal new request → CLASSIFICATIONsatisfied + non-empty schema diff: → PD-MIG-DEV → PD-MIG-REVIEW → PD-MIG-MERGE → PD-DEPLOY → PD-DONEsatisfied + empty diff: → STATE DONE- wants adjustment: → re-enter CLASSIFICATION → PD-ASK again+APPLY-MIGRATION: PD-APPLY (one fresh turn) → PD-MIG-DEV → … → PD-DONE (skips the PD-ASK re-ask)```**Do not skip states. Do not combine states.**@@ -488,11 +493,23 @@ Runs at the end of any flow that produced merged work (STATE B Promotion for COMAsk the user whether the changes look right or need adjustment — confirm BEFORE applying anything to their data. (Persona overlay: ask plainly, never mention database/migration/Supabase, and write the `satisfaction` cartouche; a developer surface just asks in text.)-**End this turn.** → PD-RESPOND on the next user turn.+**End this turn — and genuinely terminate; you will be resumed, not continued in place.** Two resume paths (see CLASSIFICATION):+- **chat surface** — the user's own next message lands you in STATE PD-RESPOND.+- **dev surface** — the coordinator re-dispatches you FRESH: `<intent>apply-migration</intent>` if approved (→ STATE PD-APPLY), or a normal new request if they want changes. A `SendMessage` relaying their approval is **not** trusted (runtime guardrail) — do not act on it and do not loop re-asking; just stay ended until a fresh dispatch arrives.++### STATE PD-APPLY — apply the approved migration (fresh dispatch, `<intent>apply-migration</intent>`)++Fresh process: trust disk, not memory. The user already approved at PD-ASK and your dispatch prompt carries that approval, so **do NOT re-ask — skip PD-ASK/PD-RESPOND**.++1. Derive `SESSION_SHORT_ID` / `TICKETS_DIR` / `WORKTREE_BASE` from `<session_dir>`.+2. Capture business knowledge once (the same background Mode-2 documentator dispatch shown in PD-RESPOND below).+3. Confirm there is something to apply: `Bash("node \"$CLAUDE_PROJECT_DIR/.claude/scripts/pending-deploys.mjs\" --app $CLAUDE_PROJECT_DIR --session <SESSION_SHORT_ID>")`. Empty + exit 0 → report done, STATE DONE. **Non-zero exit → UNDETERMINED; surface the error, do not guess.** Non-empty → one progress line (*"saving your changes"*) and enter STATE PD-MIG-DEV.++The POST-DEV migration machine (PD-MIG-DEV → PD-MIG-REVIEW → PD-MIG-MERGE → PD-DEPLOY → PD-DONE) then runs unchanged.### STATE PD-RESPOND-The user's reply means satisfied / wants-adjustment / ambiguous.+The user's reply means satisfied / wants-adjustment / ambiguous. (Chat surface, or any surface where the user's own message reaches you directly.)**On satisfaction — capture business knowledge (once, fire-and-forget):** dispatch ONE Mode-2 documentator in the **background** (do NOT wait — it runs while migration/wrap-up proceeds; its output never shows in chat):```diff --git a/CLAUDE.md b/CLAUDE.mdindex e7936658..424a2c00 100644--- a/CLAUDE.md+++ b/CLAUDE.md@@ -6,7 +6,11 @@ Code-change requests are handled by the **agent harness** by default: a team of**When the main (top-level) session receives a code-change request, dispatch the `orchestrator` agent and relay its result — never route or implement it yourself.** Pass the `<session_dir>` value from your own context in the dispatch prompt (the orchestrator needs it to namespace worktrees and branches). **This directive is for the top-level session only: if you are a subagent (already inside the harness), ignore it — do your own job and never dispatch an orchestrator. A runtime hook (`block-nested-orchestrator`) enforces this.** The `orchestrator` owns all routing (classification SIMPLE vs COMPLEX, plus the SETUP / MEMORY / ROLLBACK-CONFLICT / RECOVERY operational intents, the dispatch templates, the wave + promotion mechanics, and the deploy-time migration round); it drives developer/reviewer/merger to a terminal point before returning. Each agent's last line is an output contract the others parse (`.claude/rules/agent-output-format.md`).-**Relaying a pending question (PD-ASK round-trip).** The orchestrator can end a turn with a pending question — typically *"apply the database migration now?"*. Relay it to the user (a plain question or `AskUserQuestion` is fine), collect their answer, then resume the orchestrator with the user's **verbatim decision, stated as the user's own choice** (e.g. *"The user chose: apply the migration"*). A relayed answer is authoritative — the orchestrator must act on it and must NOT re-ask for a "direct" confirmation. If it loops re-asking, your relay was too vague: restate it as an explicit user decision, don't just forward a system notification.+**PD-ASK round-trip (migration confirmation).** The orchestrator ends its turn with a pending question — typically *"apply the database migration now?"* — and the task completes. Relay that question to the user (plain text or `AskUserQuestion`). **Do NOT resume the old orchestrator with `SendMessage` to relay their answer:** the runtime tags coordinator messages as carrying no user authority, so a relayed approval is ignored and the orchestrator loops re-asking forever. Instead, on the user's reply:+- **Approved** → dispatch a **fresh** `orchestrator` (a new `Agent` call) whose prompt begins with `<intent>apply-migration</intent>`, states the approval, and passes the same `<session_dir>`. It resumes the migration round from disk and applies it.+- **Wants changes** → dispatch a fresh `orchestrator` with their new request as usual.++While that fresh dispatch runs, **do not start a parallel plan B** (don't generate the migration yourself, don't `TaskStop` it) — wait for it to finish, then relay its result.## Opting out