diff --git a/manifest.json b/manifest.json
index a30cf1b..efbc545 100644
--- a/manifest.json
+++ b/manifest.json
@@ -519,6 +519,11 @@
       "slug": "speed-import",
       "path": "workflows/speed-import.workflow.json",
       "updated_at": "2026-07-30T18:00:00Z"
+    },
+    {
+      "slug": "catalog-launch-guard",
+      "path": "workflows/catalog-launch-guard.workflow.json",
+      "updated_at": "2026-07-31T23:20:00Z"
     }
   ]
 }
diff --git a/workflows/catalog-launch-guard.workflow.json b/workflows/catalog-launch-guard.workflow.json
new file mode 100644
index 0000000..9ccecef
--- /dev/null
+++ b/workflows/catalog-launch-guard.workflow.json
@@ -0,0 +1,215 @@
+{
+  "revision": "2026-07-31-v3-deterministic-artifacts",
+  "slug": "catalog-launch-guard",
+  "name": "Catalog Launch Guard",
+  "description": "Audit every catalog record before launch, separate confirmed blockers from legitimate merchandising structures, and publish an evidence-backed red/amber/green dashboard plus CEO page brief. Read-only against Fluid; no automatic merge, delete, repricing, or publish action.",
+  "maxParallel": 2,
+  "finalGate": {
+    "stepId": "launch-gate-review",
+    "allowNeedsReview": false
+  },
+  "steps": [
+    {
+      "id": "catalog-evidence",
+      "name": "Capture complete catalog",
+      "prompt": "Capture a fresh, complete, read-only catalog evidence set for the active company. This is a launch audit, not an import.\n\nArtifact contract (applies to this step): all run artifacts live under the run's artifact directory; every count, list, percentage, and hash you report must be printed by a verification script executed with `run_cli` as `npm exec --yes -- node <script>` — model-recalled or hand-counted numbers are a defect. Scripts must be created with `write_file`, read only saved artifact files, and follow this skeleton: (a) write EXACTLY one JSON object to a summary file (e.g. `<artifact_dir>/verify-summary.json`) and read it back with `read_file` — never parse run_cli's merged stdout/stderr stream; the object is `{\"ok\":true,...}` with exit 0, or `{\"ok\":false,\"error\":{code,message}}` with `process.exit(1)`, and consumers gate on `ok`, never on the mere presence of numbers; (b) refuse to report on data that is not there: assert a minimum expected row count and cross-check any declared count in the input against rows actually parsed — zero defects on zero or partial rows is an ERROR, never a pass; (c) cap every id list at 20 and the field inventory at 200, each with `total` and `truncated` flags, full lists to sibling artifact files; (d) emit an `integrity` block (input file sha256, byte size, declared vs observed row counts) so later steps can prove they reasoned over the same snapshot; (e) be idempotent — reruns must produce byte-identical summaries. If `npm exec` is unavailable, report that as a data gap and stop the affected check — never fall back to hand-counting. Permitted tools for audit work: `read_file`, `write_file`, `list_dir`, `search_files`, `run_cli` (npm/git only), `fluid_catalog_index`, documented v202604 GETs via `fluid_api`, and `query_docs`; do not probe other tools or undocumented paths.\n\n1. Determine the run artifact directory first: let `RUN_PREFIX` be `context.run_prefix` when the caller supplies it, otherwise mint `clg-<UTC now as YYYYMMDDTHHMMSSZ>`. Every artifact this run writes lives under `<RUN_PREFIX>/` (for example `<RUN_PREFIX>/index.json`). Emit `run_prefix` and `artifact_dir` in STEP_OUTPUT so later steps reuse it.\n2. Read optional caller `context.catalog_expectations` when present. Supported expectations are `minimum_bundle_count`, `required_phrases` (array), `allowed_zero_price_title_patterns` (array), and `minimum_subscription_product_count`. Treat absent keys as `not specified`, never as zero. These are merchant expectations, not universal rules.\n3. Call `query_docs` for the April 2026 company Product list/detail response before assuming fields. Then call `fluid_catalog_index` once with `output_path: \"<RUN_PREFIX>/index.json\"` and `verify_only: false`. Require `complete: true`, `next_cursor: null`, zero duplicate ids, first/middle/last detail receipts, and the file SHA-256. This tool proves IDENTITY completeness; it does not capture audit fields.\n4. Capture full bodies yourself: cursor-paginate `GET /api/v202604/company/products` with `fluid_api`, following every returned `meta.pagination.next_cursor` until null — never stop from a page count or `total_count`. Use the largest page size the endpoint accepts (try `page[limit]=100` first; record the size that actually worked). After EACH page, save that page's `products` array verbatim with `write_file` to `<RUN_PREFIX>/pages/page-<NN>.json` before requesting the next page. Use the documented detail endpoint only for fields the list omits on records you later need to inspect; save any detail responses you fetch to `<RUN_PREFIX>/details/<id>.json`.\n5. Create `<RUN_PREFIX>/clg-verify.mjs` with `write_file` and run it. The script must read `<RUN_PREFIX>/index.json` and every `<RUN_PREFIX>/pages/*.json`, then print/persist: row, unique-id, and duplicate-id counts; an exact two-way id-set reconciliation between the walked pages and the index (exit 1 on any delta); lifecycle counts (by `status` and `active`, sellable vs not); ids with missing or zero price per currency; ids missing `image_url` or resized versions; groups of two or more products sharing an identical `image_url` (placeholder detection); duplicate non-empty SKU groups with lifecycle; normalized-title duplicate groups with per-currency price spread; `field_inventory` as the exact union of JSON key paths across every captured record (label it as computed from the captured list pages plus any saved details); and a SHA-256 for every artifact file including itself. Write the full aggregates to `<RUN_PREFIX>/aggregates.json`; stdout carries the capped summary only.\n6. Do not change products, variants, prices, bundles, plans, images, or lifecycle. Do not infer a missing business concept from an absent response field.\n\nEnd with `STEP_OUTPUT:` containing `run_prefix`, `artifact_dir`, `index_path`, `index_sha256`, `aggregates_path`, `aggregates_sha256`, `verify_script_path`, `observed_at`, `pages`, `page_size_used`, `row_count`, `unique_id_count`, `duplicate_id_count`, `reconciliation_delta`, `lifecycle_counts`, `field_inventory_source`, `unavailable_fields`, `expectations`, and `evidence_ready: true|false`. Cap every list at 20 ids and reference the artifact file holding the full list.",
+      "target": {
+        "type": "manager"
+      },
+      "acceptance": [
+        "`fluid_catalog_index` independently proves a terminal null cursor, complete identity set, zero duplicate ids, first/middle/last detail receipts, and a SHA-256 for the run-prefixed index file.",
+        "Full product bodies are persisted page-by-page under the run's `pages/` directory, and a committed, re-runnable verification script proves an exact two-way id-set match between the walked pages and the index (reconciliation delta zero, script exit code 0).",
+        "Every count, list, and percentage in the report is script output over the saved artifacts; `aggregates.json` exists with a SHA-256; and the field inventory is the script-computed union of key paths across the captured records, labeled with exactly that provenance. Verify by reading the saved artifacts and re-deriving spot values — re-walking the live catalog is NOT required and wastes context; at most two live spot-check GETs.",
+        "The evidence capture is read-only against Fluid and claims no product, variant, price, bundle, plan, image, or lifecycle change."
+      ],
+      "qa": {
+        "enabled": true,
+        "strictness": "strict",
+        "onFail": "stop",
+        "requiredTools": [
+          {
+            "tool": "fluid_catalog_index",
+            "minSuccessfulCalls": 1
+          },
+          {
+            "tool": "read_file",
+            "minSuccessfulCalls": 2
+          }
+        ]
+      },
+      "dependsOn": [],
+      "maxReworkRounds": 2,
+      "recovery": {
+        "mode": "manual"
+      }
+    },
+    {
+      "id": "structural-audit",
+      "name": "Audit catalog structure",
+      "prompt": "Audit every captured catalog record from `catalog-evidence` and classify structural risk without assuming every unusual record is wrong. Stay read-only against Fluid. Read `artifact_dir` from the catalog-evidence STEP_OUTPUT; work from the saved artifacts — do NOT re-walk the live catalog.\n\nArtifact contract (applies to this step): all run artifacts live under the run's artifact directory; every count, list, percentage, and hash you report must be printed by a verification script executed with `run_cli` as `npm exec --yes -- node <script>` — model-recalled or hand-counted numbers are a defect. Scripts must be created with `write_file`, read only saved artifact files, and follow this skeleton: (a) write EXACTLY one JSON object to a summary file (e.g. `<artifact_dir>/verify-summary.json`) and read it back with `read_file` — never parse run_cli's merged stdout/stderr stream; the object is `{\"ok\":true,...}` with exit 0, or `{\"ok\":false,\"error\":{code,message}}` with `process.exit(1)`, and consumers gate on `ok`, never on the mere presence of numbers; (b) refuse to report on data that is not there: assert a minimum expected row count and cross-check any declared count in the input against rows actually parsed — zero defects on zero or partial rows is an ERROR, never a pass; (c) cap every id list at 20 and the field inventory at 200, each with `total` and `truncated` flags, full lists to sibling artifact files; (d) emit an `integrity` block (input file sha256, byte size, declared vs observed row counts) so later steps can prove they reasoned over the same snapshot; (e) be idempotent — reruns must produce byte-identical summaries. If `npm exec` is unavailable, report that as a data gap and stop the affected check — never fall back to hand-counting. Permitted tools for audit work: `read_file`, `write_file`, `list_dir`, `search_files`, `run_cli` (npm/git only), `fluid_catalog_index`, documented v202604 GETs via `fluid_api`, and `query_docs`; do not probe other tools or undocumented paths.\n\nCreate `<artifact_dir>/clg-audit.mjs` with `write_file` (or extend the existing verify script) so every inventory below is computed programmatically over `<artifact_dir>/pages/*.json` and `aggregates.json`. The script counts; you classify and judge. Use bounded documented v202604 detail GETs for at most 10 records where the captured data is genuinely ambiguous, saving each response to `<artifact_dir>/details/<id>.json`. Inventories:\n- exact normalized-title groups and near-title candidates, retaining every id, lifecycle, price/currency, SKU, variant count, and distinguishing field;\n- duplicate non-empty SKU assignments;\n- active/public/sellable records with missing or zero price, missing currency, no purchasable variant, missing primary image, blank title, or unusable canonical route;\n- price divergence inside an exact-title group, separated by currency, subscription vs one-time price, interval, variant/options, and package quantity when those fields exist;\n- option axes and variant combinations, flagging only explicit duplicate combinations or missing required values; never synthesize a Cartesian product;\n- bundle markers/components and subscription-plan relationships when the captured response exposes them; otherwise report the audit dimension unavailable;\n- optional `catalog_expectations`: minimum counts and required phrases apply only when supplied. Search required phrases only in documented product copy fields, case-insensitively, and report field coverage.\n\nClassify each script-surfaced finding:\n- `confirmed_blocker_candidate`: mechanically unlaunchable evidence such as a sellable record with no usable price/currency or purchasable variant, a duplicate non-empty SKU on simultaneously sellable records, or an unusable canonical route;\n- `merchant_review`: exact/near duplicate titles, divergent prices, zero prices, missing images, bundle/plan absence, or required-text misses that may be deliberate;\n- `informational`: lifecycle and coverage facts with no failure claim.\n\nA duplicate title, zero price, missing bundle marker, or price difference is NEVER automatically a confirmed blocker. Preserve distinct product ids; do not merge, delete, archive, reprice, or publish anything. Never assign avoided-revenue dollars without order/conversion evidence.\n\nWrite the complete classified findings to `<artifact_dir>/findings.json`. End with `STEP_OUTPUT:` containing `artifact_dir`, `findings_path`, `audited_ids`, `coverage_percent`, `confirmed_blocker_candidates`, `merchant_review`, `informational`, `dimension_coverage`, `expectation_results`, `currency_blocks`, `data_gaps`, and `fluid_writes_performed: false`. Cap every list at 20 ids; totals must equal the length of the corresponding list in `findings.json`.",
+      "target": {
+        "type": "manager"
+      },
+      "acceptance": [
+        "Every captured unique product id is audited exactly once with coverage computed by script over the saved pages (100%); every inventory count is script output, each finding carries the source id and exact observed fields that triggered it, and at most 10 live detail GETs were used.",
+        "Duplicate titles, price divergence, zero prices, missing images, bundle/plan absence, and required-text misses remain merchant-review findings unless independent evidence proves a mechanically unlaunchable state.",
+        "Price comparisons stay within currency and distinguish one-time/subscription, cadence, variants/options, and package quantity whenever those fields exist; unavailable dimensions are reported. Verify from the saved artifacts and `findings.json` — re-walking the live catalog is NOT required; at most two live spot-check GETs.",
+        "No merge, delete, archive, reprice, publish, bundle, plan, media, or other Fluid mutation occurred, and no unsupported avoided-revenue estimate is present."
+      ],
+      "qa": {
+        "enabled": true,
+        "strictness": "strict",
+        "onFail": "continue",
+        "requiredTools": [
+          {
+            "tool": "read_file",
+            "minSuccessfulCalls": 2
+          },
+          {
+            "tool": "fluid_api",
+            "minSuccessfulCalls": 1,
+            "input": {
+              "method": "GET"
+            }
+          }
+        ]
+      },
+      "dependsOn": [
+        "catalog-evidence"
+      ],
+      "maxReworkRounds": 2,
+      "recovery": {
+        "mode": "manual"
+      }
+    },
+    {
+      "id": "flag-review",
+      "name": "Review flagged records",
+      "prompt": "Independently validate the structural audit's flags against product detail records and produce the approval-safe launch queue. Stay read-only.\n\nRead `artifact_dir` and `findings_path` from the structural-audit STEP_OUTPUT and load the full findings from `findings.json` with `read_file` — the STEP_OUTPUT lists are capped samples, the file is the source of truth. Build a deterministic review set of at most 20 products: include every confirmed-blocker candidate when there are 20 or fewer; otherwise take the 20 highest-severity candidates sorted by stable product id. Fill remaining slots with a stratified sample across exact-title duplicates, divergent prices, zero/missing price, missing image, SKU reuse, variant/options, bundle/plan, required-text, and informational clean records. Record the selection rule.\n\nFor every selected id, GET the documented v202604 Product detail and re-check the exact trigger in context. Where a canonical route exists, use one bounded read-only `crawl` for each confirmed-blocker candidate up to a maximum of five routes; a route that renders the wrong product, errors, or is blank confirms a route blocker, while a correctly rendered PDP may clear only that route finding.\n\nClassify every sampled flag as:\n- `confirmed_blocker`: live detail/route proves the sellable record cannot be purchased or reliably identified;\n- `merchant_decision`: the structure is real but intent cannot be known from data;\n- `cleared_false_positive`: detail evidence disproves the trigger;\n- `unverifiable`: missing field, route, or access prevents judgment.\n\nCalculate sample false-positive rate as `cleared_false_positive / reviewed_flags`, and state it as the two integers plus the fraction (for example `2/18 = 11.1%`) so the arithmetic is checkable. A launch gate may be GREEN only with zero confirmed blockers, zero unverifiable critical candidates, complete evidence, and false-positive rate <=10%. AMBER means merchant decisions/data gaps remain but nothing mechanically blocks launch. RED means one or more confirmed blockers, incomplete catalog evidence, an unverifiable critical candidate, or false-positive rate above 10%.\n\nNever repair findings in this workflow. Produce an approval queue with product id, title, evidence, recommended review action, risk of acting incorrectly, and the exact future write type that would require explicit approval.\n\nWrite the complete approval queue to `<artifact_dir>/approval-queue.json`. End with `STEP_OUTPUT:` containing `artifact_dir`, `approval_queue_path`, `selection_rule`, `reviewed_products`, `reviewed_flags`, `confirmed_blockers`, `merchant_decisions`, `cleared_false_positives`, `unverifiable`, `false_positive_rate`, `gate`, `approval_queue`, and `fluid_writes_performed: false`.",
+      "target": {
+        "type": "manager"
+      },
+      "acceptance": [
+        "The deterministic review set contains at most 20 products, covers every critical candidate when possible plus stratified anomaly and clean cases, and records the exact selection rule.",
+        "Each reviewed finding is re-opened by documented Product detail GET and classified as confirmed blocker, merchant decision, cleared false positive, or unverifiable with evidence; up to five critical canonical routes are read-only crawled when available.",
+        "The false-positive rate is stated as its integer numerator and denominator with the resulting percentage, the GREEN/AMBER/RED rules are applied exactly (<=10% GREEN threshold, RED for incomplete evidence or unverifiable critical candidates), and the full approval queue is persisted to the run's artifact directory.",
+        "The approval queue names future write types and risk of acting incorrectly, while this run performs no catalog repair or Fluid mutation."
+      ],
+      "qa": {
+        "enabled": true,
+        "strictness": "strict",
+        "onFail": "continue",
+        "requiredTools": [
+          {
+            "tool": "fluid_api",
+            "minSuccessfulCalls": 3,
+            "input": {
+              "method": "GET"
+            },
+            "distinctBy": [
+              "path"
+            ]
+          }
+        ]
+      },
+      "dependsOn": [
+        "structural-audit"
+      ],
+      "maxReworkRounds": 2,
+      "recovery": {
+        "mode": "manual"
+      }
+    },
+    {
+      "id": "publish-launch-dashboard",
+      "name": "Publish launch dashboard",
+      "prompt": "Publish a CEO-ready Catalog Launch Guard dashboard and a page-ready More-for-Less brief from the verified flag review.\n\nRead `artifact_dir` from prior STEP_OUTPUTs, then load `aggregates.json`, `findings.json`, and `approval-queue.json` with `read_file` — every number on the dashboard must be copied verbatim from those artifacts or the flag-review STEP_OUTPUT, never recomputed in your head. Preserve every needs-review finding and data gap. Call `list_dashboards`, then call `show_dashboard` with one descriptor:\n- title `Catalog Launch Guard`; subtitle names the observation timestamp and says `Read-only audit`; `dataAsOf` equals evidence freshness;\n- headline `stat_tiles`: rows audited, coverage percent, confirmed blockers, merchant decisions, and false-positive rate;\n- a lifecycle breakdown `stat_rows` (active / draft / archived, sellable vs not) sourced from `aggregates.json`, so total rows are never mistaken for live products;\n- a prominent GREEN/AMBER/RED `insight_banner` containing the exact gate reason;\n- a risk breakdown `donut_chart` or `stat_rows` for blocker candidates, merchant review, cleared false positives, and unverifiable flags;\n- a `mini_table` of confirmed blockers and highest-priority merchant decisions with product id, finding, evidence, and recommended approval action;\n- a dimension-coverage card for lifecycle, price/currency, variants/options, SKU, image, route, bundle, subscription plan, and configured expectations, marking unavailable rather than silently dropping a dimension;\n- an assumptions/data-quality banner saying anomalies are not automatically errors, no repairs were made, and non-identity fields are as-of the step-1 `observed_at` timestamp.\n\nUse raw numeric metrics with `number`, `compact`, `percent`, or `ratio_percent`; do not pre-format numeric strings or invent revenue. If dashboard validation fails, repair only its descriptor.\n\nThen write a `## CEO value page brief` under 350 words to `<artifact_dir>/brief.md` with `write_file`, containing exactly: `Headline`, `What Mist checked`, `Launch decision`, `What needs approval`, `More for less`, `Controls`, and `Evidence limits`. The headline must use verified coverage and gate counts, not avoided-revenue dollars. In `More for less`, write `Wall-clock run window: reported at final gate.` — the final step fills the measured value; do not invent a runtime or speed multiplier. State that no product, variant, price, bundle, plan, image, or lifecycle record changed.\n\nSaving/showing the local dashboard and writing run artifacts are the only state changes. End with `STEP_OUTPUT:` containing `artifact_dir`, `dashboard_title`, `dashboard_id` when returned, `data_as_of`, `gate`, `coverage`, `confirmed_blockers`, `merchant_decisions`, `false_positive_rate`, `brief_path`, `data_gaps`, and `fluid_writes_performed: false`. Do NOT inline the brief text in STEP_OUTPUT — pass `brief_path` only (step outputs are truncated at 12,000 characters and a truncated brief silently corrupts downstream steps).",
+      "target": {
+        "type": "manager"
+      },
+      "acceptance": [
+        "`list_dashboards` shows a saved `Catalog Launch Guard` dashboard with the exact evidence freshness, audit coverage, gate, blocker/decision counts, and false-positive rate from the run's artifact files.",
+        "The dashboard includes a visible gate reason, risk breakdown, lifecycle breakdown (live vs archived), approval table, full dimension-coverage card, and data-quality warning, with every number traceable to the artifact files, without invented revenue or hidden unavailable evidence.",
+        "The under-350-word CEO brief exists at the run's `brief.md` with all seven required sections, defers the runtime value to the final gate rather than inventing one, uses verified coverage/counts, and does not claim anomalies are errors or repairs are complete.",
+        "STEP_OUTPUT carries `brief_path` instead of inlined brief text, and `fluid_writes_performed` is false — the local dashboard and run artifacts were the only state changes."
+      ],
+      "qa": {
+        "enabled": true,
+        "strictness": "strict",
+        "onFail": "continue",
+        "requiredTools": [
+          {
+            "tool": "list_dashboards",
+            "minSuccessfulCalls": 1
+          },
+          {
+            "tool": "read_file",
+            "minSuccessfulCalls": 1
+          }
+        ]
+      },
+      "dependsOn": [
+        "catalog-evidence",
+        "structural-audit",
+        "flag-review"
+      ],
+      "maxReworkRounds": 2,
+      "recovery": {
+        "mode": "manual"
+      }
+    },
+    {
+      "id": "launch-gate-review",
+      "name": "Review launch gate",
+      "prompt": "Perform the final independent launch-gate review. Read-only against Fluid; do not redo the whole audit and do not repair records.\n\nArtifact contract (applies to this step): all run artifacts live under the run's artifact directory; every count, list, percentage, and hash you report must be printed by a verification script executed with `run_cli` as `npm exec --yes -- node <script>` — model-recalled or hand-counted numbers are a defect. Scripts must be created with `write_file`, read only saved artifact files, and follow this skeleton: (a) write EXACTLY one JSON object to a summary file (e.g. `<artifact_dir>/verify-summary.json`) and read it back with `read_file` — never parse run_cli's merged stdout/stderr stream; the object is `{\"ok\":true,...}` with exit 0, or `{\"ok\":false,\"error\":{code,message}}` with `process.exit(1)`, and consumers gate on `ok`, never on the mere presence of numbers; (b) refuse to report on data that is not there: assert a minimum expected row count and cross-check any declared count in the input against rows actually parsed — zero defects on zero or partial rows is an ERROR, never a pass; (c) cap every id list at 20 and the field inventory at 200, each with `total` and `truncated` flags, full lists to sibling artifact files; (d) emit an `integrity` block (input file sha256, byte size, declared vs observed row counts) so later steps can prove they reasoned over the same snapshot; (e) be idempotent — reruns must produce byte-identical summaries. If `npm exec` is unavailable, report that as a data gap and stop the affected check — never fall back to hand-counting. Permitted tools for audit work: `read_file`, `write_file`, `list_dir`, `search_files`, `run_cli` (npm/git only), `fluid_catalog_index`, documented v202604 GETs via `fluid_api`, and `query_docs`; do not probe other tools or undocumented paths.\n\nRead all completed outputs and QA findings, and `artifact_dir` from prior STEP_OUTPUTs. Then:\n1. Re-run the run's committed verification scripts (`clg-verify.mjs`, `clg-audit.mjs`) with `run_cli` and require exit code 0 and printed tallies that match every number in the dashboard, `brief.md`, and prior STEP_OUTPUTs exactly.\n2. Call `fluid_catalog_index` with `output_path: \"<artifact_dir>/index-verify.json\"` and `verify_only: true`. A changed SHA-256 or id-set delta versus step 1 is a FRESHNESS finding, not an automatic failure: report the exact delta, set the gate to AMBER with reason `catalog changed during audit`, and keep RED only when a previously confirmed blocker's evidence no longer reproduces or a new mechanical blocker is proven live.\n3. Use bounded documented Product GETs to reproduce every confirmed blocker and a deterministic sample of at least five merchant decisions (or all when fewer).\n4. Call `list_dashboards` to confirm the saved artifact.\n5. Compute BY SCRIPT the wall-clock run window as the difference between step 1's `observed_at` and the current UTC time, and label it exactly `wall-clock run window (includes QA and review time)` — never present it as pure compute time. Write `<artifact_dir>/brief-final.md` as a copy of `brief.md` with the `More for less` runtime line filled with that labeled value.\n\nFail when catalog/index reconciliation is incomplete for reasons other than live catalog drift, audit coverage is below 100% of the captured set, a blocker lacks live evidence, a merchant-review anomaly was promoted to an error without proof, currencies/price types were mixed, unavailable fields were hidden, the false-positive calculation/gate is wrong, a Fluid mutation occurred, or the dashboard/brief misstates the evidence.\n\nReturn a presenter handoff:\n- `Decision`: GREEN, AMBER, or RED plus one sentence;\n- `Live proof`: observed timestamp, indexed rows, unique ids, coverage, the per-file SHA-256 list, and the wall-clock run window;\n- `Confirmed blockers`: count and ids;\n- `Needs merchant decision`: count and top items;\n- `Approval boundary`: future write types, with no action taken;\n- `Demo path`: dashboard gate -> one evidence-backed flag -> approval queue;\n- `CEO page copy`: the path to `brief-final.md` (do not inline it);\n- `Unresolved`: all data/QA gaps.\n\nEnd with `STEP_OUTPUT:` containing `ready: true|false`, `gate`, `dashboard_id`, `live_proof`, `confirmed_blockers`, `merchant_decisions`, `false_positive_rate`, `wall_clock_run_window`, `approval_boundary`, `demo_path`, `brief_final_path`, `fluid_writes_performed: false`, and `unresolved`.",
+      "target": {
+        "type": "manager"
+      },
+      "acceptance": [
+        "The verification scripts re-run with exit code 0 and reproduce every dashboard, brief, and STEP_OUTPUT tally exactly; the verify-only re-index either matches step 1's SHA-256 and id set, or the delta is reported as a freshness finding that downgrades the gate to AMBER rather than silently passing or hard-failing.",
+        "Live Product GETs reproduce every confirmed blocker plus at least five merchant decisions when available, and the final GREEN/AMBER/RED decision follows the authored thresholds exactly without elevating a duplicate title, zero price, price difference, or missing relationship into a confirmed error without evidence.",
+        "`brief-final.md` exists, matches `brief.md` except the filled `More for less` runtime line, and that value is labeled as the wall-clock run window including QA and review time — never as pure compute time or an invented speed multiplier.",
+        "`fluid_writes_performed` is false and the handoff requires explicit approval before any product, variant, price, bundle, plan, media, or lifecycle write."
+      ],
+      "qa": {
+        "enabled": true,
+        "strictness": "strict",
+        "onFail": "stop",
+        "requiredTools": [
+          {
+            "tool": "fluid_catalog_index",
+            "minSuccessfulCalls": 1
+          },
+          {
+            "tool": "fluid_api",
+            "minSuccessfulCalls": 2,
+            "input": {
+              "method": "GET"
+            },
+            "distinctBy": [
+              "path"
+            ]
+          },
+          {
+            "tool": "list_dashboards",
+            "minSuccessfulCalls": 1
+          },
+          {
+            "tool": "read_file",
+            "minSuccessfulCalls": 1
+          }
+        ]
+      },
+      "dependsOn": [
+        "catalog-evidence",
+        "structural-audit",
+        "flag-review",
+        "publish-launch-dashboard"
+      ],
+      "maxReworkRounds": 2,
+      "recovery": {
+        "mode": "manual"
+      }
+    }
+  ]
+}
\ No newline at end of file