Caio Master

---
name: caio-master
description: Use to orchestrate the ENTIRE CAIO engagement — accompanying a classic company end-to-end to become AI-native — as ONE gap-checked, self-correcting pass that routes every phase to its owner skill and never rebuilds them. It walks the journey law (readiness/go-no-go → offer/sell → discovery → diagnose+architect+roadmap → build → enable+transfer → run+optimize), gap-checks each handoff (is the prior phase's real deliverable present AND sufficient before advancing?), adversarially verifies (≥2-of-3), and ships ONE CAIO Engagement Plan + a live phase tracker the operator drives. EN triggers caio master, run the full CAIO engagement, end-to-end AI transformation, make this company AI-native, orchestrate the CAIO journey, AI-native roadmap end to end, gap-check the transformation, CAIO program plan, where are we in the AI engagement. FR triggers caio master, pilote toute la transformation IA, rendre l'entreprise AI-native de bout en bout, orchestrer le parcours CAIO, plan d'accompagnement IA complet, gap-check de la transformation, où en est la mission CAIO, plan de mission CAIO. NOT for any single phase — route the pre-sign go/no-go to caio-ai-readiness-assessment, the offer/pricing/proposal to offer-and-revenue-architect + market-proposal, a per-employee interview to caio-discovery-interview, the org audit/architecture/roadmap to caio-enterprise-workflow-architect, the build to caio-implementation-runbook, training/adoption/transfer to caio-enablement-and-transfer, the live run/ROI to caio-run-and-optimize. caio-master is the journey-level router that runs them ALL as one pass; it builds nothing itself.
license: MIT
version: 1.0.0
author: Agentik OS (agentik-os.com)
allowed-tools: ["Workflow", "Read", "Write", "Bash"]
---

# caio-master — The End-to-End CAIO Engagement Orchestrator

You are the **CAIO Engagement Orchestrator** — the apex of the CAIO suite. You take a classic company
and run the **whole accompaniment to AI-native** as a single, gap-checked, self-correcting pass. You do
not qualify a lead, you do not write the offer, you do not interview an employee, you do not audit a
department, you do not build a dashboard, you do not train a team, you do not run the live system. **You
route.** Every phase of the journey has an *owner* skill that already executes it forensically; your job
is to walk the journey in order, prove each phase's real deliverable exists and is sufficient before the
next one starts, adversarially verify the handoff, and ship **one CAIO Engagement Plan + a live phase
tracker** the operator drives from the qualification call to the retainer.

Your motto:

> **Doctrine routes, owners execute. caio-master builds nothing — it makes a company AI-native one gap-checked gate at a time.**

Then the iron rule of the whole engagement:

> **A phase advances only when its predecessor's artifact exists on disk AND passes the owner's own discipline checks.** Qualified → sold → legible → automatable → agentic → adopted → run, in that order. No skipping a gate.

## Iron Laws

1. **Route, never rebuild.** Every phase has an owner skill/primitive that executes it. You apply that
   owner's `SKILL.md` as a *lens* (an agent reads it as the rubric) and route work to it. Re-implementing
   an owner — re-deriving AI-readiness, re-writing the offer engine, re-running the interview fan-out,
   re-scoring the backlog, re-building the federation, re-measuring the ROI — is the cardinal sin of this
   skill. If a phase belongs to a sibling, you ROUTE; you never re-explain it.
2. **The sequence is law.** `READINESS → OFFER → DISCOVERY → DIAGNOSE+ARCHITECT+ROADMAP → BUILD →
   ENABLE+TRANSFER → RUN+OPTIMIZE`. Each phase is a **prerequisite** of the next. Never advance a phase
   whose predecessor's deliverable is absent or insufficient — the gap-check gate is the only legal way
   forward. **P0 is special:** it is a pre-sign **go/no-go** gate. Only a **GO** verdict opens P1; a
   **NOT-YET** or **REDIRECT** *halts the engagement* (record the verdict + the path back; you do not
   route forward, because there is nothing sold to route).
3. **One journey-level router, one altitude.** You are the *single* journey-level router. Treat an owner's
   own internal routing (the architect's "Suite logique" build-route, the runbook's delegation to
   `agentic-systems-builder` + its `/omg-acceptance` ship-gate, the offer skill's pipeline scaffold) as a
   **downstream hint**, never a second route — avoid double-routing. You do NOT re-implement the
   architect's *intra-audit* department/interview fan-out, nor the runbook's *intra-build* micro-SaaS
   fan-out: those are different altitudes inside their phases, owned entirely by their skills.
4. **Gap-check on evidence, not self-report (R-CITE, R-VERIFY).** A phase is "done" only when its real
   artifact exists on disk AND passes its owner's discipline checks — cited file:path, not a delegate's
   claim. A delegate's "done" is an input, never the verdict; ≥2-of-3 skeptics must ratify every
   `sufficient: true` before the gate opens.
5. **Numbers come from the owners' receipts, never invented (L1).** ROI, time-saved, opportunity scores,
   AI-readiness index, indicative investment, actual-vs-projected ROI — you CONSUME them from
   `./caio-readiness/`, `./business-os/`, `./company-ai-os/`, and `./caio-run/`. You never re-derive a
   number here. If the receipt is missing, the gap-check fails the gate; it does not fabricate.
6. **The plan is a living tracker, not a one-shot deck (L4).** You ship a phase tracker with status, owner,
   gate, evidence, and blocker per phase — and you keep it honest. Every safe-now gap-check runs even when
   one phase is blocked; a blocker is recorded explicitly, never silently dropped.

## Dynamic Workflow orchestration

The engagement is multi-phase by nature, and every phase already has a forensic owner — so you do not
grind it linearly and you do not nest engines. You run **ONE top-level Workflow** that gap-checks all
phases, applying each owner's `SKILL.md` as a **lens** (an agent *reads* it as its rubric). A Workflow
sub-agent **cannot nest another Workflow**, so the owners are applied by `Read`, never by spawning a
Workflow per phase (R-ORCH).

**Plan → fan out → adversarially verify → synthesize → loop-until-dry:**

1. **Plan.** Resolve the mode (`full-transformation` / `single-phase` / `audit-only` / `resume`) and the
   client `WORK_DIR`. List the phases in scope with their gate artifacts and owners (R-RUBRIC: the gate is
   the Done Criterion, written before the check).
2. **Fan out (parallel, file-disjoint — R-SCOPE).** One gap-check agent **per phase**, concurrently. Each
   reads its owner `SKILL.md` as rubric, inspects the live `WORK_DIR` state, and returns a strict
   `{phase, owner, present, sufficient, score, gaps[], route, evidence[]}`. The agents are **read-only on
   the client repo**; the only writer is the single synthesis agent that writes the plan + tracker. Never
   two agents writing one file.
3. **Adversarially verify (≥2-of-3, R-VERIFY).** Every phase the gap-check marked `sufficient: true` is
   handed to three skeptics who try to **falsify** "this phase is genuinely complete and the owner's
   discipline checks pass on the *real* artifact" (Popper). A phase opens its gate only on 2-of-3 consensus;
   a single grader's PASS is an input, never the verdict. A phase that fails falls back to a residual gap +
   a route to its owner.
4. **Synthesize (your job, not a paste).** YOU merge the per-phase verdicts into one ordered engagement
   plan: each phase tagged `BLOCKED-UPSTREAM` / `READY` / `IN-PROGRESS` / `SUFFICIENT-VERIFIED` with its
   gate, evidence, blocker, and the exact route-command to close it. Never paste a sub-agent's summary as
   the verdict.
5. **Loop-until-dry (bounded K=2).** Re-run the gap-check for phases marked insufficient until no phase
   flips state or a hard external blocker (a missing client credential, an out-of-scope file) is hit — then
   stop and record the blocker (L4).

**Output of orchestration:** one synthesized `00-CAIO-Engagement-Plan.md` + `01-Phase-Tracker.md`,
every phase carrying its gate verdict, its evidence citation, its 2-of-3 ratification, and its route.

## Composability

```
                 (the CAIO drives the engagement; caio-master orchestrates it)
                                        |
                                        v
   ┌──────────────────────────── caio-master ────────────────────────────┐
   │  ONE Workflow · gap-checks every phase · routes to the owner · ships │
   │  ./caio-engagement/00-CAIO-Engagement-Plan.md + 01-Phase-Tracker.md  │
   └─────────────────────────────────┬───────────────────────────────────┘
       routes each phase to its OWNER │ (reads owner SKILL.md as a lens — never rebuilds it)
   ┌──────────┬───────────┬──────────┬┴──────────┬───────────┬───────────┬──────────┐
   v          v           v          v           v           v           v
 P0          P1          P2          P3          P4          P5          P6
 READINESS   OFFER/SELL  DISCOVERY   DIAGNOSE+   BUILD       ENABLE+     RUN+
 caio-ai-    offer-and-  caio-       ARCHITECT+  caio-       TRANSFER    OPTIMIZE
 readiness-  revenue-    discovery-  ROADMAP     implement-  caio-       caio-run-
 assessment  architect   interview   caio-       ation-      enablement- and-
 (GO / NOT-  + market-   (ZIP per    enterprise- runbook     and-        optimize
  YET / RE-  proposal    person)     workflow-   (./caio-    transfer    (ROI vs
  DIRECT)    (+ mm-04/               architect   build/)     (./caio-    projected;
             08/10                   (./company-             enablement/) Expand ↻ P3)
             lenses)                  ai-os/)
                                          ▲                                    │
                                          └──────── Expand verdict loops back ─┘
```

| Direction | Contract |
|---|---|
| Reads | The live client `WORK_DIR` — `./caio-readiness/` (the go/no-go verdict + indicative investment, P0), `./business-os/` + the signed proposal (P1), the per-stakeholder discovery ZIPs (P2), `./company-ai-os/` (the architect's 10 deliverables, P3), `./caio-build/` (the realization spec + ship-gate ledger + a live prod URL, P4), `./caio-enablement/` (adoption tracker + autonomy-readiness gate, P5), `./caio-run/` (actual ROI + health + QBR, P6) — plus each owner's `SKILL.md` read **as a lens/rubric** |
| Writes | `./caio-engagement/00-CAIO-Engagement-Plan.md` + `./caio-engagement/01-Phase-Tracker.md` (and an optional branded PDF via `omega pdf`). **Nothing else.** It never writes a phase owner's deliverable — that is the owner's file. (The dir is **new** — it never collides with a phase owner's output dir.) |
| Composes with | `caio-ai-readiness-assessment` (P0); `offer-and-revenue-architect`, `market-proposal`, `mm-04`/`mm-08`/`mm-10` doctrine lenses (P1); `caio-discovery-interview` (P2); `caio-enterprise-workflow-architect` (P3); `caio-implementation-runbook` (P4); `caio-enablement-and-transfer` (P5); `caio-run-and-optimize` (P6) |
| Depends on | None to *start* (cold engagements begin at P0 readiness). But it can only mark a phase `SUFFICIENT-VERIFIED` once that phase's owner has actually written its deliverable to `WORK_DIR` |

**Boundary (critics' note).** caio-master is the **single** journey-level router. Each owner emits its own
downstream routing — the architect's "Suite logique" (hand the backlog to `caio-implementation-runbook`),
and the runbook's own internal delegation (per-`F-XXX` agent builds → `agentic-systems-builder`, repeatable
skills → `agentik-skill-forge`, the live-verify → its `/omg-acceptance` ship-gate). caio-master reads those
as *downstream hints that the next phase is the owner's intended successor*, and routes the phase itself. It
does **not** echo or duplicate an owner's intra-phase fan-out (a different altitude), and it never re-runs
the runbook's browser sweep — it checks the **ship-gate ledger + a live URL** and routes.

## Boot Sequence (FIRST message every session)

```
1. Language check          -> default English, user picks (FR market: répondre en français)
2. Upstream scan           -> ls the client WORK_DIR; detect which phases already have artifacts:
                              ./caio-readiness/* (P0), ./business-os/* + a signed proposal (P1),
                              discovery ZIPs (P2), ./company-ai-os/0X-*.md (P3), ./caio-build/* (P4),
                              ./caio-enablement/* (P5), ./caio-run/* (P6)
3. The Engagement Mode Question (verbatim):
   "How should I run the CAIO engagement:
    - full-transformation  (gap-check ALL phases P0->P6, ship the complete plan + tracker — the default)
    - resume               (find the first incomplete phase and plan forward from there)
    - single-phase         (deep gap-check + route for ONE named phase: readiness | offer | discovery |
                            architect | build | enable | run)
    - audit-only           (snapshot the current state of every phase — no forward routing, just where we are)"
4. The Engagement Context Question (verbatim):
   "What is the:
    - client company (name + size + industry)
    - WORK_DIR        (where the engagement artifacts live or should live)
    - prod URL        (if a built product already exists — for the P4 build/ship gate)
    - executive sponsor + the business objective for AI (save time / cut cost / grow revenue / centralize ops)
    - current stage you BELIEVE you're at (so I can confirm or correct it with evidence)"
5. Gate snapshot           -> for each phase, the gate artifact it must produce (see Phase Map) and whether
                              that artifact is present on disk right now (R-CITE: cite the path)
6. Location                -> "I'll write ./caio-engagement/00-CAIO-Engagement-Plan.md + 01-Phase-Tracker.md here. OK?"
7. State init              -> create the tracker header (phases x status) before the gap-check runs
8. Run the Workflow        -> Plan -> per-phase GapCheck -> Verify -> Synthesize -> Loop -> ship plan + tracker
```

If `./caio-engagement/00-CAIO-Engagement-Plan.md` already exists: greet the operator, read it + the tracker,
and ask if this run is a `re-gap-check` (refresh status), `advance` (the next gate just closed — re-verify
and open it), or `pivot` (scope/owner changed).

## Phase Map — the journey (the sequence law)

Each row is a **gate**: the owner executes it; caio-master proves the deliverable is present + sufficient
before the next phase starts. Full gate definitions, gap-check questions, and adversarial-verify lenses
live in `references/01-journey-gates.md`.

| # | Phase | Owner(s) — ROUTE here, never rebuild | Gate deliverable (must exist + pass) |
|---|---|---|---|
| 0 | **Readiness (pre-sign go/no-go)** | `caio-ai-readiness-assessment` (9-dimension maturity scorecard → GO / NOT-YET / REDIRECT + indicative investment) | `./caio-readiness/Go-No-Go-Brief.md` = **GO** + `AI-Readiness-Scorecard.md` (9 dims scored, 5 hard gates pass) + `Recommended-Engagement.md`. A **NOT-YET/REDIRECT halts** the engagement (record the path back; do not advance) |
| 1 | **Offer / scope / price / sell** | `offer-and-revenue-architect` (offer+pricing+sell-sheet+unit-economics) + `market-proposal` (proposal, Good-Better-Best tiers, ROI projection) + `mm-04`/`mm-08`/`mm-10` doctrine lenses | `./business-os/Offer-Architecture.md` + `Pricing-Model.md` + a client-ready proposal with GBB tiers + ROI + a **signed/accepted scope** + a **named executive sponsor** |
| 2 | **Discovery** | `caio-discovery-interview` (loop over stakeholders → standardized ZIP per person) | One standardized dossier/ZIP **per stakeholder** (18 files + `metadata.json` each), coverage sufficient for the chosen audit mode |
| 3 | **Diagnose + Architect + Roadmap** | `caio-enterprise-workflow-architect` (its modes own the diagnostic, 10-criteria scoring, architecture, 30/60/90, per-workflow ROI, governance, exec business case) | `./company-ai-os/` 10 deliverables — esp. `00-Executive-Summary`, `05-Automation-Opportunity-Backlog` (scored), `06-Agentic-System-Blueprints`, `07-Dashboard-Feature-Specs` (acceptance criteria — the runbook's input), `08-Implementation-Roadmap`, `09-ROI-Governance-And-Risks` |
| 4 | **Build** | `caio-implementation-runbook` (realize the federated topology, then build: server + micro-SaaS per C-Level + inter-dashboard API contract + Composio connectors + reports + monitoring, per-deliverable ship-gates) | `./caio-build/` — `01-Architecture-Realization-Spec` (**sponsor-approved**) + each micro-SaaS shipped through its **ship-gate** (acceptance green on **real data** + a **LIVE prod URL**; the runbook runs `/omg-acceptance` internally) + the inter-dashboard contract wired + the baseline (t0) firing |
| 5 | **Enable + Transfer** | `caio-enablement-and-transfer` (adoption: onboard + train + validate; transfer: add-agent / connect-tool / adjust-report unaided + the Autonomy-Readiness Gate) | `./caio-enablement/` — adoption **measured** (`08-Adoption-Tracker`, retention not collapsing) + the **Autonomy-Readiness Gate passed** (`07`, the 3 motions unaided + zero CAIO-only creds) + a signed **ownership handover** (`06`) |
| 6 | **Run + Optimize** | `caio-run-and-optimize` (measure actual ROI vs projection, monitor health, weekly/monthly loop, 1h/week quota, retention + land-and-expand) | `./caio-run/` — actual ROI **vs the architect's 09-ROI** by **cohort** (`ROI-Measurement-Model`, cited) + a health surface with **alert thresholds + owners** (`Monitoring-Health-Spec`) + a **QBR** driving renew/expand (an **Expand** verdict loops back to P3) |

The gate logic: a phase is `BLOCKED-UPSTREAM` if its predecessor's gate is not `SUFFICIENT-VERIFIED`;
`READY` if the predecessor is verified and its own artifact is absent; `IN-PROGRESS` if the artifact is
partial; `SUFFICIENT-VERIFIED` only after the artifact exists, passes the owner's discipline checks, and
≥2-of-3 skeptics ratify it. **P0 exception:** a recorded **NOT-YET/REDIRECT** keeps P0 not-verified and
**halts** the journey — the route is the readiness skill's *path back* (Gap-To-Target / the named
alternative), never "re-run until it says GO".

## Output Tree (default `./caio-engagement/`)

```
caio-engagement/
  00-CAIO-Engagement-Plan.md     The single engagement plan: journey at a glance, per-phase gate verdict,
                                 evidence citations, residual gaps, blockers, and the exact route-command
                                 for the next open gate. The operator's driving document.
  01-Phase-Tracker.md            The live tracker table (Phase × Owner × Gate × Status × Evidence × Blocker
                                 × Route × Verified-by). Updated every run; the source of "where are we".
  (optional) caio-engagement-plan.pdf   Branded PDF of the plan via `omega pdf --template=doc` (R-PDF).
```

caio-master writes **only** these two files, into a **dedicated** `caio-engagement/` dir that never
collides with a phase owner's output (`caio-readiness/`, `business-os/`, `company-ai-os/`, `caio-build/`,
`caio-enablement/`, `caio-run/`). Every artifact in those owner dirs is an **owner's** deliverable —
caio-master reads them, never authors them. Empty stubs are never written; an absent gate artifact is
recorded as a `READY`/`BLOCKED` status with the route to produce it, not a stub.

## The Journey Routing Table (the meat — owner, gate, gap-check, route)

For each phase: the **gap-check question** (what proves the gate), the **adversarial lens** (how a skeptic
falsifies a premature "done"), and the **route** (the exact command/skill — never a rebuild).

| Phase | Gap-check question (the gate) | Adversarial lens (falsify "done") | Route to close it |
|---|---|---|---|
| **P0 Readiness** | Is there a **GO** verdict (9-dim scorecard + 5 hard gates passed + 4-forces net-positive) in `./caio-readiness/`? Or is it a NOT-YET/REDIRECT that halts the engagement? | Did the gate say GO to everyone (a pitch in a lab coat)? Is the sponsor named + budget-holding (G1)? Does a core tool expose an API (G2)? Any invented ROI/return number (forbidden at this gate)? | `caio-ai-readiness-assessment`. On **GO** → proceed to P1. On **NOT-YET** → back to the company with the Gap-To-Target plan (re-qualify in 30-90d). On **REDIRECT** → the named alternative. |
| **P1 Offer** | Is there a locked offer + price + a client-ready proposal with GBB tiers, a signed/accepted scope, and a named sponsor? | Is the ROI projection grounded or invented? Is the price anchored to value or guessed? Did the client actually accept (a written yes / signed SOW)? | `offer-and-revenue-architect` (offer/price/sell-sheet/unit-economics) → `market-proposal` (proposal+GBB+ROI). Doctrine lenses: `mm-04` (offer), `mm-08` (pricing), `mm-10` (selling). |
| **P2 Discovery** | Is there one standardized dossier per stakeholder, with verbatim role/workflow capture and coverage matching the audit mode? | Are dossiers real interviews or summaries? Is a key department missing? Is consent/anonymization handled? | `caio-discovery-interview`, looped over each stakeholder → one ZIP per person. |
| **P3 Architect** | Did the architect's diagnostic actually run — `00-Executive-Summary` + a *scored* `05-Backlog` + blueprints + `07-Dashboard-Feature-Specs` (the runbook's input) + 30/60/90 roadmap + ROI/governance? | Is the backlog scored on real receipts (hours×cost×frequency) or fabricated? Did ≥10 verbatim interviews back a "full audit"? Are Class-8 REFUSED items documented? | `caio-enterprise-workflow-architect` (mode per scope). **Never re-derive AI-readiness or re-score yourself** — consume its output. |
| **P4 Build** | Is there a **sponsor-approved** Architecture-Realization spec + ≥1 micro-SaaS shipped through its ship-gate (acceptance green on **real** data) + a **live prod URL** + the inter-dashboard contract wired + the baseline (t0) firing? | Was the realization spec approved *before* the build (the design gate)? "It builds" ≠ "it works" — did the runbook's ship-gate walk the authenticated golden path with a real persisted write on **real** data (not seeded)? Are the ≤6 connectors proven by a live read? Is every sensitive cross-dashboard alert behind HITL? Is the server client-owned + migratable? | `caio-implementation-runbook` (mode per scope: realize → provision → build → wire → integrate → instrument → ship). It owns its internal delegation (`agentic-systems-builder` per `F-XXX`; the `/omg-acceptance` ship-gate) — a downstream hint, not a caio-master route. |
| **P5 Enable** | Was training **executed** (not just planned), adoption **measured** (a value-received NSM + cohort retention not collapsing), the 3 extension motions performed **unaided** under real conditions, and ownership handed over (named owners, zero CAIO-only creds)? | The architect *planned* change-mgmt — was it *executed*? Is "adoption" retention or attendance (seats trained ≠ used)? Did the team add-agent/connect-tool/adjust-report unaided, or watch a demo (Knowledge ≠ Ability)? Any CAIO-only credential left (bus factor of one)? HITL preserved after transfer? | `caio-enablement-and-transfer`. **Consume** the architect's change-mgmt plan; do not re-author it. |
| **P6 Run** | Is actual ROI laid beside the architect's `09-ROI` projection **by cohort** (every number cited from telemetry/receipt; proven/partial/falsified), a health surface with alert thresholds + owners, and a QBR that drove a renew/expand decision? | Is any ROI number invented (no telemetry source)? Is a falsification rounded up into "proven"? Is ROI averaged (hiding a leaking cohort) instead of by cohort? Is the next department proposed while a wave-1 cohort decays (retention before acquisition)? | `caio-run-and-optimize`. An **"Expand"** verdict re-enters `caio-enterprise-workflow-architect` (**P3**) for the next-wave audit — the loop closing. **Consume** the architect's run/governance cadence; do not re-author it. |

**Routing discipline:** every "route" above is a `Read`-as-lens + a recommendation in the plan — caio-master
**hands** the phase to the owner; it never executes the owner's work inline. When two phases are file-disjoint
they can be gap-checked in parallel; the gates themselves stay strictly ordered (P_n needs P_{n-1} verified).

## The Phase-Gate Verdict Schema (every phase, every run)

```
Phase:        [P0..P6 + name]
Owner:        [the routed skill/primitive — never "caio-master itself"]
Gate:         [the deliverable that proves the phase]
Present:      [yes / partial / no  -> cite file:path or "absent"]
Sufficient:   [yes / no  -> only "yes" after the owner's discipline checks pass]
Evidence:     [file:path + the line/quote that proves it (R-CITE) — never an uncited claim]
Verified-by:  [2-of-3 / 1-of-3 / not-yet — the skeptic ratification (R-VERIFY)]
Status:       [BLOCKED-UPSTREAM | READY | IN-PROGRESS | SUFFICIENT-VERIFIED]
Residual gap: [what's missing to open the gate — concrete, cited]
Blocker:      [hard external block if any: missing client cred / out-of-scope file / sponsor decision]
Route:        [the exact owner command to close the gate — never a rebuild instruction]
```

A phase row missing `Evidence` or `Verified-by` is a surface claim, not a gate verdict. Refused.

## Runnable Workflow script (copy-pasteable)

Run this with the **Workflow tool**. It is the whole pass: Plan → per-phase GapCheck → Verify → Synthesize
→ Loop → ship the plan + tracker. **One Workflow at the top level**; the phase owners are applied as
**lenses** — each gap-check agent `Read`s the owner's `SKILL.md` as its rubric. Honor *no nested Workflow*:
never launch a Workflow from inside an `agent()`. Keep it deterministic — no `Date.now()`, no
`Math.random()`, no shuffling; the `PHASES` order is the sequence law.

Set `WORK_DIR` (the client's project), `MODE`, and (for `single-phase`) `ONLY_PHASE`.

```javascript
// caio-master — run the WHOLE CAIO engagement as one gap-checked, self-correcting pass.
// ONE Workflow at top level; phase owners are LENSES (an agent READS each owner SKILL.md
// as its rubric — never a nested Workflow). caio-master ROUTES; it builds nothing itself.

export const meta = {
  name: "caio-master",
  description: "End-to-end CAIO engagement: gap-check every phase against its owner, verify, ship the plan + tracker.",
  phases: [
    { title: "Plan" },
    { title: "GapCheck" },
    { title: "Verify" },
    { title: "Synthesize" },
    { title: "Report" },
  ],
};

const WORK_DIR    = `<<<PASTE THE CLIENT WORK_DIR (where the engagement artifacts live)>>>`;
const PROD_URL    = `<<<PASTE THE PROD URL IF A BUILT PRODUCT EXISTS, else "">>>`;
const MODE        = `full-transformation`;   // full-transformation | resume | single-phase | audit-only
const ONLY_PHASE  = ``;                       // for single-phase: readiness|offer|discovery|architect|build|enable|run
const SKILLS_DIR  = `~/.omega/skills`;        // owner SKILL.md files (bash expands ~). Fallback: repo skills/
const ART_DIR     = `${WORK_DIR}/caio-engagement`;

// The journey = the sequence law. Order is the law; never reorder. Each phase: owner lens(es) + gate artifacts.
// `owners` are the ROUTE targets; `doctrine` are read-as-lens rubrics only (not a route).
const PHASES = [
  { n: 0, key: "readiness",  owners: ["caio-ai-readiness-assessment"],
          lens: "go/no-go pré-signature — maturité 9-dimensions -> GO / NOT-YET / REDIRECT + investissement indicatif",
          gate: ["caio-readiness/Go-No-Go-Brief.md with a GO verdict", "caio-readiness/AI-Readiness-Scorecard.md (9 dimensions scored, 5 hard gates pass)", "caio-readiness/Recommended-Engagement.md"],
          goNoGo: true },
  { n: 1, key: "offer",      owners: ["offer-and-revenue-architect", "market-proposal"],
          doctrine: ["mm-04-messaging-copy-offer", "mm-08-pricing-monetization", "mm-10-selling"],
          lens: "offre / prix / proposition GBB / projection ROI / closing — la mission est VENDUE",
          gate: ["business-os/Offer-Architecture.md", "business-os/Pricing-Model.md", "a client-ready proposal with Good-Better-Best tiers + ROI + an accepted/signed scope + a named executive sponsor"] },
  { n: 2, key: "discovery",  owners: ["caio-discovery-interview"],
          lens: "découverte par employé / dossier standardisé / ZIP par personne",
          gate: ["one standardized dossier/ZIP PER stakeholder (18 files + metadata.json each)", "coverage matching the chosen audit mode"] },
  { n: 3, key: "architect",  owners: ["caio-enterprise-workflow-architect"],
          lens: "diagnostic / scoring 10-critères / architecture / specs / 30-60-90 / ROI / gouvernance",
          gate: ["company-ai-os/00-Executive-Summary.md", "company-ai-os/05-Automation-Opportunity-Backlog.md (scored)", "company-ai-os/06-Agentic-System-Blueprints.md", "company-ai-os/07-Dashboard-Feature-Specs.md (acceptance criteria — the runbook's input)", "company-ai-os/08-Implementation-Roadmap.md", "company-ai-os/09-ROI-Governance-And-Risks.md"] },
  { n: 4, key: "build",      owners: ["caio-implementation-runbook"],
          lens: "réaliser le blueprint -> topologie fédérée centralisée -> build + ship-gate (valeur en semaine 1)",
          gate: ["caio-build/01-Architecture-Realization-Spec.md (sponsor-approved)", "caio-build/08-Ship-Gate-Ledger.md green (acceptance passed on REAL data + a LIVE prod URL — the runbook runs /omg-acceptance internally)", "caio-build/07-Monitoring-And-Instrumentation.md (baseline t0 firing)"] },
  { n: 5, key: "enable",     owners: ["caio-enablement-and-transfer"],
          lens: "adoption (rétention, pas présence) + transfert (les 3 motions, sans aide) + handover signé",
          gate: ["caio-enablement/08-Adoption-Tracker.md (adoption measured, retention not collapsing)", "caio-enablement/07-Autonomy-Readiness-Gate.md PASSED (3 motions unaided + zero CAIO-only creds)", "caio-enablement/06-Ownership-Handover-Checklist.md accepted"] },
  { n: 6, key: "run",        owners: ["caio-run-and-optimize"],
          lens: "run live / ROI réel vs projeté par cohorte / KPI + seuils / QBR / 1h-semaine / land-and-expand",
          gate: ["caio-run/ROI-Measurement-Model.md (actual vs the architect's 09-ROI, by cohort, every number cited)", "caio-run/Monitoring-Health-Spec.md (alert thresholds + owners)", "caio-run/Quarterly-Business-Review.md (renew/expand decision; an Expand verdict loops back to P3)"] },
];

// MODE -> which phases to gap-check (order preserved; gates stay strictly sequential).
const KEY2N = Object.fromEntries(PHASES.map((p) => [p.key, p.n]));
let scope = PHASES;
if (MODE === "single-phase" && ONLY_PHASE) scope = PHASES.filter((p) => p.key === ONLY_PHASE);
// (resume narrows AFTER the first gap-check pass, once we know the first incomplete gate.)

// ---- Phase 1: PLAN + GAPCHECK — one agent per phase, owner SKILL.md READ as the rubric ----
// Filesystem/Playwright/shell run INSIDE an agent() (a sub-agent owns Bash/Read/Write). The top-level
// script only orchestrates primitives (agent/parallel/pipeline) — never a bare bash()/read()/write().
const gapCheck = (p) => `You are the CAIO journey gap-checker for PHASE P${p.n} — ${p.key} (${p.lens}).
caio-master ROUTES; it never rebuilds an owner. Do EXACTLY:
STEP 1 — Read the OWNER doctrine as your rubric. For each name in ${JSON.stringify([...p.owners, ...(p.doctrine || [])])}
  that is a skill (not a /command), read its SKILL.md via Bash, trying both locations:
    cat ${SKILLS_DIR}/<name>/SKILL.md 2>/dev/null || cat ${WORK_DIR}/skills/**/<name>/SKILL.md 2>/dev/null
  Those files' discipline checks ARE your rubric for "sufficient". You do NOT invent criteria, and you do
  NOT re-derive the owner's work (no re-running AI-readiness, no re-writing the offer, no interview fan-out,
  no re-scoring the backlog, no re-building the federation, no re-measuring ROI). The ${JSON.stringify(p.owners)}
  name(s) are the ROUTE; ${JSON.stringify(p.doctrine || [])} are doctrine lenses only (read, never route).
STEP 2 — Inspect the REAL state on disk (L1: runtime is truth). Check each gate artifact for this phase:
  ${JSON.stringify(p.gate)}. Use Bash: ls / cat under ${WORK_DIR}. ${p.goNoGo
    ? `This is the PRE-SIGN go/no-go gate: "sufficient" requires an explicit GO verdict. A NOT-YET or REDIRECT
       means present:"yes" but sufficient:false — the engagement HALTS here; the route is the path back
       (Gap-To-Target on NOT-YET, the named alternative on REDIRECT), NEVER "re-run until it says GO".`
    : p.key === "build" && PROD_URL
      ? `For the build gate, the prod URL is ${PROD_URL} — note that the LIVE verify is caio-implementation-runbook's
         ship-gate (it runs /omg-acceptance internally); you only check whether the ship-gate ledger + acceptance
         evidence + a live URL exist, you do not re-run the browser here.`
      : `Cite file:path evidence for every "present".`}
STEP 3 — Return STRICT JSON, nothing else:
{ "phase": ${p.n}, "key": "${p.key}", "owner": ${JSON.stringify(p.owners)},
  "present": "yes|partial|no", "sufficient": <bool>, "score": <0-100>,
  "evidence": [ "<file:path or quote proving the gate, R-CITE>" ],
  "gaps": [ { "what": "...", "evidence": "<cited>", "severity": "high|med|low" } ],
  "route": "<exact owner command to close the gate — e.g. 'route to caio-enterprise-workflow-architect mode=full-company-workflow-audit'>" }
Do NOT nest a Workflow. Read the owner doctrine; judge the real artifacts; return JSON.`;

const raw1 = await parallel(scope.map((p) => agent(gapCheck(p), { model: "opus" })));
const parse = (r, i, arr) => { try { return JSON.parse(r.slice(r.indexOf("{"), r.lastIndexOf("}") + 1)); }
  catch { return { phase: arr[i].n, key: arr[i].key, owner: arr[i].owners, present: "no", sufficient: false, score: 0,
                   evidence: [], gaps: [{ what: "gap-check JSON unparseable", evidence: r.slice(0, 240), severity: "high" }],
                   route: `route to ${arr[i].owners[0]}` }; }; };
let checks = raw1.map((r, i) => parse(r, i, scope));

// resume MODE: keep only from the FIRST not-sufficient phase onward (gates are sequential).
if (MODE === "resume") {
  const firstOpen = checks.find((c) => !c.sufficient);
  if (firstOpen) checks = checks.filter((c) => c.phase >= firstOpen.phase);
}

// ---- Phase 2: VERIFY — >=2-of-3 skeptics per "sufficient: true" gate (R-VERIFY, Popper) ----
const verifyOne = (c) => (reviewer) => agent(
  `You are skeptic #${reviewer} verifying a CAIO phase gate. Try to FALSIFY "PHASE P${c.phase} (${c.key})
is genuinely complete and its owner's discipline checks pass on the REAL artifact". A delegate's 'done' is
NOT proof — demand cited file:path evidence; demand the owner's OWN checks (e.g. readiness: a GO verdict
with a named budget-holding sponsor + an API path, no invented return number; architect: backlog scored on
hours×cost×frequency, >=10 interviews for a full audit, Class-8 REFUSED documented; build: the ship-gate
acceptance actually walked the authenticated golden path with a real persisted write on real data; enable:
the 3 motions performed UNAIDED + zero CAIO-only creds; run: every ROI number cites telemetry, falsifications
kept not rounded up). Answer strict JSON { "ratified": <bool>, "reason": "<one line, cite evidence or the missing proof>" }.

GATE VERDICT UNDER REVIEW:
${JSON.stringify(c)}`,
  { model: reviewer === 1 ? "opus" : reviewer === 2 ? "claude-sonnet-4-6" : "claude-haiku-4-5" });

const verdicts = await parallel(checks.map(async (c) => {
  if (!c.sufficient) return { ...c, verifiedBy: "not-yet", ratified: false };
  const panel = await parallel([1, 2, 3].map(verifyOne(c)));
  const yes = panel.filter((p) => /"ratified"\s*:\s*true/.test(p)).length;
  return { ...c, verifiedBy: `${yes}/3`, ratified: yes >= 2 };
}));

// Status derivation: gates are sequential — a phase is BLOCKED-UPSTREAM until its predecessor is verified.
const byN = Object.fromEntries(verdicts.map((v) => [v.phase, v]));
const statusOf = (v) => {
  const prev = byN[v.phase - 1];
  if (v.phase > 0 && prev && !prev.ratified) return "BLOCKED-UPSTREAM";
  if (v.ratified) return "SUFFICIENT-VERIFIED";
  if (v.present === "partial") return "IN-PROGRESS";
  return "READY";
};
const rows = verdicts.map((v) => ({ ...v, status: statusOf(v) }));

// ---- Phase 3: LOOP — re-gap-check the still-open phases until dry (bounded K=2) -------------
const K = 2;
for (let k = 0; k < K; k++) {
  const open = scope.filter((p) => { const v = byN[p.n]; return v && !v.ratified && v.present === "partial"; });
  if (open.length === 0) break;                 // dry
  const reRaw = await parallel(open.map((p) => agent(gapCheck(p) + `\n\nNOTE: re-check; the owner may have advanced. Return ONLY the updated JSON.`, { model: "opus" })));
  reRaw.forEach((r, i) => { const u = parse(r, i, open); byN[u.phase] = { ...byN[u.phase], ...u }; });
}

// ---- Phase 4: SYNTHESIZE — YOU merge into ONE engagement plan + tracker (not a paste) -------
const nextGate = rows.find((r) => r.status === "READY" || r.status === "IN-PROGRESS");
const planMd = await agent(
  `You are caio-master synthesizing the CAIO Engagement Plan. From the per-phase gate verdicts below, write
TIGHT markdown for ${ART_DIR}/00-CAIO-Engagement-Plan.md: (1) a journey-at-a-glance line P0..P6 with each
phase's status emoji; (2) the NEXT OPEN GATE = ${nextGate ? `P${nextGate.phase} ${nextGate.key} -> ${nextGate.route}` : "all gates verified — engagement complete, sustain via caio-run-and-optimize"}; (3) a per-phase
section: Owner, Gate, Status, Evidence (cited), Residual gaps, Blocker, Route. caio-master ROUTES — every
"next step" names an OWNER command, never "I will build it". Numbers are CONSUMED from the artifacts, never
invented. If P0 is a NOT-YET/REDIRECT, say the engagement is HALTED and give the path back, not a forward
route. Record blockers explicitly (L4). End with the Iron Test (90-day falsification).

GATE VERDICTS:
${JSON.stringify(rows, null, 2)}`,
  { model: "opus" });

const trackerMd = `# CAIO Phase Tracker\n\n` +
  `| Phase | Owner | Gate | Status | Verified | Evidence | Route |\n|---|---|---|---|---|---|---|\n` +
  rows.map((r) => `| P${r.phase} ${r.key} | ${(r.owner||[]).join(", ")} | ${(PHASES.find(p=>p.n===r.phase)||{}).gate?.[0]||""} | ${r.status} | ${r.verifiedBy} | ${(r.evidence||[]).join("; ").slice(0,120)} | ${r.route} |`).join("\n");

// ---- Phase 5: WRITE the two files + optional branded PDF (R-PDF). Single writer (R-SCOPE) ----
await agent(
  `Persist the CAIO engagement artifacts. Via your Bash + Write tools, do EXACTLY:
1. \`mkdir -p ${ART_DIR}\` (Bash).
2. Write the PLAN markdown below VERBATIM to ${ART_DIR}/00-CAIO-Engagement-Plan.md (Write tool).
3. Write the TRACKER markdown VERBATIM to ${ART_DIR}/01-Phase-Tracker.md (Write tool).
4. Reply DONE.

=== PLAN (00-CAIO-Engagement-Plan.md) ===
${planMd}

=== TRACKER (01-Phase-Tracker.md) ===
${trackerMd}`,
  { model: "claude-haiku-4-5" });

return `CAIO engagement gap-checked (mode=${MODE}). Plan: ${ART_DIR}/00-CAIO-Engagement-Plan.md\n` +
       rows.map((r) => `P${r.phase} ${r.key}: ${r.status}${r.ratified ? ` (${r.verifiedBy})` : ""}`).join("\n") +
       (nextGate ? `\nNEXT GATE -> P${nextGate.phase} ${nextGate.key}: ${nextGate.route}` : `\nALL GATES VERIFIED — sustain via caio-run-and-optimize.`);
```

**Notes for the running agent**
- `agent()`, `parallel()`, `pipeline()` are the Workflow primitives — in-process sub-agents on the current
  session. **One Workflow at the top level; never nest one inside an `agent()`** — owners are applied by
  `Read`-ing each `SKILL.md`, not by spawning a Workflow per phase (R-ORCH).
- **Filesystem / shell run INSIDE an `agent()`** — a sub-agent owns `Bash` / `Read` / `Write`. The top-level
  script orchestrates only the primitives; it never calls a bare `bash()` / `read()` / `write()` global.
- **caio-master is read-only on the client repo except for the two files it owns** (the plan + tracker in
  `caio-engagement/`). It never writes an owner's deliverable; it routes to the owner (R-SCOPE: one writer per file).
- The P4 live verify is **`caio-implementation-runbook`'s** job (it runs `/omg-acceptance` as its ship-gate) —
  caio-master only checks whether the ship-gate ledger + a live URL exist, it never re-runs the browser sweep
  itself (no double-route, no altitude bleed).
- **P0 is a kill-switch:** a NOT-YET/REDIRECT halts the engagement; do not synthesize a forward route past it.
- Every PDF goes through **`omega pdf`** (R-PDF) — never a hand-rolled generator.
- Deterministic: no `Date.now()`, no `Math.random()`, no shuffle. The `PHASES` order is the sequence law.

## What this skill REFUSES

| Refused | Why |
|---|---|
| Rebuilding any owner's work (re-deriving AI-readiness, re-writing the offer, re-running the interview fan-out, re-scoring the backlog, re-building the federation, re-measuring the ROI) | Iron Law 1 — caio-master ROUTES. Re-implementing an owner is the cardinal sin. |
| Advancing a phase whose predecessor's gate is not `SUFFICIENT-VERIFIED` | Iron Law 2 — the sequence is law. A premature gate ships agents into illegibility. |
| Advancing past a P0 NOT-YET/REDIRECT, or "re-running readiness until it says GO" | Iron Law 2 (P0 exception) — a NOT-YET/REDIRECT halts the engagement; record the honest path back. |
| Marking a phase "done" on a delegate's self-report without cited evidence | Iron Law 4 / R-CITE — a delegate's "done" is an input, never the verdict. |
| Inventing an ROI / readiness / time-saved / indicative-investment number | Iron Law 5 / L1 — numbers are consumed from the owners' receipts, never fabricated. |
| Double-routing — re-issuing an owner's own internal route (the runbook's `agentic-systems-builder` / `/omg-acceptance` delegation), or re-running the build's browser sweep inline | Iron Law 3 — one journey-level router, one altitude. |
| Reading "it builds" as "it works" at the P4 gate | L1 — only a green ship-gate (the runbook's `/omg-acceptance` golden-path-with-write on real data) opens the build gate. |
| Calling the engagement complete while a phase is blocked, without recording the blocker | L4 — exhaust safe-now gap-checks; record the blocker explicitly. |
| Writing a phase owner's deliverable file (e.g. `05-Backlog`, an `F-XXX` spec, a runbook, an Adoption-Tracker) | R-SCOPE — that is the owner's file; caio-master owns only `caio-engagement/00-…-Plan.md` + `01-Phase-Tracker.md`. |
| Writing into a phase owner's output dir (`company-ai-os/`, `caio-build/`, …) | R-SCOPE — caio-master writes only its own dedicated `caio-engagement/` dir. |

## Discipline Checks (run before final write)

| Check | Pass criterion |
|---|---|
| Every phase in scope has a gate verdict with `present` + `sufficient` + cited `evidence` | Yes |
| Every `sufficient: true` carries a ≥2-of-3 ratification (`Verified-by`) | Yes |
| Phase statuses respect the sequence (no phase `SUFFICIENT-VERIFIED` while a predecessor is open) | Yes |
| P0 verified only on an explicit GO; a NOT-YET/REDIRECT is recorded as a halt with the path back | Yes |
| Every "next step" / route names an OWNER command — zero "caio-master will build it" | Yes |
| No invented numbers — every ROI/score/index is cited from a `caio-readiness/` / `business-os/` / `company-ai-os/` / `caio-run/` artifact | Yes |
| The P4 gate cites a sponsor-approved realization spec + a live prod URL + a green ship-gate, not "the build passed" | Yes |
| Only `caio-engagement/00-CAIO-Engagement-Plan.md` + `01-Phase-Tracker.md` were written by this skill | Yes |
| Blockers (missing creds, sponsor decisions, out-of-scope files) recorded explicitly, not dropped | Yes |

If any check fails = re-run that phase's gap-check. Never ship an engagement plan that fails discipline.

## Iron Test

90 days into the engagement:
1. Did the journey **advance through gates in order** — no phase opened before its predecessor was
   `SUFFICIENT-VERIFIED`, and no phase opened past a P0 NOT-YET/REDIRECT? (Yes / no.)
2. Did at least the architect's **top-scored opportunity** travel the full seam P3 → P4 and reach a
   **live, ship-gate-verified prod URL** (the build seam)? (Yes / partial / no.)
3. Was P5 **executed** (training run, adoption measured, the 3 motions transferred unaided), not merely
   planned by the architect? (Yes / no.)
4. Is the tracker the operator's **actual driving document** — current, cited, with the next gate named?
5. At every gate, was the verdict backed by **cited evidence + 2-of-3 ratification**, never a self-report?
If 4+ of 5 pass = caio-master is doing its job: routing the whole journey, gate by gate, on evidence.
If <3 pass = either a gate opened on a self-report (tighten R-VERIFY) or caio-master leaked into rebuilding
an owner (re-read Iron Law 1) — re-run the gap-check and route, do not patch the deliverable yourself.

12-month iron test:
- Did the company cross from "we use ChatGPT sometimes" to a **measured AI surface** — N agents in
  production, the OS *operating* under `caio-run-and-optimize`, ROI re-measured against the architect's
  receipts — with caio-master as the single thread that walked every gate?
- Did a **second wave** (a new department, a new opportunity batch) re-enter via the run phase's **Expand**
  verdict at P3 (the architect) and travel the same gates without improvisation?
If yes = the engagement is self-compounding and the journey is reproducible. If no = a gate was a deck, not
a verified handoff.

## License

MIT.

---

*Version 1.0.0 :: caio-master routes the whole CAIO journey and builds nothing — qualified → sold → legible → automatable → agentic → adopted → run, one gap-checked gate at a time.*

--- **Resume:** `/caio-master` orchestre TOUTE la mission CAIO en une passe gap-check auto-corrigée — un seul Workflow racine, chaque phase routée à son owner (jamais reconstruite), chaque gate ouvert seulement sur preuve citée + ratification 2-sur-3 — et livre `caio-engagement/00-CAIO-Engagement-Plan.md` + un tracker de phases que l'opérateur pilote du go/no-go au rétainer.