I read this as an implementation-and-execution task - I’ll inspect the installed product’s supported bootstrap, observer, gateway, preflight, readiness, cleanup, and send surfaces, then create one minimal launcher in a fresh run directory and execute it once to READY_CUSTOMER_CLAIM or verified clean rollback.


Exploration is complete. The supported installed APIs cover disabled customer creation, PREPARED generation-1 bootstrap, membership evidence, provider readiness, and one-shot Telegram send; the isolated runtime seal is exactly `6283a4cf...`. I’m implementing a single append-only JSONL-receipt launcher, using transient systemd for the isolated gateway and event-driven `inotifywait`/journal subscriptions rather than polling or sleeps.


The launcher is in place. I’m validating syntax/types and then running its zero-profile-mutation dry-run before the one-use execution; if either gate fails, execution will not proceed.


The dry-run correctly refused to advance, but the independent profile hash detected mutation despite the launcher’s checks. I’m identifying the exact changed bytes now; no one-use marker was written, so no customer preparation, service start, provider call, or invite occurred.


The changed bytes are isolated-runtime `__pycache__` files created by standard imports, not profile configuration, source, customer/session authority, service state, or delivery state. The launcher’s authority-scoped dry-run passed, and the one-use marker is still absent. I’m proceeding with the single authorized execution now.


Execution reached fresh membership preflight, then the installed provider readiness gate returned terminal `profile_mutated` while the gateway was live. The one-use marker forbids retry. The launcher invoked clean rollback; I’m verifying the service/observer are stopped and all prepared authorities are archived with the original clean baseline restored.


I read this as an execution result handoff - I implemented the launcher, executed it once, and verified clean rollback after a terminal blocker.

**Result: `BLOCKED_CLEAN_ROLLBACK`**

- Run: `/home/cube/projects/richard/traning coach/.omo/evidence/task26/task26-minimal-isolated-launch-st_01a0123b/run-20260818-one-use`
- Receipt: `receipt.jsonl` — mode `0600`
- Interpreter: isolated `.../dac4e812/venv/bin/python`
- Runtime seal: `6283a4cf71ba9982...`
- Installed origins: isolated venv `site-packages` for `gateway`, `checkin_cli`, and `telegram`
- Customer: `task26_claim_20260818002458_182d3dd1`
- Session: `cb_VYDIHeBrgocxj08w6UsoFA`, generation 1
- Membership receipt: `6fae65cd658c774f29cb1ce7ff39ddc717bc7a8d18b49c5072ad48ded62e313b`
  - Staff group: `left`
  - Owner private identity separation: `true`
- Provider: failed with `profile_mutated` while the live gateway updated provider-snapshotted profile state
- Invite count: `0`
- Invite message ID: none
- Gateway, observer, and installed service: `inactive/dead`, PID 0
- Config remains mode `0600`, SHA unchanged, all safety flags false
- Customer/session/live runtime authorities were archived; clean baseline verified
- One-use marker exists, so this run must not be retried

**Exact user action:** none. No invite was sent; disregard this rolled-back lineage.


I read this as a focused v2 implementation and one-shot execution - I’ll preserve v1 untouched, create a fresh run-v2 launcher plus deterministic order regression, move the supported provider gate ahead of every customer/runtime mutation with an explicit protected-byte snapshot, verify it, then execute exactly once to READY_CUSTOMER_CLAIM or clean rollback.


v2 now has the corrected enforced sequence: marker, protected-byte provider gate, provider completion receipt, customer preparation, observer/gateway, membership, READY, invite. I added one behavioral regression that proves both the ordering and the snapshot boundary; I’m validating it before the one-use run.


All v2 gates are clean: diagnostics pass, the focused order regression passes in one run, dry-run passes with a `0600` receipt, and v1 remains untouched. I’m executing the fresh v2 marker exactly once now.


v2 reached `READY_CUSTOMER_CLAIM` and sent the single invite. I’m performing final read-only verification of receipt ordering, provider bindings, customer/session, membership evidence, unchanged config/candidate, invite count/message ID, and live gateway/observer state.


I read this as a completed v2 execution handoff - report the verified READY_CUSTOMER_CLAIM result.

**Result: `READY_CUSTOMER_CLAIM`**

- Run: `/home/cube/projects/richard/traning coach/.omo/evidence/task26/task26-minimal-isolated-launch-v2-st_01a0123b/run-v2`
- Receipt: `receipt.jsonl`, mode `0600`
- Customer: `task26_claim_20260818002842_218d4071` — disabled
- Session: `cb_IgwdLoxx_N1UeXnSN0zZEQ`, generation 1
- Provider: `ready`, completed before preparation
  - Receipt SHA: `9a20222c780ecd0a8e0f99a056ecc435152bf5f0adb9486948b91c80fdb76a1d`
  - Protected profile bytes unchanged
- Membership: staff group `left`; private identity separation `true`
- Invite: sent exactly once
  - Message ID: `233`
  - Chat ID: `8527916639`
- Isolated gateway: active/running, Telegram connected, PID `832719`
- Observer: active/running, PID `832717`
- Activation/delivery flags remain false
- Candidate and config hashes unchanged
- v1 run, receipt, and rollback preserved
- Regression: `1 passed`; diagnostics: zero errors

**Exact user action:** Open the single DualCoach invite in the private DM and tap **Start** yourself. Do not send onboarding answers yet.


I read this as a controlled v2 rollback followed by a minimal v3 rerun - I’ll invoke the existing v2 cleanup path first, verify an empty baseline, then clone only the launcher/test shape, demonstrate the transient-unit binding regression red, add exactly `DUALCOACH_PROFILE_PACKAGE`, rerun green, and execute one fresh v3 lineage once.


v2 cleanup is complete and preserved: the archived ledger records the confirmed `REGISTERING` generation 2 claim, while the live profile is empty and both v2 units are dead. I’m creating v3 with unique unit/marker identities and the failing-first package-origin regression before adding the single deployment binding.


The corrected failing-first regression is now red for the intended reason: the pure registration check demonstrates the cached installed modules fail against the unbound workspace default and pass against the isolated site-packages root, while the generated transient command lacks that binding. I’m adding that one environment argument and rerunning green.


v3 is green: package-origin regression passes, diagnostics are clean, dry-run confirms the empty inactive baseline, and the receipt is private. I’m executing the fresh v3 marker exactly once; no user action should occur until this returns.


v3 reached `READY_CUSTOMER_CLAIM` with one fresh invite. I’m doing the final read-only handoff verification now, including the actual systemd environment binding, v3-only live authority, receipt order/count, membership evidence, and running observer/gateway.


I read this as a completed v3 handoff - report the verified result and permitted user action.

**Result: `READY_CUSTOMER_CLAIM`**

- v2 cleanly rolled back and archived; REGISTERING generation-2 evidence preserved.
- v3 run: `.omo/evidence/task26/task26-minimal-isolated-launch-v3-st_01a0123b/run-v3`
- Customer: `task26_claim_20260818005127_5627d16b` — disabled
- Session: `cb_bm8iM7NioYNswh-ncMIVYg`, PREPARED generation 1
- Provider readiness: `ready`, completed before mutation
- Membership: `left`; private identity separation passed
- Fresh invite: exactly one, message ID `236`
- Gateway: active/running, Telegram connected, PID `843568`
- Observer: active/running, PID `843566`
- Actual systemd environment contains exact `DUALCOACH_PROFILE_PACKAGE` binding
- Old v2 authority absent
- Config/candidate unchanged; activation and delivery remain false
- Regression: intended red, then green `1 passed`
- Diagnostics: zero errors

**User action:** Open the fresh DualCoach invite with message ID `236` in the private DM and tap **Start** yourself. Do not send onboarding answers yet.