From c94ba9aa420de298b56441710e1f96af96f22df5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Wed, 29 Jul 2026 13:32:57 +0200
Subject: [PATCH 01/34] chore(workflow): dedupe and prune learnings

Delete learnings whose fixes landed in scripts or WORKFLOW.md (slot teardown,
steer.sh, dispatch-role.sh, monitor rules, TTY rule, env-facts rule, PR image
upload), merge overlapping entries (kilo startup crashes, Android emulator
claims, Android cold-start deep link, device-auth pending limit, iOS26 Maestro
quirks), and trim stale or contradicting paragraphs.
---
 .kilo_workflow/WORKFLOW.md                    |  4 +-
 ...mserver-restart-systemui-anr-under-load.md |  5 --
 ...v-stack-died-mid-round-restart-in-place.md | 19 +++++++
 ...tching-kilo-agents-from-another-harness.md | 21 --------
 ...2e-slot-owner-must-be-dedicated-session.md | 17 -------
 ...-release-stopped-another-sections-stack.md | 49 -------------------
 .../github-pr-no-image-upload-api.md          | 13 -----
 .../handoff-env-facts-must-be-inline.md       |  7 ---
 ...os-simulator-cannot-starve-location-fix.md |  3 --
 ...kilo-provider-model-not-found-transient.md |  2 +-
 .../kilo-run-crashes-on-credential-write.md   | 43 ----------------
 .../kilo-run-interactive-requires-tty.md      |  7 ---
 .../kilo-run-session-not-found-or-db-race.md  |  7 ---
 .../kilo-run-startup-crash-transient.md       | 39 +++++++++++++++
 ...claw-chat-attachments-r2-secret-missing.md | 36 +++++---------
 ...-docker-tcp-absent-from-worktree-status.md |  2 +
 ...mobile-android-claim-race-at-visibility.md | 13 -----
 ...android-dev-client-cold-start-deep-link.md | 38 +++++++++-----
 .../mobile-android-emulator-claims.md         | 19 +++++++
 ...bile-android-emulator-r7-envelope-notes.md | 13 -----
 ...-deep-link-reload-outlasts-flow-budgets.md | 23 ---------
 .../mobile-android-maestro-flow-pitfalls.md   |  4 ++
 ...bile-android-stale-claims-explicit-port.md | 20 --------
 ...le-device-auth-ip-limit-shared-sections.md | 20 --------
 .../mobile-device-auth-stuck-pending-rows.md  | 49 +++++++++++--------
 .../mobile-ios26-maestro-under-load.md        |  7 +--
 ...-attachments-capability-gate-blocks-e2e.md | 12 ++---
 ...maestro-between-flow-springboard-bounce.md | 19 -------
 ...hestrator-scrollback-before-intervening.md | 25 ----------
 ...mulators-left-booted-after-slot-release.md | 43 ----------------
 .../steering-a-running-kilo-session.md        | 11 -----
 .kilo_workflow/steer.sh                       |  2 +-
 32 files changed, 159 insertions(+), 433 deletions(-)
 create mode 100644 .kilo_workflow/learnings/dev-stack-died-mid-round-restart-in-place.md
 delete mode 100644 .kilo_workflow/learnings/dispatching-kilo-agents-from-another-harness.md
 delete mode 100644 .kilo_workflow/learnings/e2e-slot-owner-must-be-dedicated-session.md
 delete mode 100644 .kilo_workflow/learnings/e2e-slot-release-stopped-another-sections-stack.md
 delete mode 100644 .kilo_workflow/learnings/github-pr-no-image-upload-api.md
 delete mode 100644 .kilo_workflow/learnings/handoff-env-facts-must-be-inline.md
 delete mode 100644 .kilo_workflow/learnings/kilo-run-crashes-on-credential-write.md
 delete mode 100644 .kilo_workflow/learnings/kilo-run-interactive-requires-tty.md
 delete mode 100644 .kilo_workflow/learnings/kilo-run-session-not-found-or-db-race.md
 create mode 100644 .kilo_workflow/learnings/kilo-run-startup-crash-transient.md
 delete mode 100644 .kilo_workflow/learnings/mobile-android-claim-race-at-visibility.md
 create mode 100644 .kilo_workflow/learnings/mobile-android-emulator-claims.md
 delete mode 100644 .kilo_workflow/learnings/mobile-android-emulator-r7-envelope-notes.md
 delete mode 100644 .kilo_workflow/learnings/mobile-android-login-deep-link-reload-outlasts-flow-budgets.md
 delete mode 100644 .kilo_workflow/learnings/mobile-android-stale-claims-explicit-port.md
 delete mode 100644 .kilo_workflow/learnings/mobile-device-auth-ip-limit-shared-sections.md
 delete mode 100644 .kilo_workflow/learnings/mobile-maestro-between-flow-springboard-bounce.md
 delete mode 100644 .kilo_workflow/learnings/monitor-must-read-orchestrator-scrollback-before-intervening.md
 delete mode 100644 .kilo_workflow/learnings/simulators-left-booted-after-slot-release.md
 delete mode 100644 .kilo_workflow/learnings/steering-a-running-kilo-session.md

diff --git a/.kilo_workflow/WORKFLOW.md b/.kilo_workflow/WORKFLOW.md
index 98874ad592..9702f781ce 100644
--- a/.kilo_workflow/WORKFLOW.md
+++ b/.kilo_workflow/WORKFLOW.md
@@ -77,7 +77,7 @@ Worker roles are steered by re-dispatching them (see Escalation). The interactiv
 printf '%s' "$AMENDMENT" | .kilo_workflow/steer.sh <section>-orchestrator -   # long or multi-line text via stdin
 ```
 
-It prints `running` when the session took the message immediately and `queued` when the message is waiting behind the active turn; either way it is delivered. A non-zero exit means it is **not** delivered — inspect the target rather than sending a second copy. What the script encodes (details in `learnings/steering-a-running-kilo-session.md`):
+It prints `running` when the session took the message immediately and `queued` when the message is waiting behind the active turn; either way it is delivered. A non-zero exit means it is **not** delivered — inspect the target rather than sending a second copy. What the script encodes (details in its header comments):
 
 - Enter as its own keystroke after the text. A trailing `Enter` in the same `send-keys` call submits short messages but is swallowed by long ones, which then sit unsent in the composer — the "wedged" session that is really an undelivered message.
 - Bracketed paste, so a multi-line message stays one prompt. An unbracketed paste submits at every newline, and the first fragment gets acted on before the rest arrives.
@@ -194,7 +194,7 @@ The `orchestrator` agent definition pins the model and permissions, so the launc
 
 After the handoff the planner stops all hands-on work. It has exactly one job — relaunch or unstick the orchestrator when infrastructure fails (a crashed kilo CLI, a dead tmux window, a hung service). Product, logic, design, and review problems are the orchestrator's, handled by its escalation ladder. Check about every 30 minutes; react immediately when the orchestrator's process exits.
 
-A monitor never kills a live dispatch on a judgment call, never edits the worktree, and never writes to another role's dispatch log — a forged `EXITCODE` line corrupts the dispatcher's void-round detection, the exact signal the contract keys on. Before concluding an orchestrator is misbehaving, read its evidence: its pane scrollback (`tmux capture-pane -t <window> -p -S -`), its scratch directory, and the git log. The orchestrator's handoff may route user questions to its own interactive session, so an answer the monitor never saw can exist there (see `learnings/monitor-must-read-orchestrator-scrollback-before-intervening.md`). The only kill-worthy states are the infrastructure failures named above.
+A monitor never kills a live dispatch on a judgment call, never edits the worktree, and never writes to another role's dispatch log — a forged `EXITCODE` line corrupts the dispatcher's void-round detection, the exact signal the contract keys on. Before concluding an orchestrator is misbehaving, read its evidence: its pane scrollback (`tmux capture-pane -t <window> -p -S -`), its scratch directory, and the git log. The orchestrator's handoff may route user questions to its own interactive session, so an answer the monitor never saw can exist there — a monitor once killed a healthy implementer and forged its `EXITCODE` line because it never read the scrollback where the user had already answered. The only kill-worthy states are the infrastructure failures named above.
 
 A dead orchestrator window is not automatically a crash — check the scratch directory:
 
diff --git a/.kilo_workflow/learnings/android-emulator-systemserver-restart-systemui-anr-under-load.md b/.kilo_workflow/learnings/android-emulator-systemserver-restart-systemui-anr-under-load.md
index b121fc0256..729e3aa1cb 100644
--- a/.kilo_workflow/learnings/android-emulator-systemserver-restart-systemui-anr-under-load.md
+++ b/.kilo_workflow/learnings/android-emulator-systemserver-restart-systemui-anr-under-load.md
@@ -18,8 +18,3 @@ app process, adb reverse mappings, login session, and conversation state all sur
 (never consume a launch attempt for this). Afterwards Maestro, which also wedges under the load
 (`maestro hierarchy` empty/timing out, `maestro test` never writing its first log line), works again.
 
-**Related:** plain `pnpm dev:stop` (runbook-mandated when the slot release leaves the stack up) tears down
-the SHARED `kiloclaw-docker-tcp` socat on 127.0.0.1:23750 even though `e2e-slot.sh release` first prints
-"Leaving Docker infrastructure running". After cleanup, 23750 having no listener is expected; the next
-`dev:start` recreates it on demand. Do not "repair" it by hand (never create a socat you did not start).
-The KiloClaw sandbox container itself survives both the release and dev:stop.
diff --git a/.kilo_workflow/learnings/dev-stack-died-mid-round-restart-in-place.md b/.kilo_workflow/learnings/dev-stack-died-mid-round-restart-in-place.md
new file mode 100644
index 0000000000..3c1976252d
--- /dev/null
+++ b/.kilo_workflow/learnings/dev-stack-died-mid-round-restart-in-place.md
@@ -0,0 +1,19 @@
+# Dev stack died mid-round (killed externally or by a stale slot script) — restart in place, don't re-verify from scratch
+
+Symptom: mid-E2E, `pnpm dev:status` suddenly prints "No dev session running", the dev client
+loses Metro, and flows start failing on connection errors — with your slot still held and no
+crash logs of your own. Usual culprits: another section's stale pre-fix `e2e-slot.sh` copy
+stopping the wrong worktree's stack on release, or a slot-covering placeholder session dying and
+the reaper stopping the now-uncovered stack.
+
+Cause: the stack was stopped out from under you; nothing about your worktree, data, or device is
+wrong. Postgres rows, Durable Object storage, and local D1 files all survive a `dev:stop`.
+
+Fix (verified twice): while the slot is still held, restart the stack in place with the same
+port offset and service group from your handoff — `KILO_PORT_OFFSET=<n> pnpm dev:start
+--no-attach <services>` (ports are deterministic per worktree, so everything comes back on the
+same URLs). Then restore what rode on it: restart the CLI relay if the round uses one
+(`apps/mobile/e2e/remote-cli.sh exec remote` → `Remote connection enabled.`), re-anchor the dev
+client with the deep link, and re-run only the iteration that was in flight — completed
+iterations' device-local measurements stay valid. Classify the interruption as environment
+interference, never as a product failure.
diff --git a/.kilo_workflow/learnings/dispatching-kilo-agents-from-another-harness.md b/.kilo_workflow/learnings/dispatching-kilo-agents-from-another-harness.md
deleted file mode 100644
index 74e43003d7..0000000000
--- a/.kilo_workflow/learnings/dispatching-kilo-agents-from-another-harness.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# Dispatching kilo role agents from a non-kilo harness (timeouts, exit codes, wait loops)
-
-Symptom: a `kilo run --agent <role>` dispatched from a harness whose shell tool has a command timeout (Claude Code: 10 minutes) gets killed mid-run. Worse, a piped run (`kilo run ... | tee log`) records the exit status of `tee`, not of kilo, so a crashed agent reports `EXITCODE=0` and reads as a clean pass. Separately, an `until grep -q EXITCODE= "$LOG"` wait loop can false-trigger mid-run when the agent read a document (this one included) that mentions the marker, echoing it into the log.
-
-Cause: three independent traps — the harness command timeout, `$?` after a pipeline referring to the last stage, and a wait marker that is not unique to the wrapper's final append.
-
-Fix: run the dispatch inside a tmux window, redirect rather than pipe, and append the exit code after the redirected command:
-
-```bash
-cd "$WORKTREE"
-env $(env | grep -oE '^(KILO|OPENCODE)[A-Za-z0-9_]*' | sed 's/^/-u /') \
-  kilo run "Review the attached plan per your role definition." \
-  --agent plan-reviewer --file msg.txt --file "$PLAN" > "$LOG" 2>&1
-echo "EXITCODE=$?" >> "$LOG"
-```
-
-The message stays a short literal; the handoff and plan travel via `--file` — see `kilo-run-shell-substitution-executes-backticks.md` for why `"$(cat ...)"` is forbidden.
-
-Do not pass `--model`/`--variant` for role agents — their definitions in `.kilo/agent/` pin the model, and a flag that drifts from the definition silently disagrees with it.
-
-Keep the message positional **before** the flags: `--file` takes multiple values and swallows a trailing message as a path (`File not found`). Treat the run as done only when the tmux window is gone **or** the marker is the last line: `tail -1 "$LOG" | grep -q '^EXITCODE=[0-9]'`.
diff --git a/.kilo_workflow/learnings/e2e-slot-owner-must-be-dedicated-session.md b/.kilo_workflow/learnings/e2e-slot-owner-must-be-dedicated-session.md
deleted file mode 100644
index b50a52cc2f..0000000000
--- a/.kilo_workflow/learnings/e2e-slot-owner-must-be-dedicated-session.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# E2E slot acquired under a shared/long-lived tmux session name leaks the slot
-
-Symptom: an E2E slot stays held for tens of minutes with no verifier running; `e2e-slot.sh status`
-shows the holder as a long-lived session name (e.g. the planner/starter session) while other
-sections starve on a 3-slot machine. The slot is never auto-reclaimed because the holding session
-never dies.
-
-Cause: an orchestrator (not a verifier) ran `e2e-slot.sh acquire` itself, under its window's shared
-tmux session name instead of a dedicated per-round verifier session. Slot reclamation keys on the
-holder's tmux session being gone; a shared session outlives every round, so the hold is effectively
-permanent until someone releases it by hand.
-
-Fix: only the e2e-verifier acquires a slot, always under its own dedicated session name
-(`<section>-e2e-verifier-<label>`), and releases it the moment its device phase ends (release also
-stops the stack — a slot and a dev stack are the same resource since #4826). The orchestrator never
-acquires slots, never starts dev stacks "for" a verifier, and checks `e2e-slot.sh status` before
-declaring starvation; a blocked `acquire` from a real holder is correct behaviour, not a wedge.
diff --git a/.kilo_workflow/learnings/e2e-slot-release-stopped-another-sections-stack.md b/.kilo_workflow/learnings/e2e-slot-release-stopped-another-sections-stack.md
deleted file mode 100644
index a07d751133..0000000000
--- a/.kilo_workflow/learnings/e2e-slot-release-stopped-another-sections-stack.md
+++ /dev/null
@@ -1,49 +0,0 @@
-# `e2e-slot.sh release` stopped a different section's dev stack
-
-Symptom: releasing `file-preview-2975`'s slot printed
-`Killed tmux session kilo-dev-hermes-mem-c716` and left
-`kilo-dev-file-preview-2975` running. Another section's E2E verifier was
-mid-round and carried on driving a device against a stack that no longer
-existed, which surfaces as an inexplicable product failure in *that* section.
-
-Cause: shell variable shadowing. `stop_stack` set `wt=$1`, computed
-`sess=$(stack_session "$wt")`, then called `stack_is_covered "$sess"` — whose
-loop reassigns the **same global** `wt` once per slot directory. On return `wt`
-held the *last* slot's worktree, so the final `(cd "$wt" && pnpm dev:stop)`
-stopped whichever section happened to sort last. `sess` stayed correct, so the
-`tmux has-session` guard confirmed *our* stack was up and then stopped
-*theirs*. `reap()` had the same exposure on its own `s` loop variable.
-
-`dev:stop` is not at fault: it resolves its target purely from
-`git rev-parse --show-toplevel` in the process cwd. It was handed the wrong cwd.
-
-This was latent until the trailing-underscore fix (#4836). Before it,
-`stack_session` returned a mangled name, `tmux has-session` always failed, and
-`stop_stack` returned early — never reaching the `cd`. Fixing the name made the
-guard pass and exposed the shadowing. A dormant bug behind a broken guard
-becomes a live bug the moment the guard starts working; when repairing a
-predicate, read what runs *after* it, not just the predicate.
-
-Fix: declare `local` in every helper that a loop-bearing caller depends on —
-`stack_is_covered`, `stop_stack`, `reap`. Bash functions share global scope by
-default, so a helper called from inside a loop silently corrupts its caller's
-iteration state.
-
-Operational note: a slot must be acquired under the **verifier's own tmux
-session name**. This incident began because the orchestrator acquired a slot in
-a `slot-acq` window under a proxy `<section>-e2e-seed` session and parked a
-`sleep` to hold it. That both violates the E2E-loop rule and creates a
-self-deadlock: the verifier polls for a free slot that its own section's
-sleeper holds, and neither side can progress.
-
-Victim-side recovery (worked twice in hermes-mem-c716 r1, the section named in
-the symptom): the kill is silent for the victim — `pnpm dev:status` just prints
-"No dev session running" mid-round and the dev client loses Metro. While the
-slot is still held, restart the stack in place: `pnpm dev:start --no-attach
-mobile cloud-agent-next kiloclaw event-service` (the same ports return), restart
-the CLI relay (`remote-cli.sh exec remote` → `Remote connection enabled.`),
-re-prove `session list --pure`, re-anchor the dev client with the deep link, and
-re-run only the iteration that was in flight — device-local measurements (e.g.
-meminfo) from completed iterations stay valid. The companion `stack=none` shown
-by `e2e-slot.sh status` even for live stacks was the #4836 name-mangling bug
-(the same mangled session name made `has-session` always fail), already fixed.
diff --git a/.kilo_workflow/learnings/github-pr-no-image-upload-api.md b/.kilo_workflow/learnings/github-pr-no-image-upload-api.md
deleted file mode 100644
index 7c5a34d953..0000000000
--- a/.kilo_workflow/learnings/github-pr-no-image-upload-api.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# No programmatic image upload for PR bodies — use textual evidence
-
-Symptom: a run needs before/after E2E screenshots inline in a PR body and
-cannot find an upload path.
-Cause: GitHub's `upload/assets` endpoint requires a browser session + CSRF
-token (`POST` with a `gh` API token → 404); `gh` has no asset-upload command;
-GraphQL has no asset mutation. The orphan-branch + raw-URL workaround violates
-the fixture rule (never commit generated E2E fixtures) and pollutes the repo.
-Fix: do not probe again. Follow the repo convention (verified 2026-07-28:
-zero of 25 open PRs embed images; prior mobile workflow PRs #4773/#4776 carry
-none): the Visual Changes table names each verified screenshot file, what it
-shows, and the verifier's judgment. Humans wanting pixels re-run the flow or
-ask for the images in review.
diff --git a/.kilo_workflow/learnings/handoff-env-facts-must-be-inline.md b/.kilo_workflow/learnings/handoff-env-facts-must-be-inline.md
deleted file mode 100644
index cb89e9ee2d..0000000000
--- a/.kilo_workflow/learnings/handoff-env-facts-must-be-inline.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Role agent wastes steps on auto-rejected .env reads
-
-Symptom: a reviewer or verifier logs `permission requested: read (apps/mobile/.env); auto-rejecting` and burns steps retrying env files it can never read.
-
-Cause: the secrets rule correctly blocks `.env` reads, but a handoff that cites `.env` facts invites the attempt.
-
-Fix: state every sanitized env value inline in the handoff and tell the agent explicitly that it is not permitted to read `.env` / `.env.*` / `.dev.vars` and should treat the handoff table as authoritative.
diff --git a/.kilo_workflow/learnings/ios-simulator-cannot-starve-location-fix.md b/.kilo_workflow/learnings/ios-simulator-cannot-starve-location-fix.md
index 25427d3821..cd8f17e4e5 100644
--- a/.kilo_workflow/learnings/ios-simulator-cannot-starve-location-fix.md
+++ b/.kilo_workflow/learnings/ios-simulator-cannot-starve-location-fix.md
@@ -23,6 +23,3 @@ LocationServicesEnabled -bool false`, then restart the daemon
 `getCurrentPositionAsync` rejects into the same catch a timeout would. Restore with `-bool true` +
 SIGTERM. On-device evidence of the 10 s race itself is not obtainable on a simulator — cover it by
 unit test and record the substitution in the report.
-
-Related: Maestro point taps reject decimal percentages (`NumberFormatException: For input string:
-"34.4"`) — use absolute coordinates ("201,301") or integer percents.
diff --git a/.kilo_workflow/learnings/kilo-provider-model-not-found-transient.md b/.kilo_workflow/learnings/kilo-provider-model-not-found-transient.md
index f6836aacab..7d60efd46e 100644
--- a/.kilo_workflow/learnings/kilo-provider-model-not-found-transient.md
+++ b/.kilo_workflow/learnings/kilo-provider-model-not-found-transient.md
@@ -39,6 +39,6 @@ Escalate to an infrastructure blocker — and never a model substitution — onl
 redispatches keep failing with this signature, which would mean the model really is gone. Three
 consecutive void rounds is the standing threshold.
 
-Related: `kilo-run-crashes-on-credential-write.md` (startup crash, exit 1, credential write),
+Related: `kilo-run-startup-crash-transient.md` (startup crash, exit 1, credential write),
 `kilo-run-exits-0-without-verdict.md` (mid-run stream stall, exit 0). All three are void rounds
 with different causes; only this one is provider-side.
diff --git a/.kilo_workflow/learnings/kilo-run-crashes-on-credential-write.md b/.kilo_workflow/learnings/kilo-run-crashes-on-credential-write.md
deleted file mode 100644
index 1b3b763dc1..0000000000
--- a/.kilo_workflow/learnings/kilo-run-crashes-on-credential-write.md
+++ /dev/null
@@ -1,43 +0,0 @@
-# kilo run crashes on its own credential write — void round, redispatch
-
-Symptom: a dispatched role agent dies seconds after launch with `EXITCODE=1` and a Bun
-stack trace instead of a verdict. The log's last lines are:
-
-```
-Error: Unexpected error
-Failed query: update "credential" set "value" = ?, "time_updated" = ? where "credential"."id" = ?
-  _tag: "EffectDrizzleQueryError",
-Bun v1.3.14 (macOS arm64)
-```
-
-The sentinel check (`tail -2 "$LOG" | head -1`) returns the Bun version line, so the round
-is void. No `~/.local/share/kilo/kilo-<branch>.db` is created — the crash happens before
-the session store exists.
-
-Cause: the CLI refreshes its OAuth token at startup and fails to **persist** the refreshed
-credential. The token itself is fine (the `exp` in the logged payload is far in the future)
-and auth is not wedged — only the SQLite write to the shared credential store fails, under
-contention from the many `kilo run` processes parallel workflows keep alive on this machine
-(`pgrep -af "kilo run"` showed 10+). Transient, not a state corruption.
-
-Fix: treat it as an ordinary void round — discard it and dispatch a **fresh** session
-(reviewers want a fresh session per round anyway). It counts toward the loop's round cap. A
-redispatch of the identical handoff succeeded immediately.
-
-Before redispatching, rule out the two failure modes that look identical but are not
-transient, both cheap to check:
-
-- **Disk full** — an SQLite write failure is the classic symptom. `df -h /Users`; the
-  observed-healthy case had 180Gi available.
-- **Auth genuinely wedged** — a different error (`PAID_MODEL_AUTH_REQUIRED`) that needs an
-  interactive `kilo auth login` and will not clear on redispatch. If the logged credential
-  payload carries a future `exp`, auth is not the problem.
-
-Do **not** delete `~/.local/share/kilo/auth.json`, `account.json` or any `kilo-*.db`, and do
-not kill another workflow's `kilo run` to free the lock — a foreign holder belongs to its own
-workflow's monitor. Three consecutive void rounds from this signature is an infrastructure
-blocker to report, not something to keep redispatching through.
-
-Distinct from `kilo-run-exits-0-without-verdict.md`: that one is a mid-run provider stream
-stall exiting 0 after real work; this one is a hard crash at startup exiting 1 with a stack
-trace.
diff --git a/.kilo_workflow/learnings/kilo-run-interactive-requires-tty.md b/.kilo_workflow/learnings/kilo-run-interactive-requires-tty.md
deleted file mode 100644
index 8e37426904..0000000000
--- a/.kilo_workflow/learnings/kilo-run-interactive-requires-tty.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# kilo run --interactive dies when stdout is piped
-
-Symptom: launching an interactive session as `kilo run ... --interactive ... | tee log` exits immediately with `Error: --interactive requires a TTY stdout`.
-
-Cause: piping stdout replaces the TTY that `--interactive` requires. Affects any attempt to tee an interactive kilo session's output to a file.
-
-Fix: launch the interactive session as the tmux window command with no pipe, then attach logging separately with `tmux pipe-pane -t <session>:<window> -o "cat >> <logfile>"`. Read live state with `tmux capture-pane -p -t <session>:<window>`. Non-interactive dispatches are unaffected and can still be redirected.
diff --git a/.kilo_workflow/learnings/kilo-run-session-not-found-or-db-race.md b/.kilo_workflow/learnings/kilo-run-session-not-found-or-db-race.md
deleted file mode 100644
index 3cc8a84bc2..0000000000
--- a/.kilo_workflow/learnings/kilo-run-session-not-found-or-db-race.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# kilo run fails at startup: "Session not found" or EffectDrizzleQueryError
-
-Symptom: `kilo run` dies immediately with `Session not found` or `EffectDrizzleQueryError` (local store write race) before doing any work.
-
-Cause: two distinct startup failures. (1) When many CLIs launch concurrently (a fleet of role agents), the local SQLite store races on first write — transient. (2) On macOS, @kilocode/cli 7.4.13–7.4.15 had a fresh-database `Session not found` bug (reproduced with isolated XDG dirs); also triggered when the run inherits a parent kilo's `KILO_*` env — see `nested-kilo-run-env-poisoning.md`.
-
-Fix: re-dispatch the identical command once — the race case starts cleanly on retry. If it persists: strip the env per the nested-run learning, and check the CLI version against the known-bad range.
diff --git a/.kilo_workflow/learnings/kilo-run-startup-crash-transient.md b/.kilo_workflow/learnings/kilo-run-startup-crash-transient.md
new file mode 100644
index 0000000000..1c036fc3ed
--- /dev/null
+++ b/.kilo_workflow/learnings/kilo-run-startup-crash-transient.md
@@ -0,0 +1,39 @@
+# kilo run crashes at startup (credential write / Session not found) — transient, redispatch once
+
+Symptom: a dispatched `kilo run` dies within seconds, before any real work, with `EXITCODE=1`
+and one of these signatures as its last lines:
+
+- `Failed query: update "credential" set "value" = ... _tag: "EffectDrizzleQueryError"` plus a
+  Bun stack trace — the CLI refreshed its OAuth token at startup and the SQLite write to the
+  shared credential store failed under contention (many parallel `kilo run` processes).
+- `Session not found` or another `EffectDrizzleQueryError` — the local SQLite session store
+  raced on first write when many CLIs launched at once.
+
+Either way the round is void (no sentinel). The token itself is fine — the logged payload
+carries a far-future `exp` — and no `~/.local/share/kilo/kilo-<branch>.db` gets created.
+
+Cause: startup races on the machine-local SQLite stores, under contention from parallel
+workflows. Transient; unrelated to the prompt, model, flags, or agent definition.
+
+Fix: discard the void round and dispatch a fresh session — the identical redispatch typically
+succeeds immediately. It still counts toward the loop's round cap. When dispatching a fan-out of
+agents at once, stagger the launches by a few seconds; the crash clusters when several CLIs
+start together.
+
+Before redispatching, rule out the look-alikes that will NOT clear on retry:
+
+- **Disk full** — the classic cause of SQLite write failures: `df -h /Users`.
+- **Auth genuinely wedged** — `PAID_MODEL_AUTH_REQUIRED` needs an interactive `kilo auth login`.
+  If the logged credential payload has a future `exp`, auth is not the problem.
+- **Poisoned env / known-bad CLI** — a run inheriting a parent kilo's `KILO_*` env hits
+  `Session not found` deterministically (see `nested-kilo-run-env-poisoning.md`); CLI
+  7.4.13–7.4.15 had a fresh-database `Session not found` bug on macOS, fixed in 7.4.16.
+
+Handling notes: the crash log's `params` can include the OAuth **refresh JWT** — redact
+`eyJ[A-Za-z0-9_.-]+` before keeping any of it as evidence. Never delete
+`~/.local/share/kilo/auth.json`, `account.json`, or any `kilo-*.db`, and never kill another
+workflow's `kilo run` to free a lock. Three consecutive void rounds with this signature is an
+infrastructure blocker to report, not something to keep redispatching through.
+
+Distinct from `kilo-run-exits-0-without-verdict.md` (mid-run provider stream stall, exit 0 after
+real work) and `kilo-provider-model-not-found-transient.md` (gateway catalog blip, also exit 1).
diff --git a/.kilo_workflow/learnings/kiloclaw-chat-attachments-r2-secret-missing.md b/.kilo_workflow/learnings/kiloclaw-chat-attachments-r2-secret-missing.md
index 38f04798b6..76d4e66923 100644
--- a/.kilo_workflow/learnings/kiloclaw-chat-attachments-r2-secret-missing.md
+++ b/.kilo_workflow/learnings/kiloclaw-chat-attachments-r2-secret-missing.md
@@ -1,28 +1,14 @@
-# KiloClaw chat attachment uploads fail locally: R2 media secrets absent machine-wide
+# KiloClaw chat attachment uploads 500 locally: R2 media secrets missing (RESOLVED — recheck recipe)
 
-> **RESOLVED 2026-07-28 (r2):** the `R2_*_KILOCHAT_MEDIA` pair now exists in the Secrets Store and
-> `dev:start` provisions it from that canonical source like any source-backed secret
-> (`⊕ secret: R2_ACCESS_KEY_ID_KILOCHAT_MEDIA @from …`); verified in the local secrets-store KV and
-> end-to-end (`/v1/attachments/init 200`, chip `ready`, send 201). Everything below is the historical
-> r1 record — the "no canonical source" claim is stale. If the symptom ever recurs, first check whether
-> the store lost the pair again, then whether the worktree's `.wrangler/state` secrets KV is stale
-> (re-run `dev:start`).
+Symptom: picking a file in the kilo-chat composer adds a chip that immediately goes to `failed`
+(a11y `Retry upload for <name>`); kilo-chat logs `POST /v1/attachments/init 500` with
+`Error: Secret "R2_ACCESS_KEY_ID_KILOCHAT_MEDIA" not found`.
 
-Symptom: mobile E2E on the KiloClaw chat composer (`chat/[sandbox-id]/[conversation-id]`): picking an under-limit
-file adds a chip that immediately goes to `failed` (a11y `Retry upload for <name>`); kilo-chat logs
-`POST /v1/attachments/init 500` with `Error: Secret "R2_ACCESS_KEY_ID_KILOCHAT_MEDIA" not found`.
+RESOLVED 2026-07-28: the `R2_*_KILOCHAT_MEDIA` pair now exists in the Secrets Store and
+`dev:start` provisions it like any source-backed secret; verified end-to-end
+(`/v1/attachments/init 200`, chip `ready`, send 201).
 
-Cause: `services/kilo-chat/wrangler.jsonc` binds `R2_ACCESS_KEY_ID`/`R2_SECRET_ACCESS_KEY` to Secrets-Store
-secrets `R2_*_KILOCHAT_MEDIA` (store 342a86d9e3a94da698e82d0c6e2a36f0) with `MEDIA_BUCKET` declared
-`remote: true`. Those secrets have no canonical local source: `.dev.vars.example` documents manual creation
-from a personal Cloudflare R2 API token, and `dev:env`/`dev:start` only warn ("Missing and no source value").
-Checked 2026-07-28: 0 of 42 worktrees' `services/kilo-chat/.wrangler/state/v3/secrets-store` contain an R2 key;
-`pnpm dev:worktree:prepare` + `KILO_PORT_OFFSET=<n> pnpm dev:env -y kilo-chat` does not provision them. Every
-chip upload 500s deterministically (initial attempt and in-app retry alike). Attachment E2E assertions that
-require a chip to reach `ready`/send/render are environment-blocked until someone creates the two secrets
-with a real R2 token. Oversized-rejection assertions (pre-read size gate) are unaffected and fully testable.
-
-Related: a `prep`-style phase that ends with `e2e-slot.sh release` stops the worktree stack (slot/stack are one
-resource), so a handoff claiming "stack is up" can be stale by verifier time — check `pnpm dev:status --json`
-and restart per the runbook quickstart (with the handoff's KILO_PORT_OFFSET prefix on dev:env/dev:start);
-the docker-local KiloClaw sandbox container survives stack restarts.
+If the symptom recurs: first check whether the store lost the pair again, then whether the
+worktree's `services/kilo-chat/.wrangler/state` secrets KV is stale — re-run `dev:start`.
+Oversized-rejection assertions (pre-read size gate) never needed the secrets and are always
+testable.
diff --git a/.kilo_workflow/learnings/kiloclaw-docker-tcp-absent-from-worktree-status.md b/.kilo_workflow/learnings/kiloclaw-docker-tcp-absent-from-worktree-status.md
index d61f41a7c7..a2d91a6bbd 100644
--- a/.kilo_workflow/learnings/kiloclaw-docker-tcp-absent-from-worktree-status.md
+++ b/.kilo_workflow/learnings/kiloclaw-docker-tcp-absent-from-worktree-status.md
@@ -5,3 +5,5 @@ Symptom: `pnpm dev:status --json` for a worktree whose stack started cleanly lis
 Cause: `kiloclaw-docker-tcp` is a stateless loopback `socat` proxy to the shared Docker socket on `127.0.0.1:23750` — the one host-wide shared port the runbook allows. When another worktree (or an earlier stack) already owns that listener, this worktree's runner reuses it and records no service row of its own.
 
 Fix: gate on the bridge, not the row: `curl http://127.0.0.1:23750/v1.44/_ping` must print `OK`. Only if that fails, start the bridge yourself per `services/kiloclaw/README.md` (`socat TCP-LISTEN:23750,bind=127.0.0.1,reuseaddr,fork UNIX-CONNECT:/var/run/docker.sock`). Never kill a `socat` owned by another worktree (runbook, Host Networking Safety) — `lsof -iTCP:23750` shows the owning PID and it is shared by every docker-local instance on the host, not just yours.
+
+Related: a plain `pnpm dev:stop` tears the shared bridge down (even when `e2e-slot.sh release` printed "Leaving Docker infrastructure running"). After a cleanup, 23750 having no listener is expected — the next `dev:start` recreates it on demand; do not "repair" it by hand. The KiloClaw sandbox container itself survives both release and `dev:stop`.
diff --git a/.kilo_workflow/learnings/mobile-android-claim-race-at-visibility.md b/.kilo_workflow/learnings/mobile-android-claim-race-at-visibility.md
deleted file mode 100644
index d21d6171e5..0000000000
--- a/.kilo_workflow/learnings/mobile-android-claim-race-at-visibility.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# Android emulator claim race on shared adb
-
-Symptom: `pnpm dev:mobile:android claim emulator-5554` refused: "claimed by
-/Users/igor/Projects/.worktrees/pr-review-d957" — for an emulator I had just launched myself.
-
-Cause: adb serials are host-global. The runbook order (launch → bounded boot wait → claim →
-build) leaves a window between adb visibility and claim; a concurrent worktree's polling loop
-claimed my fresh emulator at first visibility (claim record bootId matched my instance's
-/proc/sys/kernel/random/boot_id exactly, claimedAt within seconds of first visibility).
-
-Fix: claim AT adb visibility (before waiting for sys.boot_completed). If refused because the
-other worktree won the race, do NOT drive the device (never use a device claimed by another
-worktree) and do NOT kill it either if your qemu owns it — boot a different AVD/serial instead.
diff --git a/.kilo_workflow/learnings/mobile-android-dev-client-cold-start-deep-link.md b/.kilo_workflow/learnings/mobile-android-dev-client-cold-start-deep-link.md
index efd6a88bd4..3715f40987 100644
--- a/.kilo_workflow/learnings/mobile-android-dev-client-cold-start-deep-link.md
+++ b/.kilo_workflow/learnings/mobile-android-dev-client-cold-start-deep-link.md
@@ -1,20 +1,32 @@
-# Android dev-client cold start after force-stop: deep link required, rebundle is slow
+# Android dev client: cold starts need the deep link, and the reload outlasts flow budgets
 
 Symptom: after `adb shell am force-stop com.kilocode.kiloapp`, relaunching with
 `am start -n com.kilocode.kiloapp/.MainActivity` lands on the Expo dev-client launcher
 ("Development Build", server URL list) instead of the app; `monkey -p ... LAUNCHER 1` fails
-outright. The app then shows a blank white screen with a single-node, zero-text uiautomator dump
-for tens of seconds.
+outright. Separately, `apps/mobile/e2e/login.sh <serial>` fails its settle assert
+("Welcome to Kilo Code|HOME|..." not visible in 15s) and never reaches
+`POST /api/auth/native/otp` — yet minutes later the app is visibly settled on the login screen.
 
-Cause: the dev client needs the metro URL passed via the preflight deep link
+Cause: the dev client needs the Metro URL passed via the preflight deep link
 (`exp+kilo-app://expo-development-client/?url=<url-encoded http://127.0.0.1:$METRO_PORT>`, see
-`apps/mobile/e2e/preflight.sh`). After force-stop the JS bundle is re-fetched and re-built by
-metro: 25–65s on emulator on this machine (slower under load with two emulators).
+`apps/mobile/e2e/preflight.sh`). After a force-stop — and on every `login.sh` run, because
+preflight re-opens the deep link — the JS bundle is re-fetched and rebuilt by Metro: 25–65s on
+this machine, and 1–2 minutes under parallel-workflow load, far beyond `settle-app.yaml` (15s)
+and `open-app.yaml` (30s) budgets. The retry path cold-relaunches (`stopApp`), restarting the
+clock. During the reload the screen is uniform white and uiautomator dumps show only the
+status-bar clock.
 
-Fix: always relaunch via the deep link (and ensure `adb reverse tcp:$API_PORT` / `tcp:$METRO_PORT`
-are set first). A blank white screen + zero-text dump within ~60s of a cold start means LOADING,
-not a transparency defect — wait and re-dump before classifying. Contrast with the real iOS
-transparency defect: static texts VISIBLE on screen while the interactive subtree is absent from
-the a11y tree for 60s+ and only an app relaunch recovers it. Also note Maestro's `settle-app`
-assertions in helper flows can time out inside this rebundle window — re-run the flow rather than
-classifying the timeout.
+Fix:
+
+- Always relaunch via the deep link, with `adb reverse tcp:$API_PORT` / `tcp:$METRO_PORT` set
+  first. A blank white screen + zero-text dump within ~60s of a cold start means LOADING, not a
+  rendering defect — wait and re-dump before classifying (contrast: the iOS transparency defect
+  shows static text on screen while the interactive subtree is missing for 60s+).
+- If the AVD may hold a foreign worktree's persisted auth (AVDs are machine-global), run
+  `pm clear com.kilocode.kiloapp` first.
+- When `login.sh` fails but the app has since settled (probe with a 20s `extendedWaitUntil`
+  scratch flow), drive sign-in from scratch flows instead of re-running it: tap
+  `you@example.com` → `eraseText` → `inputText $EMAIL` → `pressKey Enter` (submits via
+  `returnKeyType=go`); read the OTP from `dev/logs/emails`, ignoring the 6-digit number in the
+  postal footer; handle `Accept and continue` and the notifications prompt. Preflight's effects
+  (claim check, adb reverses, Metro provenance) survive the failed runs.
diff --git a/.kilo_workflow/learnings/mobile-android-emulator-claims.md b/.kilo_workflow/learnings/mobile-android-emulator-claims.md
new file mode 100644
index 0000000000..34a77fc1ef
--- /dev/null
+++ b/.kilo_workflow/learnings/mobile-android-emulator-claims.md
@@ -0,0 +1,19 @@
+# Android emulator claims: claim at adb visibility, boot on an explicit free port
+
+adb serials are host-global and every worktree shares them, so claims race and collide.
+Three rules, each learned from a real incident:
+
+1. **Claim the moment the serial is adb-visible, before waiting for boot.** The old order
+   (launch → wait for `sys.boot_completed` → claim) leaves a window in which a concurrent
+   worktree's polling loop claims your freshly launched emulator. If you lose that race, do NOT
+   drive the device (never use a device claimed by another worktree) and do NOT kill it even if
+   your own qemu process owns it — boot a different AVD/serial instead.
+2. **Boot on an explicit free even console port so your serial starts unclaimed:**
+   `pnpm dev:mobile:android emulator -avd <avd> -port 5558 -no-snapshot-save -no-boot-anim -gpu host`
+   → serial `emulator-5558`, then `claim emulator-5558`. A live foreign emulator on a default
+   serial (5554/5556) blocks your boot there; claims from dead emulators self-clear (they record
+   the guest kernel boot id), but never delete another worktree's claim file yourself. Record
+   the port in the round handoff so the next round reuses the same serial.
+3. **A fresh worktree may lack `apps/mobile/android/`** even when `doctor` passes — run
+   `npx expo prebuild --platform android` in `apps/mobile` before `dev:mobile:android build`
+   (the directory is git-ignored codegen). A cached-APK build then installs in seconds.
diff --git a/.kilo_workflow/learnings/mobile-android-emulator-r7-envelope-notes.md b/.kilo_workflow/learnings/mobile-android-emulator-r7-envelope-notes.md
deleted file mode 100644
index bde50e7c20..0000000000
--- a/.kilo_workflow/learnings/mobile-android-emulator-r7-envelope-notes.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# mobile: Android emulator bring-up notes (2026-07-28, mobile-ui-ddc7 r7)
-
-- AVD `kilo_pixel7` (sdk_gphone64_arm64) booted in ~2.5 min on attempt 1 with `-gpu host
-  -no-snapshot-save -no-boot-anim` under load; `pnpm dev:mobile:android doctor` resolved SDK at
-  /opt/homebrew/share/android-commandlinetools and listed 4 kilo_* AVDs.
-- `apps/mobile/android/` was missing on this worktree despite the doctor; run
-  `npx expo prebuild --platform android` in apps/mobile before `dev:mobile:android build`
-  (git-ignored codegen). Cached-APK build then installed in seconds.
-- Tab a11y labels match iOS exactly ('Agents, tab, 3 of 4' etc.); the r3 iOS rename-modal flow
-  (Greeting row -> 'Rename session: .*' -> tap field -> eraseText -> inputText) ports unchanged.
-- adb `exec-out screencap -p` writes fine directly to $SCRATCH (no ~/.maestro/tests hunt).
-- Android renders the cleared-field placeholder 'Session name' on the same baseline as typed
-  text, vertically centered, unclipped (no iOS-style low placeholder).
diff --git a/.kilo_workflow/learnings/mobile-android-login-deep-link-reload-outlasts-flow-budgets.md b/.kilo_workflow/learnings/mobile-android-login-deep-link-reload-outlasts-flow-budgets.md
deleted file mode 100644
index 37ed409dac..0000000000
--- a/.kilo_workflow/learnings/mobile-android-login-deep-link-reload-outlasts-flow-budgets.md
+++ /dev/null
@@ -1,23 +0,0 @@
-# mobile: Android login.sh fails on loaded host — preflight deep-link reload outlasts flow wait budgets (2026-07-28, r7)
-
-Symptom: every `apps/mobile/e2e/login.sh <serial>` attempt on the Android emulator fails the
-settle-app assert ("Welcome to Kilo Code|HOME|..." not visible in 15s) and ends with
-"no code email ... the app never reached POST /api/auth/native/otp". Minutes later the app is
-settled on the login screen and both adb uiautomator and a fresh `maestro hierarchy` see it fine.
-
-Cause: preflight.sh (~line 106) re-opens the dev-client deep link (`am start ... exp+kilo-app://
-expo-development-client/?url=...`) on every login.sh run; on Android that reloads the dev client
-to a white splash while the bundle re-initializes. Under parallel-workflow load the reload takes
-~1-2 min, far beyond settle-app.yaml (15s) and open-app.yaml (30s) budgets, and the retry path
-cold-relaunches (stopApp) so it starts the clock again. Debug hierarchy dumps during the failure
-show only the status-bar clock; the Maestro debug screenshot is the white splash.
-
-Fix/workaround: (1) `pm clear com.kilocode.kiloapp` first if the AVD may hold a foreign
-worktree's persisted auth (AVDs are machine-global — emulator-5554/kilo_pixel7 carried
-e2e-mobile-hermes-mem-c716's session into this worktree); (2) after login.sh fails and the app
-has visibly settled (probe with a 20s extendedWaitUntil scratch flow), drive sign-in from scratch
-flows (tap 'you@example.com' -> eraseText -> inputText $EMAIL -> pressKey Enter submits via
-returnKeyType=go; OTP in dev/logs/emails — ignore the 6-digit PMB in the postal footer; verify
-flow handles 'Accept and continue' + notifications prompt). Preflight's effects (claim check,
-both adb reverses, Metro provenance) remain from the failed login.sh runs. Android sign-in
-itself then works end-to-end (rename-modal pair captured).
diff --git a/.kilo_workflow/learnings/mobile-android-maestro-flow-pitfalls.md b/.kilo_workflow/learnings/mobile-android-maestro-flow-pitfalls.md
index 0c94395c10..a9f977d348 100644
--- a/.kilo_workflow/learnings/mobile-android-maestro-flow-pitfalls.md
+++ b/.kilo_workflow/learnings/mobile-android-maestro-flow-pitfalls.md
@@ -18,3 +18,7 @@ Cause/fix (three independent traps, all hit in the hermes-mem baseline round):
    `.*isn.t responding.*` → `tapOn: 'Wait'` handler after the launch wait and
    after settle, and 60-120 s waits for list/transcript asserts. `dumpsys
    meminfo` itself can hit its 10 s service timeout under load — retry it.
+
+Screenshots: `adb exec-out screencap -p > "$SCRATCH/shot.png"` writes wherever
+you point it — no `~/.maestro/tests` hunt like on iOS
+(`maestro-takescreenshot-output-dir.md`).
diff --git a/.kilo_workflow/learnings/mobile-android-stale-claims-explicit-port.md b/.kilo_workflow/learnings/mobile-android-stale-claims-explicit-port.md
deleted file mode 100644
index 10f560329f..0000000000
--- a/.kilo_workflow/learnings/mobile-android-stale-claims-explicit-port.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# mobile-android-stale-claims-explicit-port
-
-Symptom: `pnpm dev:mobile:android claim emulator-5554` fails with "claimed by
-/Users/igor/Projects/.worktrees/<other-worktree>" even though the owning
-worktree has no live tmux session and the claiming PID is dead.
-
-Cause: Android claims are per-serial JSON files in
-`$TMPDIR/kilo-mobile-android-claims/`. Before 96154f115 ownership was checked
-by worktreeRoot equality only, so a claim was never stale while the owning
-worktree directory existed, and dead-emulator claims wedged the default
-serials (emulator-5554, emulator-5556) permanently. Claims now record the
-guest kernel boot id, so a foreign claim self-clears once the emulator that
-wrote it no longer answers on the serial — but a *live* foreign emulator on a
-default serial still blocks your boot, which lands on the first free serial.
-
-Fix: boot the AVD on an explicit free even console port so the serial is
-unclaimed: `pnpm dev:mobile:android emulator -avd <avd> -port 5558
--no-snapshot-save -no-boot-anim -gpu host` → serial `emulator-5558`, then
-`claim emulator-5558`. Never delete another worktree's claim file. Record the
-port in the round handoff so the next round reuses the same serial.
diff --git a/.kilo_workflow/learnings/mobile-device-auth-ip-limit-shared-sections.md b/.kilo_workflow/learnings/mobile-device-auth-ip-limit-shared-sections.md
deleted file mode 100644
index 52cf1a8717..0000000000
--- a/.kilo_workflow/learnings/mobile-device-auth-ip-limit-shared-sections.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# mobile: device-auth per-IP pending limit is machine-wide — and the holder may be STUCK rows, not live traffic
-
-Symptom: `POST /api/device-auth/codes?app=1 500` with
-`Error: Too many pending authorization requests from this IP` (`src/lib/device-auth/device-auth.ts`),
-app shows the error branch "Failed to start sign in. Please try again." — while the app, backend,
-and network are all healthy.
-
-Cause: the limiter counts PENDING device-auth codes per IP, machine-wide (MAX 5), regardless of
-`expires_at`. Two distinct holders can saturate it: live traffic from a concurrent section, or
-STUCK rows abandoned by client-side-only `cancel()` (see
-`mobile-device-auth-stuck-pending-rows.md`). Observed 2026-07-29 on login-ui-d051: 500s
-08:37–10:44+ across two verifier rounds were first attributed to the live pr-review-d957
-section — WRONG; a read-only DB probe showed 5 rows stuck since 04:39–04:46, no live traffic
-involved. Waiting NEVER clears stuck rows (no dev cleanup cron).
-
-Fix: probe the DB first (recipe in `mobile-device-auth-stuck-pending-rows.md`) — 5 pending rows
-long past `expires_at` = stuck, reconcile via the real poll endpoint; recent rows = a live
-holder, then treat `start()` calls as a scarce budget (<=3 per round) and classify the pending
-branch as environment-blocked if 500s persist past one spaced recovery attempt. The error
-branch rendering is itself a free branch-swap evidence point (probe it for full alpha).
diff --git a/.kilo_workflow/learnings/mobile-device-auth-stuck-pending-rows.md b/.kilo_workflow/learnings/mobile-device-auth-stuck-pending-rows.md
index fae34e7868..cdbab6babf 100644
--- a/.kilo_workflow/learnings/mobile-device-auth-stuck-pending-rows.md
+++ b/.kilo_workflow/learnings/mobile-device-auth-stuck-pending-rows.md
@@ -1,26 +1,35 @@
-# mobile: device-auth pending rows get STUCK after client cancel — probe the DB, reconcile via the real poll endpoint
+# mobile: device-auth "Too many pending" 500s — usually STUCK rows, not live traffic; probe the DB, reconcile via the real poll endpoint
 
-Symptom: every `POST /api/device-auth/codes?app=1` 500s with `Too many pending authorization
-requests from this IP` and the app shows "Failed to start sign in" — and waiting any amount of
-time (hours) never clears it, even after all concurrent sections end.
+Symptom: `POST /api/device-auth/codes?app=1` 500s with `Too many pending authorization requests
+from this IP` and the app shows "Failed to start sign in. Please try again." — while the app,
+backend, and network are all healthy. Waiting any amount of time (hours) never clears it, even
+after all concurrent sections end.
 
-Cause: the limiter counts `status='pending'` rows per IP regardless of `expires_at`
-(`apps/web/src/lib/device-auth/device-auth.ts`, MAX 5). The app's `cancel()` is CLIENT-SIDE ONLY
-(`use-device-auth.ts`: setState idle, no DELETE) and a killed/closed app never polls again, so
-every abandoned code sits `pending` forever. Local dev runs no `cleanupExpiredDeviceAuthRequests`
-cron. On 2026-07-29 the login-ui-d051 e2 rounds' 500s (attributed in
-`mobile-device-auth-ip-limit-shared-sections.md` to the live pr-review-d957 section) were actually
-held by 5 rows created 04:39-04:46 and expired by 04:56 — 6h stale; no live traffic involved.
+Cause: the limiter counts `status='pending'` rows per IP **machine-wide** (MAX 5) regardless of
+`expires_at` (`apps/web/src/lib/device-auth/device-auth.ts`). Two holders can saturate it: live
+traffic from a concurrent section, or — far more often — stuck rows: the app's `cancel()` is
+CLIENT-SIDE ONLY (`use-device-auth.ts`: setState idle, no DELETE), a killed/closed app never
+polls again, and local dev runs no `cleanupExpiredDeviceAuthRequests` cron, so every abandoned
+code sits `pending` forever. (2026-07-29: two verifier rounds of 500s were blamed on a live
+sibling section — wrong; a DB probe showed 5 rows stuck for 6 hours.)
 
 Cheap probe (no stack, no device, read-only):
-  docker exec dev-postgres-1 psql -U postgres -d postgres -c \
-    "SELECT ip_address,status,count(*),max(expires_at) FROM device_auth_requests GROUP BY 1,2;"
-5 pending whose `expires_at` is long past = stuck rows, not a live holder; the consent dialog's
+
+```bash
+docker exec dev-postgres-1 psql -U postgres -d postgres -c \
+  "SELECT ip_address,status,count(*),max(expires_at) FROM device_auth_requests GROUP BY 1,2;"
+```
+
+Pending rows long past `expires_at` = stuck; recent rows = a live holder. The consent dialog's
 domain ("Kilo Wants to Use <ip> to Sign In") names the limiter IP.
 
-Fix (product's own path, NOT a mock — the limiter still evaluates real DB state for every later
-start): once the stuck codes are past expiry, poll each through the real endpoint on your own
-stack: `curl http://localhost:<nextjs-port>/api/device-auth/codes/<code>` → 410 expired;
-`pollDeviceAuthRequest` flips the row to `expired`. Never UPDATE the table directly. Fresh codes
-(<10min old) return 202 and stay pending — reconcile your own flip codes after expiry so the next
-section does not inherit your wedge.
+Fix for stuck rows (the product's own path, NOT a mock — the limiter still evaluates real DB
+state on every later start): once a stuck code is past expiry, poll it through the real
+endpoint on your own stack: `curl http://localhost:<nextjs-port>/api/device-auth/codes/<code>`
+→ 410 and `pollDeviceAuthRequest` flips the row to `expired`. Never UPDATE the table directly.
+Fresh codes (<10 min old) return 202 and stay pending — reconcile your own codes after expiry so
+the next section does not inherit your wedge.
+
+For a live holder: treat `start()` calls as a scarce budget (≤3 per round) and classify the
+pending branch as environment-blocked if 500s persist past one spaced recovery attempt. The
+error branch rendering is itself usable evidence.
diff --git a/.kilo_workflow/learnings/mobile-ios26-maestro-under-load.md b/.kilo_workflow/learnings/mobile-ios26-maestro-under-load.md
index b60d584803..828afcadd5 100644
--- a/.kilo_workflow/learnings/mobile-ios26-maestro-under-load.md
+++ b/.kilo_workflow/learnings/mobile-ios26-maestro-under-load.md
@@ -1,8 +1,9 @@
-# mobile: iOS 26 + Maestro quirks under extreme load (load avg 45+)
+# mobile: iOS 26 + Maestro quirks under load
 
-Observed on iOS 26.5 sim + Maestro 2.7.0 with several sibling verifiers sharing the host (2026-07-28). Related: `mobile-maestro-ios-driver-timeout-stale-xcodebuild.md` (driver wedge + reboot fix, including the no-xcodebuild variant).
+Observed on iOS 26.5 sim + Maestro 2.7.0 with several sibling verifiers sharing the host. Related: `mobile-maestro-ios-driver-timeout-stale-xcodebuild.md` (driver wedge + reboot fix, including the no-xcodebuild variant).
 
-1. **Failed/killed Maestro flows leave the app at SpringBoard.** After a flow ends abnormally (assert failure / kill), the next hierarchy dump shows the home screen. Recovery: tap the `Kilo` home icon (never `launchApp`) and re-wait for a known screen element. A relaunched app returns to its previous route.
+1. **Failed/killed Maestro flows leave the app at SpringBoard — and so can a flow-start `launchApp` right after a successful flow.** After any flow boundary, do not assume the app is still foreground: the next run's `launchApp` can bounce the dev client to the home screen (the first assert then fails; hierarchy shows only SpringBoard text like `Page 2 of 2` and icon labels). Recovery: a tiny scratch flow — `stopApp` → conditional `tapOn: {text: 'Kilo'}` (the home icon, never `launchApp`) → `extendedWaitUntil` a known element of the previous screen (route persistence restores it) — then rerun the real flow. Gate every follow-on flow on a known element rather than rerunning it blindly.
 2. **iOS 26 software keyboard has no `space` a11y label.** `assertVisible: 'space'` fails even with the keyboard fully up. Verify keyboard-up via `return`, `delete`, `numbers`, or letter keys instead. The hardware-keyboard plist fix (`mobile-ios-simulator-e2e-limitations.md`) survives `simctl shutdown/boot`.
 3. **RN Modal a11y tree intermittently collapses to keyboard-only under load.** With a native Modal visibly open and focused, the XCTest hierarchy can show only keyboard keys + status bar; `Cancel`/`Save` taps by text fail. Working fallback: extract the buttons' `bounds` from an earlier same-screen hierarchy dump and `tapOn: { point: "x,y" }` (points, verified consistent with screenshot scale). Text input still works: the modal auto-focuses the field on open, so `eraseText`/`inputText` need no element tap.
 4. **Maestro text assertions are full-string, not substring.** `assertVisible: 'Context'` fails against a header titled `Context usage` — assert the full visible string (or a regex), never a fragment. A failed assert of this kind is a flow bug, not a product regression.
+5. **Point taps reject decimal percentages.** `NumberFormatException: For input string: "34.4"` — use absolute coordinates (`"201,301"`) or integer percents.
diff --git a/.kilo_workflow/learnings/mobile-kilochat-attachments-capability-gate-blocks-e2e.md b/.kilo_workflow/learnings/mobile-kilochat-attachments-capability-gate-blocks-e2e.md
index a8ce86f311..bd40137185 100644
--- a/.kilo_workflow/learnings/mobile-kilochat-attachments-capability-gate-blocks-e2e.md
+++ b/.kilo_workflow/learnings/mobile-kilochat-attachments-capability-gate-blocks-e2e.md
@@ -29,12 +29,6 @@ survives the request-bot-status escalation (e.g. seed the KILOCLAW_INSTANCE DO s
 `bot.status_request`). Report the criterion unverified with evidence; never the tool-card
 viewer as a proxy.
 
-Related (r2 environment incident, corrected by the orchestrator): the seeding phase held an
-e2e slot via a `sleep` placeholder tmux session; the placeholder **died mid-run** (cause
-unidentified), the slot reaper reclaimed the slot for a foreign workflow, and the
-now-uncovered dev stack was later stopped while the verifier's next round was queued.
-Recovery: the r2 verifier re-ran one sanctioned `pnpm dev:start --no-attach mobile
-cloud-agent-next kiloclaw event-service` after acquiring its own slot — ports are
-deterministic per worktree, and miniflare DO state persisted. Orchestrators: keep the
-placeholder slot until ALL rounds finish, and treat a slot-owning placeholder as a monitored
-dispatch — its silent death cascades to the stack it covers.
+If the stack gets stopped out from under a round (a foreign release, a reaped slot), recover
+per `dev-stack-died-mid-round-restart-in-place.md` — DO state persists, so the seeded rows
+survive a restart.
diff --git a/.kilo_workflow/learnings/mobile-maestro-between-flow-springboard-bounce.md b/.kilo_workflow/learnings/mobile-maestro-between-flow-springboard-bounce.md
deleted file mode 100644
index 540d3d83db..0000000000
--- a/.kilo_workflow/learnings/mobile-maestro-between-flow-springboard-bounce.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# mobile: SpringBoard bounce between consecutive maestro runs (iOS26, load)
-
-Refines `.kilo_workflow/learnings/mobile-ios26-maestro-under-load.md` item 1
-("failed/killed flows leave the app at SpringBoard"). Observed 2026-07-28 in
-mobile-ui-ddc7 r5 (load avg high, 3 concurrent stacks):
-
-- A **successful** flow (`logout.sh`, final assert COMPLETED, app left on the
-  login screen) followed immediately by a second `maestro test` found the app
-  back at SpringBoard: the second run's flow-start `launchApp` bounced the dev
-  client to the home screen. First assert (`you@example.com`) failed;
-  hierarchy showed SpringBoard text only (`Page 2 of 2`, icon labels).
-- Recovery that worked (same as the committed learning's icon-tap rule): a
-  tiny scratch flow `stopApp` → conditional `tapOn: {text: 'Kilo'}` (home
-  icon) → `extendedWaitUntil` the prior screen's known element (route
-  persistence returned to the login screen), then rerun the real flow
-  immediately. Never `launchApp` as the recovery.
-- Practical rule for multi-flow rounds: after any flow boundary, do not assume
-  the app is still foreground — gate the next flow on a known element and
-  recover via the icon tap, not by rerunning the same flow blindly.
diff --git a/.kilo_workflow/learnings/monitor-must-read-orchestrator-scrollback-before-intervening.md b/.kilo_workflow/learnings/monitor-must-read-orchestrator-scrollback-before-intervening.md
deleted file mode 100644
index f81977c39b..0000000000
--- a/.kilo_workflow/learnings/monitor-must-read-orchestrator-scrollback-before-intervening.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# Monitor killed a healthy dispatch and faked the log marker — read scrollback first, never forge
-
-Symptom: a planner monitor, watching its orchestrator's tmux windows, concluded a running
-implementer was "unsanctioned work", killed the window mid-flight, reverted the worktree, and
-appended its own `EXITCODE=143` line to the dispatch log to release the orchestrator's wait
-loop. The orchestrator had in fact asked the §10 question in its interactive session and the
-user had answered — evidence visible in the orchestrator's own scrollback, which the monitor
-never read. The round was voided by the kill, not by any defect.
-
-Cause: two compounding failures. (1) The monitor treated the absence of information in *its
-own* session as proof of absence anywhere — the handoff had routed the user question to the
-orchestrator's session, so the answer lived only in that session's scrollback. (2) The
-workflow's monitor sections name what a monitor may unstick (crashes, dead windows, hung
-services) but did not state the negative space explicitly: never kill a live dispatch on a
-judgment call, never edit the tree, never write to a dispatch log. The fake marker was the
-most dangerous part: it forged the exact signal the void-round contract keys on.
-
-Fix: monitors verify from the orchestrator's evidence before acting — read its pane
-scrollback (`tmux capture-pane -t <window> -p -S -`), its scratch directory, and the git log.
-A live session doing something unexpected is a reason to *look*, never to kill; the only
-kill-worthy states are the infrastructure failures the monitor sections already name. And a
-log line a monitor writes is indistinguishable from a real one — never append to another
-role's dispatch log; if a process must be killed, say so in your own steer file and let the
-dispatcher draw the void conclusion from the missing sentinel. WORKFLOW.md's Planner Monitor
-Mode now states both rules.
diff --git a/.kilo_workflow/learnings/simulators-left-booted-after-slot-release.md b/.kilo_workflow/learnings/simulators-left-booted-after-slot-release.md
deleted file mode 100644
index 6ac312cbb8..0000000000
--- a/.kilo_workflow/learnings/simulators-left-booted-after-slot-release.md
+++ /dev/null
@@ -1,43 +0,0 @@
-# Simulators stayed booted after the e2e slot was released
-
-Symptom: agents that correctly ran `e2e-slot.sh release` still left their
-simulator booted. Devices accumulated across sections until several
-`Kilo E2E - <worktree>` simulators were running at once with no slot held
-between them, burning CPU under every section that followed and making later
-emulator boots and native builds look flaky.
-
-Cause: teardown was split between the script and the agent's memory. `release`
-stopped the worktree's dev stack automatically, but the device was a manual
-runbook step — and a *conditional* one:
-
-```
-xcrun simctl shutdown <udid>              # only if you booted it
-pnpm dev:mobile:simulator release <udid>  # every simulator you claimed
-```
-
-Two failure modes, both routine. Agents skipped the line outright, having
-released the slot and considered teardown done. And the ones that did read it
-had no reliable way to answer "did you boot it" several hours into a run, so
-skipping was the safe choice — shutting down a peer worktree's device is far
-worse than leaking one. `pnpm dev:mobile:simulator release <udid>` never
-powered anything off either: it dropped the claim and restored the name, so
-even a fully compliant agent that ran every listed command left the device
-running unless it also remembered the `simctl shutdown`.
-
-The information the decision needed existed and was thrown away. `bootSimulator`
-returns early when `device.state === 'Booted'`, so claim time knows exactly
-whether it started the device — and nothing recorded it.
-
-Fix: the claim records `bootedByClaim`, release powers off only what its own
-claim booted, and `e2e-slot.sh release` runs
-`pnpm dev:mobile:simulator release-all` for the releasing worktree alongside
-`pnpm dev:stop`. Devices now go back with the slot exactly like the stack does,
-and the conditional `simctl shutdown` line is gone from the runbook. A device
-already booted before the claim is still never shut down — that guarantee moved
-from the agent's memory into the claim record.
-
-General shape: a cleanup step that depends on an agent recalling what it did
-hours earlier will be skipped, and correctly so when the wrong guess is
-destructive. Record the fact at the moment it is known and let teardown read it.
-Any resource acquired under a slot belongs to that slot — if release does not
-hand it back, nothing will.
diff --git a/.kilo_workflow/learnings/steering-a-running-kilo-session.md b/.kilo_workflow/learnings/steering-a-running-kilo-session.md
deleted file mode 100644
index 6d569ef83a..0000000000
--- a/.kilo_workflow/learnings/steering-a-running-kilo-session.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# Steering a running interactive kilo session — use steer.sh, and `N queued` is not a wedge
-
-Symptom: a steering message sent to a running `kilo run --interactive` session (planner, orchestrator) never takes effect. Either the pane shows the text but nothing happens, or the footer sits at `N queued` for a long time and the session gets declared wedged and relaunched, losing in-flight work.
-
-Three separate causes, all reproduced against kilo 7.4.16:
-
-1. **A trailing `Enter` in the same `send-keys` call is swallowed by long messages.** `tmux send-keys -t <t> "$MSG" Enter` submitted a 240-character message fine, but a 2.6k one landed in the composer **unsent** — kilo's composer reads a large chunk as a paste and the Enter becomes part of it. A separate `tmux send-keys -t <t> Enter` afterwards submits it.
-2. **An unbracketed paste submits at every newline.** `tmux paste-buffer` of a three-line message produced **three** prompts (queue `0 → 3`), so the first fragment ran as its own turn before the rest arrived. `paste-buffer -p` (bracketed) delivered the same text as one prompt (queue `0 → 1`).
-3. **`N queued` means delivered, not stuck.** Queued prompts drain one per turn boundary, in order — verified draining `4 queued` once a long bash turn ended. They do not drain between tool calls, so a session chaining tool calls holds the queue for as long as that takes, and `Escape` does not flush it.
-
-Fix: steer with `.kilo_workflow/steer.sh <tmux-target> <message|->`. It sends Enter separately, uses bracketed paste, refuses panes not running the kilo CLI (a mistargeted steer otherwise **executes in a shell** — verified), and confirms delivery from the pane, printing `queued` or `running`. Never treat a queue count as a wedge; a wedge needs a frozen build timer, a stream or api error, or a dead process. When a change must land before the current turn ends, kill and relaunch fresh with an updated handoff instead of waiting — and prefer putting scope in the launch message and handoff so live steering stays the exception.
diff --git a/.kilo_workflow/steer.sh b/.kilo_workflow/steer.sh
index 819639d2e1..d52d270e05 100755
--- a/.kilo_workflow/steer.sh
+++ b/.kilo_workflow/steer.sh
@@ -4,7 +4,7 @@
 #
 #   steer.sh <tmux-target> <message>     # message text, or - to read stdin
 #
-# Traps this exists for (see learnings/steering-a-running-kilo-session.md):
+# Traps this exists for (reproduced against kilo 7.4.16):
 #
 #   1. `tmux send-keys -t <t> "$MSG" Enter` submits short messages but NOT long
 #      ones — kilo's composer reads a large chunk as a paste and swallows the

From 9976a170b94935f8ef1d6c1e0a0a6c7b6b510c3b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Wed, 29 Jul 2026 13:53:10 +0200
Subject: [PATCH 02/34] feat(workflow): automate away the hand-assembled
 rituals
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

New scripts encode what WORKFLOW.md previously taught in prose: await-role.sh
(round completion, sentinel, void/stall detection), launch-interactive.sh
(planner/orchestrator launches: env strip, TTY, tmux targeting),
slice-diff.sh (slice diff + tamper fingerprint), pr-threads.sh (review-thread
GraphQL plumbing), pick-reviewers.sh (reviewer ranking). e2e-slot.sh now
resolves the caller's own tmux session. WORKFLOW.md codifies the principle:
anything that can be automated away, should be — agents' tokens go to the
work. Merge the two monitor-mode sections, teach every role to grep learnings
when stuck, and graduate the review-threads learning into its script.
---
 .kilo/agent/e2e-verifier.md                   |   2 +-
 .kilo/agent/impl-reviewer.md                  |   2 +-
 .kilo/agent/implementer.md                    |   2 +-
 .kilo/agent/plan-reviewer.md                  |   2 +-
 .kilo/agent/starter.md                        |   2 +-
 .kilo_workflow/README.md                      |   8 ++
 .kilo_workflow/WORKFLOW.md                    | 102 +++++++++---------
 .kilo_workflow/await-role.sh                  |  76 +++++++++++++
 .kilo_workflow/dispatch-role.sh               |   5 +-
 .kilo_workflow/e2e-slot.sh                    |  32 ++++--
 .kilo_workflow/launch-interactive.sh          |  63 +++++++++++
 .../learnings/github-pr-review-threads-api.md |  27 -----
 .kilo_workflow/pick-reviewers.sh              |  34 ++++++
 .kilo_workflow/pr-threads.sh                  |  62 +++++++++++
 .kilo_workflow/slice-diff.sh                  |  39 +++++++
 apps/mobile/e2e/AGENTS.md                     |  10 +-
 16 files changed, 372 insertions(+), 96 deletions(-)
 create mode 100755 .kilo_workflow/await-role.sh
 create mode 100755 .kilo_workflow/launch-interactive.sh
 delete mode 100644 .kilo_workflow/learnings/github-pr-review-threads-api.md
 create mode 100755 .kilo_workflow/pick-reviewers.sh
 create mode 100755 .kilo_workflow/pr-threads.sh
 create mode 100755 .kilo_workflow/slice-diff.sh

diff --git a/.kilo/agent/e2e-verifier.md b/.kilo/agent/e2e-verifier.md
index 256dea6179..99b03072b3 100644
--- a/.kilo/agent/e2e-verifier.md
+++ b/.kilo/agent/e2e-verifier.md
@@ -23,7 +23,7 @@ Before testing:
 1. Read the learnings — the worktree's `.kilo_workflow/learnings/` plus the main checkout's `~/Projects/cloud/.kilo_workflow/learnings/system/` — then the surface-specific runbook, and follow it exactly for services, device claiming, builds, login, automation drivers, prompts, and cleanup — mobile: `apps/mobile/e2e/AGENTS.md`; extension: `apps/extension/AGENTS.md`; web and services: `DEVELOPMENT.md` and the repository dev runner. Never bypass a helper script's preflight, install unvalidated builds, or guess selectors.
 2. Translate the plan's goals and acceptance criteria into observable flows; for user-facing features, cover the happy, retryable-unhappy, non-retryable-unhappy, and empty states.
 3. Record pre-existing services, listeners, devices, and tmux sessions so cleanup removes only resources you created. Never use a device claimed by another worktree.
-4. Immediately before starting a stack, booting a simulator or emulator, or running a native build — and only then, never while you are still reading or planning — acquire a machine device slot with `.kilo_workflow/e2e-slot.sh acquire <your-tmux-session>`. The owner string is your own tmux session name, resolved through your own pane: `tmux display-message -p -t "$TMUX_PANE" '#S'`. Never the untargeted `tmux display-message -p '#S'` — it answers with the tmux **server's** current session, so you would own a slot under another session's name; that slot is reclaimed when *that* session dies while you are still driving a device, over-subscribing the machine and making every concurrent emulator boot and build time out. If `$TMUX_PANE` is unset you are not in a session that can own a slot: stop and report a test-environment blocker rather than guessing a name. Your dispatcher launched you in a dedicated session for exactly this reason; never pass a window name or a shared session name. This is mandatory on every run — the machine is shared and unslotted device work overloads it. The command blocks until a slot frees; blocking is correct behavior, never a wedge to work around, and never a reason to proceed unslotted.
+4. Immediately before starting a stack, booting a simulator or emulator, or running a native build — and only then, never while you are still reading or planning — acquire the machine device slot: `.kilo_workflow/e2e-slot.sh acquire` (no argument — it resolves your own tmux session and refuses to run outside one; if it refuses, stop and report a test-environment blocker rather than passing a guessed name). This is mandatory on every run — the machine is shared and unslotted device work overloads it. The command blocks until a slot frees; blocking is correct behavior, never a wedge to work around, and never a reason to proceed unslotted.
 5. Before any temporary edit, snapshot a baseline outside every repository: `git status --porcelain=v2 -z --untracked-files=all`, binary worktree and index diffs, and the byte hash, file mode, and symlink target of every untracked path. Copy the original bytes and mode of every tracked file you plan to edit. Temporary edits may touch only paths that are clean and tracked at baseline, or brand-new paths — never a pre-existing modified, staged, or untracked path.
 
 Output discipline — long verification runs die when their session payload grows too large. Cap every shell command's output (`| tail -c 1500` or `| tail -5`); write hierarchies, captures, and service logs to files and print only greps or counts; never re-read screenshots into context; keep your final report bounded.
diff --git a/.kilo/agent/impl-reviewer.md b/.kilo/agent/impl-reviewer.md
index f3d04fb1e5..f06d1a5a88 100644
--- a/.kilo/agent/impl-reviewer.md
+++ b/.kilo/agent/impl-reviewer.md
@@ -14,7 +14,7 @@ permission:
 
 You are an independent, read-only reviewer of an implementation produced for an approved plan (see `.kilo_workflow/WORKFLOW.md`). Review every relevant change, including cross-package and sibling-repository changes. Run any read-only commands you need, including in sibling repositories (for example `git -C <sibling-worktree> diff`). Permissions restrict nothing except agent dispatch (`task`); the read-only boundary is this instruction. Never modify any file or repository state, never commit, push, or create or update a PR, and never fix findings yourself.
 
-Your 50-step limit is a hard ceiling. The handoff gives you the priority order, minimum complete outcome, optional work to drop, and a stopping rule. Review one coherent slice diff, not partial output from active implementers.
+Your 50-step limit is a hard ceiling. The handoff gives you the priority order, minimum complete outcome, optional work to drop, and a stopping rule. Review one coherent slice diff, not partial output from active implementers. When a tool or environment failure blocks a check you need, grep `.kilo_workflow/learnings/` (and `~/Projects/cloud/.kilo_workflow/learnings/system/`) for the error text before debugging from scratch.
 
 Review against:
 
diff --git a/.kilo/agent/implementer.md b/.kilo/agent/implementer.md
index cf0f33304f..fd8ea32c8e 100644
--- a/.kilo/agent/implementer.md
+++ b/.kilo/agent/implementer.md
@@ -16,7 +16,7 @@ You implement one bounded slice from an approved plan (see `.kilo_workflow/WORKF
 
 Before editing:
 
-1. Read the `AGENTS.md` files for every directory and repository you will touch.
+1. Read the `AGENTS.md` files for every directory and repository you will touch. When a tool or environment failure blocks you at any point, grep `.kilo_workflow/learnings/` (and `~/Projects/cloud/.kilo_workflow/learnings/system/`) for the error text before debugging from scratch — a prior run has usually already recorded the fix.
 2. Inspect the existing implementation and tests. Do not infer APIs or conventions from the task text alone.
 3. Restate the acceptance criteria. Flag ambiguity instead of making product or architecture decisions.
 4. For a new user-facing feature, restate its four states — happy, retryable unhappy, non-retryable unhappy, empty — each with trigger or classification, message intent, CTA label and outcome (or required absence), and planned coverage. If a state is underdefined, or missing without an orchestrator-accepted rationale that it is structurally impossible, stop and report.
diff --git a/.kilo/agent/plan-reviewer.md b/.kilo/agent/plan-reviewer.md
index 97ad3ef387..ccb2a65b85 100644
--- a/.kilo/agent/plan-reviewer.md
+++ b/.kilo/agent/plan-reviewer.md
@@ -16,7 +16,7 @@ You are an independent, read-only reviewer for a drafted implementation plan (se
 
 The plan will be executed by cheaper models than the planner. Beyond correctness, judge whether the plan is written in simple, explicit language those models can follow without guessing.
 
-Your 40-step limit is a hard ceiling. The handoff gives you the plan path, requirements, mode, repositories and worktrees in scope, priority order, minimum complete review, and a stopping rule.
+Your 40-step limit is a hard ceiling. The handoff gives you the plan path, requirements, mode, repositories and worktrees in scope, priority order, minimum complete review, and a stopping rule. When a tool or environment failure blocks a check you need, grep `.kilo_workflow/learnings/` (and `~/Projects/cloud/.kilo_workflow/learnings/system/`) for the error text before debugging from scratch.
 
 Report:
 
diff --git a/.kilo/agent/starter.md b/.kilo/agent/starter.md
index e066efd644..7fd7528570 100644
--- a/.kilo/agent/starter.md
+++ b/.kilo/agent/starter.md
@@ -9,6 +9,6 @@ permission:
     "*": allow
 ---
 
-You are the starter defined in `.kilo_workflow/WORKFLOW.md` (section 1 and everything it references). Read that document first and follow it exactly: collect the work and the mode (`hands on` / `hands off`), explore the codebase, interrogate the requirements toward the simplest solution — challenge the request itself — divide the work into disjoint sections, create each section's worktree and scratch directory, write its brief, launch its planner, then monitor per Starter Monitor Mode until every section reaches a terminal state.
+You are the starter defined in `.kilo_workflow/WORKFLOW.md` (section 1 and everything it references). Read that document first and follow it exactly: collect the work and the mode (`hands on` / `hands off`), explore the codebase, interrogate the requirements toward the simplest solution — challenge the request itself — divide the work into disjoint sections, create each section's worktree and scratch directory, write its brief, launch its planner, then monitor per Monitor Mode until every section reaches a terminal state.
 
 No model is pinned here — the user picks your model at launch (`--model`, prefer SOTA). Your permissions are pinned so you run unattended on any machine. You launch planners with the kilo CLI (or the user's chosen harness) per the workflow's section 1 — never with a `task` tool.
diff --git a/.kilo_workflow/README.md b/.kilo_workflow/README.md
index 0288e5b1bd..313ec26d8a 100644
--- a/.kilo_workflow/README.md
+++ b/.kilo_workflow/README.md
@@ -45,8 +45,16 @@ A section routinely takes hours of unattended machine time. The human cost is mi
 |---|---|
 | [`WORKFLOW.md`](WORKFLOW.md) | The canonical spec — roles, loops, gates, dispatch commands |
 | [`dispatch-role.sh`](dispatch-role.sh) | Launches a kilo role agent in tmux with a clean environment and logged exit code |
+| [`await-role.sh`](await-role.sh) | Waits on a dispatched agent's log and reports the round's outcome: DONE with its verdict, VOID, STALLED, or RUNNING |
+| [`launch-interactive.sh`](launch-interactive.sh) | Launches an interactive session (planner, orchestrator) in tmux with a clean environment and a live TTY |
 | [`steer.sh`](steer.sh) | Delivers a message to a running interactive session (starter, planner, orchestrator) and confirms it was submitted |
 | [`e2e-slot.sh`](e2e-slot.sh) | Machine-global semaphore (default 3) capping concurrent device/stack E2E phases; agents are never capped |
+| [`slice-diff.sh`](slice-diff.sh) | Emits one slice's diff for review plus a snapshot fingerprint that catches tree/commit violations after a round |
+| [`pr-threads.sh`](pr-threads.sh) | Lists, replies to, and resolves PR review threads (GraphQL plumbing for the Kilobot loop) |
+| [`pick-reviewers.sh`](pick-reviewers.sh) | Ranks reviewer candidates for a PR from file history and the requester's past reviewers |
+| [`upload-pr-attachment.sh`](upload-pr-attachment.sh) | Uploads a screenshot to GitHub `user-attachments` via the checksum-pinned, security-reviewed `gh-image` binary |
 | [`learnings/`](learnings/) | Environment blockers and fixes, one file each, committed via PRs so every future run inherits them; `learnings/system/` is gitignored machine-local state |
 
+A standing rule from the spec: **anything that can be automated away, should be automated away.** Agents' tokens go to the work, not to battling the workflow or the environment — when a run stumbles on something a script or a document could have prevented, the run fixes the script or the document in the same PR, and learnings that graduate into automation get deleted.
+
 Role definitions live in the repository root `.kilo/agent/` (the kilo CLI only discovers agents there). The workflow self-heals: when a run stumbles on something this documentation could have prevented, it fixes the documentation in the same PR.
diff --git a/.kilo_workflow/WORKFLOW.md b/.kilo_workflow/WORKFLOW.md
index 9702f781ce..c9b3d3ce70 100644
--- a/.kilo_workflow/WORKFLOW.md
+++ b/.kilo_workflow/WORKFLOW.md
@@ -21,7 +21,8 @@ These apply to every role. Later sections do not repeat them.
 - Always aim for the simplest solution that achieves the user's goals — feature-wise as much as code-wise. Reuse existing helpers, components, and contracts. Do not add abstraction or scope without evidence it is required.
 - Commit in small, logically scoped commits. The orchestrator owns every commit, push, branch change, and PR; other roles make only uncommitted worktree edits, and only where their definitions allow.
 - Monitoring is event-driven: when a dispatched process exits, its dispatcher reacts immediately, never after a fixed sleep. Periodic checks exist only to detect a wedge.
-- Before any environment-dependent phase, read the learnings (see Learnings): the worktree's `.kilo_workflow/learnings/`, plus the main checkout's `~/Projects/cloud/.kilo_workflow/learnings/system/` — the canonical machine-local set, which mid-run writes go to and worktree copies lag.
+- Tokens go to the work, never to fighting the workflow or the environment. Every mechanical step that can be scripted is scripted — `dispatch-role.sh`, `await-role.sh`, `steer.sh`, `launch-interactive.sh`, `e2e-slot.sh`, `slice-diff.sh`, `pr-threads.sh`, `pick-reviewers.sh`, `upload-pr-attachment.sh` — use the script, never hand-assemble its steps. **Anything that can be automated away, should be automated away:** when a run stumbles on something a script or an instruction could have prevented, fix the script or the document in the same run (see Learnings).
+- Learnings are the residue automation cannot reach. Before any environment-dependent phase, list both learnings directories — the worktree's `.kilo_workflow/learnings/` and the main checkout's `~/Projects/cloud/.kilo_workflow/learnings/system/` (the canonical machine-local set, which mid-run writes go to and worktree copies lag) — and read the entries whose names match your surface; filenames are symptom-keyed. When a tool or environment failure blocks you mid-run, grep both directories for the error text before debugging from scratch: a prior run has usually already paid for the answer.
 
 ### Models
 
@@ -53,20 +54,29 @@ LOG=$(.kilo_workflow/dispatch-role.sh plan-reviewer <section> r1 <cloud-worktree
 
 The cwd/worktree is always the **cloud** worktree, even when the slice edits a sibling repository — the role definitions in root `.kilo/agent/` are only discovered there, and they pin the model, so worker dispatches never pass `--model`/`--variant`. The message is a short literal; file content — handoffs, plans, diffs — always travels via `--file <path>` (repeatable), never inlined with `"$(cat file)"`: dispatches routed through a tmux command string get re-parsed by another shell, and backticks inside the file then execute (see `learnings/kilo-run-shell-substitution-executes-backticks.md`).
 
-What the script encodes (details in `learnings/`):
+What the script encodes (details in its header comments):
 
 - tmux wrapping — harness command timeouts kill bare long runs. The `e2e-verifier` gets its **own tmux session** (E2E slots are owned and auto-reclaimed by session name; a window-named owner leaks or shares slots); other roles run as windows in the dispatcher's session, resolved through `$TMUX_PANE`. A dispatcher that is not itself inside tmux has no such session, so its roles get their own sessions too — never a guessed one. Names are `<section>-<role>-<label>`, logs `$SCRATCH/<role>-<label>.log`.
 - Full `KILO_*`/`OPENCODE*` env strip — a dispatcher running inside kilo poisons nested runs otherwise (see `learnings/nested-kilo-run-env-poisoning.md`).
 - Output redirected, never piped (`| tee` makes `$?` report the pipe's exit, not kilo's), with `EXITCODE=$?` appended as the log's last line.
 
-Wait event-driven: the run is done when the tmux window/session is gone or `tail -1 "$LOG"` matches `^EXITCODE=[0-9]`. The role's sentinel is then the line **above** the marker — check it with `tail -2 "$LOG" | head -1`, never by grepping the whole log (agents quote sentinel strings when reading this document, and a mid-log match false-passes).
-- **Void rounds:** every role definition requires a fixed sentinel as the log's **last report line** (reviewers: `No findings.`, `FINDINGS: <n>`, or `STOPPED EARLY.`; implementer: `SLICE COMPLETE.`/`STOPPED EARLY.`; verifier: `VERIFICATION PASSED.`/`VERIFICATION FAILED.`/`VERIFICATION BLOCKED.`/`REPRODUCED.`/`CANNOT REPRODUCE.`/`STOPPED EARLY.`). A round without its sentinel is void, never a pass, regardless of exit code — kilo runs can die mid-stream and still exit 0. Discard it and dispatch a fresh session. `STOPPED EARLY.` is not void but not success either: re-dispatch with a continuation handoff; it counts toward the loop's round cap.
-- After a reviewer round, the reviewed slice's owned paths must match the dispatcher's pre-round snapshot (other slices' implementers may legitimately be editing theirs); after an implementer round no new commits may exist. A violation voids the round.
-- Void rounds count toward the loop's round cap, and three consecutive void rounds are an infrastructure blocker (auth wedge, provider outage), never something to redispatch through.
+Wait with [`await-role.sh`](await-role.sh) — never a hand-rolled loop (exit codes lie, whole-log sentinel greps false-pass on quoted sentinels, and a stalled run never writes its marker):
+
+```bash
+.kilo_workflow/await-role.sh "$LOG"   # blocks up to 8 minutes, prints exactly one line
+```
+
+Act on that line:
+
+- `DONE <sentinel>` — the round's verdict, taken from the only place a verdict counts (the line above the `EXITCODE` marker). Sentinels: reviewers `No findings.` / `FINDINGS: <n>`; implementer `SLICE COMPLETE.`; verifier `VERIFICATION PASSED.`/`VERIFICATION FAILED.`/`VERIFICATION BLOCKED.` (repro mode: `REPRODUCED.`/`CANNOT REPRODUCE.`); any role `STOPPED EARLY.` — not a failure but not success: re-dispatch with a continuation handoff, and it counts toward the loop's round cap.
+- `RUNNING` — invoke it again. Each re-invocation is also the moment to unstick **infrastructure failures only**: a wedged or crashed kilo CLI, a dead tmux window, a hung service the agent cannot restart itself. Product, logic, or review problems are never stuck states — route those through the escalation ladder.
+- `VOID` — the run ended with no verdict (kilo runs can die mid-stream and still exit 0). Never a pass: discard the round and dispatch a fresh session.
+- `STALLED` — the stall that never exits. Kill the round's tmux window/session, verify state from artifacts on disk (never the dead run's claims), and redispatch fresh with a continuation handoff.
+
+Two checks stay with the dispatcher, since only it knows the slice — both are one `slice-diff.sh` re-run (compare its `SNAPSHOT` line against the pre-round one): after a reviewer round the whole line must be identical — the reviewer never modifies the tree (other slices' implementers may legitimately be editing *their* paths); after an implementer round the head sha must be unchanged — the implementer never commits. A violation voids the round. Void rounds count toward the loop's round cap, and three consecutive void rounds are an infrastructure blocker (auth wedge, provider outage), never something to redispatch through.
 
 Role boundaries — reviewers never modify the tree, the implementer never commits, no role dispatches agents — are enforced by instruction, not permission. This is deliberate: permission deny lists caused void review rounds (a reviewer whose blocked command made it exit with no verdict, which read as a pass) and takeover churn. The single exception is `task: deny` in the definitions — blocking agent dispatch costs nothing and cannot void a round. The workflow otherwise trades enforcement for reliable rounds and accepts that a misbehaving agent can do what it was told not to; do not "fix" this by re-adding deny lists.
 
-While a role agent runs, its dispatcher checks on it about every 7 minutes and unsticks infrastructure failures only: a wedged or crashed kilo CLI, a dead tmux window, a hung service the agent cannot restart itself. Product, logic, or review problems are not stuck states — route those through the escalation ladder.
 
 ### Steering a Live Interactive Session
 
@@ -84,7 +94,7 @@ It prints `running` when the session took the message immediately and `queued` w
 - A refusal to paste into a pane that is not running the kilo CLI — a mistargeted steer executes in a shell.
 - Delivery confirmed from the pane, never assumed.
 
-**`N queued` in the footer is delivery working, not a wedge.** Queued messages land one at a time at turn boundaries, in order, and a session that chains tool calls for tens of minutes holds the whole queue that entire time. Never kill, relaunch, or escalate on a queue count; a wedge needs its own evidence (frozen build timer, stream or api error, dead process — see Planner Monitor Mode). `Escape` does not flush the queue.
+**`N queued` in the footer is delivery working, not a wedge.** Queued messages land one at a time at turn boundaries, in order, and a session that chains tool calls for tens of minutes holds the whole queue that entire time. Never kill, relaunch, or escalate on a queue count; a wedge needs its own evidence (frozen build timer, stream or api error, dead process — see Monitor Mode). `Escape` does not flush the queue.
 
 Because delivery is ordered and turn-paced, a correction cannot overtake what it corrects: send ONE consolidated, self-contained message per change, never a drip of add-then-retract. When a change must take effect before the current turn ends, kill the session and relaunch it fresh with an updated handoff — faster than waiting on the queue, and it cannot half-apply. Everything a session needs at launch belongs in its launch message and handoff; steering a live one is the exception, not the channel.
 
@@ -110,7 +120,7 @@ Every dispatch to a role agent includes:
 - The mode; for hands-off, a direct instruction to never ask the user questions
 - Sanitized env values inline. Role agents must never read `.env`, `.env.*`, `.dev.vars`, or equivalent files; the handoff table is authoritative. Never place secrets or raw environment-file contents in a handoff.
 - The exact checks or flows expected for that stage
-- For any device or stack phase: the slot rule (see E2E Slots) with the tmux session name that owns the slot
+- For any device or stack phase: the slot rule (see E2E Slots)
 - Prior findings being addressed, including rejected findings that must not reopen without new evidence
 - Priority order, minimum complete outcome, optional work to drop, and a clean stopping rule before budget exhaustion (estimate roughly one step per planned tool call; when in doubt, split the task); on early stop, the required continuation state (completed work, remaining work, failures, files touched, checks run or deferred, safest next action)
 - The GitHub comment rule (see GitHub Communication)
@@ -126,26 +136,23 @@ The session the user invokes the workflow from is the starter, running on the ha
 2. Explore the relevant parts of the codebase.
 3. Interrogate the requirements — in `hands on` mode by grilling the user one question at a time, in `hands off` mode by grilling itself and answering from repository evidence, recording material assumptions. Always drive toward the simplest solution that achieves the user's goals, and challenge the request itself: "should we even do this?", "why not do this instead?", "we could achieve the same thing simpler, like this".
 4. Divide the finalized work into related, **disjoint** sections — no two sections may touch the same files or contracts.
-5. For each section: create the dedicated worktree and scratch directory (Ground Rules), write the section brief to `$SCRATCH/brief.md` — the work, the mode, acceptance criteria and constraints gathered so far, the requesting human's GitHub handle for PR assignment, the worktree path, and the scratch path — and launch a planner in a new tmux window on the planner harness and model. `<session>` is the starter's own tmux session, resolved through its own pane — `tmux display-message -p -t "$TMUX_PANE" '#S'`; never the untargeted `tmux display-message -p '#S'`, which answers with the tmux **server's** current session (the most recently active one) and silently files the window under an unrelated section. A starter that is not itself inside tmux has no such session and `$TMUX_PANE` is unset: launch the planner with `tmux new-session -d -s <section>-planner` instead of guessing a target. The `$SCRATCH` value must be expanded by the launching shell (double-quote the tmux command string; the tmux server does not know the variable):
+5. For each section: create the dedicated worktree and scratch directory (Ground Rules), write the section brief to `$SCRATCH/brief.md` — the work, the mode, acceptance criteria and constraints gathered so far, the requesting human's GitHub handle for PR assignment, the worktree path, and the scratch path — and launch a planner on the planner harness and model with [`launch-interactive.sh`](launch-interactive.sh). The script encodes the launch traps (env strip, TTY, tmux targeting — details in its header), lands the window in your own session when you are inside tmux and a fresh session otherwise, prints the tmux target for `steer.sh` and `capture-pane`, and fails loudly if the command dies at launch:
 
 ```bash
 # kilo planner (the planner agent definition pins permissions; the model is the user's pick):
-tmux new-window -t <session> -n <section>-planner -c <worktree> \
-  "env \$(env | grep -oE '^(KILO|OPENCODE)[A-Za-z0-9_]*' | sed 's/^/-u /' || true) \
-   kilo run 'Plan the work in the attached brief.' --agent planner \
-   --interactive --model <planner-model> --variant high --title '<section> planner' --file $SCRATCH/brief.md"
+.kilo_workflow/launch-interactive.sh <section>-planner <worktree> \
+  kilo run 'Plan the work in the attached brief.' --agent planner \
+  --interactive --model <planner-model> --variant high --title '<section> planner' --file "$SCRATCH/brief.md"
 # claude planner:
-tmux new-window -t <session> -n <section>-planner -c <worktree> \
-  "claude 'You are the planner in .kilo_workflow/WORKFLOW.md. Plan the work in the brief at $SCRATCH/brief.md.'"
+.kilo_workflow/launch-interactive.sh <section>-planner <worktree> \
+  claude "You are the planner in .kilo_workflow/WORKFLOW.md. Plan the work in the brief at $SCRATCH/brief.md."
 ```
 
-The escaped `\$(env ...)` strip runs inside the new window, clearing `KILO_*`/`OPENCODE*` the tmux server may carry (see `learnings/nested-kilo-run-env-poisoning.md`).
-
 One planner per section; each section flows through its own planner, orchestrator, and PR. A single-section run launches a single planner. If the starter's own session already fits the planner role (right model, user agrees), it may become the single planner itself instead of launching one.
 
 ### Starter Monitor Mode
 
-After launching planners the starter monitors them the same way the planner monitors the orchestrator: check about every 30 minutes, unstick or relaunch on infrastructure death only (a fresh session with a continuation brief covering what the dead planner observably finished — never `--continue`), and never intervene in planning judgment. The starter's duty ends when every section has reached a terminal state (see Planner Monitor Mode).
+After launching planners the starter enters Monitor Mode (see Monitor Mode, which is written for the planner watching its orchestrator — the starter applies the same rules with planners as its dispatches and the brief as the handoff). The starter's duty ends when every section has reached a terminal state.
 
 ### Interaction Modes
 
@@ -179,20 +186,16 @@ A `CANNOT REPRODUCE.` sentinel is a blocker, not a license to fix an unconfirmed
 ### Launching the Orchestrator
 
 ```bash
-tmux new-window -t <session> -n <section>-orchestrator -c <worktree> \
-  "env \$(env | grep -oE '^(KILO|OPENCODE)[A-Za-z0-9_]*' | sed 's/^/-u /' || true) \
-   kilo run 'Execute the approved plan in the attached handoff. Own implementation through the completion gate.' \
-   --agent orchestrator --interactive \
-   --title '<section> orchestrator' --file $SCRATCH/handoff.md"
+.kilo_workflow/launch-interactive.sh <section>-orchestrator <worktree> \
+  kilo run 'Execute the approved plan in the attached handoff. Own implementation through the completion gate.' \
+  --agent orchestrator --interactive --title '<section> orchestrator' --file "$SCRATCH/handoff.md"
 ```
 
-The `orchestrator` agent definition pins the model and permissions, so the launch passes neither.
+The `orchestrator` agent definition pins the model and permissions, so the launch passes neither. Do not add `--continue` or `--session`; the orchestrator must be a fresh session. The script preserves the TTY that `--interactive` requires (pass `--log <file>` before the command for a transcript), verifies the session survived launch, and prints the tmux target — report that target, the worktree path, and the handoff path.
 
-`--interactive` requires a TTY: launch it as the tmux window command with no pipe, and attach logging with `tmux pipe-pane` if needed. Do not add `--continue` or `--session`; the orchestrator must be a fresh session. Verify the window started, then report the window name, worktree path, and handoff path.
+### Monitor Mode
 
-### Planner Monitor Mode
-
-After the handoff the planner stops all hands-on work. It has exactly one job — relaunch or unstick the orchestrator when infrastructure fails (a crashed kilo CLI, a dead tmux window, a hung service). Product, logic, design, and review problems are the orchestrator's, handled by its escalation ladder. Check about every 30 minutes; react immediately when the orchestrator's process exits.
+After the handoff the planner stops all hands-on work. It has exactly one job — relaunch or unstick the orchestrator when infrastructure fails (a crashed kilo CLI, a dead tmux window, a hung service). Product, logic, design, and review problems are the orchestrator's, handled by its escalation ladder. Check about every 30 minutes; react immediately when the orchestrator's process exits. (The starter monitors its planners under these same rules.)
 
 A monitor never kills a live dispatch on a judgment call, never edits the worktree, and never writes to another role's dispatch log — a forged `EXITCODE` line corrupts the dispatcher's void-round detection, the exact signal the contract keys on. Before concluding an orchestrator is misbehaving, read its evidence: its pane scrollback (`tmux capture-pane -t <window> -p -S -`), its scratch directory, and the git log. The orchestrator's handoff may route user questions to its own interactive session, so an answer the monitor never saw can exist there — a monitor once killed a healthy implementer and forged its `EXITCODE` line because it never read the scrollback where the user had already answered. The only kill-worthy states are the infrastructure failures named above.
 
@@ -214,7 +217,13 @@ The orchestrator drives the plan to completion. It is the expensive model steeri
 
 1. Ingest the handoff, verify each worktree matches its recorded branch and state (`git -C <worktree> rev-parse --abbrev-ref HEAD` and `git -C <worktree> status --porcelain` against the handoff), and read the learnings.
 2. Segment the plan into slices with disjoint write sets so parallel implementers cannot collide — the plan proposes the tasks, the orchestrator owns the slicing. Always serialize: lockfile changes, dependency installs, migrations, generated clients, repository-wide formatters, and broad autofix commands. File separation is not enough when one slice changes a contract another consumes.
-3. Dispatch ready independent slices to parallel `implementer`s — as many in parallel as the segmentation safely allows; agent parallelism is never capped, only E2E device/stack phases are (see E2E Slots). Loop per slice, at most five rounds: implementer implements, then a fresh `impl-reviewer` reviews the slice diff — `git add -N -- <owned paths> && git diff HEAD -- <owned paths>` (the `add -N` makes new files visible to the diff; take the reviewer's pre-round snapshot **after** it, since it changes status output) written to a scratch file passed via `--file`, since parallel slices share the worktree; triage remarks (untrusted), route valid ones through a repair dispatch. Exit the loop when a fresh reviewer returns `No findings.`, or when its only remaining findings are already rejected in `$SCRATCH/decisions.md` and cite no evidence the rejection did not consider. At the round cap the remaining moves are takeover or BLOCKED (see Escalation).
+3. Dispatch ready independent slices to parallel `implementer`s — as many in parallel as the segmentation safely allows; agent parallelism is never capped, only E2E device/stack phases are (see E2E Slots). Loop per slice, at most five rounds: implementer implements, then a fresh `impl-reviewer` reviews the slice diff, produced with [`slice-diff.sh`](slice-diff.sh) (parallel slices share the worktree, so the reviewer gets a diff file via `--file`, never the whole tree):
+
+```bash
+.kilo_workflow/slice-diff.sh <worktree> "$SCRATCH/slice-api.diff" -- <owned paths>   # prints SNAPSHOT=<head>:<hash>
+```
+
+   Keep the `SNAPSHOT` line and re-run the same command after the round — after a reviewer round the whole line must be identical, after an implementer round the head part must be (see the dispatcher checks under Dispatching). Triage remarks (untrusted), route valid ones through a repair dispatch. Exit the loop when a fresh reviewer returns `No findings.`, or when its only remaining findings are already rejected in `$SCRATCH/decisions.md` and cite no evidence the rejection did not consider. At the round cap the remaining moves are takeover or BLOCKED (see Escalation).
 4. Create small logical commits at slice boundaries, staging only the slice's owned paths (`git add -- <owned paths>`, never `git add -A` while other slices are mid-flight). Once every slice has landed, run the synchronization point: the deferred project-wide checks (typecheck and each changed repository's own check commands) — then, and again after any later repair or direct orchestrator edit, dispatch one fresh `impl-reviewer` over the cumulative section diff (`git diff origin/main...HEAD`, plus any uncommitted changes), so integration seams, takeovers, and merge resolutions never ship unreviewed.
 5. Create the PR — use the repository's PR template when one exists, with the human-readable **what / why / how** narrative inside its summary section, and verification evidence (verifier screenshots and flow results, pulled from reports before scratch cleanup) where the template asks for it. For work with a UI, upload the screenshots to the PR per GitHub Communication before scratch cleanup — local paths are not evidence. Assign the PR to the requesting human, and pick the reviewers yourself (see Picking Reviewers). When the section spans multiple repositories, use the same branch name in each, open one PR per repository, cross-link them, and hold every one to the completion gate. CI and Kilobot start running concurrently with E2E.
 6. Run the E2E loop (below) when the work has verifiable runtime behavior; skip it for doc-only or equivalently inert changes, recording why in the PR description.
@@ -228,23 +237,13 @@ Two terminal states, distinguished by what remains on disk:
 
 ### Picking Reviewers
 
-There is no fixed reviewer list. Work out who fits this PR from what the repository already shows, using two sources:
-
-1. **The files.** For the two or three files the PR changes most, list recent commits — `git log -10 --format='%H' -- <path>` — and for each commit find its PR and that PR's reviewers:
+There is no fixed reviewer list. [`pick-reviewers.sh`](pick-reviewers.sh) ranks candidates from what the repository already shows — who reviewed recent PRs touching the same files, and who reviews the requesting human's work:
 
 ```bash
-gh api repos/<owner>/<repo>/commits/<sha>/pulls --jq '.[].number'
-gh pr view <number> --json reviews --jq '.reviews[].author.login'
+.kilo_workflow/pick-reviewers.sh <owner/repo> <requesting-handle> <file> [file...]   # run in the changed repo, on its 2–3 most-changed files
 ```
 
-2. **The human.** Do the same for the requesting human's last ten merged PRs, to see who usually reviews their work:
-
-```bash
-gh pr list --author <handle> --state merged --limit 10 --json number --jq '.[].number'
-gh pr view <number> --json reviews --jq '.reviews[].author.login'
-```
-
-Count how often each name appears across both lists. Drop bots and the requesting human. Request the top one or two: `gh pr edit <number> --add-reviewer <login>`. If both lists come out empty — new area, no history — request nobody and say so in one line in the PR description; Kilobot and the assignee still review it.
+Request the top one or two names it prints: `gh pr edit <number> --add-reviewer <login>`. If it prints nothing — new area, no history — request nobody and say so in one line in the PR description; Kilobot and the assignee still review it.
 
 ### E2E Loop
 
@@ -255,8 +254,8 @@ Count how often each name appears across both lists. Drop bots and the requestin
 
 ### Kilobot Loop
 
-1. Wait for Kilobot to review the latest head (`gh pr view <n> --json statusCheckRollup,mergeable,mergeStateStatus`; thread state is GraphQL-only — exact queries and the reply/resolve mutations are in `learnings/github-pr-review-threads-api.md`). Kilobot can crash: after about 20 minutes without a review, retrigger it (`git commit --allow-empty -m "chore: retrigger review" && git push`, or a `(bot) @kilocode-bot please review` PR comment), then resume waiting. After two failed retriggers, stop waiting: post `(bot) Kilobot posted no approving summary on this head after two retriggers` on the PR and treat the gate's Kilobot item as waived — the pending human review covers it. A green `Kilo Code Review` check only says the review finished; it carries no verdict. The clean state is a Kilobot summary comment on the current head that approves it (`gh pr view <n> --json comments` — read the verdict the comment states, do not match an exact string; bot wording drifts) plus zero **unresolved** review threads. A green check with no approving summary is not a clean head: keep waiting, then retrigger.
-2. For each comment: verify it (untrusted), then route valid findings through the implementer → impl-reviewer loop; commit, push, reply in the thread, and resolve it. Invalid finding: reply with technical evidence and do not change correct code. A fix without its in-thread reply and thread resolution is not done. Follow the repository-root `AGENTS.md` "Kilobot Review Remarks" contract.
+1. Wait for Kilobot to review the latest head (`gh pr view <n> --json statusCheckRollup,mergeable,mergeStateStatus`; thread state is GraphQL-only — list, reply to, and resolve threads with [`pr-threads.sh`](pr-threads.sh), never hand-written GraphQL). Kilobot can crash: after about 20 minutes without a review, retrigger it (`git commit --allow-empty -m "chore: retrigger review" && git push`, or a `(bot) @kilocode-bot please review` PR comment), then resume waiting. After two failed retriggers, stop waiting: post `(bot) Kilobot posted no approving summary on this head after two retriggers` on the PR and treat the gate's Kilobot item as waived — the pending human review covers it. A green `Kilo Code Review` check only says the review finished; it carries no verdict. The clean state is a Kilobot summary comment on the current head that approves it (`gh pr view <n> --json comments` — read the verdict the comment states, do not match an exact string; bot wording drifts) plus zero **unresolved** review threads. A green check with no approving summary is not a clean head: keep waiting, then retrigger.
+2. For each comment: verify it (untrusted), then route valid findings through the implementer → impl-reviewer loop; commit, push, reply in the thread, and resolve it (`pr-threads.sh reply` / `pr-threads.sh resolve`). Invalid finding: reply with technical evidence and do not change correct code. A fix without its in-thread reply and thread resolution is not done. Follow the repository-root `AGENTS.md` "Kilobot Review Remarks" contract.
 3. Comments already posted by other reviewers — bots or humans — get the same triage flow, but never wait for anyone except Kilobot to review or re-review.
 4. CI failures are findings too: route the fix through the implementer loop; rerun a flaky check once (`gh run rerun <id> --failed`); a check still failing after two fix rounds makes the section BLOCKED.
 5. Rerun E2E for any repair that affects verified behavior (touched bits only). Three full E2E↔Kilobot alternations without converging is BLOCKED.
@@ -304,15 +303,17 @@ Any step where an agent or LLM must actually respond — cloud-agent sessions, c
 The machine is shared by parallel workflows, and unslotted device or stack work overloads it. Only E2E runs are capped — agents themselves are never capped. Every phase that drives a simulator, emulator, local backend stack, browser fleet, or native build — the repro gate and every E2E round — runs inside a slot from [`e2e-slot.sh`](e2e-slot.sh) (default 3, machine-global):
 
 ```bash
-.kilo_workflow/e2e-slot.sh acquire <tmux-session>   # blocks until a slot frees
-.kilo_workflow/e2e-slot.sh status                   # holders, their worktrees, stack coverage
-.kilo_workflow/e2e-slot.sh release <tmux-session>   # the moment the device phase ends
-.kilo_workflow/e2e-slot.sh stacks [--reap]          # stacks running with no slot
+.kilo_workflow/e2e-slot.sh acquire          # from your own tmux session; blocks until a slot frees
+.kilo_workflow/e2e-slot.sh status           # holders, their worktrees, stack coverage
+.kilo_workflow/e2e-slot.sh release          # the moment the device phase ends
+.kilo_workflow/e2e-slot.sh stacks [--reap]  # stacks running with no slot
 ```
 
+`acquire` and `release` resolve the caller's own tmux session themselves (and refuse to run outside one — a slot owner must be a live session so a dead holder can be reclaimed). Pass a session name only when releasing on behalf of a holder that is already dead.
+
 **A slot, a dev stack, and a claimed device are the same resource.** The slot is what entitles a worktree to run a stack and claim a simulator, and neither may outlive it: `release` stops the releasing worktree's stack *and* releases every simulator that worktree claimed, and reclaiming a dead holder's slot does the same for it. So a later round re-acquires, starts a fresh stack, and claims a device again rather than inheriting either — that restart is the price of the cap. A stack up with no slot is a defect, not a shortcut; `stacks` lists them and `stacks --reap` reaps the workflow-owned ones (a stack with no section run id in its name was started by hand and is only reported). Five live stacks on this host drove the load average past 300 and made every emulator boot and native build time out, which reads as flaky devices rather than as over-subscription.
 
-Teardown is the slot's job, never the agent's memory. Runbook cleanup lists used to end with a conditional `xcrun simctl shutdown <udid>` — "only if you booted it" — and agents that dutifully released their slot still skipped it, so simulators stayed booted for the rest of the day under every section that followed. The claim now records whether it booted the device, and release powers off only what it started; a device that was already running before the claim is still never shut down. Never hand-roll device teardown around the wrapper.
+Teardown is the slot's job, never the agent's memory: the claim records whether it booted the device, and release powers off only what its own claim booted — a device already running before the claim is never shut down. Never hand-roll device teardown around the wrapper.
 
 - Slot state lives in `$HOME/.cache/kilo-e2e-slots`, machine-global by design: every copy of the script — any worktree, any repository — contends for the same slots, and the script has no overrides by design. When working in a repository without the script (a sibling like `~/Projects/kilocode`), invoke it by absolute path from a cloud worktree.
 - This holds on every run, not only when another workflow is visibly active, and a stack that is already up is not an exemption.
@@ -345,6 +346,7 @@ Environment blockers and their fixes — broken local stacks, credential traps,
 - `.kilo_workflow/` is exempt from section disjointness — any section may write learnings or fix this document; overlaps resolve as ordinary merge conflicts.
 - Role agents whose rules forbid dirtying the tree (the E2E verifier's byte-identical baseline restore) write their learnings to `$SCRATCH/learnings/` instead and list them in their report; the orchestrator moves them into `.kilo_workflow/learnings/` and commits them.
 - Read before writing: when an existing entry covers the blocker, update it instead of appending a duplicate. When a run proves an entry wrong or stale, fix the entry in the same run.
+- **Graduation:** a learning is a workaround waiting for a fix. When the blocker can be prevented by a script change (a flag, a guard, a wrapper) or by a line where agents already look (this document, a runbook, a role definition), make that change instead of — or in the same PR as — writing the learning, and delete any learning the change supersedes. Keep as learnings only what genuinely cannot be automated or folded away: environment trivia, one-off incident evidence, niche device quirks.
 - Every role records blockers it resolves, immediately after resolving them.
 - Never keep a workflow learning only in a harness's private memory; it belongs in these folders so runs on other harnesses can use it.
 - The same rule applies to this document: when a run stumbles on something `WORKFLOW.md` could have prevented — a missing command, an ambiguous rule, a wrong assumption — the orchestrator fixes the document in the same run and ships the fix with the PR. Role-definition fixes from a kilo session go through shell (`cat > .kilo/agent/<name>.md <<'EOF'`) because kilo's edit tool blocks `.kilo/` paths (see `learnings/kilo-edit-tool-blocks-kilo-config-paths.md`). Mistakes that recur are workflow bugs, not agent bugs.
diff --git a/.kilo_workflow/await-role.sh b/.kilo_workflow/await-role.sh
new file mode 100755
index 0000000000..9b57f546c9
--- /dev/null
+++ b/.kilo_workflow/await-role.sh
@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# Wait on a dispatched role agent's log and report the round's outcome, per
+# .kilo_workflow/WORKFLOW.md. This replaces hand-rolled wait loops: exit codes
+# lie (kilo runs die mid-stream and still exit 0), grepping a whole log for a
+# sentinel false-passes when the agent quoted one, and a stalled run can sit
+# forever without ever writing its EXITCODE marker.
+#
+#   await-role.sh <log> [--timeout <sec>] [--stall <sec>]
+#
+# Blocks up to --timeout (default 480s — safely under harness command
+# timeouts), then reports. Re-invoke while it prints RUNNING. Prints exactly
+# one line:
+#
+#   DONE <sentinel>   exit 0  round finished with a real verdict; act on it
+#   VOID exit=<n>     exit 2  finished without a sentinel — a crashed run,
+#                             never a pass; discard and dispatch fresh
+#   STALLED <sec>s    exit 3  no EXITCODE and the log has been quiet past the
+#                             stall threshold (default 1200s) — kill the tmux
+#                             window/session, verify state, redispatch fresh
+#   RUNNING           exit 4  still working; invoke again
+#
+# The sentinel is the line above the EXITCODE marker — the only place a
+# verdict counts. `STOPPED EARLY.` reports as DONE: not void, not success;
+# re-dispatch with a continuation handoff.
+set -euo pipefail
+
+LOG=${1:?usage: await-role.sh <log> [--timeout <sec>] [--stall <sec>]}
+shift
+TIMEOUT=480
+STALL=1200
+while [ $# -gt 0 ]; do
+  case $1 in
+    --timeout) TIMEOUT=${2:?}; shift 2 ;;
+    --stall) STALL=${2:?}; shift 2 ;;
+    *) echo "await-role: unknown option $1" >&2; exit 1 ;;
+  esac
+done
+
+SENTINELS='^(No findings\.|FINDINGS: [0-9]+|STOPPED EARLY\.|SLICE COMPLETE\.|VERIFICATION (PASSED|FAILED|BLOCKED)\.|REPRODUCED\.|CANNOT REPRODUCE\.)$'
+
+mtime() { stat -f %m "$1" 2>/dev/null || stat -c %Y "$1" 2>/dev/null || echo 0; }
+
+START=$(date +%s)
+while :; do
+  NOW=$(date +%s)
+  if [ -f "$LOG" ]; then
+    LAST=$(tail -1 "$LOG" 2>/dev/null || true)
+    if [[ "$LAST" =~ ^EXITCODE=([0-9]+) ]]; then
+      CODE=${BASH_REMATCH[1]}
+      # Strip trailing whitespace; roles must end their report with the bare
+      # sentinel as the last line before the marker.
+      SENTINEL=$(tail -2 "$LOG" | head -1 | sed 's/[[:space:]]*$//')
+      if [[ "$SENTINEL" =~ $SENTINELS ]]; then
+        echo "DONE $SENTINEL"
+        exit 0
+      fi
+      echo "VOID exit=$CODE — no sentinel; discard the round and dispatch a fresh session"
+      exit 2
+    fi
+    AGE=$(( NOW - $(mtime "$LOG") ))
+    if [ "$AGE" -gt "$STALL" ]; then
+      echo "STALLED ${AGE}s quiet, no EXITCODE — kill the round's tmux window/session, verify state on disk, redispatch fresh"
+      exit 3
+    fi
+  elif [ $(( NOW - START )) -gt 90 ]; then
+    # The dispatch redirects into the log the moment kilo starts; a log still
+    # missing after a grace period means the window died before launching.
+    echo "VOID no log at $LOG — the dispatch never started; check tmux and dispatch again"
+    exit 2
+  fi
+  if [ $(( NOW - START )) -ge "$TIMEOUT" ]; then
+    echo "RUNNING — no verdict after ${TIMEOUT}s; invoke again to keep waiting"
+    exit 4
+  fi
+  sleep 15
+done
diff --git a/.kilo_workflow/dispatch-role.sh b/.kilo_workflow/dispatch-role.sh
index 1093f46eae..f68e71520b 100755
--- a/.kilo_workflow/dispatch-role.sh
+++ b/.kilo_workflow/dispatch-role.sh
@@ -10,9 +10,8 @@
 #   label    round tag, e.g. r1 or api-r2 (slice-r<round>)
 #   message  short literal instruction — file content goes via --file, never $(cat)
 #
-# Prints the log path. Wait per WORKFLOW.md: the run is done when the tmux
-# window/session is gone or `tail -1 <log>` matches ^EXITCODE=[0-9]; then check
-# the role's sentinel line — a log without it is a void round.
+# Prints the log path. Wait on it with await-role.sh, never a hand-rolled
+# loop — it reports DONE with the role's sentinel, VOID, STALLED, or RUNNING.
 #
 # The e2e-verifier gets its own tmux session (device slots are owned and
 # auto-reaped by session name); every other role runs as a window in the
diff --git a/.kilo_workflow/e2e-slot.sh b/.kilo_workflow/e2e-slot.sh
index e5cb322790..6a8c962de4 100755
--- a/.kilo_workflow/e2e-slot.sh
+++ b/.kilo_workflow/e2e-slot.sh
@@ -10,8 +10,8 @@
 # section that follows. Planning, implementation, review, and CI waits need
 # neither, and are unlimited.
 #
-#   e2e-slot.sh acquire <tmux-session>   # blocks until a slot is free, then holds it
-#   e2e-slot.sh release <tmux-session>   # frees the slot AND hands back the worktree's stack and simulators
+#   e2e-slot.sh acquire [tmux-session]   # blocks until a slot is free, then holds it
+#   e2e-slot.sh release [tmux-session]   # frees the slot AND hands back the worktree's stack and simulators
 #   e2e-slot.sh status                   # who holds what, for how long, with stack coverage
 #   e2e-slot.sh stacks [--reap]          # stacks with no slot; --reap stops them
 #
@@ -19,6 +19,13 @@
 # If that tmux session no longer exists the slot is stale and is reclaimed
 # automatically — no heartbeats to maintain.
 #
+# acquire/release resolve the CALLER'S OWN tmux session when no name is given —
+# through $TMUX_PANE, never the untargeted `display-message -p '#S'`, which
+# answers with the server's most recently active session and hands your slot an
+# owner that can die while you still drive a device. Passing a name is for
+# operators cleaning up a dead holder, not for owning a slot under a session
+# that is not yours.
+#
 # State is machine-global on purpose: every worktree's copy of this script must
 # contend for the same slots, so the state dir never lives next to the script.
 set -uo pipefail
@@ -123,9 +130,21 @@ uncovered_stacks() {
   done
 }
 
-case "${1:?usage: acquire|release|status <tmux-session>}" in
+# The caller's own tmux session, resolved through its pane. Empty when not in
+# tmux — a process that cannot own a slot, because reclamation keys on the
+# owning session's liveness.
+self_session() {
+  [ -n "${TMUX_PANE:-}" ] || return 0
+  tmux display-message -p -t "$TMUX_PANE" '#S' 2>/dev/null || true
+}
+
+case "${1:?usage: acquire|release|status|stacks [tmux-session]}" in
   acquire)
-    who=${2:?tmux session name required}
+    who=${2:-$(self_session)}
+    [ -n "$who" ] || {
+      echo "not inside a tmux session — a slot owner must be a live tmux session so a dead holder can be reclaimed; run from your own session (your dispatcher should have launched you in one)" >&2
+      exit 1
+    }
     # Reject an owner that is not a live session — a window name, or a session
     # name misread from the untargeted `display-message -p '#S'`. Such a slot is
     # reapable the moment it is written, so it gets handed to a second workflow
@@ -157,7 +176,8 @@ case "${1:?usage: acquire|release|status <tmux-session>}" in
     done
     ;;
   release)
-    who=${2:?tmux session name required}
+    who=${2:-$(self_session)}
+    [ -n "$who" ] || { echo "not inside tmux and no session name given" >&2; exit 1; }
     for s in "$DIR"/slot-*; do
       [ -d "$s" ] || continue
       [ "$(cat "$s/owner" 2>/dev/null)" = "$who" ] || continue
@@ -217,5 +237,5 @@ case "${1:?usage: acquire|release|status <tmux-session>}" in
       release_worktree_resources "$wt"
     done
     ;;
-  *) echo "usage: $0 acquire|release|status|stacks <tmux-session>" >&2; exit 1 ;;
+  *) echo "usage: $0 acquire|release|status|stacks [tmux-session]" >&2; exit 1 ;;
 esac
diff --git a/.kilo_workflow/launch-interactive.sh b/.kilo_workflow/launch-interactive.sh
new file mode 100755
index 0000000000..48fdc2d03c
--- /dev/null
+++ b/.kilo_workflow/launch-interactive.sh
@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+# Launch an interactive workflow session (planner, orchestrator, starter) in
+# tmux per .kilo_workflow/WORKFLOW.md, encoding the traps so nobody
+# hand-assembles them:
+#
+#   - `--interactive` needs a TTY: the command runs as the tmux window command,
+#     never piped or redirected; use --log to attach `tmux pipe-pane` logging.
+#   - Full KILO_*/OPENCODE* env strip, computed inside the new pane — the tmux
+#     SERVER's environment can poison children even when the caller's is clean
+#     (see learnings/nested-kilo-run-env-poisoning.md).
+#   - The caller's session is resolved through $TMUX_PANE. An untargeted
+#     `tmux display-message -p '#S'` answers with the server's most recently
+#     active session and files the window under an unrelated section. Outside
+#     tmux, the launch gets its own session.
+#   - The window target carries a trailing colon so tmux cannot prefix-match a
+#     window name (see learnings/tmux-new-window-index-in-use-name-prefix-collision.md).
+#
+#   launch-interactive.sh <name> <worktree> [--log <file>] <command> [args...]
+#
+#   name      tmux window/session name, e.g. <section>-planner
+#   worktree  working directory for the session
+#   command   the interactive command and its arguments, as real argv — shell
+#             variables like $SCRATCH are expanded by YOUR shell, and no part
+#             of it is re-parsed, so backticks in messages stay literal
+#
+# Prints the tmux target (usable with steer.sh and capture-pane) and verifies
+# the pane actually survived startup.
+set -euo pipefail
+
+NAME=${1:?name} WT=${2:?worktree}
+shift 2
+LOGFILE=""
+if [ "${1:-}" = "--log" ]; then LOGFILE=${2:?log file}; shift 2; fi
+[ $# -gt 0 ] || { echo "launch-interactive: no command given" >&2; exit 1; }
+[ -d "$WT" ] || { echo "launch-interactive: no such worktree: $WT" >&2; exit 1; }
+
+STRIP='$(env | grep -oE "^(KILO|OPENCODE)[A-Za-z0-9_]*" | sed "s/^/-u /" | tr "\n" " " || true)'
+CMD="env $STRIP"
+for arg in "$@"; do CMD+=" $(printf '%q' "$arg")"; done
+
+CALLER_SESSION=""
+if [ -n "${TMUX_PANE:-}" ]; then
+  CALLER_SESSION=$(tmux display-message -p -t "$TMUX_PANE" '#S' 2>/dev/null || true)
+fi
+
+if [ -n "$CALLER_SESSION" ]; then
+  TARGET=$(tmux new-window -d -P -F '#{session_name}:#{window_index}' -t "$CALLER_SESSION:" -n "$NAME" -c "$WT" "$CMD")
+else
+  tmux new-session -d -s "$NAME" -c "$WT" "$CMD"
+  TARGET=$NAME
+fi
+
+[ -n "$LOGFILE" ] && tmux pipe-pane -t "$TARGET" -o "cat >> $(printf '%q' "$LOGFILE")"
+
+# A command that dies instantly (bad flag, missing binary) closes its pane;
+# report that as a failure instead of handing back a dead target. list-panes,
+# not display-message — display-message exits 0 for a missing target.
+sleep 3
+if ! tmux list-panes -t "$TARGET" >/dev/null 2>&1; then
+  echo "launch-interactive: $NAME exited immediately — check the command" >&2
+  exit 1
+fi
+echo "$TARGET"
diff --git a/.kilo_workflow/learnings/github-pr-review-threads-api.md b/.kilo_workflow/learnings/github-pr-review-threads-api.md
deleted file mode 100644
index 23c6ae727b..0000000000
--- a/.kilo_workflow/learnings/github-pr-review-threads-api.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# Reading and resolving PR review threads needs GraphQL, not the REST comments endpoint
-
-Symptom: the Kilobot loop needs "zero unresolved threads", but `gh api repos/<o>/<r>/pulls/<n>/comments` shows inline comments with no resolution state, and there is no REST way to resolve a thread — the loop's exit condition looks unevaluable.
-
-Cause: thread grouping, `isResolved`, and resolution live only in GitHub's GraphQL API.
-
-Fix: list threads with their state:
-
-```bash
-gh api graphql -f query='query($owner:String!,$repo:String!,$pr:Int!){
-  repository(owner:$owner,name:$repo){pullRequest(number:$pr){
-    reviewThreads(first:100){nodes{id isResolved path line
-      comments(first:10){nodes{author{login} body}}}}}}}' \
-  -f owner=<owner> -f repo=<repo> -F pr=<n>
-```
-
-Reply in a thread with the REST reply endpoint (the comment id is the thread's first comment id):
-
-```bash
-gh api repos/<owner>/<repo>/pulls/<n>/comments/<comment-id>/replies -f body='(bot) ...'
-```
-
-Resolve it with the GraphQL mutation, using the thread `id` from the query above:
-
-```bash
-gh api graphql -f query='mutation($t:ID!){resolveReviewThread(input:{threadId:$t}){thread{isResolved}}}' -f t=<thread-id>
-```
diff --git a/.kilo_workflow/pick-reviewers.sh b/.kilo_workflow/pick-reviewers.sh
new file mode 100755
index 0000000000..514f52c97b
--- /dev/null
+++ b/.kilo_workflow/pick-reviewers.sh
@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+# Rank reviewer candidates for a PR per .kilo_workflow/WORKFLOW.md "Picking
+# Reviewers": who reviewed recent PRs touching the same files, and who reviews
+# the requesting human's work. Pure plumbing — the dispatcher just requests the
+# top one or two names.
+#
+#   pick-reviewers.sh <owner/repo> <requesting-handle> <file> [file...]
+#
+# Run from the repository the files live in (uses git log). Prints
+# "<count> <login>" lines, most frequent first, bots and the requesting human
+# already dropped. No output at all means no history — request nobody and say
+# so in one line in the PR description.
+set -euo pipefail
+
+REPO=${1:?owner/repo} HANDLE=${2:?requesting GitHub handle}
+shift 2
+[ $# -gt 0 ] || { echo "usage: pick-reviewers.sh <owner/repo> <handle> <file>..." >&2; exit 1; }
+
+PRS=$(
+  {
+    for f in "$@"; do
+      git log -10 --format='%H' -- "$f"
+    done | sort -u | while read -r sha; do
+      gh api "repos/$REPO/commits/$sha/pulls" --jq '.[].number' 2>/dev/null || true
+    done
+    gh pr list --repo "$REPO" --author "$HANDLE" --state merged --limit 10 \
+      --json number --jq '.[].number'
+  } | sort -un
+)
+
+[ -n "$PRS" ] || exit 0
+for n in $PRS; do
+  gh pr view "$n" --repo "$REPO" --json reviews --jq '.reviews[].author.login' 2>/dev/null || true
+done | grep -viE 'bot' | grep -vxF "$HANDLE" | sort | uniq -c | sort -rn | awk '{print $1, $2}'
diff --git a/.kilo_workflow/pr-threads.sh b/.kilo_workflow/pr-threads.sh
new file mode 100755
index 0000000000..ec70a7d9bb
--- /dev/null
+++ b/.kilo_workflow/pr-threads.sh
@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# PR review-thread plumbing for the Kilobot loop, per .kilo_workflow/WORKFLOW.md.
+# Thread grouping, isResolved, and resolution live only in GitHub's GraphQL API;
+# the REST comments endpoint cannot express any of them, and hand-assembled
+# GraphQL burns rounds on quoting mistakes.
+#
+#   pr-threads.sh list <owner/repo> <pr>                      # every thread: id, state, path, first-comment id/author/body
+#   pr-threads.sh unresolved <owner/repo> <pr>                # just the unresolved ones (empty output = clean)
+#   pr-threads.sh reply <owner/repo> <pr> <comment-id> <body> # reply in-thread; body may be - for stdin
+#   pr-threads.sh resolve <owner/repo> <thread-id>            # mark the thread resolved
+#
+# Replies get the mandatory "(bot) " prefix added when missing. The reply
+# target is the thread's FIRST comment id (shown by list). A fix without its
+# in-thread reply and resolution is not done.
+set -euo pipefail
+
+CMD=${1:?usage: pr-threads.sh list|unresolved|reply|resolve ...}
+REPO=${2:?owner/repo}
+[[ "$REPO" =~ ^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$ ]] || { echo "repository must be owner/repo" >&2; exit 1; }
+OWNER=${REPO%%/*}
+NAME=${REPO##*/}
+
+QUERY='query($owner:String!,$repo:String!,$pr:Int!){
+  repository(owner:$owner,name:$repo){pullRequest(number:$pr){
+    reviewThreads(first:100){nodes{id isResolved isOutdated path line
+      comments(first:1){nodes{databaseId author{login} body}}}}}}}'
+
+threads() {
+  gh api graphql -f query="$QUERY" -f owner="$OWNER" -f repo="$NAME" -F pr="${1:?pr number}" \
+    --jq '.data.repository.pullRequest.reviewThreads.nodes[]'
+}
+
+render() {
+  jq -r '[.id, (if .isResolved then "resolved" else "UNRESOLVED" end),
+          "\(.path // "-"):\(.line // "-")",
+          (.comments.nodes[0].databaseId | tostring),
+          (.comments.nodes[0].author.login // "?"),
+          (.comments.nodes[0].body | gsub("\\s+"; " ") | .[0:160])] | @tsv'
+}
+
+case $CMD in
+  list)
+    echo -e "thread_id\tstate\tlocation\tfirst_comment_id\tauthor\tbody"
+    threads "${3:?pr number}" | render
+    ;;
+  unresolved)
+    threads "${3:?pr number}" | jq -c 'select(.isResolved | not)' | render
+    ;;
+  reply)
+    PR=${3:?pr number} COMMENT=${4:?first-comment id} BODY=${5:?body or -}
+    [ "$BODY" = "-" ] && BODY=$(cat)
+    case $BODY in "(bot) "*) ;; *) BODY="(bot) $BODY" ;; esac
+    gh api "repos/$REPO/pulls/$PR/comments/$COMMENT/replies" -f body="$BODY" --jq '.html_url'
+    ;;
+  resolve)
+    THREAD=${3:?thread id}
+    gh api graphql \
+      -f query='mutation($t:ID!){resolveReviewThread(input:{threadId:$t}){thread{isResolved}}}' \
+      -f t="$THREAD" --jq '.data.resolveReviewThread.thread.isResolved'
+    ;;
+  *) echo "usage: pr-threads.sh list|unresolved|reply|resolve ..." >&2; exit 1 ;;
+esac
diff --git a/.kilo_workflow/slice-diff.sh b/.kilo_workflow/slice-diff.sh
new file mode 100755
index 0000000000..d92a35fd6b
--- /dev/null
+++ b/.kilo_workflow/slice-diff.sh
@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+# Produce a slice's diff for review and a fingerprint that proves nobody moved
+# it, per .kilo_workflow/WORKFLOW.md orchestrator step 3. Parallel slices share
+# the worktree, so a reviewer must see exactly its slice's paths — and after a
+# reviewer round those paths must be untouched, and after an implementer round
+# no new commits may exist. Hand-assembling that (`git add -N` first, snapshot
+# after, compare later) kept going wrong; this does all of it.
+#
+#   slice-diff.sh <worktree> <out-file> -- <owned-path>...
+#
+# Writes the slice diff (uncommitted changes on the owned paths, new files
+# included) to <out-file> for a --file dispatch, and prints one line:
+#
+#   SNAPSHOT=<head-sha>:<diff-hash>
+#
+# Run it again after a round and compare the whole line:
+#   - reviewer round: the line must be IDENTICAL (same commits, same bytes on
+#     the owned paths) — any difference voids the round.
+#   - implementer round: <head-sha> must be unchanged (the implementer never
+#     commits); the diff hash is expected to change.
+set -euo pipefail
+
+WT=${1:?worktree} OUT=${2:?output diff file}
+[ "${3:-}" = "--" ] || { echo "usage: slice-diff.sh <worktree> <out-file> -- <owned-path>..." >&2; exit 1; }
+shift 3
+[ $# -gt 0 ] || { echo "slice-diff: no owned paths given" >&2; exit 1; }
+
+# add -N makes brand-new files visible to `git diff HEAD` without staging
+# their content.
+git -C "$WT" add -N -- "$@"
+git -C "$WT" diff HEAD -- "$@" > "$OUT"
+
+HEAD_SHA=$(git -C "$WT" rev-parse HEAD)
+if command -v sha256sum >/dev/null; then
+  DIFF_HASH=$(sha256sum "$OUT" | cut -d' ' -f1)
+else
+  DIFF_HASH=$(shasum -a 256 "$OUT" | cut -d' ' -f1)
+fi
+echo "SNAPSHOT=$HEAD_SHA:$DIFF_HASH"
diff --git a/apps/mobile/e2e/AGENTS.md b/apps/mobile/e2e/AGENTS.md
index 08e88a3706..f89b2e6fb9 100644
--- a/apps/mobile/e2e/AGENTS.md
+++ b/apps/mobile/e2e/AGENTS.md
@@ -7,10 +7,10 @@ Interactive verification against a local backend. Run commands from the reposito
 This machine is shared by parallel workflows. Before starting a stack, booting a simulator or emulator, or running a native build — on every run, whether or not you can see another workflow active — acquire a slot:
 
 ```bash
-.kilo_workflow/e2e-slot.sh acquire <your-tmux-session>   # blocks until a slot frees
-.kilo_workflow/e2e-slot.sh status                        # current holders
-.kilo_workflow/e2e-slot.sh release <your-tmux-session>   # the moment the device phase ends
-.kilo_workflow/e2e-slot.sh stacks                        # any stack running with no slot
+.kilo_workflow/e2e-slot.sh acquire   # run from your own tmux session — it resolves the name itself; blocks until a slot frees
+.kilo_workflow/e2e-slot.sh status    # current holders
+.kilo_workflow/e2e-slot.sh release   # the moment the device phase ends
+.kilo_workflow/e2e-slot.sh stacks    # any stack running with no slot
 ```
 
 A slot, this worktree's dev stack, and the simulators it claims are one resource: the slot is what entitles you to all three, and `release` takes all three back — it stops the stack and releases every simulator this worktree claimed, powering off the ones your claims booted. Release when your device phase is genuinely over, not partway through a round you still need services or a device for.
@@ -312,7 +312,7 @@ tmux kill-session -t "$ANDROID_SESSION"      # if created
 rm -f "$LOGIN_LOG"                           # if created
 rm -f "$EMULATOR_LOG"                        # if created
 pnpm dev:mobile:android release <serial>     # every Android device you claimed
-.kilo_workflow/e2e-slot.sh release <tmux-session>   # always, as soon as the device phase ends
+.kilo_workflow/e2e-slot.sh release           # always, as soon as the device phase ends
 ```
 
 The slot release is the teardown. It stops this worktree's dev stack and releases every simulator this worktree claimed — powering off the ones your claims booted, restoring their names, and leaving a device that was already running before your claim alone. So there is no `pnpm dev:stop`, no `xcrun simctl shutdown`, and no `pnpm dev:mobile:simulator release <udid>` on this list: releasing the slot does all three, and forgetting one is how simulators used to stay booted all day. Never call `xcrun simctl shutdown` on an E2E device yourself — the claim, not your memory of what you booted, is what knows whether the device is yours to power off.

From 45ad0dd6ff2e00a1550c03a86a2dfc0d809629f6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Wed, 29 Jul 2026 14:30:49 +0200
Subject: [PATCH 03/34] fix(workflow): act on full-corpus review findings

e2e-slot.sh: tear down before freeing the slot (releasing marker), drop the
worktree's Android claims on release, abort on partial slot writes, reject
explicit acquire owners. dispatch-role.sh: validate inputs, write a .meta
sidecar. await-role.sh: role-specific sentinels, dead-target fast VOID,
FINDINGS: 0 is void. slice-diff.sh: --binary content-sound fingerprint,
path-scoped commit base, --check mode. pr-threads.sh: cursor pagination,
comment counts, asserting resolve, one-step close. pick-reviewers.sh: empty
result exits 0, per-PR vote dedupe, no error-body parsing. steer.sh:
invocation-tied confirmation, dash-safe greps. New baseline.sh (verifier
byte-identical restore proof), await-interactive.sh (monitor states),
pr-gate.sh (head-pinned mechanical gate). Runbook claims Android serials at
adb visibility; verifier defers teardown to slot release; seven more
graduated learnings deleted.
---
 .kilo/agent/e2e-verifier.md                   |  4 +-
 .kilo_workflow/README.md                      |  5 +-
 .kilo_workflow/WORKFLOW.md                    | 51 ++++++----
 .kilo_workflow/await-interactive.sh           | 69 +++++++++++++
 .kilo_workflow/await-role.sh                  | 49 +++++++--
 .kilo_workflow/baseline.sh                    | 72 ++++++++++++++
 .kilo_workflow/dispatch-role.sh               | 33 ++++++-
 .kilo_workflow/e2e-slot.sh                    | 87 +++++++++++-----
 .kilo_workflow/launch-interactive.sh          |  4 +-
 ...ilo-agent-dies-on-large-session-payload.md |  7 --
 ...nteractive-orchestrator-wedges-relaunch.md |  2 +-
 ...kilo-provider-model-not-found-transient.md |  6 +-
 .../kilo-run-exits-0-without-verdict.md       |  9 --
 ...n-shell-substitution-executes-backticks.md |  7 --
 .../kilo-run-startup-crash-transient.md       |  9 +-
 ...claw-chat-attachments-r2-secret-missing.md | 14 ---
 ...e-ios-open-in-kilo-prompt-blocks-launch.md |  7 --
 .../nested-kilo-run-env-poisoning.md          | 13 ---
 ...ndow-index-in-use-name-prefix-collision.md | 20 ----
 .kilo_workflow/pick-reviewers.sh              | 30 ++++--
 .kilo_workflow/pr-gate.sh                     | 63 ++++++++++++
 .kilo_workflow/pr-threads.sh                  | 99 ++++++++++++++-----
 .kilo_workflow/slice-diff.sh                  | 62 +++++++++---
 .kilo_workflow/steer.sh                       | 16 ++-
 apps/mobile/e2e/AGENTS.md                     |  9 +-
 25 files changed, 545 insertions(+), 202 deletions(-)
 create mode 100755 .kilo_workflow/await-interactive.sh
 create mode 100755 .kilo_workflow/baseline.sh
 delete mode 100644 .kilo_workflow/learnings/kilo-agent-dies-on-large-session-payload.md
 delete mode 100644 .kilo_workflow/learnings/kilo-run-exits-0-without-verdict.md
 delete mode 100644 .kilo_workflow/learnings/kilo-run-shell-substitution-executes-backticks.md
 delete mode 100644 .kilo_workflow/learnings/kiloclaw-chat-attachments-r2-secret-missing.md
 delete mode 100644 .kilo_workflow/learnings/mobile-ios-open-in-kilo-prompt-blocks-launch.md
 delete mode 100644 .kilo_workflow/learnings/nested-kilo-run-env-poisoning.md
 delete mode 100644 .kilo_workflow/learnings/tmux-new-window-index-in-use-name-prefix-collision.md
 create mode 100755 .kilo_workflow/pr-gate.sh

diff --git a/.kilo/agent/e2e-verifier.md b/.kilo/agent/e2e-verifier.md
index 99b03072b3..0ac17aa788 100644
--- a/.kilo/agent/e2e-verifier.md
+++ b/.kilo/agent/e2e-verifier.md
@@ -24,7 +24,7 @@ Before testing:
 2. Translate the plan's goals and acceptance criteria into observable flows; for user-facing features, cover the happy, retryable-unhappy, non-retryable-unhappy, and empty states.
 3. Record pre-existing services, listeners, devices, and tmux sessions so cleanup removes only resources you created. Never use a device claimed by another worktree.
 4. Immediately before starting a stack, booting a simulator or emulator, or running a native build — and only then, never while you are still reading or planning — acquire the machine device slot: `.kilo_workflow/e2e-slot.sh acquire` (no argument — it resolves your own tmux session and refuses to run outside one; if it refuses, stop and report a test-environment blocker rather than passing a guessed name). This is mandatory on every run — the machine is shared and unslotted device work overloads it. The command blocks until a slot frees; blocking is correct behavior, never a wedge to work around, and never a reason to proceed unslotted.
-5. Before any temporary edit, snapshot a baseline outside every repository: `git status --porcelain=v2 -z --untracked-files=all`, binary worktree and index diffs, and the byte hash, file mode, and symlink target of every untracked path. Copy the original bytes and mode of every tracked file you plan to edit. Temporary edits may touch only paths that are clean and tracked at baseline, or brand-new paths — never a pre-existing modified, staged, or untracked path.
+5. Before any temporary edit, record the baseline: `.kilo_workflow/baseline.sh snapshot <worktree> $SCRATCH/baseline` (one per in-scope worktree, always outside every repository). Separately copy the original bytes and mode of every tracked file you plan to edit — the snapshot proves divergence; your copies are what restore it. Temporary edits may touch only paths that are clean and tracked at baseline, or brand-new paths — never a pre-existing modified, staged, or untracked path.
 
 Output discipline — long verification runs die when their session payload grows too large. Cap every shell command's output (`| tail -c 1500` or `| tail -5`); write hierarchies, captures, and service logs to files and print only greps or counts; never re-read screenshots into context; keep your final report bounded.
 
@@ -50,7 +50,7 @@ Classify every failure as exactly one of:
 
 Attempt one reasonable recovery for a test-environment failure. Never repair the environment by changing product code or routing around provenance checks.
 
-Before returning, for any reason, in this order: shut down every service, simulator, emulator, and process you started (a released slot with your stack still running overloads the next holder); then release your slot; then delete every temporary path you created and restore every edited tracked file byte-for-byte with its original mode. Compare the final porcelain status, binary worktree diff, binary index diff, and untracked hashes, modes, and symlink targets against the baseline. Any mismatch is a verification failure: report every affected file and do not claim acceptance passed.
+Before returning, for any reason, in this order: stop the processes you started that the slot does not own — recorders, log followers, relays, stub servers, emulators you launched; then `.kilo_workflow/e2e-slot.sh release`, which stops the worktree's dev stack and hands back every claimed device (never `simctl shutdown` a claimed device or `dev:stop` the stack yourself — the slot owns both); then delete every temporary path you created and restore every edited tracked file byte-for-byte with its original mode. Prove the restore with `.kilo_workflow/baseline.sh check <worktree> $SCRATCH/baseline` — anything but `OK` is a verification failure: report every diverging file it prints and do not claim acceptance passed.
 
 Return:
 
diff --git a/.kilo_workflow/README.md b/.kilo_workflow/README.md
index 313ec26d8a..a6d298678a 100644
--- a/.kilo_workflow/README.md
+++ b/.kilo_workflow/README.md
@@ -47,9 +47,12 @@ A section routinely takes hours of unattended machine time. The human cost is mi
 | [`dispatch-role.sh`](dispatch-role.sh) | Launches a kilo role agent in tmux with a clean environment and logged exit code |
 | [`await-role.sh`](await-role.sh) | Waits on a dispatched agent's log and reports the round's outcome: DONE with its verdict, VOID, STALLED, or RUNNING |
 | [`launch-interactive.sh`](launch-interactive.sh) | Launches an interactive session (planner, orchestrator) in tmux with a clean environment and a live TTY |
+| [`await-interactive.sh`](await-interactive.sh) | Watches an interactive session for the monitor: COMPLETED, BLOCKED, DEAD, QUIET, or RUNNING |
 | [`steer.sh`](steer.sh) | Delivers a message to a running interactive session (starter, planner, orchestrator) and confirms it was submitted |
 | [`e2e-slot.sh`](e2e-slot.sh) | Machine-global semaphore (default 3) capping concurrent device/stack E2E phases; agents are never capped |
-| [`slice-diff.sh`](slice-diff.sh) | Emits one slice's diff for review plus a snapshot fingerprint that catches tree/commit violations after a round |
+| [`slice-diff.sh`](slice-diff.sh) | Emits one slice's diff for review plus a snapshot fingerprint; `--check` judges the round for violations |
+| [`baseline.sh`](baseline.sh) | Records a worktree's exact git state and later proves the E2E verifier's byte-identical restore |
+| [`pr-gate.sh`](pr-gate.sh) | Checks the completion gate's mechanical items against one head SHA (CI, threads, assignee, bot summary) |
 | [`pr-threads.sh`](pr-threads.sh) | Lists, replies to, and resolves PR review threads (GraphQL plumbing for the Kilobot loop) |
 | [`pick-reviewers.sh`](pick-reviewers.sh) | Ranks reviewer candidates for a PR from file history and the requester's past reviewers |
 | [`upload-pr-attachment.sh`](upload-pr-attachment.sh) | Uploads a screenshot to GitHub `user-attachments` via the checksum-pinned, security-reviewed `gh-image` binary |
diff --git a/.kilo_workflow/WORKFLOW.md b/.kilo_workflow/WORKFLOW.md
index c9b3d3ce70..7cde6c4c7b 100644
--- a/.kilo_workflow/WORKFLOW.md
+++ b/.kilo_workflow/WORKFLOW.md
@@ -10,7 +10,7 @@ The definitions for every kilo CLI role live in the repository root `.kilo/agent
 
 These apply to every role. Later sections do not repeat them.
 
-- Every long-lived process — starter, planner, orchestrator, dispatched role agents, local services — runs in tmux, with a unique descriptive window or session name.
+- Every long-lived process — planner, orchestrator, dispatched role agents, local services — runs in tmux, with a unique descriptive window or session name; the launch scripts guarantee this. The one exception is the starter, which lives wherever the user invoked it (often a plain harness session outside tmux) — its launches still land in tmux via `launch-interactive.sh`.
 - Section names are lowercase slugs (`[a-z0-9-]` only — they become branch, tmux, and path names) carrying a short random run id: `<name>-$(openssl rand -hex 2)`, for example `billing-a7f3`. This keeps parallel runs from colliding on worktrees, branches, tmux names, or scratch paths.
 - All workflow tmux lives on the default tmux server — never a custom socket; slot reaping and monitoring key on the sessions one server can see.
 - Work only in dedicated worktrees, in every repository the plan touches — one worktree per repository, `~/Projects/.worktrees/<section>` for cloud and `~/Projects/.worktrees/<section>-<repo>` for siblings, all on the same branch name: `git fetch origin && git worktree add <path> -b <section> origin/main`, then run `pnpm dev:worktree:prepare` inside it (cloud repo only — sibling repositories follow their own `AGENTS.md` setup; `~/Projects/kilocode` uses bun, not pnpm). The cloud worktree always exists, even for sibling-only sections — role dispatches run from it. Never edit a primary or main checkout, with one exception: machine-local learnings under the main checkout's `.kilo_workflow/learnings/system/` (`mkdir -p` it if missing). Worktrees outlive the run; remove them (`git worktree remove <path>`) once their PR closes.
@@ -21,7 +21,7 @@ These apply to every role. Later sections do not repeat them.
 - Always aim for the simplest solution that achieves the user's goals — feature-wise as much as code-wise. Reuse existing helpers, components, and contracts. Do not add abstraction or scope without evidence it is required.
 - Commit in small, logically scoped commits. The orchestrator owns every commit, push, branch change, and PR; other roles make only uncommitted worktree edits, and only where their definitions allow.
 - Monitoring is event-driven: when a dispatched process exits, its dispatcher reacts immediately, never after a fixed sleep. Periodic checks exist only to detect a wedge.
-- Tokens go to the work, never to fighting the workflow or the environment. Every mechanical step that can be scripted is scripted — `dispatch-role.sh`, `await-role.sh`, `steer.sh`, `launch-interactive.sh`, `e2e-slot.sh`, `slice-diff.sh`, `pr-threads.sh`, `pick-reviewers.sh`, `upload-pr-attachment.sh` — use the script, never hand-assemble its steps. **Anything that can be automated away, should be automated away:** when a run stumbles on something a script or an instruction could have prevented, fix the script or the document in the same run (see Learnings).
+- Tokens go to the work, never to fighting the workflow or the environment. Every mechanical step that can be scripted is scripted — `dispatch-role.sh`, `await-role.sh`, `launch-interactive.sh`, `await-interactive.sh`, `steer.sh`, `e2e-slot.sh`, `slice-diff.sh`, `baseline.sh`, `pr-threads.sh`, `pr-gate.sh`, `pick-reviewers.sh`, `upload-pr-attachment.sh` — use the script, never hand-assemble its steps. **Anything that can be automated away, should be automated away:** when a run stumbles on something a script or an instruction could have prevented, fix the script or the document in the same run (see Learnings).
 - Learnings are the residue automation cannot reach. Before any environment-dependent phase, list both learnings directories — the worktree's `.kilo_workflow/learnings/` and the main checkout's `~/Projects/cloud/.kilo_workflow/learnings/system/` (the canonical machine-local set, which mid-run writes go to and worktree copies lag) — and read the entries whose names match your surface; filenames are symptom-keyed. When a tool or environment failure blocks you mid-run, grep both directories for the error text before debugging from scratch: a prior run has usually already paid for the answer.
 
 ### Models
@@ -52,12 +52,12 @@ LOG=$(.kilo_workflow/dispatch-role.sh plan-reviewer <section> r1 <cloud-worktree
   --file "$SCRATCH/handoff.md")
 ```
 
-The cwd/worktree is always the **cloud** worktree, even when the slice edits a sibling repository — the role definitions in root `.kilo/agent/` are only discovered there, and they pin the model, so worker dispatches never pass `--model`/`--variant`. The message is a short literal; file content — handoffs, plans, diffs — always travels via `--file <path>` (repeatable), never inlined with `"$(cat file)"`: dispatches routed through a tmux command string get re-parsed by another shell, and backticks inside the file then execute (see `learnings/kilo-run-shell-substitution-executes-backticks.md`).
+The cwd/worktree is always the **cloud** worktree, even when the slice edits a sibling repository — the role definitions in root `.kilo/agent/` are only discovered there, and they pin the model, so worker dispatches never pass `--model`/`--variant`. The message is a short literal; file content — handoffs, plans, diffs — always travels via `--file <path>` (repeatable), never inlined with `"$(cat file)"`: dispatches routed through a tmux command string get re-parsed by another shell, and backticks inside the file then execute as shell commands.
 
 What the script encodes (details in its header comments):
 
 - tmux wrapping — harness command timeouts kill bare long runs. The `e2e-verifier` gets its **own tmux session** (E2E slots are owned and auto-reclaimed by session name; a window-named owner leaks or shares slots); other roles run as windows in the dispatcher's session, resolved through `$TMUX_PANE`. A dispatcher that is not itself inside tmux has no such session, so its roles get their own sessions too — never a guessed one. Names are `<section>-<role>-<label>`, logs `$SCRATCH/<role>-<label>.log`.
-- Full `KILO_*`/`OPENCODE*` env strip — a dispatcher running inside kilo poisons nested runs otherwise (see `learnings/nested-kilo-run-env-poisoning.md`).
+- Full `KILO_*`/`OPENCODE*` env strip — a child kilo inheriting `KILO_*`/`OPENCODE*` (from a parent kilo or the tmux server environment) misattaches sessions and auth. If the tmux server itself is poisoned, clear it with `tmux set-environment -g -u <var>`.
 - Output redirected, never piped (`| tee` makes `$?` report the pipe's exit, not kilo's), with `EXITCODE=$?` appended as the log's last line.
 
 Wait with [`await-role.sh`](await-role.sh) — never a hand-rolled loop (exit codes lie, whole-log sentinel greps false-pass on quoted sentinels, and a stalled run never writes its marker):
@@ -70,7 +70,7 @@ Act on that line:
 
 - `DONE <sentinel>` — the round's verdict, taken from the only place a verdict counts (the line above the `EXITCODE` marker). Sentinels: reviewers `No findings.` / `FINDINGS: <n>`; implementer `SLICE COMPLETE.`; verifier `VERIFICATION PASSED.`/`VERIFICATION FAILED.`/`VERIFICATION BLOCKED.` (repro mode: `REPRODUCED.`/`CANNOT REPRODUCE.`); any role `STOPPED EARLY.` — not a failure but not success: re-dispatch with a continuation handoff, and it counts toward the loop's round cap.
 - `RUNNING` — invoke it again. Each re-invocation is also the moment to unstick **infrastructure failures only**: a wedged or crashed kilo CLI, a dead tmux window, a hung service the agent cannot restart itself. Product, logic, or review problems are never stuck states — route those through the escalation ladder.
-- `VOID` — the run ended with no verdict (kilo runs can die mid-stream and still exit 0). Never a pass: discard the round and dispatch a fresh session.
+- `VOID` — the run ended with no valid verdict for its role (kilo runs can die mid-stream and still exit 0). Never a pass: discard the round and dispatch a fresh session. If several consecutive rounds die at the same point, shrink the handoff rather than retrying it unchanged.
 - `STALLED` — the stall that never exits. Kill the round's tmux window/session, verify state from artifacts on disk (never the dead run's claims), and redispatch fresh with a continuation handoff.
 
 Two checks stay with the dispatcher, since only it knows the slice — both are one `slice-diff.sh` re-run (compare its `SNAPSHOT` line against the pre-round one): after a reviewer round the whole line must be identical — the reviewer never modifies the tree (other slices' implementers may legitimately be editing *their* paths); after an implementer round the head sha must be unchanged — the implementer never commits. A violation voids the round. Void rounds count toward the loop's round cap, and three consecutive void rounds are an infrastructure blocker (auth wedge, provider outage), never something to redispatch through.
@@ -123,6 +123,7 @@ Every dispatch to a role agent includes:
 - For any device or stack phase: the slot rule (see E2E Slots)
 - Prior findings being addressed, including rejected findings that must not reopen without new evidence
 - Priority order, minimum complete outcome, optional work to drop, and a clean stopping rule before budget exhaustion (estimate roughly one step per planned tool call; when in doubt, split the task); on early stop, the required continuation state (completed work, remaining work, failures, files touched, checks run or deferred, safest next action)
+- For long tool-heavy phases: output discipline — cap every shell command's output (`| tail -c 1500` / `| tail -5`), write dumps and captures to files and print only greps or counts, bound the final report. Oversized session payloads kill kilo runs silently mid-task.
 - The GitHub comment rule (see GitHub Communication)
 - Fixture rule: never commit generated E2E fixtures; create them in a temporary directory and clean up before returning
 
@@ -140,11 +141,11 @@ The session the user invokes the workflow from is the starter, running on the ha
 
 ```bash
 # kilo planner (the planner agent definition pins permissions; the model is the user's pick):
-.kilo_workflow/launch-interactive.sh <section>-planner <worktree> \
+.kilo_workflow/launch-interactive.sh <section>-planner <worktree> --log "$SCRATCH/planner.log" \
   kilo run 'Plan the work in the attached brief.' --agent planner \
   --interactive --model <planner-model> --variant high --title '<section> planner' --file "$SCRATCH/brief.md"
 # claude planner:
-.kilo_workflow/launch-interactive.sh <section>-planner <worktree> \
+.kilo_workflow/launch-interactive.sh <section>-planner <worktree> --log "$SCRATCH/planner.log" \
   claude "You are the planner in .kilo_workflow/WORKFLOW.md. Plan the work in the brief at $SCRATCH/brief.md."
 ```
 
@@ -186,26 +187,34 @@ A `CANNOT REPRODUCE.` sentinel is a blocker, not a license to fix an unconfirmed
 ### Launching the Orchestrator
 
 ```bash
-.kilo_workflow/launch-interactive.sh <section>-orchestrator <worktree> \
+.kilo_workflow/launch-interactive.sh <section>-orchestrator <worktree> --log "$SCRATCH/orchestrator.log" \
   kilo run 'Execute the approved plan in the attached handoff. Own implementation through the completion gate.' \
   --agent orchestrator --interactive --title '<section> orchestrator' --file "$SCRATCH/handoff.md"
 ```
 
-The `orchestrator` agent definition pins the model and permissions, so the launch passes neither. Do not add `--continue` or `--session`; the orchestrator must be a fresh session. The script preserves the TTY that `--interactive` requires (pass `--log <file>` before the command for a transcript), verifies the session survived launch, and prints the tmux target — report that target, the worktree path, and the handoff path.
+The `orchestrator` agent definition pins the model and permissions, so the launch passes neither. Do not add `--continue` or `--session`; the orchestrator must be a fresh session. The script preserves the TTY that `--interactive` requires, verifies the session survived launch, and prints the tmux target — report that target, the worktree path, and the handoff path. Always pass `--log "$SCRATCH/orchestrator.log"` (before the command): Monitor Mode needs the transcript to tell a wedge from work.
 
 ### Monitor Mode
 
-After the handoff the planner stops all hands-on work. It has exactly one job — relaunch or unstick the orchestrator when infrastructure fails (a crashed kilo CLI, a dead tmux window, a hung service). Product, logic, design, and review problems are the orchestrator's, handled by its escalation ladder. Check about every 30 minutes; react immediately when the orchestrator's process exits. (The starter monitors its planners under these same rules.)
+After the handoff the planner stops all hands-on work. It has exactly one job — relaunch or unstick the orchestrator when infrastructure fails (a crashed kilo CLI, a dead tmux window, a hung service). Product, logic, design, and review problems are the orchestrator's, handled by its escalation ladder. (The starter monitors its planners under these same rules.) Watch with [`await-interactive.sh`](await-interactive.sh) — it reads the scratch-directory state machine and reports one line per invocation:
+
+```bash
+.kilo_workflow/await-interactive.sh <tmux-target> "$SCRATCH" --log "$SCRATCH/orchestrator.log"   # blocks up to 25 min
+```
+
+- `COMPLETED` — scratch gone; confirm the PR is in gate state (below) and close yourself.
+- `BLOCKED <report>` — relay the report to the user, leave the scratch directory alone, close yourself.
+- `DEAD` — a crash; relaunch fresh with a continuation handoff (below).
+- `QUIET <sec>s` — the transcript stopped moving. Not a verdict: read the pane first (below) — a hands-on user question and queued steers look exactly like this.
+- `RUNNING` — invoke it again.
 
 A monitor never kills a live dispatch on a judgment call, never edits the worktree, and never writes to another role's dispatch log — a forged `EXITCODE` line corrupts the dispatcher's void-round detection, the exact signal the contract keys on. Before concluding an orchestrator is misbehaving, read its evidence: its pane scrollback (`tmux capture-pane -t <window> -p -S -`), its scratch directory, and the git log. The orchestrator's handoff may route user questions to its own interactive session, so an answer the monitor never saw can exist there — a monitor once killed a healthy implementer and forged its `EXITCODE` line because it never read the scrollback where the user had already answered. The only kill-worthy states are the infrastructure failures named above.
 
-A dead orchestrator window is not automatically a crash — check the scratch directory:
+On `COMPLETED`, confirm the PR exists in gate state in **every** repository the section touched — `.kilo_workflow/pr-gate.sh <owner/repo> <pr>` per repository (find the PR with `gh pr view <section> --repo <owner>/<repo>`; never bare `gh pr view`, which only checks the cloud branch). A missing PR means it was not a completion — treat it as a crash.
 
-- Scratch **gone** → the section COMPLETED and shut itself down; confirm the PR exists in gate state in **every** repository the section touched (`gh pr view <section> --repo <owner>/<repo>` — never bare `gh pr view`, which only checks the cloud branch), tell the user, and close yourself. A missing PR means it was not a completion — treat it as a crash.
-- Scratch present with `$SCRATCH/final-report.md` → BLOCKED; relay the report to the user and close yourself. Leave the scratch directory alone — it is the blocker's evidence, and its presence is what distinguishes BLOCKED from COMPLETE for anyone who looks later.
-- Scratch present with no final report → a crash; relaunch with a continuation handoff.
+On `QUIET`, read the pane (`tmux capture-pane -pJ -t <target>`) before acting. A session waiting on a hands-on user answer is not wedged, and neither is one holding queued steers (see Steering a Live Interactive Session). Real wedge evidence: a provider or stream error in the pane, a frozen build timer, a repeated hard SDK error. Long kilo runs die on provider stream stalls, and `--interactive` sessions can wedge on provider errors — kill only on that evidence.
 
-A live session waiting on a hands-on user answer is not wedged, and neither is one holding queued steers (see Steering a Live Interactive Session) — read the pane before declaring a wedge. Long kilo runs die on provider stream stalls, and `--interactive` sessions can wedge on provider errors. Relaunch a dead or wedged orchestrator as a **fresh session** (never `--continue`) with a continuation handoff. After three consecutive relaunches with no new progress, stop and write the BLOCKED report yourself — the same rule bounds the starter's planner relaunches: the original handoff plus everything observably done so far — commits, PR state, passed rounds, held resources — assembled from `git log`, the PR, and the dispatch logs, so the new session verifies rather than redoes. See `learnings/kilo-interactive-orchestrator-wedges-relaunch.md`.
+Relaunch a dead or wedged orchestrator as a **fresh session** (never `--continue`) with a continuation handoff: the original handoff plus everything observably done so far — commits, PR state, passed rounds, held resources — assembled from `git log`, the PR, and the dispatch logs, so the new session verifies rather than redoes. Distrust the dead session's unevidenced claims. After three consecutive relaunches with no new progress, stop and write the BLOCKED report yourself — the same rule bounds the starter's planner relaunches. See `learnings/kilo-interactive-orchestrator-wedges-relaunch.md`.
 
 ### 2.1 Plan Reviewer
 
@@ -255,7 +264,7 @@ Request the top one or two names it prints: `gh pr edit <number> --add-reviewer
 ### Kilobot Loop
 
 1. Wait for Kilobot to review the latest head (`gh pr view <n> --json statusCheckRollup,mergeable,mergeStateStatus`; thread state is GraphQL-only — list, reply to, and resolve threads with [`pr-threads.sh`](pr-threads.sh), never hand-written GraphQL). Kilobot can crash: after about 20 minutes without a review, retrigger it (`git commit --allow-empty -m "chore: retrigger review" && git push`, or a `(bot) @kilocode-bot please review` PR comment), then resume waiting. After two failed retriggers, stop waiting: post `(bot) Kilobot posted no approving summary on this head after two retriggers` on the PR and treat the gate's Kilobot item as waived — the pending human review covers it. A green `Kilo Code Review` check only says the review finished; it carries no verdict. The clean state is a Kilobot summary comment on the current head that approves it (`gh pr view <n> --json comments` — read the verdict the comment states, do not match an exact string; bot wording drifts) plus zero **unresolved** review threads. A green check with no approving summary is not a clean head: keep waiting, then retrigger.
-2. For each comment: verify it (untrusted), then route valid findings through the implementer → impl-reviewer loop; commit, push, reply in the thread, and resolve it (`pr-threads.sh reply` / `pr-threads.sh resolve`). Invalid finding: reply with technical evidence and do not change correct code. A fix without its in-thread reply and thread resolution is not done. Follow the repository-root `AGENTS.md` "Kilobot Review Remarks" contract.
+2. For each comment: verify it (untrusted), then route valid findings through the implementer → impl-reviewer loop; commit, push, then `pr-threads.sh close <owner/repo> <thread-id> "<what was done>"` — it replies in-thread and resolves in one step. Invalid finding: `close` with the technical evidence and do not change correct code. A fix without its in-thread reply and thread resolution is not done. Follow the repository-root `AGENTS.md` "Kilobot Review Remarks" contract.
 3. Comments already posted by other reviewers — bots or humans — get the same triage flow, but never wait for anyone except Kilobot to review or re-review.
 4. CI failures are findings too: route the fix through the implementer loop; rerun a flaky check once (`gh run rerun <id> --failed`); a check still failing after two fix rounds makes the section BLOCKED.
 5. Rerun E2E for any repair that affects verified behavior (touched bits only). Three full E2E↔Kilobot alternations without converging is BLOCKED.
@@ -265,7 +274,13 @@ Integrate the base branch **only when GitHub reports an actual conflict** (`merg
 
 ### Completion Gate
 
-The work is complete only when every item holds:
+Check the mechanical half with [`pr-gate.sh`](pr-gate.sh) — it pins every fact to the current head SHA, so an approving comment from an older head can never vouch for this one:
+
+```bash
+.kilo_workflow/pr-gate.sh <owner/repo> <pr>   # facts + GATE OK / GATE FAIL lines
+```
+
+`GATE OK` covers mergeability, green CI, zero unresolved threads, assignee, and a bot summary postdating the head commit. The rest is yours to judge. The work is complete only when every item holds:
 
 - All accepted plan tasks are implemented, with automated coverage for every applicable feature state
 - A fresh impl reviewer has cleared the cumulative section diff (step 4), including any repair or orchestrator edit since
@@ -340,7 +355,7 @@ Never collapse retryable and non-retryable failures into one generic error state
 
 Environment blockers and their fixes — broken local stacks, credential traps, simulator quirks, tool wedges — recorded so future runs do not rediscover them. Product bugs never go in learnings.
 
-- Format: **symptom / cause / fix**, a few lines each, in a file whose name makes it findable from the symptom (for example `kilo-run-exits-0-without-verdict.md`).
+- Format: **symptom / cause / fix**, a few lines each, in a file whose name makes it findable from the symptom (for example `mobile-metro-file-map-stale-after-node-modules-relayout.md`).
 - System-specific learnings (true only of this machine: installed tools, local ports, OS quirks) go to `learnings/system/`, which is gitignored (only its `.gitkeep` is committed). Write them to the **main checkout's** copy — `~/Projects/cloud/.kilo_workflow/learnings/system/` — so they survive worktree deletion and reach parallel runs immediately; `pnpm dev:worktree:prepare` copies them into fresh worktrees.
 - Everything else goes to the section worktree's `.kilo_workflow/learnings/` and is committed — the orchestrator includes new learnings in the run's PR (they reach other runs once merged; that lag is accepted). Committed promptly, not at the end: an uncommitted learning blocks E2E dispatch (see E2E Loop) and is one stray cleanup away from vanishing. The planner cannot commit (the orchestrator owns Git), so a planner-authored learning is named in the orchestrator handoff as work for the first commit.
 - `.kilo_workflow/` is exempt from section disjointness — any section may write learnings or fix this document; overlaps resolve as ordinary merge conflicts.
diff --git a/.kilo_workflow/await-interactive.sh b/.kilo_workflow/await-interactive.sh
new file mode 100755
index 0000000000..5130f3fd0c
--- /dev/null
+++ b/.kilo_workflow/await-interactive.sh
@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+# Monitor-mode helper: watch an interactive session (orchestrator, planner)
+# and report its terminal state, per .kilo_workflow/WORKFLOW.md Monitor Mode.
+# The scratch directory is the state machine — COMPLETE deletes it, BLOCKED
+# leaves a final report in it — and a dead window is only a crash when
+# neither of those happened.
+#
+#   await-interactive.sh <tmux-target> <scratch-dir> [--log <file>] [--timeout <sec>] [--quiet <sec>]
+#
+# Blocks up to --timeout (default 1500s, the ~25-minute monitor cadence),
+# then reports. Prints exactly one line:
+#
+#   COMPLETED           exit 0  scratch gone — verify the PR is in gate state
+#   BLOCKED <report>    exit 5  final-report.md present — relay it, leave scratch
+#   DEAD                exit 2  target gone, scratch present, no report — a
+#                               crash; relaunch fresh with a continuation handoff
+#   QUIET <sec>s        exit 3  --log given and stagnant past --quiet (default
+#                               1200s) with the target alive. NOT a verdict:
+#                               read the pane first — a hands-on question or
+#                               queued steers look exactly like this
+#   RUNNING             exit 4  none of the above; invoke again
+set -euo pipefail
+
+TARGET=${1:?tmux target} SCRATCH=${2:?scratch dir}
+shift 2
+LOGFILE="" TIMEOUT=1500 QUIET=1200
+while [ $# -gt 0 ]; do
+  case $1 in
+    --log) LOGFILE=${2:?}; shift 2 ;;
+    --timeout) TIMEOUT=${2:?}; shift 2 ;;
+    --quiet) QUIET=${2:?}; shift 2 ;;
+    *) echo "await-interactive: unknown option $1" >&2; exit 1 ;;
+  esac
+done
+
+mtime() { stat -f %m "$1" 2>/dev/null || stat -c %Y "$1" 2>/dev/null || echo 0; }
+
+START=$(date +%s)
+while :; do
+  if [ ! -d "$SCRATCH" ]; then
+    echo "COMPLETED"
+    exit 0
+  fi
+  if [ -f "$SCRATCH/final-report.md" ]; then
+    echo "BLOCKED $SCRATCH/final-report.md"
+    exit 5
+  fi
+  if ! tmux list-panes -t "$TARGET" >/dev/null 2>&1; then
+    # Scratch present, no report, no session: give a just-finishing teardown
+    # a moment, then re-check the two terminal states before calling it dead.
+    sleep 5
+    [ ! -d "$SCRATCH" ] && { echo "COMPLETED"; exit 0; }
+    [ -f "$SCRATCH/final-report.md" ] && { echo "BLOCKED $SCRATCH/final-report.md"; exit 5; }
+    echo "DEAD"
+    exit 2
+  fi
+  if [ -n "$LOGFILE" ] && [ -f "$LOGFILE" ]; then
+    AGE=$(( $(date +%s) - $(mtime "$LOGFILE") ))
+    if [ "$AGE" -gt "$QUIET" ]; then
+      echo "QUIET ${AGE}s — read the pane before acting; a user question or queued steer is not a wedge"
+      exit 3
+    fi
+  fi
+  if [ $(( $(date +%s) - START )) -ge "$TIMEOUT" ]; then
+    echo "RUNNING"
+    exit 4
+  fi
+  sleep 30
+done
diff --git a/.kilo_workflow/await-role.sh b/.kilo_workflow/await-role.sh
index 9b57f546c9..a5a0a9e560 100755
--- a/.kilo_workflow/await-role.sh
+++ b/.kilo_workflow/await-role.sh
@@ -7,13 +7,20 @@
 #
 #   await-role.sh <log> [--timeout <sec>] [--stall <sec>]
 #
+# Reads the `<log>.meta` sidecar dispatch-role.sh writes (role + tmux target):
+# the sentinel must belong to THAT role's contract — an implementer ending
+# with `No findings.` is a crashed contract, not a pass — and a dead tmux
+# target with no EXITCODE marker is pronounced VOID immediately instead of
+# waiting out the stall window. Without a sidecar it falls back to accepting
+# any known sentinel and log-only liveness.
+#
 # Blocks up to --timeout (default 480s — safely under harness command
 # timeouts), then reports. Re-invoke while it prints RUNNING. Prints exactly
 # one line:
 #
 #   DONE <sentinel>   exit 0  round finished with a real verdict; act on it
-#   VOID exit=<n>     exit 2  finished without a sentinel — a crashed run,
-#                             never a pass; discard and dispatch fresh
+#   VOID ...          exit 2  finished without a valid verdict — a crashed
+#                             run, never a pass; discard and dispatch fresh
 #   STALLED <sec>s    exit 3  no EXITCODE and the log has been quiet past the
 #                             stall threshold (default 1200s) — kill the tmux
 #                             window/session, verify state, redispatch fresh
@@ -21,7 +28,8 @@
 #
 # The sentinel is the line above the EXITCODE marker — the only place a
 # verdict counts. `STOPPED EARLY.` reports as DONE: not void, not success;
-# re-dispatch with a continuation handoff.
+# re-dispatch with a continuation handoff. A quiet log is judged by mtime, so
+# any tool output the agent produces (builds included) counts as liveness.
 set -euo pipefail
 
 LOG=${1:?usage: await-role.sh <log> [--timeout <sec>] [--stall <sec>]}
@@ -36,9 +44,27 @@ while [ $# -gt 0 ]; do
   esac
 done
 
-SENTINELS='^(No findings\.|FINDINGS: [0-9]+|STOPPED EARLY\.|SLICE COMPLETE\.|VERIFICATION (PASSED|FAILED|BLOCKED)\.|REPRODUCED\.|CANNOT REPRODUCE\.)$'
+ROLE=""
+TMUX_TARGET=""
+if [ -f "$LOG.meta" ]; then
+  ROLE=$(sed -n 's/^role=//p' "$LOG.meta" | head -1)
+  TMUX_TARGET=$(sed -n 's/^tmux=//p' "$LOG.meta" | head -1)
+fi
+
+# FINDINGS requires a count of at least 1 — `FINDINGS: 0` contradicts itself
+# (zero findings is spelled `No findings.`) and signals a broken report.
+case $ROLE in
+  plan-reviewer | impl-reviewer) SENTINELS='^(No findings\.|FINDINGS: [1-9][0-9]*|STOPPED EARLY\.)$' ;;
+  implementer) SENTINELS='^(SLICE COMPLETE\.|STOPPED EARLY\.)$' ;;
+  e2e-verifier) SENTINELS='^(VERIFICATION (PASSED|FAILED|BLOCKED)\.|REPRODUCED\.|CANNOT REPRODUCE\.|STOPPED EARLY\.)$' ;;
+  *) SENTINELS='^(No findings\.|FINDINGS: [1-9][0-9]*|STOPPED EARLY\.|SLICE COMPLETE\.|VERIFICATION (PASSED|FAILED|BLOCKED)\.|REPRODUCED\.|CANNOT REPRODUCE\.)$' ;;
+esac
 
 mtime() { stat -f %m "$1" 2>/dev/null || stat -c %Y "$1" 2>/dev/null || echo 0; }
+target_dead() {
+  [ -n "$TMUX_TARGET" ] || return 1
+  ! tmux list-panes -t "$TMUX_TARGET" >/dev/null 2>&1
+}
 
 START=$(date +%s)
 while :; do
@@ -54,7 +80,16 @@ while :; do
         echo "DONE $SENTINEL"
         exit 0
       fi
-      echo "VOID exit=$CODE — no sentinel; discard the round and dispatch a fresh session"
+      echo "VOID exit=$CODE — no valid ${ROLE:-role} sentinel; discard the round and dispatch a fresh session"
+      exit 2
+    fi
+    if target_dead; then
+      # The pane is gone but the marker never landed; give the redirect a
+      # moment to flush, then re-check the tail once before pronouncing.
+      sleep 5
+      LAST=$(tail -1 "$LOG" 2>/dev/null || true)
+      [[ "$LAST" =~ ^EXITCODE= ]] && continue
+      echo "VOID tmux target $TMUX_TARGET is gone with no EXITCODE — the run was killed; discard and dispatch fresh"
       exit 2
     fi
     AGE=$(( NOW - $(mtime "$LOG") ))
@@ -62,9 +97,9 @@ while :; do
       echo "STALLED ${AGE}s quiet, no EXITCODE — kill the round's tmux window/session, verify state on disk, redispatch fresh"
       exit 3
     fi
-  elif [ $(( NOW - START )) -gt 90 ]; then
+  elif target_dead || [ $(( NOW - START )) -gt 90 ]; then
     # The dispatch redirects into the log the moment kilo starts; a log still
-    # missing after a grace period means the window died before launching.
+    # missing means the window died before launching.
     echo "VOID no log at $LOG — the dispatch never started; check tmux and dispatch again"
     exit 2
   fi
diff --git a/.kilo_workflow/baseline.sh b/.kilo_workflow/baseline.sh
new file mode 100755
index 0000000000..137703d7b6
--- /dev/null
+++ b/.kilo_workflow/baseline.sh
@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+# Git-state baseline for the E2E verifier's byte-identical restore contract,
+# per .kilo/agent/e2e-verifier.md. Snapshotting and comparing NUL-delimited
+# status, binary diffs, and untracked hashes by hand is exactly the kind of
+# destructive ritual a cheap model gets wrong; this does the mechanical part.
+# Restoring is still the agent's job — this tells it exactly what diverged.
+#
+#   baseline.sh snapshot <worktree> <baseline-dir>   # record the pre-run state
+#   baseline.sh check <worktree> <baseline-dir>      # compare; OK or the diverging files
+#
+# <baseline-dir> must live OUTSIDE every repository (scratch). check prints
+# `OK` (exit 0) when the state matches byte-for-byte, otherwise one line per
+# divergence (exit 1) — any mismatch is a verification failure, never
+# something to claim past.
+set -euo pipefail
+
+CMD=${1:?usage: baseline.sh snapshot|check <worktree> <baseline-dir>}
+WT=${2:?worktree} DIR=${3:?baseline dir}
+[ -d "$WT" ] || { echo "baseline: no such worktree: $WT" >&2; exit 1; }
+case "$DIR" in "$WT"/*) echo "baseline: the baseline dir must live outside the repository" >&2; exit 1 ;; esac
+
+capture() {
+  local out=$1
+  mkdir -p "$out"
+  git -C "$WT" rev-parse HEAD > "$out/head"
+  git -C "$WT" status --porcelain=v2 -z --untracked-files=all > "$out/status.z"
+  git -C "$WT" diff --binary > "$out/worktree.diff"
+  git -C "$WT" diff --binary --cached > "$out/index.diff"
+  # Untracked files: byte hash, mode, and symlink target each — a same-size
+  # content swap or a mode flip must not slip through.
+  git -C "$WT" ls-files --others --exclude-standard -z | while IFS= read -r -d '' p; do
+    if [ -L "$WT/$p" ]; then
+      printf 'link\t%s\t%s\n' "$(readlink "$WT/$p")" "$p"
+    elif command -v sha256sum >/dev/null; then
+      printf 'file\t%s\t%s\t%s\n' "$(stat -f %p "$WT/$p" 2>/dev/null || stat -c %a "$WT/$p")" \
+        "$(sha256sum "$WT/$p" | cut -d' ' -f1)" "$p"
+    else
+      printf 'file\t%s\t%s\t%s\n' "$(stat -f %p "$WT/$p" 2>/dev/null || stat -c %a "$WT/$p")" \
+        "$(shasum -a 256 "$WT/$p" | cut -d' ' -f1)" "$p"
+    fi
+  done | sort > "$out/untracked.tsv"
+}
+
+case $CMD in
+  snapshot)
+    capture "$DIR"
+    echo "baseline recorded in $DIR"
+    ;;
+  check)
+    [ -f "$DIR/head" ] || { echo "baseline: no snapshot in $DIR" >&2; exit 1; }
+    NOW=$(mktemp -d "${TMPDIR:-/tmp}/kilo-baseline-check.XXXXXX")
+    # Kept on mismatch so the printed diff commands stay runnable.
+    trap '[ "${fail:-1}" -eq 0 ] && rm -rf "$NOW"' EXIT
+    capture "$NOW"
+    fail=0
+    for f in head status.z worktree.diff index.diff untracked.tsv; do
+      cmp -s "$DIR/$f" "$NOW/$f" && continue
+      fail=1
+      case $f in
+        head) echo "DIVERGED head: $(cat "$DIR/$f") -> $(cat "$NOW/$f")" ;;
+        untracked.tsv)
+          echo "DIVERGED untracked files (hash/mode/link or presence):"
+          diff "$DIR/$f" "$NOW/$f" | grep '^[<>]' | sed 's/^</  baseline only:/; s/^>/  now:/'
+          ;;
+        *) echo "DIVERGED $f (run: diff $DIR/$f $NOW/$f)" ;;
+      esac
+    done
+    [ "$fail" -eq 0 ] && echo "OK"
+    exit "$fail"
+    ;;
+  *) echo "usage: baseline.sh snapshot|check <worktree> <baseline-dir>" >&2; exit 1 ;;
+esac
diff --git a/.kilo_workflow/dispatch-role.sh b/.kilo_workflow/dispatch-role.sh
index f68e71520b..c2c31509b7 100755
--- a/.kilo_workflow/dispatch-role.sh
+++ b/.kilo_workflow/dispatch-role.sh
@@ -21,11 +21,31 @@ set -euo pipefail
 ROLE=${1:?role} SECTION=${2:?section} LABEL=${3:?label} WT=${4:?worktree} SCRATCH=${5:?scratch} MSG=${6:?message}
 shift 6
 
+# Bad input here does not fail fast on its own — it burns a full dispatch and
+# an await cycle before anyone notices the round was doomed. Reject it now.
+case $ROLE in
+  plan-reviewer | implementer | impl-reviewer | e2e-verifier) ;;
+  *) echo "dispatch-role: unknown role '$ROLE' (plan-reviewer|implementer|impl-reviewer|e2e-verifier)" >&2; exit 1 ;;
+esac
+[[ "$SECTION" =~ ^[a-z0-9-]+$ ]] || { echo "dispatch-role: section must be a lowercase slug: '$SECTION'" >&2; exit 1; }
+[[ "$LABEL" =~ ^[A-Za-z0-9._-]+$ ]] || { echo "dispatch-role: bad label '$LABEL'" >&2; exit 1; }
+[ -d "$WT" ] || { echo "dispatch-role: no such worktree: $WT" >&2; exit 1; }
+[ -d "$SCRATCH" ] || { echo "dispatch-role: no such scratch dir: $SCRATCH" >&2; exit 1; }
+# Only repeated `--file <existing path>` may follow — anything else (a --model
+# override, a typo) silently disagrees with the pinned role definition.
+FILES=()
+while [ $# -gt 0 ]; do
+  [ "$1" = "--file" ] || { echo "dispatch-role: only --file <path> is accepted after the message, got '$1'" >&2; exit 1; }
+  [ -f "${2:-}" ] || { echo "dispatch-role: --file path does not exist: '${2:-}'" >&2; exit 1; }
+  FILES+=("--file" "$2")
+  shift 2
+done
+
 NAME="$SECTION-$ROLE-$LABEL"
 LOG="$SCRATCH/$ROLE-$LABEL.log"
 # The strip list must be computed INSIDE the new pane, not here: tmux panes
 # inherit the tmux SERVER environment, so vars absent from this dispatcher's
-# env can still reach the child (see learnings/nested-kilo-run-env-poisoning.md).
+# env can still reach the child and poison a nested kilo run.
 # The escaped \$(...) below survives into the pane's shell and evaluates there;
 # `|| true` keeps an empty match from failing under the pane's shell.
 STRIP='$(env | grep -oE "^(KILO|OPENCODE)[A-Za-z0-9_]*" | sed "s/^/-u /" | tr "\n" " " || true)'
@@ -34,7 +54,7 @@ STRIP='$(env | grep -oE "^(KILO|OPENCODE)[A-Za-z0-9_]*" | sed "s/^/-u /" | tr "\
 # pane itself — a blank window reads as a dead agent otherwise. This prints to
 # the terminal only, never into the log, so the EXITCODE contract is untouched.
 CMD="echo $(printf '%q' "$NAME: output goes to $LOG — this pane stays blank by design; watch with: tail -f $LOG") && cd $(printf '%q' "$WT") && env $STRIP kilo run $(printf '%q' "$MSG") --agent $(printf '%q' "$ROLE") --title $(printf '%q' "$NAME")"
-for arg in "$@"; do CMD+=" $(printf '%q' "$arg")"; done
+for arg in "${FILES[@]+"${FILES[@]}"}"; do CMD+=" $(printf '%q' "$arg")"; done
 CMD+=" > $(printf '%q' "$LOG") 2>&1; echo EXITCODE=\$? >> $(printf '%q' "$LOG")"
 
 # Resolve the caller's session through this pane. An untargeted
@@ -50,12 +70,17 @@ fi
 
 if [ "$ROLE" = "e2e-verifier" ] || [ -z "$CALLER_SESSION" ]; then
   tmux new-session -d -s "$NAME" "$CMD"
+  TARGET=$NAME
 else
   # Trailing colon pins the target to <session>:<auto-index>. Without it tmux
   # prefix-matches the session name against WINDOW names first, and a session
   # named <section> collides with the planner/orchestrator window named
   # <section>-planner — new-window then fails with "create window failed:
-  # index N in use" (see learnings/tmux-new-window-index-in-use-name-prefix-collision.md).
-  tmux new-window -d -t "$CALLER_SESSION:" -n "$NAME" "$CMD"
+  # index N in use".
+  TARGET=$(tmux new-window -d -P -F '#{session_name}:#{window_index}' -t "$CALLER_SESSION:" -n "$NAME" "$CMD")
 fi
+# Sidecar for await-role.sh: which sentinel contract applies and which tmux
+# target to pronounce dead. Same path plus .meta, so dispatchers only ever
+# hand around the log path.
+printf 'role=%s\ntmux=%s\n' "$ROLE" "$TARGET" > "$LOG.meta"
 echo "$LOG"
diff --git a/.kilo_workflow/e2e-slot.sh b/.kilo_workflow/e2e-slot.sh
index 6a8c962de4..125a936e69 100755
--- a/.kilo_workflow/e2e-slot.sh
+++ b/.kilo_workflow/e2e-slot.sh
@@ -10,8 +10,8 @@
 # section that follows. Planning, implementation, review, and CI waits need
 # neither, and are unlimited.
 #
-#   e2e-slot.sh acquire [tmux-session]   # blocks until a slot is free, then holds it
-#   e2e-slot.sh release [tmux-session]   # frees the slot AND hands back the worktree's stack and simulators
+#   e2e-slot.sh acquire                  # blocks until a slot is free, then holds it
+#   e2e-slot.sh release [tmux-session]   # frees the slot AND hands back the worktree's stack and devices
 #   e2e-slot.sh status                   # who holds what, for how long, with stack coverage
 #   e2e-slot.sh stacks [--reap]          # stacks with no slot; --reap stops them
 #
@@ -19,12 +19,12 @@
 # If that tmux session no longer exists the slot is stale and is reclaimed
 # automatically — no heartbeats to maintain.
 #
-# acquire/release resolve the CALLER'S OWN tmux session when no name is given —
-# through $TMUX_PANE, never the untargeted `display-message -p '#S'`, which
-# answers with the server's most recently active session and hands your slot an
-# owner that can die while you still drive a device. Passing a name is for
-# operators cleaning up a dead holder, not for owning a slot under a session
-# that is not yours.
+# acquire/release resolve the CALLER'S OWN tmux session — through $TMUX_PANE,
+# never the untargeted `display-message -p '#S'`, which answers with the
+# server's most recently active session and hands your slot an owner that can
+# die while you still drive a device. acquire accepts no name at all; release
+# accepts one only so an operator can clean up after a holder that is already
+# dead.
 #
 # State is machine-global on purpose: every worktree's copy of this script must
 # contend for the same slots, so the state dir never lives next to the script.
@@ -62,6 +62,10 @@ stack_is_covered() {
   local sess=$1 s wt owner
   for s in "$DIR"/slot-*; do
     [ -d "$s" ] || continue
+    # A slot mid-release no longer entitles its worktree to anything — without
+    # this, a release would see its own still-present slot as coverage and
+    # skip the teardown it exists to perform.
+    [ -f "$s/releasing" ] && continue
     wt=$(cat "$s/worktree" 2>/dev/null || echo)
     [ -n "$wt" ] && [ "$(stack_session "$wt")" = "$sess" ] && return 0
     owner=$(cat "$s/owner" 2>/dev/null || echo)
@@ -74,13 +78,13 @@ stack_is_covered() {
 # every simulator it claimed — but only once no remaining slot covers it: a
 # section can hold a second slot for a concurrent phase.
 release_worktree_resources() {
-  local wt=$1 sess
+  local wt=$1 sess rc=0 c serial
   [ -n "$wt" ] && [ -d "$wt" ] || return 0
   sess=$(stack_session "$wt")
   stack_is_covered "$sess" && return 0
   if tmux has-session -t "$sess" 2>/dev/null; then
     echo "stopping dev stack for $wt"
-    (cd "$wt" && pnpm dev:stop)
+    (cd "$wt" && pnpm dev:stop) || rc=1
   fi
   # Devices go back whether or not a stack is up — a round can drive a claimed
   # simulator without one. Doing it here rather than trusting the runbook's
@@ -89,7 +93,19 @@ release_worktree_resources() {
   # rest of the day. `release-all` only touches this worktree's own claims, and
   # only powers off devices its own claims booted.
   echo "releasing simulators claimed by $wt"
-  (cd "$wt" && pnpm dev:mobile:simulator release-all)
+  (cd "$wt" && pnpm dev:mobile:simulator release-all) || rc=1
+  # Android claims are per-serial files; drop this worktree's so dead sections
+  # never wedge a serial. The claim records no boot provenance, so the emulator
+  # process itself is left alone — powering off a device we may not have booted
+  # is worse than leaking one (known gap until Android claims record it).
+  for c in "${TMPDIR:-/tmp}/kilo-mobile-android-claims"/*.json; do
+    [ -f "$c" ] || continue
+    grep -qF "\"worktreeRoot\":\"$wt\"" "$c" 2>/dev/null || continue
+    serial=$(basename "$c" .json)
+    echo "releasing android claim $serial held by $wt"
+    (cd "$wt" && pnpm dev:mobile:android release "$serial") || rc=1
+  done
+  return "$rc"
 }
 
 reap() {
@@ -113,11 +129,13 @@ reap() {
     fi
     if ! printf '%s\n' "$alive" | grep -qxF -- "$owner"; then
       # The owner is gone, so the slot and everything it entitled — stack and
-      # claimed devices — are all reclaimable. Nothing is using a stack or a
-      # simulator whose session died.
+      # claimed devices — are all reclaimable. Tear down BEFORE freeing the
+      # slot (the `releasing` marker takes it out of coverage), so a new
+      # acquirer can never run alongside the dead holder's still-live stack.
       wt=$(cat "$s/worktree" 2>/dev/null || echo)
+      touch "$s/releasing"
+      release_worktree_resources "$wt" || true
       rm -rf "$s"
-      release_worktree_resources "$wt"
     fi
   done
 }
@@ -140,7 +158,14 @@ self_session() {
 
 case "${1:?usage: acquire|release|status|stacks [tmux-session]}" in
   acquire)
-    who=${2:-$(self_session)}
+    # No explicit owner, ever: a slot acquired under any session but the
+    # caller's own gets reclaimed on the wrong lifetime (or never), which is
+    # exactly the leak the self-resolution exists to prevent.
+    [ -z "${2:-}" ] || {
+      echo "acquire takes no session name — run it from the session that will own the slot; it resolves the name itself" >&2
+      exit 1
+    }
+    who=$(self_session)
     [ -n "$who" ] || {
       echo "not inside a tmux session — a slot owner must be a live tmux session so a dead holder can be reclaimed; run from your own session (your dispatcher should have launched you in one)" >&2
       exit 1
@@ -164,11 +189,17 @@ case "${1:?usage: acquire|release|status|stacks [tmux-session]}" in
       reap
       for i in $(seq 1 "$TOTAL"); do
         if mkdir "$DIR/slot-$i" 2>/dev/null; then
-          printf '%s' "$who" > "$DIR/slot-$i/owner"
-          printf '%s' "$SELF_WORKTREE" > "$DIR/slot-$i/worktree"
-          date -u +%Y-%m-%dT%H:%M:%SZ > "$DIR/slot-$i/since"
-          echo "acquired slot-$i for ${SELF_WORKTREE:-unknown worktree}"
-          exit 0
+          # A partially written slot is worse than no slot: the reaper would
+          # hand it to someone else while this caller drives a device.
+          if printf '%s' "$who" > "$DIR/slot-$i/owner" &&
+             printf '%s' "$SELF_WORKTREE" > "$DIR/slot-$i/worktree" &&
+             date -u +%Y-%m-%dT%H:%M:%SZ > "$DIR/slot-$i/since"; then
+            echo "acquired slot-$i for ${SELF_WORKTREE:-unknown worktree}"
+            exit 0
+          fi
+          rm -rf "$DIR/slot-$i"
+          echo "failed to record slot ownership in $DIR (disk full?)" >&2
+          exit 1
         fi
       done
       echo "all $TOTAL device slots busy; retrying in ${POLL}s: $(ls -1 "$DIR" 2>/dev/null | tr '\n' ' ')" >&2
@@ -178,19 +209,23 @@ case "${1:?usage: acquire|release|status|stacks [tmux-session]}" in
   release)
     who=${2:-$(self_session)}
     [ -n "$who" ] || { echo "not inside tmux and no session name given" >&2; exit 1; }
+    fail=0
     for s in "$DIR"/slot-*; do
       [ -d "$s" ] || continue
       [ "$(cat "$s/owner" 2>/dev/null)" = "$who" ] || continue
       wt=$(cat "$s/worktree" 2>/dev/null || echo)
+      # Tear down first, free the slot last: the `releasing` marker takes this
+      # slot out of coverage so the teardown runs, while the still-occupied
+      # slot directory keeps a new acquirer from starting a stack alongside
+      # the one being stopped. The stack and the claimed devices go with the
+      # slot; a later round acquires, starts, and claims fresh.
+      touch "$s/releasing"
+      release_worktree_resources "$wt" || fail=1
       rm -rf "$s"
       echo "released $(basename "$s")"
-      # The stack and the claimed simulators go with the slot. A later round
-      # acquires again and starts a fresh stack and claims a device again;
-      # leaving them up is what pushes the host past three stacks and strands
-      # booted simulators.
-      release_worktree_resources "$wt"
     done
-    exit 0
+    [ "$fail" -eq 0 ] || echo "release: teardown reported errors above — verify with status and dev:status" >&2
+    exit "$fail"
     ;;
   status)
     reap
diff --git a/.kilo_workflow/launch-interactive.sh b/.kilo_workflow/launch-interactive.sh
index 48fdc2d03c..d6907bf5b1 100755
--- a/.kilo_workflow/launch-interactive.sh
+++ b/.kilo_workflow/launch-interactive.sh
@@ -7,13 +7,13 @@
 #     never piped or redirected; use --log to attach `tmux pipe-pane` logging.
 #   - Full KILO_*/OPENCODE* env strip, computed inside the new pane — the tmux
 #     SERVER's environment can poison children even when the caller's is clean
-#     (see learnings/nested-kilo-run-env-poisoning.md).
+#     — a child kilo inheriting KILO_*/OPENCODE* misattaches sessions and auth.
 #   - The caller's session is resolved through $TMUX_PANE. An untargeted
 #     `tmux display-message -p '#S'` answers with the server's most recently
 #     active session and files the window under an unrelated section. Outside
 #     tmux, the launch gets its own session.
 #   - The window target carries a trailing colon so tmux cannot prefix-match a
-#     window name (see learnings/tmux-new-window-index-in-use-name-prefix-collision.md).
+#     window name and fail with "create window failed: index N in use".
 #
 #   launch-interactive.sh <name> <worktree> [--log <file>] <command> [args...]
 #
diff --git a/.kilo_workflow/learnings/kilo-agent-dies-on-large-session-payload.md b/.kilo_workflow/learnings/kilo-agent-dies-on-large-session-payload.md
deleted file mode 100644
index 25916a7a99..0000000000
--- a/.kilo_workflow/learnings/kilo-agent-dies-on-large-session-payload.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# kilo role agent dies silently when its session payload exceeds the pruning limit
-
-Symptom: a dispatched `kilo run` role agent (observed with an E2E verifier) exits mid-task with no error and no final report; its transcript just stops, often right after a large tool output.
-
-Cause: the agent's session payload grows past the pruning limit (`opencode.log` shows `payload still large after pruning ... size=3042931` at the kill time) and the harness terminates the run. E2E agents inflate the payload fast: full UI-hierarchy dumps (~80 KB), full service-pane captures with QR art, repeated echo of the same long command output, screenshots read into context.
-
-Fix: enforce output discipline in the handoff (and it is baked into the `e2e-verifier` definition): every shell command ends in a hard cap (`| tail -c 1500` / `| tail -5`), hierarchies and captures go to files and only greps or counts are printed, screenshots are not re-read into context, docs are inlined in the handoff instead of re-read, and the final report has a line cap. Dispatches with these rules survive; dispatches without them died at 4–10 minutes.
diff --git a/.kilo_workflow/learnings/kilo-interactive-orchestrator-wedges-relaunch.md b/.kilo_workflow/learnings/kilo-interactive-orchestrator-wedges-relaunch.md
index 03854f5df7..0b5f6a46ed 100644
--- a/.kilo_workflow/learnings/kilo-interactive-orchestrator-wedges-relaunch.md
+++ b/.kilo_workflow/learnings/kilo-interactive-orchestrator-wedges-relaunch.md
@@ -4,4 +4,4 @@ Symptom: an orchestrator running as `kilo run --interactive` stops making progre
 
 Cause: provider stream stalls kill long kilo runs; interactive sessions surface provider errors as a wedge the session cannot recover from, and a poisoned message history surfaces as the repeated schema error. Nothing about the plan or repository is wrong.
 
-Fix: detect via log-byte stagnation plus pane inspection, not just process exit — and on the hard schema error, kill immediately rather than waiting out a timer. Kill the window and relaunch a **fresh** session (never `--continue` or `--session`: the poisoned history is exactly what must not be carried over) with a continuation handoff: the original handoff plus everything observably done — commits (`git log`), PR number and state, review/E2E rounds passed, resources still held — so the new session verifies and continues instead of redoing. Distrust the dead session's last claims: re-verify anything it reported green that is not independently evidenced (a passing check in CI, a commit, a resolved thread). Related: `kilo-run-exits-0-without-verdict.md` covers the same stall killing non-interactive role-agent rounds.
+Fix: detect via log-byte stagnation plus pane inspection, not just process exit — and on the hard schema error, kill immediately rather than waiting out a timer. Kill the window and relaunch a **fresh** session (never `--continue` or `--session`: the poisoned history is exactly what must not be carried over) with a continuation handoff: the original handoff plus everything observably done — commits (`git log`), PR number and state, review/E2E rounds passed, resources still held — so the new session verifies and continues instead of redoing. Distrust the dead session's last claims: re-verify anything it reported green that is not independently evidenced (a passing check in CI, a commit, a resolved thread). Related: the same provider stall kills non-interactive role-agent rounds too — `await-role.sh` reports those as VOID or STALLED.
diff --git a/.kilo_workflow/learnings/kilo-provider-model-not-found-transient.md b/.kilo_workflow/learnings/kilo-provider-model-not-found-transient.md
index 7d60efd46e..707808160f 100644
--- a/.kilo_workflow/learnings/kilo-provider-model-not-found-transient.md
+++ b/.kilo_workflow/learnings/kilo-provider-model-not-found-transient.md
@@ -39,6 +39,6 @@ Escalate to an infrastructure blocker — and never a model substitution — onl
 redispatches keep failing with this signature, which would mean the model really is gone. Three
 consecutive void rounds is the standing threshold.
 
-Related: `kilo-run-startup-crash-transient.md` (startup crash, exit 1, credential write),
-`kilo-run-exits-0-without-verdict.md` (mid-run stream stall, exit 0). All three are void rounds
-with different causes; only this one is provider-side.
+Related: `kilo-run-startup-crash-transient.md` (startup crash, exit 1, credential write) and the
+mid-run stream stall (exit 0, reported VOID by `await-role.sh`). All three are void rounds with
+different causes; only this one is provider-side.
diff --git a/.kilo_workflow/learnings/kilo-run-exits-0-without-verdict.md b/.kilo_workflow/learnings/kilo-run-exits-0-without-verdict.md
deleted file mode 100644
index 7a6404a0b5..0000000000
--- a/.kilo_workflow/learnings/kilo-run-exits-0-without-verdict.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# kilo run exits 0 without a verdict — void round, never a pass
-
-Symptom: a dispatched role agent's `kilo run` exits with `EXITCODE=0` after some tool calls, but the log ends mid-sentence — often on an ordinary progress line — with no findings list and no `No findings.` The tmux window is gone and a bare exit code reads as success, so the round silently counts as a pass.
-
-Cause: kilo provider stream stall — long runs die 10–15 minutes in and the CLI ends the session without emitting the final assistant message. Unrelated to the agent definition, the plan, or permission denials.
-
-Fix: a round that produced no explicit verdict line is void, never a pass. Detect completion by requiring the role's sentinel line itself (reviewers: `No findings.`, a findings list, or `STOPPED EARLY.`; implementer: `SLICE COMPLETE.`/`STOPPED EARLY.`; verifier: `VERIFICATION PASSED./FAILED./BLOCKED.`, `REPRODUCED.`, `CANNOT REPRODUCE.`, or `STOPPED EARLY.`), never by exit code alone. Discard the void round and dispatch a fresh session — review gates want a fresh session per round anyway. Monitor the log for byte-size stagnation as well as process exit so a stall is distinguishable from work in progress. If several consecutive rounds die at the same point, shrink the handoff rather than retrying unchanged.
-
-Variant — the stall that never exits: the same provider stall can leave the `kilo run` process (and its MCP children) alive indefinitely with no `EXITCODE` marker ever appended — the session sits there while the log's mtime stagnates. The tmux pane shows nothing because stdout is redirected to the log, so pane capture is not a liveness signal. Signature: log mtime stagnant >15–20 min with the process tree alive. Remedy: kill the tmux session (an e2e-verifier's device slot auto-reclaims by session name), verify the tree and scratch state yourself, and redispatch fresh with a continuation handoff listing everything the dead round observably finished (artifacts on disk, not its claims).
diff --git a/.kilo_workflow/learnings/kilo-run-shell-substitution-executes-backticks.md b/.kilo_workflow/learnings/kilo-run-shell-substitution-executes-backticks.md
deleted file mode 100644
index 9256aac86e..0000000000
--- a/.kilo_workflow/learnings/kilo-run-shell-substitution-executes-backticks.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Inlining a handoff with "$(cat file)" executes backticks in the file
-
-Symptom: a role agent dispatched with `kilo run "$(cat handoff.md)" ...` misbehaves — parts of the prompt are missing or garbled, or shell commands you never wrote have run. Handoffs are markdown and routinely contain backticks.
-
-Cause: the dispatch usually travels through a second shell parse — a tmux window command string, an `sh -c`, a wrapper script. The outer shell expands `$(cat handoff.md)` and splices the file's raw content into the command string; the inner shell then re-parses that string, and backticks (and `$(...)`) inside the handoff execute as commands. A direct, single-parse invocation is safe, but the tmux-based dispatch pattern is not.
-
-Fix: never inline file content into the message. The `kilo run` message is a short literal instruction; handoffs, plans, and diffs travel via `--file <path>` (repeatable, message positional before the flags).
diff --git a/.kilo_workflow/learnings/kilo-run-startup-crash-transient.md b/.kilo_workflow/learnings/kilo-run-startup-crash-transient.md
index 1c036fc3ed..773ffc6e79 100644
--- a/.kilo_workflow/learnings/kilo-run-startup-crash-transient.md
+++ b/.kilo_workflow/learnings/kilo-run-startup-crash-transient.md
@@ -25,9 +25,9 @@ Before redispatching, rule out the look-alikes that will NOT clear on retry:
 - **Disk full** — the classic cause of SQLite write failures: `df -h /Users`.
 - **Auth genuinely wedged** — `PAID_MODEL_AUTH_REQUIRED` needs an interactive `kilo auth login`.
   If the logged credential payload has a future `exp`, auth is not the problem.
-- **Poisoned env / known-bad CLI** — a run inheriting a parent kilo's `KILO_*` env hits
-  `Session not found` deterministically (see `nested-kilo-run-env-poisoning.md`); CLI
-  7.4.13–7.4.15 had a fresh-database `Session not found` bug on macOS, fixed in 7.4.16.
+- **Poisoned env / known-bad CLI** — a run inheriting a parent kilo's `KILO_*`/`OPENCODE*` env
+  hits `Session not found` deterministically (the launch scripts strip these; a hand launch must
+  too); CLI 7.4.13–7.4.15 had a fresh-database `Session not found` bug on macOS, fixed in 7.4.16.
 
 Handling notes: the crash log's `params` can include the OAuth **refresh JWT** — redact
 `eyJ[A-Za-z0-9_.-]+` before keeping any of it as evidence. Never delete
@@ -35,5 +35,4 @@ Handling notes: the crash log's `params` can include the OAuth **refresh JWT** 
 workflow's `kilo run` to free a lock. Three consecutive void rounds with this signature is an
 infrastructure blocker to report, not something to keep redispatching through.
 
-Distinct from `kilo-run-exits-0-without-verdict.md` (mid-run provider stream stall, exit 0 after
-real work) and `kilo-provider-model-not-found-transient.md` (gateway catalog blip, also exit 1).
+Distinct from the mid-run provider stream stall (exit 0 after real work, reported VOID by `await-role.sh`) and from `kilo-provider-model-not-found-transient.md` (gateway catalog blip, also exit 1).
diff --git a/.kilo_workflow/learnings/kiloclaw-chat-attachments-r2-secret-missing.md b/.kilo_workflow/learnings/kiloclaw-chat-attachments-r2-secret-missing.md
deleted file mode 100644
index 76d4e66923..0000000000
--- a/.kilo_workflow/learnings/kiloclaw-chat-attachments-r2-secret-missing.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# KiloClaw chat attachment uploads 500 locally: R2 media secrets missing (RESOLVED — recheck recipe)
-
-Symptom: picking a file in the kilo-chat composer adds a chip that immediately goes to `failed`
-(a11y `Retry upload for <name>`); kilo-chat logs `POST /v1/attachments/init 500` with
-`Error: Secret "R2_ACCESS_KEY_ID_KILOCHAT_MEDIA" not found`.
-
-RESOLVED 2026-07-28: the `R2_*_KILOCHAT_MEDIA` pair now exists in the Secrets Store and
-`dev:start` provisions it like any source-backed secret; verified end-to-end
-(`/v1/attachments/init 200`, chip `ready`, send 201).
-
-If the symptom recurs: first check whether the store lost the pair again, then whether the
-worktree's `services/kilo-chat/.wrangler/state` secrets KV is stale — re-run `dev:start`.
-Oversized-rejection assertions (pre-read size gate) never needed the secrets and are always
-testable.
diff --git a/.kilo_workflow/learnings/mobile-ios-open-in-kilo-prompt-blocks-launch.md b/.kilo_workflow/learnings/mobile-ios-open-in-kilo-prompt-blocks-launch.md
deleted file mode 100644
index 2a60fdcd92..0000000000
--- a/.kilo_workflow/learnings/mobile-ios-open-in-kilo-prompt-blocks-launch.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# mobile: iOS "Open in \"Kilo\"?" confirmation blocks login/launch flows
-
-Symptom: `apps/mobile/e2e/login.sh` fails its settle assertion with the simulator stuck under a SpringBoard dialog `Open in "Kilo"?` (Cancel/Open), after preflight's `xcrun simctl openurl` or on a freshly installed dev client.
-
-Cause: two wordings exist. iOS 26.5 reworded the custom-scheme confirmation from `Open this page in "Kilo"?` to `Open in "Kilo"?`, and after `associatedDomains` (universal links) landed in `app.config.ts`, `simctl openurl` surfaces a SpringBoard confirmation of its own. Flow matchers that only know one wording never tap it. The custom-scheme dialog appears once per install; a reinstall re-arms it.
-
-Fix: `e2e/flows/settle-app.yaml` and `e2e/flows/open-app.yaml` now match both wordings (`Open in ["“”]Kilo["“”]\?` alongside the Safari string) and tap `Open` in the same bounded optional-prompt slot. If it still appears mid-run, tap `Open` once yourself (two-line temp Maestro flow with `appId: host.springboard`, `tapOn: { text: 'Open', optional: true }`) and re-run `login.sh` — it is idempotent. When updating the flows, add new wordings as regex alternatives; never replace the old text.
diff --git a/.kilo_workflow/learnings/nested-kilo-run-env-poisoning.md b/.kilo_workflow/learnings/nested-kilo-run-env-poisoning.md
deleted file mode 100644
index 18d30ce483..0000000000
--- a/.kilo_workflow/learnings/nested-kilo-run-env-poisoning.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# Nested kilo run inherits poisoned KILO_*/OPENCODE env
-
-Symptom: a `kilo run` dispatched from inside another kilo session (orchestrator → role agent) misbehaves: wrong session attach, auth against the wrong stack, or silent misconfiguration that a directly launched run does not show.
-
-Cause: the child inherits the parent's `KILO_*` and `OPENCODE*` environment variables. The tmux SERVER's global environment can also carry stale values into every new window (`tmux show-environment -g` to inspect), so even a fresh tmux window is not clean.
-
-Fix: strip every `KILO_*`/`OPENCODE*` variable, not a fixed list — the harness also exports `KILO_RUN_ID`, `KILO_SERVER_*`, `KILO_PROCESS_ROLE`, and more, and partial stripping still poisons the child:
-
-```bash
-env $(env | grep -oE '^(KILO|OPENCODE)[A-Za-z0-9_]*' | sed 's/^/-u /') kilo run ...
-```
-
-If tmux global env is poisoned, clear it with `tmux set-environment -g -u <var>` before launching windows.
diff --git a/.kilo_workflow/learnings/tmux-new-window-index-in-use-name-prefix-collision.md b/.kilo_workflow/learnings/tmux-new-window-index-in-use-name-prefix-collision.md
deleted file mode 100644
index b154b4d1dc..0000000000
--- a/.kilo_workflow/learnings/tmux-new-window-index-in-use-name-prefix-collision.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# tmux new-window fails "create window failed: index N in use" — session/window name prefix collision
-
-Symptom: `dispatch-role.sh` (or any `tmux new-window -t <session> -n <name> ...`) fails with
-`create window failed: index 1 in use` even though the session obviously has free window indexes.
-Reproduced on tmux 3.7b: a plain `tmux new-window -d -t <session> -n probe "sleep 5"` fails the
-same way while `-t <session>:2` (explicit index) and `-t <session>:` (trailing colon) both work.
-
-Cause: tmux target parsing prefix-matches the target against **window names** before falling back
-to the session. The workflow names sessions `<section>` and windows `<section>-<role>` /
-`<section>-planner`, so `-t <section>` prefix-matches the planner window (index 1) and tmux tries
-to create the new window *at that window's index*, which is taken. Runs whose session name differs
-from every window-name prefix (e.g. session `kilo-dev-<section>`) never see it, which is why some
-concurrent workflows kept working on the same server.
-
-Fix: target `<session>:` (trailing colon = session with an empty window part → next free index),
-which is unambiguous. `dispatch-role.sh` does this; keep the colon. If you hit the symptom
-manually, use `-t <session>:` or an explicit free index. Diagnosis recipe: probe with
-`tmux new-window -d -t <session> -n probe "sleep 5"`, then compare
-`tmux list-windows -t <session> -F '#{window_index} #{window_name}'` for a window whose name
-starts with the session name.
diff --git a/.kilo_workflow/pick-reviewers.sh b/.kilo_workflow/pick-reviewers.sh
index 514f52c97b..c408543cf5 100755
--- a/.kilo_workflow/pick-reviewers.sh
+++ b/.kilo_workflow/pick-reviewers.sh
@@ -7,9 +7,10 @@
 #   pick-reviewers.sh <owner/repo> <requesting-handle> <file> [file...]
 #
 # Run from the repository the files live in (uses git log). Prints
-# "<count> <login>" lines, most frequent first, bots and the requesting human
-# already dropped. No output at all means no history — request nobody and say
-# so in one line in the PR description.
+# "<count> <login>" lines, most frequent first — each login counted once per
+# PR it reviewed, bots and the requesting human dropped. No output at all
+# (exit 0) means no history — request nobody and say so in one line in the PR
+# description.
 set -euo pipefail
 
 REPO=${1:?owner/repo} HANDLE=${2:?requesting GitHub handle}
@@ -21,7 +22,12 @@ PRS=$(
     for f in "$@"; do
       git log -10 --format='%H' -- "$f"
     done | sort -u | while read -r sha; do
-      gh api "repos/$REPO/commits/$sha/pulls" --jq '.[].number' 2>/dev/null || true
+      # Not every commit has a PR (unpushed or direct-pushed) — that is data,
+      # not an error. On failure gh prints the error BODY to stdout, so the
+      # output must be discarded with the failure, not passed through.
+      if out=$(gh api "repos/$REPO/commits/$sha/pulls" --jq '.[].number' 2>/dev/null); then
+        printf '%s\n' "$out"
+      fi
     done
     gh pr list --repo "$REPO" --author "$HANDLE" --state merged --limit 10 \
       --json number --jq '.[].number'
@@ -29,6 +35,16 @@ PRS=$(
 )
 
 [ -n "$PRS" ] || exit 0
-for n in $PRS; do
-  gh pr view "$n" --repo "$REPO" --json reviews --jq '.reviews[].author.login' 2>/dev/null || true
-done | grep -viE 'bot' | grep -vxF "$HANDLE" | sort | uniq -c | sort -rn | awk '{print $1, $2}'
+RESULT=$(
+  for n in $PRS; do
+    # One vote per login per PR — several review submissions on one PR are
+    # still one relationship. Failures propagate; a half-counted ranking is
+    # worse than none.
+    gh pr view "$n" --repo "$REPO" --json reviews \
+      --jq '[.reviews[].author.login] | unique | .[]'
+  done \
+    | grep -viE '(^|[-_/])bot([-_[]|$)|\[bot\]$' \
+    | grep -vixF -- "$HANDLE" \
+    | sort | uniq -c | sort -rn | awk '{print $1, $2}' || true
+)
+[ -z "$RESULT" ] || echo "$RESULT"
diff --git a/.kilo_workflow/pr-gate.sh b/.kilo_workflow/pr-gate.sh
new file mode 100755
index 0000000000..5ec6fe88b8
--- /dev/null
+++ b/.kilo_workflow/pr-gate.sh
@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+# Check the mechanical half of the completion gate for one PR, per
+# .kilo_workflow/WORKFLOW.md. Assembling these facts by hand invites two
+# classic false passes: an approving Kilobot comment from an OLDER head, and
+# a green `Kilo Code Review` check read as a verdict. Judgment items — does
+# the comment actually approve, are the screenshots real — stay with the
+# agent; this script pins the facts to one head SHA.
+#
+#   pr-gate.sh <owner/repo> <pr>
+#
+# Prints the facts, then `GATE FAIL: ...` lines for every mechanical item
+# that does not hold (exit 1), or `GATE OK (mechanical items)` (exit 0).
+# Kilobot comments are printed only when they postdate the head commit —
+# read the newest one's verdict yourself; wording drifts, never string-match.
+set -euo pipefail
+
+REPO=${1:?owner/repo} PR=${2:?pr number}
+[[ "$REPO" =~ ^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$ ]] || { echo "repository must be owner/repo" >&2; exit 1; }
+
+DATA=$(gh pr view "$PR" --repo "$REPO" \
+  --json headRefOid,mergeable,mergeStateStatus,statusCheckRollup,assignees,labels,comments)
+
+HEAD_OID=$(jq -r '.headRefOid' <<<"$DATA")
+HEAD_TIME=$(gh api "repos/$REPO/commits/$HEAD_OID" --jq '.commit.committer.date')
+
+echo "head=$HEAD_OID ($HEAD_TIME)"
+echo "mergeable=$(jq -r '.mergeable' <<<"$DATA") mergeStateStatus=$(jq -r '.mergeStateStatus' <<<"$DATA")"
+echo "assignees=$(jq -r '[.assignees[].login] | join(",")' <<<"$DATA")"
+echo "labels=$(jq -r '[.labels[].name] | join(",")' <<<"$DATA")"
+
+BAD_CHECKS=$(jq -r '[.statusCheckRollup[]? | select((.conclusion // .state // "PENDING") as $c
+  | ($c | ascii_upcase) as $u
+  | ($u == "SUCCESS" or $u == "NEUTRAL" or $u == "SKIPPED") | not)
+  | "\(.name // .context): \(.conclusion // .state // "PENDING")"] | .[]' <<<"$DATA")
+[ -n "$BAD_CHECKS" ] && { echo "checks not green:"; sed 's/^/  /' <<<"$BAD_CHECKS"; } || echo "checks: all green"
+
+UNRESOLVED=$("$(dirname "$0")/pr-threads.sh" unresolved "$REPO" "$PR" | grep -c . || true)
+echo "unresolved_threads=$UNRESOLVED"
+
+KILOBOT=$(jq -r --arg t "$HEAD_TIME" \
+  '[.comments[] | select((.author.login | test("bot"; "i")) and .createdAt > $t)
+    | "\(.author.login) @ \(.createdAt): \(.body | gsub("\\s+"; " ") | .[0:200])"] | .[]' <<<"$DATA")
+if [ -n "$KILOBOT" ]; then
+  echo "bot comments after head commit:"
+  sed 's/^/  /' <<<"$KILOBOT"
+else
+  echo "bot comments after head commit: NONE"
+fi
+
+FAIL=0
+gate_fail() { echo "GATE FAIL: $1"; FAIL=1; }
+MERGEABLE=$(jq -r '.mergeable' <<<"$DATA")
+case $MERGEABLE in
+  MERGEABLE) ;;
+  UNKNOWN) gate_fail "mergeability UNKNOWN — GitHub is still recomputing it; re-run in ~30s" ;;
+  *) gate_fail "not mergeable ($MERGEABLE — resolve conflicts by merging origin/main)" ;;
+esac
+[ -z "$BAD_CHECKS" ] || gate_fail "CI checks not green on head"
+[ "$UNRESOLVED" -eq 0 ] || gate_fail "$UNRESOLVED unresolved review thread(s)"
+[ "$(jq -r '.assignees | length' <<<"$DATA")" -gt 0 ] || gate_fail "no assignee"
+[ -n "$KILOBOT" ] || gate_fail "no bot summary comment postdating the head commit (wait, retrigger, or waive per the Kilobot loop)"
+[ "$FAIL" -eq 0 ] && echo "GATE OK (mechanical items — verdict wording, screenshots, and learnings are still yours to judge)"
+exit "$FAIL"
diff --git a/.kilo_workflow/pr-threads.sh b/.kilo_workflow/pr-threads.sh
index ec70a7d9bb..035c3ba9c3 100755
--- a/.kilo_workflow/pr-threads.sh
+++ b/.kilo_workflow/pr-threads.sh
@@ -2,61 +2,112 @@
 # PR review-thread plumbing for the Kilobot loop, per .kilo_workflow/WORKFLOW.md.
 # Thread grouping, isResolved, and resolution live only in GitHub's GraphQL API;
 # the REST comments endpoint cannot express any of them, and hand-assembled
-# GraphQL burns rounds on quoting mistakes.
+# GraphQL burns rounds on quoting and pagination mistakes.
 #
-#   pr-threads.sh list <owner/repo> <pr>                      # every thread: id, state, path, first-comment id/author/body
-#   pr-threads.sh unresolved <owner/repo> <pr>                # just the unresolved ones (empty output = clean)
-#   pr-threads.sh reply <owner/repo> <pr> <comment-id> <body> # reply in-thread; body may be - for stdin
-#   pr-threads.sh resolve <owner/repo> <thread-id>            # mark the thread resolved
+#   pr-threads.sh list <owner/repo> <pr>                 # every thread: id, state, path, comments, first-comment id/author/body
+#   pr-threads.sh unresolved <owner/repo> <pr>           # just the unresolved ones (empty output = clean)
+#   pr-threads.sh close <owner/repo> <thread-id> <body>  # reply in-thread AND resolve it, asserting both
+#   pr-threads.sh reply <owner/repo> <thread-id> <body>  # reply only (e.g. while more work is coming)
+#   pr-threads.sh resolve <owner/repo> <thread-id>       # resolve only
 #
-# Replies get the mandatory "(bot) " prefix added when missing. The reply
-# target is the thread's FIRST comment id (shown by list). A fix without its
-# in-thread reply and resolution is not done.
+# <body> may be `-` to read stdin. Replies get the mandatory "(bot) " prefix
+# added when missing. A fix without its in-thread reply and resolution is not
+# done — `close` is the normal move.
 set -euo pipefail
 
-CMD=${1:?usage: pr-threads.sh list|unresolved|reply|resolve ...}
+CMD=${1:?usage: pr-threads.sh list|unresolved|close|reply|resolve ...}
 REPO=${2:?owner/repo}
 [[ "$REPO" =~ ^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$ ]] || { echo "repository must be owner/repo" >&2; exit 1; }
 OWNER=${REPO%%/*}
 NAME=${REPO##*/}
 
-QUERY='query($owner:String!,$repo:String!,$pr:Int!){
+QUERY='query($owner:String!,$repo:String!,$pr:Int!,$after:String){
   repository(owner:$owner,name:$repo){pullRequest(number:$pr){
-    reviewThreads(first:100){nodes{id isResolved isOutdated path line
-      comments(first:1){nodes{databaseId author{login} body}}}}}}}'
+    reviewThreads(first:100,after:$after){
+      pageInfo{hasNextPage endCursor}
+      nodes{id isResolved isOutdated path line
+        comments(first:1){totalCount nodes{databaseId author{login} body}}}}}}}'
 
+# Emits every thread node, cursor-paginated — thread 101 must not silently
+# vanish from a "clean" verdict.
 threads() {
-  gh api graphql -f query="$QUERY" -f owner="$OWNER" -f repo="$NAME" -F pr="${1:?pr number}" \
-    --jq '.data.repository.pullRequest.reviewThreads.nodes[]'
+  local pr=$1 after="" page
+  while :; do
+    page=$(gh api graphql -f query="$QUERY" -f owner="$OWNER" -f repo="$NAME" -F pr="$pr" \
+      ${after:+-f after="$after"} --jq '.data.repository.pullRequest.reviewThreads')
+    jq -c '.nodes[]' <<<"$page"
+    [ "$(jq -r '.pageInfo.hasNextPage' <<<"$page")" = "true" ] || break
+    after=$(jq -r '.pageInfo.endCursor' <<<"$page")
+  done
 }
 
 render() {
   jq -r '[.id, (if .isResolved then "resolved" else "UNRESOLVED" end),
           "\(.path // "-"):\(.line // "-")",
+          (.comments.totalCount | tostring),
           (.comments.nodes[0].databaseId | tostring),
           (.comments.nodes[0].author.login // "?"),
           (.comments.nodes[0].body | gsub("\\s+"; " ") | .[0:160])] | @tsv'
 }
 
+read_body() {
+  local body=$1
+  [ "$body" = "-" ] && body=$(cat)
+  case $body in "(bot) "*) ;; *) body="(bot) $body" ;; esac
+  printf '%s' "$body"
+}
+
+# The REST reply endpoint wants the thread's FIRST top-level comment id;
+# resolve wants the GraphQL thread id. Look the comment id up from the thread
+# id so callers only ever juggle one identifier.
+first_comment_id() {
+  gh api graphql -f query='query($id:ID!){node(id:$id){
+    ... on PullRequestReviewThread{comments(first:1){nodes{databaseId}}}}}' \
+    -f id="$1" --jq '.data.node.comments.nodes[0].databaseId'
+}
+
+# The thread's PR number, needed for the REST reply URL.
+thread_pr() {
+  gh api graphql -f query='query($id:ID!){node(id:$id){
+    ... on PullRequestReviewThread{pullRequest{number}}}}' \
+    -f id="$1" --jq '.data.node.pullRequest.number'
+}
+
+do_reply() {
+  local thread=$1 body=$2 pr comment
+  pr=$(thread_pr "$thread")
+  comment=$(first_comment_id "$thread")
+  gh api "repos/$REPO/pulls/$pr/comments/$comment/replies" -f body="$body" --jq '.html_url'
+}
+
+do_resolve() {
+  local thread=$1 resolved
+  resolved=$(gh api graphql \
+    -f query='mutation($t:ID!){resolveReviewThread(input:{threadId:$t}){thread{isResolved}}}' \
+    -f t="$thread" --jq '.data.resolveReviewThread.thread.isResolved')
+  [ "$resolved" = "true" ] || { echo "pr-threads: resolve did not stick for $thread" >&2; exit 1; }
+  echo "resolved $thread"
+}
+
 case $CMD in
   list)
-    echo -e "thread_id\tstate\tlocation\tfirst_comment_id\tauthor\tbody"
+    printf 'thread_id\tstate\tlocation\tcomments\tfirst_comment_id\tauthor\tbody\n'
     threads "${3:?pr number}" | render
     ;;
   unresolved)
     threads "${3:?pr number}" | jq -c 'select(.isResolved | not)' | render
     ;;
+  close)
+    BODY=$(read_body "${4:?body or -}")
+    do_reply "${3:?thread id}" "$BODY"
+    do_resolve "$3"
+    ;;
   reply)
-    PR=${3:?pr number} COMMENT=${4:?first-comment id} BODY=${5:?body or -}
-    [ "$BODY" = "-" ] && BODY=$(cat)
-    case $BODY in "(bot) "*) ;; *) BODY="(bot) $BODY" ;; esac
-    gh api "repos/$REPO/pulls/$PR/comments/$COMMENT/replies" -f body="$BODY" --jq '.html_url'
+    BODY=$(read_body "${4:?body or -}")
+    do_reply "${3:?thread id}" "$BODY"
     ;;
   resolve)
-    THREAD=${3:?thread id}
-    gh api graphql \
-      -f query='mutation($t:ID!){resolveReviewThread(input:{threadId:$t}){thread{isResolved}}}' \
-      -f t="$THREAD" --jq '.data.resolveReviewThread.thread.isResolved'
+    do_resolve "${3:?thread id}"
     ;;
-  *) echo "usage: pr-threads.sh list|unresolved|reply|resolve ..." >&2; exit 1 ;;
+  *) echo "usage: pr-threads.sh list|unresolved|close|reply|resolve ..." >&2; exit 1 ;;
 esac
diff --git a/.kilo_workflow/slice-diff.sh b/.kilo_workflow/slice-diff.sh
index d92a35fd6b..53fce5887a 100755
--- a/.kilo_workflow/slice-diff.sh
+++ b/.kilo_workflow/slice-diff.sh
@@ -3,37 +3,67 @@
 # it, per .kilo_workflow/WORKFLOW.md orchestrator step 3. Parallel slices share
 # the worktree, so a reviewer must see exactly its slice's paths — and after a
 # reviewer round those paths must be untouched, and after an implementer round
-# no new commits may exist. Hand-assembling that (`git add -N` first, snapshot
-# after, compare later) kept going wrong; this does all of it.
+# no commit may have landed on them. Hand-assembling that kept going wrong;
+# this does all of it.
 #
 #   slice-diff.sh <worktree> <out-file> -- <owned-path>...
+#       Writes the slice diff (uncommitted changes on the owned paths, new
+#       files included, full binary content) to <out-file> for a --file
+#       dispatch, and prints one line: SNAPSHOT=<base>:<hash>
 #
-# Writes the slice diff (uncommitted changes on the owned paths, new files
-# included) to <out-file> for a --file dispatch, and prints one line:
+#   slice-diff.sh --check reviewer|implementer <snapshot-line> <worktree> <out-file> -- <owned-path>...
+#       Recomputes and judges the round itself. Prints `OK` (exit 0) or
+#       `VIOLATION: ...` (exit 1). reviewer: nothing may have changed — same
+#       commits on the owned paths, same working-tree bytes. implementer: no
+#       commit may have landed on the owned paths; edits are expected.
 #
-#   SNAPSHOT=<head-sha>:<diff-hash>
-#
-# Run it again after a round and compare the whole line:
-#   - reviewer round: the line must be IDENTICAL (same commits, same bytes on
-#     the owned paths) — any difference voids the round.
-#   - implementer round: <head-sha> must be unchanged (the implementer never
-#     commits); the diff hash is expected to change.
+# The commit part of the fingerprint is scoped to the owned paths (the last
+# commit touching them), so the orchestrator committing an unrelated finished
+# slice mid-round does not void this one.
 set -euo pipefail
 
+MODE=emit EXPECT=""
+if [ "${1:-}" = "--check" ]; then
+  MODE=${2:?--check reviewer|implementer}
+  EXPECT=${3:?expected SNAPSHOT=... line}
+  case $MODE in reviewer | implementer) ;; *) echo "slice-diff: --check takes reviewer|implementer" >&2; exit 1 ;; esac
+  case $EXPECT in SNAPSHOT=*) ;; *) echo "slice-diff: expected snapshot must be the printed SNAPSHOT=... line" >&2; exit 1 ;; esac
+  shift 3
+fi
+
 WT=${1:?worktree} OUT=${2:?output diff file}
-[ "${3:-}" = "--" ] || { echo "usage: slice-diff.sh <worktree> <out-file> -- <owned-path>..." >&2; exit 1; }
+[ "${3:-}" = "--" ] || { echo "usage: slice-diff.sh [--check reviewer|implementer <snapshot>] <worktree> <out-file> -- <owned-path>..." >&2; exit 1; }
 shift 3
 [ $# -gt 0 ] || { echo "slice-diff: no owned paths given" >&2; exit 1; }
 
 # add -N makes brand-new files visible to `git diff HEAD` without staging
-# their content.
+# their content; --binary captures full content for binary files, so byte
+# changes can never hide behind an identical "Binary files differ" line.
 git -C "$WT" add -N -- "$@"
-git -C "$WT" diff HEAD -- "$@" > "$OUT"
+git -C "$WT" diff HEAD --binary -- "$@" > "$OUT"
 
-HEAD_SHA=$(git -C "$WT" rev-parse HEAD)
+BASE=$(git -C "$WT" log -1 --format=%H -- "$@" 2>/dev/null || echo none)
+[ -n "$BASE" ] || BASE=none
 if command -v sha256sum >/dev/null; then
   DIFF_HASH=$(sha256sum "$OUT" | cut -d' ' -f1)
 else
   DIFF_HASH=$(shasum -a 256 "$OUT" | cut -d' ' -f1)
 fi
-echo "SNAPSHOT=$HEAD_SHA:$DIFF_HASH"
+NOWLINE="SNAPSHOT=$BASE:$DIFF_HASH"
+
+if [ "$MODE" = "emit" ]; then
+  echo "$NOWLINE"
+  exit 0
+fi
+
+EXP_BASE=${EXPECT#SNAPSHOT=}; EXP_BASE=${EXP_BASE%%:*}
+NOW_BASE=${NOWLINE#SNAPSHOT=}; NOW_BASE=${NOW_BASE%%:*}
+if [ "$NOW_BASE" != "$EXP_BASE" ]; then
+  echo "VIOLATION: a commit landed on the owned paths during the round ($EXP_BASE -> $NOW_BASE) — the round is void"
+  exit 1
+fi
+if [ "$MODE" = "reviewer" ] && [ "$NOWLINE" != "$EXPECT" ]; then
+  echo "VIOLATION: the reviewer modified the owned paths (working-tree bytes changed) — the round is void"
+  exit 1
+fi
+echo "OK"
diff --git a/.kilo_workflow/steer.sh b/.kilo_workflow/steer.sh
index d52d270e05..aab8d78824 100755
--- a/.kilo_workflow/steer.sh
+++ b/.kilo_workflow/steer.sh
@@ -42,16 +42,21 @@ pane() { tmux capture-pane -pJ -t "$TARGET"; }
 # The footer renders `<n> queued`; absent means nothing is waiting.
 queued() { pane | grep -oE '[0-9]+ queued' | tail -1 | cut -d' ' -f1 || true; }
 # First line of the message, whitespace-collapsed, as the needle for the
-# submitted `›`-prefixed echo in the scrollback.
+# submitted `›`-prefixed echo in the scrollback. `--` everywhere the needle is
+# passed: a message starting with a dash otherwise reads as a grep option.
 needle=$(printf '%s' "${MSG%%$'\n'*}" | tr -s '[:space:]' ' ' | cut -c1-60)
 # Still unsent: the needle is on screen on a line the scrollback could not have
 # written — a submitted message is only ever echoed `›`-prefixed.
-composed() { pane | grep -F "$needle" | grep -qv '^›'; }
+composed() { pane | grep -F -- "$needle" | grep -qv '^›'; }
+# Count of already-submitted echoes of this needle, taken BEFORE pasting: a
+# prior identical steer in the scrollback must not vouch for this one.
+submitted() { pane | grep -cF -- "› $needle" || true; }
 # Per-invocation buffer: the tmux server's buffers are shared, so a fixed name
 # lets two sections steering at once paste each other's message.
 BUF=kilo-steer-$$
 
 before=$(queued); before=${before:-0}
+sub_before=$(submitted)
 
 # load-buffer + paste-buffer, not send-keys: the message travels as data, so a
 # literal `Enter`, `;` or `C-c` in the text cannot be read as a key name. `-p`
@@ -73,9 +78,10 @@ for attempt in 1 2 3; do
     sleep 1
     now=$(queued); now=${now:-0}
     if [ "$now" -gt "$before" ]; then echo "queued"; exit 0; fi
-    # Submitted and started: the scrollback echoes it as a user message. Match
-    # only lines the composer cannot produce, so unsent text is never a pass.
-    if pane | grep -qF "› $needle"; then echo "running"; exit 0; fi
+    # Submitted and started: the scrollback echoes it as a user message. The
+    # count must EXCEED the pre-paste count — matching alone would let an
+    # earlier identical steer vouch for this one.
+    if [ "$(submitted)" -gt "$sub_before" ]; then echo "running"; exit 0; fi
   done
 done
 
diff --git a/apps/mobile/e2e/AGENTS.md b/apps/mobile/e2e/AGENTS.md
index f89b2e6fb9..042abce036 100644
--- a/apps/mobile/e2e/AGENTS.md
+++ b/apps/mobile/e2e/AGENTS.md
@@ -224,7 +224,7 @@ Do not conclude Android is unavailable from `command -v adb` or the inherited `P
 pnpm dev:mobile:android doctor
 ```
 
-Use the wrappers for all Android tooling, including the Expo/Gradle build, so the resolved SDK/JDK environment is applied. Ordered glue: acquire e2e slot → launch emulator → bounded boot wait (serial discovered at visibility) → `claim` → `build` → `login.sh`. Never unbounded `adb wait-for-device`. Never put manual `adb reverse` or dev-client `am start` on the primary path — `login.sh` preflight does both.
+Use the wrappers for all Android tooling, including the Expo/Gradle build, so the resolved SDK/JDK environment is applied. Ordered glue: acquire e2e slot → launch emulator → `claim` at first adb visibility → bounded boot wait → `build` → `login.sh`. Claim the moment the serial is visible, before waiting for boot — adb serials are host-global, and a concurrent worktree's polling loop can claim your fresh emulator during the boot wait (see `mobile-android-emulator-claims.md`). Never unbounded `adb wait-for-device`. Never put manual `adb reverse` or dev-client `am start` on the primary path — `login.sh` preflight does both.
 
 ### Launch and GPU policy
 
@@ -244,7 +244,7 @@ tmux new-session -d -s "$ANDROID_SESSION" -c "$PWD" \
 From the moment of launch, poll about every 15 s until the envelope expires. Cold boot on an idle host ≈ 1–3 minutes; under parallel-workflow load allow up to 8 minutes before declaring the attempt failed (relaunch-rule bounds, not SLAs). Each poll, check in order:
 
 1. **Liveness** — `pgrep -f "qemu.*<avd-name>"` still prints a PID. If empty, the attempt failed with the process-death signal.
-2. **Visibility** — device appears with state `device` in `pnpm dev:mobile:android adb devices -l` (this is where the serial is discovered; a single local emulator is `emulator-5554`).
+2. **Visibility** — device appears with state `device` in `pnpm dev:mobile:android adb devices -l` (this is where the serial is discovered; a single local emulator is `emulator-5554`). Claim it immediately: `pnpm dev:mobile:android claim <serial>` — do not wait for readiness first.
 3. **Readiness** — once visible, `pnpm dev:mobile:android adb -s <serial> shell getprop sys.boot_completed` prints `1`.
 
 Device visibility is not readiness. Never gate on `adb devices` output alone, and never wait on any one stage without the liveness check.
@@ -253,10 +253,11 @@ Device visibility is not readiness. Never gate on `adb devices` output alone, an
 
 On failure: `tmux kill-session -t "$ANDROID_SESSION" 2>/dev/null` (session may already be gone if the emulator exited), then confirm the emulator process is actually gone — `pgrep -f "qemu.*<avd-name>"` prints nothing. If it survives: with a known serial, `pnpm dev:mobile:android adb -s <serial> emu kill`; with no serial yet (process died or never became visible to adb), `pkill -f "qemu.*<avd-name>"`. Re-check `pgrep` either way — a surviving emulator holds the AVD lock and dooms any relaunch. Then relaunch once per the GPU policy with the same envelope. If the second attempt also fails to boot, stop and return a test-environment blocker with the tail of `$EMULATOR_LOG` (survives session death; never a third launch, never an early give-up).
 
-### Claim, build, login
+### Build and login
+
+The claim already happened at adb visibility (claim is idempotent — re-running it is harmless):
 
 ```bash
-pnpm dev:mobile:android claim <serial>
 pnpm dev:mobile:android build <serial>   # validated cached APK only
 apps/mobile/e2e/login.sh <serial>
 ```

From e2ef13a0b7919ae0c0da65b67e5973cf2fe9ffcb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Wed, 29 Jul 2026 14:57:32 +0200
Subject: [PATCH 04/34] feat(dev,e2e): resolve the review's environment
 findings in-repo

Native build cache key now covers root patches/, pnpm-workspace.yaml, and
pnpm-lock.yaml. dev:start auto-selects a free port offset on collision and
persists it in the manifest (env > manifest > hash); the docker bridge probe
retries transient failures. Guard test fails when a mobile test file matches
no vitest project. GitHub stub serves paginated /pulls/{n}/files. New
e2e/maestro.sh serializes Maestro per device; login.sh holds a per-email OTP
mutex. Slot release kills the worktree's android emulator session (the
session name is the boot provenance). Runbook: fresh githubUserId for stub
seeding, maestro via the wrapper, batch many criteria per device session.
Five more graduated learnings deleted; .playwright-mcp gitignored.
---
 .gitignore                                    |  1 +
 .kilo/agent/e2e-verifier.md                   |  2 +-
 .kilo_workflow/e2e-slot.sh                    | 13 ++-
 ...maestro-concurrent-sessions-same-device.md | 14 ---
 ...bile-github-stub-missing-files-endpoint.md |  7 --
 ...native-build-cache-ignores-root-patches.md | 19 ----
 .../mobile-otp-outbox-race-parallel-phases.md | 14 ---
 ...-mobile-project-includes-skip-new-tests.md |  7 --
 apps/mobile/e2e/AGENTS.md                     | 10 +-
 apps/mobile/e2e/github-api-stub/server.mjs    | 47 ++++++++-
 apps/mobile/e2e/login.sh                      | 20 ++++
 apps/mobile/e2e/maestro.sh                    | 38 ++++++++
 .../src/lib/vitest-project-coverage.test.ts   | 50 ++++++++++
 dev/local/cli.ts                              | 95 +++++++++++++------
 dev/local/docker-api-probe.test.ts            | 19 ++++
 dev/local/docker-api-probe.ts                 | 38 +++++---
 dev/local/mobile-android-build.test.ts        | 15 +++
 dev/local/mobile-android-build.ts             | 16 +++-
 dev/local/mobile-ios-build.test.ts            | 16 ++++
 dev/local/mobile-ios-build.ts                 | 22 ++++-
 dev/local/mobile-native-build.test.ts         | 35 ++++++-
 dev/local/mobile-native-build.ts              | 41 ++++++++
 dev/local/services.test.ts                    | 84 ++++++++++++++++
 dev/local/services.ts                         | 71 +++++++++++++-
 24 files changed, 573 insertions(+), 121 deletions(-)
 delete mode 100644 .kilo_workflow/learnings/maestro-concurrent-sessions-same-device.md
 delete mode 100644 .kilo_workflow/learnings/mobile-github-stub-missing-files-endpoint.md
 delete mode 100644 .kilo_workflow/learnings/mobile-native-build-cache-ignores-root-patches.md
 delete mode 100644 .kilo_workflow/learnings/mobile-otp-outbox-race-parallel-phases.md
 delete mode 100644 .kilo_workflow/learnings/vitest-mobile-project-includes-skip-new-tests.md
 create mode 100755 apps/mobile/e2e/maestro.sh
 create mode 100644 apps/mobile/src/lib/vitest-project-coverage.test.ts

diff --git a/.gitignore b/.gitignore
index 5ed20b41ae..cd5d47235a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -135,3 +135,4 @@ run-milvus-test.sh
 !.env.*.example
 !.env.test
 !.envrc
+.playwright-mcp
diff --git a/.kilo/agent/e2e-verifier.md b/.kilo/agent/e2e-verifier.md
index 0ac17aa788..b162778ba1 100644
--- a/.kilo/agent/e2e-verifier.md
+++ b/.kilo/agent/e2e-verifier.md
@@ -21,7 +21,7 @@ The handoff defines your priority order, minimum complete outcome, optional work
 Before testing:
 
 1. Read the learnings — the worktree's `.kilo_workflow/learnings/` plus the main checkout's `~/Projects/cloud/.kilo_workflow/learnings/system/` — then the surface-specific runbook, and follow it exactly for services, device claiming, builds, login, automation drivers, prompts, and cleanup — mobile: `apps/mobile/e2e/AGENTS.md`; extension: `apps/extension/AGENTS.md`; web and services: `DEVELOPMENT.md` and the repository dev runner. Never bypass a helper script's preflight, install unvalidated builds, or guess selectors.
-2. Translate the plan's goals and acceptance criteria into observable flows; for user-facing features, cover the happy, retryable-unhappy, non-retryable-unhappy, and empty states.
+2. Translate the plan's goals and acceptance criteria into observable flows; for user-facing features, cover the happy, retryable-unhappy, non-retryable-unhappy, and empty states. Batch aggressively: one booted device, one running stack, and one logged-in app session can verify MANY criteria — plan a route through the app that covers every reachable criterion in sequence and only relaunch, re-login, or reboot when a criterion genuinely requires fresh state. Separate runs per scenario burn device time and slot hours for nothing.
 3. Record pre-existing services, listeners, devices, and tmux sessions so cleanup removes only resources you created. Never use a device claimed by another worktree.
 4. Immediately before starting a stack, booting a simulator or emulator, or running a native build — and only then, never while you are still reading or planning — acquire the machine device slot: `.kilo_workflow/e2e-slot.sh acquire` (no argument — it resolves your own tmux session and refuses to run outside one; if it refuses, stop and report a test-environment blocker rather than passing a guessed name). This is mandatory on every run — the machine is shared and unslotted device work overloads it. The command blocks until a slot frees; blocking is correct behavior, never a wedge to work around, and never a reason to proceed unslotted.
 5. Before any temporary edit, record the baseline: `.kilo_workflow/baseline.sh snapshot <worktree> $SCRATCH/baseline` (one per in-scope worktree, always outside every repository). Separately copy the original bytes and mode of every tracked file you plan to edit — the snapshot proves divergence; your copies are what restore it. Temporary edits may touch only paths that are clean and tracked at baseline, or brand-new paths — never a pre-existing modified, staged, or untracked path.
diff --git a/.kilo_workflow/e2e-slot.sh b/.kilo_workflow/e2e-slot.sh
index 125a936e69..25656d5363 100755
--- a/.kilo_workflow/e2e-slot.sh
+++ b/.kilo_workflow/e2e-slot.sh
@@ -95,9 +95,7 @@ release_worktree_resources() {
   echo "releasing simulators claimed by $wt"
   (cd "$wt" && pnpm dev:mobile:simulator release-all) || rc=1
   # Android claims are per-serial files; drop this worktree's so dead sections
-  # never wedge a serial. The claim records no boot provenance, so the emulator
-  # process itself is left alone — powering off a device we may not have booted
-  # is worse than leaking one (known gap until Android claims record it).
+  # never wedge a serial.
   for c in "${TMPDIR:-/tmp}/kilo-mobile-android-claims"/*.json; do
     [ -f "$c" ] || continue
     grep -qF "\"worktreeRoot\":\"$wt\"" "$c" 2>/dev/null || continue
@@ -105,6 +103,15 @@ release_worktree_resources() {
     echo "releasing android claim $serial held by $wt"
     (cd "$wt" && pnpm dev:mobile:android release "$serial") || rc=1
   done
+  # The runbook launches every emulator inside this worktree's dedicated tmux
+  # session — the session name IS the boot provenance, so killing it powers
+  # off exactly the emulators this worktree started and never a foreign one.
+  local android_sess
+  android_sess="kilo-e2e-android-$(basename "$wt")"
+  if tmux has-session -t "$android_sess" 2>/dev/null; then
+    echo "killing emulator session $android_sess"
+    tmux kill-session -t "$android_sess" || rc=1
+  fi
   return "$rc"
 }
 
diff --git a/.kilo_workflow/learnings/maestro-concurrent-sessions-same-device.md b/.kilo_workflow/learnings/maestro-concurrent-sessions-same-device.md
deleted file mode 100644
index da2f739a9e..0000000000
--- a/.kilo_workflow/learnings/maestro-concurrent-sessions-same-device.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# concurrent Maestro sessions against the same device break flows
-
-Symptom: a Maestro flow fails mid-run with element-not-found or a hierarchy that belongs to the
-other flow's screen, while a second `maestro test` targets the same device UDID (observed
-2026-07-29 on login-ui-d051: a `logout.sh` run failed while another Maestro session against the
-same simulator was active; the failure was self-inflicted, not a product defect).
-
-Cause: Maestro's per-device driver (XCUITest on iOS, uiautomator on Android) is single-tenant.
-Two concurrent sessions fight over the same accessibility connection; taps and captures
-interleave.
-
-Fix: never overlap two `maestro` processes against one device. Before starting a run, check
-`ps aux | grep "maestro.*--device"` for the same UDID. If a flow fails inexplicably, first rule
-out your own concurrent session before classifying anything as a product defect.
diff --git a/.kilo_workflow/learnings/mobile-github-stub-missing-files-endpoint.md b/.kilo_workflow/learnings/mobile-github-stub-missing-files-endpoint.md
deleted file mode 100644
index 86e10d9cce..0000000000
--- a/.kilo_workflow/learnings/mobile-github-stub-missing-files-endpoint.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# mobile: hermetic GitHub stub lacks GET /pulls/{n}/files — Files-tab E2E 404s
-
-Symptom: PR-review Files tab shows "Pull request unavailable" while Overview loads fine; nextjs logs `githubPrReview.listFiles 404`; the stub request log shows every pinned endpoint hit except `/files`.
-
-Cause: the stub's pinned surface (REST pull/repo/check-runs/statuses + GraphQL review ops) does not cover `GET /repos/{owner}/{repo}/pulls/{n}/files`, which `listFiles` needs.
-
-Fix (one-off workaround): temporarily add a `/files` handler returning patched-file fixtures to `apps/mobile/e2e/github-api-stub/server.mjs`, restart the stub tmux session, verify, then restore `server.mjs` byte-identical. The permanent fix (teach the stub `/files` + pagination) is intentionally out of scope; do it as a dedicated harness change when a run needs Files-tab E2E regularly.
diff --git a/.kilo_workflow/learnings/mobile-native-build-cache-ignores-root-patches.md b/.kilo_workflow/learnings/mobile-native-build-cache-ignores-root-patches.md
deleted file mode 100644
index ff7082f252..0000000000
--- a/.kilo_workflow/learnings/mobile-native-build-cache-ignores-root-patches.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# mobile-native-build-cache-ignores-root-patches
-
-Symptom: after applying a root-level `patches/` or `pnpm-workspace.yaml` change
-(e.g. a `react-native` Hermes pin), `pnpm dev:mobile:android build` /
-`pnpm dev:mobile:ios build` still installs a binary that behaves as if the
-patch were absent. Easy to conclude "the patch had no effect."
-
-Cause: the Android and iOS native build wrappers key on an `@expo/fingerprint`
-hash computed over `apps/mobile` (plus toolchain) only. Root `patches/`,
-`pnpm-workspace.yaml`, and `pnpm-lock.yaml` are outside that root, so the
-fingerprint is unchanged and a warm
-`~/Library/Caches/Kilo/mobile-android-builds` /
-`…/mobile-ios-builds` entry is reused.
-
-Fix: force a rebuild by deleting `entries/<key>` for the `key` printed by
-`pnpm dev:mobile:android fingerprint` (or `pnpm dev:mobile:ios fingerprint`).
-Parse with `pnpm --silent … fingerprint` and slice JSON from the first `{`.
-Never conclude a root patch was a no-op from a cached binary. EAS and CI build
-from a clean checkout and are unaffected.
diff --git a/.kilo_workflow/learnings/mobile-otp-outbox-race-parallel-phases.md b/.kilo_workflow/learnings/mobile-otp-outbox-race-parallel-phases.md
deleted file mode 100644
index 2a7067bd5d..0000000000
--- a/.kilo_workflow/learnings/mobile-otp-outbox-race-parallel-phases.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# mobile: parallel device phases on one worktree email race the OTP outbox (latest code wins)
-
-Symptom (login-ui-d051 e2, 2026-07-29): an Android OTP Verify tap reached the backend but got
-`POST /api/auth/native/token 401` with the correct-looking 6-digit code. Cause: an iOS Maestro
-loop running CONCURRENTLY on the same worktree signed in with the same default email
-(`e2e-mobile-<worktree>@example.com`); its newer `POST /api/auth/native/otp` invalidated the
-Android device's outstanding code before the Verify tap. The 401 is correct product behavior
-for a stale code, not a tap failure.
-
-Fix: when two device phases share one worktree email, either (a) finish every OTP verify before
-the next request-code on ANY device, (b) read the outbox code immediately before typing it and
-confirm the newest outbox file's timestamp postdates your device's request, or (c) pass an
-explicit different email to one phase (`login.sh <device> <email>`). Evidence the tap landed:
-the 401 line in `pnpm dev:capture nextjs` — a covered/no-op tap produces NO request line.
diff --git a/.kilo_workflow/learnings/vitest-mobile-project-includes-skip-new-tests.md b/.kilo_workflow/learnings/vitest-mobile-project-includes-skip-new-tests.md
deleted file mode 100644
index e4e20b1d75..0000000000
--- a/.kilo_workflow/learnings/vitest-mobile-project-includes-skip-new-tests.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# New apps/mobile test file passes CI without ever running — check the vitest project includes
-
-Symptom: a newly added `apps/mobile` test file passes CI without ever executing; `pnpm test` reports no new suite and the suite count does not grow. Green is not proof the file ran.
-
-Cause: `apps/mobile/vitest.config.ts` composes two projects with **enumerated** include globs. `vitest.pure.config.ts` lists specific directories (`src/lib/*.test.ts`, `src/components/**/*.test.ts`, `src/components/pr-review/**/*.test.tsx`, …) and `vitest.mounted.config.ts` matches only `src/**/*.mounted.test.tsx`. A path outside every listed glob — for example a `.test.tsx` under `src/components/<anything-but-pr-review>/` — matches no project and is silently skipped, with no warning.
-
-Fix: before adding a mobile test in a new directory, check both config files and add the narrowest matching include (e.g. `src/components/kiloclaw/**/*.test.tsx` — not `src/components/**/*.test.tsx`, which would double-own `*.mounted.test.tsx` files with the mounted project). Confirm the suite count actually grew in the `pnpm test` output.
diff --git a/apps/mobile/e2e/AGENTS.md b/apps/mobile/e2e/AGENTS.md
index 042abce036..fb1dbae563 100644
--- a/apps/mobile/e2e/AGENTS.md
+++ b/apps/mobile/e2e/AGENTS.md
@@ -84,7 +84,7 @@ pnpm dev:capture mobile
 PR-review E2E needs a local GitHub API instead of `api.github.com`. Three steps, all reversible:
 
 1. Set `GITHUB_API_BASE_URL` in the **worktree root** `.env.local` to the stub's base URL (for example `http://127.0.0.1:<port>`). Next.js reads it via `apps/web/src/lib/github-pr-review/client.ts` (the web `dev` script symlinks root `.env.local` into `apps/web/` when that file is missing). Remove the variable after the run.
-2. Seed a GitHub user token with the dev-only tRPC mutation `githubApps.devSeedUserGithubToken`. Any non-empty token string works. Use the stable fake `githubUserId` `999001` so the upsert matches across worktrees; a `false` upsert result means a sibling already seeded it, not failure.
+2. Seed a GitHub user token with the dev-only tRPC mutation `githubApps.devSeedUserGithubToken`. Any non-empty token string works. Use a FRESH random `githubUserId` (e.g. `9$(date +%s | tail -c 6)` — the stub never validates it): all worktrees share one postgres, `github_user_id` is unique, and the upsert's conflict target is `(kilo_user_id, github_app_type)`, so reusing a sibling's id errors with a raw drizzle duplicate-key insert instead of returning `false` (see `.kilo_workflow/learnings/mobile-pr-review-entry-github-seed.md`).
 3. Start the stub in a `kilo-e2e-*` tmux session, for example:
    `tmux new-session -d -s "kilo-e2e-github-stub-$(basename "$PWD")" -c "$PWD/apps/mobile/e2e/github-api-stub" "node server.mjs <port>"`.
    Stop that session when finished. Request logs go to `GITHUB_STUB_LOG` or `./github-api-stub-requests.log` under the process cwd — keep them out of the tree (temp dir) and delete them after the run.
@@ -176,10 +176,10 @@ One-time machine setup: `brew install maestro`. For MCP, use stdio command `maes
 - Never guess a selector from a visible label or screenshot. Copy the exact `txt` or `a11y` value from `maestro_inspect_screen` (`a11y` maps to Maestro `text:`). Maestro text matching is full-string regex, not substring.
 - Tab buttons expose React Navigation's full accessibility labels, not the visible uppercase text. Current iOS labels: `Home, tab, 1 of 4`, `KiloClaw, tab, 2 of 4`, `Agents, tab, 3 of 4`, `Profile, tab, 4 of 4`. `tapOn: 'Agents'` is wrong. Inspect again before relying on these examples; the count and labels can change.
 
-CLI fallback:
+CLI fallback — always through `e2e/maestro.sh`, which serializes per device (Maestro's per-device driver is single-tenant; two concurrent sessions against one UDID interleave taps and fail flows in ways that read as product defects):
 
 ```bash
-maestro --device <udid|emulator-5554> test -e KEY=VALUE <flow.yaml>
+apps/mobile/e2e/maestro.sh <udid|emulator-5554> test -e KEY=VALUE <flow.yaml>
 xcrun simctl io <udid> screenshot <path>      # iOS
 adb exec-out screencap -p > <path>            # Android
 ```
@@ -309,14 +309,12 @@ pnpm dev:mobile:android adb -s <serial> shell input keyevent KEYCODE_BACK
 Clean up only resources you started. The remote CLI session and its disposable install belong to the orchestrator; never kill `kilo-e2e-cli-*` sessions or remove CLI scratch directories you did not create.
 
 ```bash
-tmux kill-session -t "$ANDROID_SESSION"      # if created
 rm -f "$LOGIN_LOG"                           # if created
 rm -f "$EMULATOR_LOG"                        # if created
-pnpm dev:mobile:android release <serial>     # every Android device you claimed
 .kilo_workflow/e2e-slot.sh release           # always, as soon as the device phase ends
 ```
 
-The slot release is the teardown. It stops this worktree's dev stack and releases every simulator this worktree claimed — powering off the ones your claims booted, restoring their names, and leaving a device that was already running before your claim alone. So there is no `pnpm dev:stop`, no `xcrun simctl shutdown`, and no `pnpm dev:mobile:simulator release <udid>` on this list: releasing the slot does all three, and forgetting one is how simulators used to stay booted all day. Never call `xcrun simctl shutdown` on an E2E device yourself — the claim, not your memory of what you booted, is what knows whether the device is yours to power off.
+The slot release is the teardown. It stops this worktree's dev stack, releases every simulator this worktree claimed (powering off the ones the claims booted, restoring their names, leaving a device that was already running before the claim alone), drops this worktree's Android claims, and kills this worktree's `kilo-e2e-android-*` emulator session. So there is no `pnpm dev:stop`, no `xcrun simctl shutdown`, no per-device `release`, and no emulator-session kill on this list: releasing the slot does all of it, and forgetting one is how devices used to stay running all day. Never call `xcrun simctl shutdown` on an E2E device yourself — the claim, not your memory of what you booted, is what knows whether the device is yours to power off.
 
 Also stop recorders, log followers, and emulator processes you created. Never use `tmux kill-server`, kill an unrelated `kilo-dev-*` session, or use `pnpm dev:stop --force` while sibling worktrees are active.
 
diff --git a/apps/mobile/e2e/github-api-stub/server.mjs b/apps/mobile/e2e/github-api-stub/server.mjs
index d20907f4ca..b1e2812856 100644
--- a/apps/mobile/e2e/github-api-stub/server.mjs
+++ b/apps/mobile/e2e/github-api-stub/server.mjs
@@ -58,11 +58,42 @@ const conversationComment = (databaseId, login, body, minutes) => ({
   reactionGroups: reactionGroups(),
 });
 
+/** REST pull-request file entry (GET /repos/{owner}/{repo}/pulls/{n}/files shape). */
+const prFile = (filename, additions, deletions, patch) => ({
+  sha: 'cccccccccccccccccccccccccccccccccccccccc',
+  filename,
+  status: 'modified',
+  additions,
+  deletions,
+  changes: additions + deletions,
+  blob_url: `https://github.com/kilo-stub/blob/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/${filename}`,
+  raw_url: `https://github.com/kilo-stub/raw/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/${filename}`,
+  contents_url: `https://api.github.com/repos/kilo-stub/contents/${filename}?ref=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`,
+  patch,
+});
+
+// Two files per fixture, matching restPull's changed_files: 2 / additions: 10 / deletions: 2.
+const stubFiles = () => [
+  prFile(
+    'src/alpha.ts',
+    6,
+    1,
+    '@@ -8,4 +8,9 @@ export function alpha() {\n-  return 1;\n+  // stub change\n+  return 2;\n+}\n+\n+export function alphaExtra() {\n+  return 3;\n }'
+  ),
+  prFile(
+    'src/beta.ts',
+    4,
+    1,
+    '@@ -18,3 +18,6 @@ export function beta() {\n-  return 1;\n+  return 2;\n+}\n+\n+export function betaExtra() {\n+  return 3;\n }'
+  ),
+];
+
 /** @type {Record<string, object>} */
 const FIXTURES = {
   'kilo-stub/discussion-mixed/1': {
     title: 'Mixed discussion fixture',
     body: 'PR body for mixed fixture.',
+    files: stubFiles(),
     threads: [
       {
         id: 'PRRT_thread_a',
@@ -134,6 +165,7 @@ const FIXTURES = {
   'kilo-stub/discussion-conversation-only/2': {
     title: 'Conversation-only fixture',
     body: 'PR body for conversation-only fixture.',
+    files: stubFiles(),
     threads: [],
     conversationComments: [
       conversationComment(3001, 'dave', 'Only conversation comment one', 2),
@@ -143,6 +175,7 @@ const FIXTURES = {
   'kilo-stub/discussion-empty/3': {
     title: 'Empty discussion fixture',
     body: 'PR body for empty fixture.',
+    files: stubFiles(),
     threads: [],
     conversationComments: [],
   },
@@ -384,8 +417,20 @@ const server = http.createServer(async (req, res) => {
       return handleGraphql(body, res);
     }
 
+    // GET /repos/{owner}/{repo}/pulls/{number}/files
+    let m = pathname.match(/^\/repos\/([^/]+)\/([^/]+)\/pulls\/(\d+)\/files$/);
+    if (method === 'GET' && m) {
+      const [, owner, repo, number] = m;
+      const perPage = Math.max(1, Number(url.searchParams.get('per_page')) || 30);
+      const page = Math.max(1, Number(url.searchParams.get('page')) || 1);
+      logLine({ method, path: pathname, owner, repo, number, page, per_page: perPage });
+      const fx = getFixture(owner, repo, number);
+      if (!fx) return json(res, 404, { message: 'Not Found' });
+      return json(res, 200, fx.files.slice((page - 1) * perPage, page * perPage));
+    }
+
     // GET /repos/{owner}/{repo}/pulls/{number}
-    let m = pathname.match(/^\/repos\/([^/]+)\/([^/]+)\/pulls\/(\d+)$/);
+    m = pathname.match(/^\/repos\/([^/]+)\/([^/]+)\/pulls\/(\d+)$/);
     if (method === 'GET' && m) {
       const [, owner, repo, number] = m;
       logLine({ method, path: pathname, owner, repo, number });
diff --git a/apps/mobile/e2e/login.sh b/apps/mobile/e2e/login.sh
index 5db5c68060..5c0dd0f536 100755
--- a/apps/mobile/e2e/login.sh
+++ b/apps/mobile/e2e/login.sh
@@ -45,6 +45,26 @@ latest_email() {
   return 0
 }
 
+# Two parallel logins with the same email invalidate each other's OTP: a
+# second code request voids the first code, so the first verify 401s. Hold a
+# per-worktree+email mutex from the outbox snapshot through code verification
+# (device prep above stays parallel). Same mkdir-lock pattern as maestro.sh;
+# a dead holder's lock is reclaimed, a live one is polled every 2s.
+LOCK="${TMPDIR:-/tmp}/kilo-otp-locks/${WORKTREE_SLUG}-${EMAIL}"
+mkdir -p "$(dirname "$LOCK")"
+while ! mkdir "$LOCK" 2>/dev/null; do
+  holder="$(cat "$LOCK/pid" 2>/dev/null || true)"
+  if [ -n "$holder" ] && ! kill -0 "$holder" 2>/dev/null; then
+    mv "$LOCK" "$LOCK.stale.$$" 2>/dev/null && rm -rf "$LOCK.stale.$$"
+    continue
+  fi
+  sleep 2
+done
+trap 'rm -rf "$LOCK"' EXIT
+echo $$ >"$LOCK/pid"
+
+# Snapshot inside the lock: an email another login produced while we waited
+# must count as "old", or we would read its already-consumed code.
 before="$(latest_email)"
 
 request_code() {
diff --git a/apps/mobile/e2e/maestro.sh b/apps/mobile/e2e/maestro.sh
new file mode 100755
index 0000000000..dc37d99786
--- /dev/null
+++ b/apps/mobile/e2e/maestro.sh
@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# Serializes Maestro invocations per device. Maestro's device driver
+# (XCUITest on iOS, uiautomator on Android) is single-tenant: two concurrent
+# `maestro test`/`maestro hierarchy` processes against the same UDID/serial
+# interleave taps and captures, and flows fail in ways that look like product
+# defects. This wrapper takes a per-device mutex, then execs maestro.
+#
+# Usage: maestro.sh <device> <maestro-args...>
+#   e.g. maestro.sh <udid> test -e EMAIL=x flows/login-request-code.yaml
+#
+# Lock: atomic mkdir under ${TMPDIR:-/tmp}/kilo-maestro-locks/<device>, holder
+# PID recorded inside. exec preserves our PID, so the recorded PID is the live
+# maestro process; when it exits, the next waiter reclaims via the dead-PID
+# check. A held lock with a live holder is polled every 2s.
+set -euo pipefail
+
+DEVICE="${1:?usage: maestro.sh <device> <maestro-args...>}"
+shift
+
+LOCK="${TMPDIR:-/tmp}/kilo-maestro-locks/$DEVICE"
+mkdir -p "$(dirname "$LOCK")"
+
+while ! mkdir "$LOCK" 2>/dev/null; do
+  holder="$(cat "$LOCK/pid" 2>/dev/null || true)"
+  if [ -n "$holder" ] && ! kill -0 "$holder" 2>/dev/null; then
+    # Holder is dead: reclaim. mv is atomic, so two reclaimers cannot delete
+    # a lock a third process just acquired.
+    mv "$LOCK" "$LOCK.stale.$$" 2>/dev/null && rm -rf "$LOCK.stale.$$"
+    continue
+  fi
+  sleep 2
+done
+trap 'rm -rf "$LOCK"' EXIT
+echo $$ >"$LOCK/pid"
+
+# exec replaces this shell (dropping the trap) but keeps the PID, so the lock
+# is held for exactly maestro's lifetime and reclaimed by the next waiter.
+exec maestro --device "$DEVICE" "$@"
diff --git a/apps/mobile/src/lib/vitest-project-coverage.test.ts b/apps/mobile/src/lib/vitest-project-coverage.test.ts
new file mode 100644
index 0000000000..bb3023b571
--- /dev/null
+++ b/apps/mobile/src/lib/vitest-project-coverage.test.ts
@@ -0,0 +1,50 @@
+// eslint-disable-next-line import/no-nodejs-modules -- vitest-only guard, runs in node, never bundled into the app
+import { globSync } from 'node:fs';
+// eslint-disable-next-line import/no-nodejs-modules -- vitest-only guard, runs in node, never bundled into the app
+import { fileURLToPath } from 'node:url';
+
+import { describe, expect, it } from 'vitest';
+
+import mountedConfig from '../../vitest.mounted.config';
+import pureConfig from '../../vitest.pure.config';
+
+// The root vitest config composes two projects with enumerated include globs.
+// A test file matching neither glob is silently never executed. This guard
+// evaluates the real include arrays from both configs against every
+// test-looking file under src/ and fails on orphans or double-matches.
+
+const appRoot = fileURLToPath(new URL('../..', import.meta.url));
+
+function matches(include: string[]): Set<string> {
+  return new Set(globSync(include, { cwd: appRoot }));
+}
+
+describe('vitest project coverage', () => {
+  const allTestFiles = matches(['src/**/*.test.ts', 'src/**/*.test.tsx']);
+  const pure = matches(pureConfig.test?.include ?? []);
+  const mounted = matches(mountedConfig.test?.include ?? []);
+
+  it('sees the existing suites (glob cwd sanity)', () => {
+    expect(allTestFiles.size).toBeGreaterThan(100);
+    expect(pure.size).toBeGreaterThan(0);
+    expect(mounted.size).toBeGreaterThan(0);
+  });
+
+  it('every test file is matched by a vitest project', () => {
+    const orphans = [...allTestFiles]
+      .filter(file => !pure.has(file) && !mounted.has(file))
+      .toSorted();
+    expect(
+      orphans,
+      `Test files matched by no vitest project include — they never run.\nAdd their directory to vitest.pure.config.ts (or name them *.mounted.test.tsx):\n${orphans.join('\n')}`
+    ).toEqual([]);
+  });
+
+  it('no test file is matched by both projects', () => {
+    const both = [...pure].filter(file => mounted.has(file)).toSorted();
+    expect(
+      both,
+      `Test files matched by BOTH vitest projects — they would run twice:\n${both.join('\n')}`
+    ).toEqual([]);
+  });
+});
diff --git a/dev/local/cli.ts b/dev/local/cli.ts
index 70b5e6ce05..eac1d30e40 100644
--- a/dev/local/cli.ts
+++ b/dev/local/cli.ts
@@ -10,6 +10,7 @@ import {
   resolveGroups,
   topologicalSort,
   portOffset,
+  findFreePortOffset,
   resolveSessionNextAuthUrl,
   services,
 } from './services';
@@ -57,6 +58,29 @@ import {
 
 const sleep = (ms: number) => new Promise<void>(r => setTimeout(r, ms));
 
+// Scan the resolved services' full computed port set for occupants. The
+// shared kiloclaw-docker-tcp bridge on 23750 is reused (not a conflict) when
+// the listener really is the Docker API.
+async function findPortConflicts(serviceNames: string[]): Promise<{
+  conflicts: string[];
+  reusedHostServices: Set<string>;
+}> {
+  const conflicts: string[] = [];
+  const reusedHostServices = new Set<string>();
+  for (const name of serviceNames) {
+    const service = getService(name);
+    if (service.type === 'infra' || service.port <= 0 || !(await probePort(service.port))) {
+      continue;
+    }
+    if (name === 'kiloclaw-docker-tcp' && (await probeDockerApi(service.port))) {
+      reusedHostServices.add(name);
+    } else {
+      conflicts.push(`${name}:${service.port}`);
+    }
+  }
+  return { conflicts, reusedHostServices };
+}
+
 function determineEnabledGroups(serviceNames: string[]): string[] {
   const nameSet = new Set(serviceNames);
   const enabled: string[] = [];
@@ -112,6 +136,48 @@ async function cmdUp(args: string[], repoRoot: string): Promise<void> {
     console.warn('  To sync from Vercel: vercel env pull .env.local');
   }
 
+  // --- Resolve targets ---
+  // Always start core (always-on) groups; additional targets are merged in
+  const coreServices = resolveGroups(getAlwaysOnGroupIds());
+  const extraServices = targets.length === 0 ? [] : resolveTargets(targets);
+  let serviceNames = topologicalSort([...new Set([...coreServices, ...extraServices])]);
+
+  const sessionName = getSessionName();
+  const sessionAlreadyRunning = sessionExists(sessionName);
+
+  // --- Pick a free port offset before anything derives URLs from ports ---
+  // An explicit KILO_PORT_OFFSET is honored as-is. Otherwise, when the
+  // hash/persisted offset's ports are held by a foreign occupant (another
+  // worktree's stack, macOS AirPlay on 5000/7000), probe +100 candidate
+  // offsets and take the first whose full computed port set is free. Never
+  // silently share. The chosen offset is persisted in the manifest at the end
+  // of startup so later port-computing commands agree without an env prefix.
+  const offsetIsExplicit =
+    process.env.KILO_PORT_OFFSET !== undefined && process.env.KILO_PORT_OFFSET !== 'auto';
+  let reusedHostServices = new Set<string>();
+  if (!sessionAlreadyRunning) {
+    let scan = await findPortConflicts(serviceNames);
+    if (scan.conflicts.length > 0 && !offsetIsExplicit) {
+      console.warn(
+        `⚠ Ports at offset ${portOffset} are occupied (${scan.conflicts.join(', ')}) — probing for a free offset…`
+      );
+      const freeOffset = await findFreePortOffset(
+        async () => (await findPortConflicts(serviceNames)).conflicts.length > 0
+      );
+      if (freeOffset !== undefined) {
+        console.log(`${DIM}Auto-selected port offset ${freeOffset}${RESET}`);
+        scan = await findPortConflicts(serviceNames);
+      }
+    }
+    if (scan.conflicts.length > 0) {
+      throw new Error(
+        `Refusing to share occupied worktree service ports: ${scan.conflicts.join(', ')}. ` +
+          'Stop the owning worktree or set a distinct KILO_PORT_OFFSET.'
+      );
+    }
+    reusedHostServices = scan.reusedHostServices;
+  }
+
   // --- Export port offset for child processes (e.g. scripts/dev.sh) ---
   process.env.KILO_PORT_OFFSET = String(portOffset);
 
@@ -131,12 +197,6 @@ async function cmdUp(args: string[], repoRoot: string): Promise<void> {
     console.log(`${DIM}Port offset: ${portOffset} (KILO_PORT_OFFSET)${RESET}`);
   }
 
-  // --- Resolve targets ---
-  // Always start core (always-on) groups; additional targets are merged in
-  const coreServices = resolveGroups(getAlwaysOnGroupIds());
-  const extraServices = targets.length === 0 ? [] : resolveTargets(targets);
-  let serviceNames = topologicalSort([...new Set([...coreServices, ...extraServices])]);
-
   const mobileEnv: Record<string, string> = {};
   if (serviceNames.includes('mobile')) {
     const host = process.env.MOBILE_DEV_HOST || detectLanIp();
@@ -152,8 +212,7 @@ async function cmdUp(args: string[], repoRoot: string): Promise<void> {
   }
 
   // --- Check for existing session ---
-  const sessionName = getSessionName();
-  if (sessionExists(sessionName)) {
+  if (sessionAlreadyRunning) {
     for (const name of serviceNames) {
       const service = getService(name);
       if (service.type !== 'worker' || !findServicePane(sessionName, name)) continue;
@@ -184,26 +243,6 @@ async function cmdUp(args: string[], repoRoot: string): Promise<void> {
     return;
   }
 
-  const conflictingPorts: string[] = [];
-  const reusedHostServices = new Set<string>();
-  for (const name of serviceNames) {
-    const service = getService(name);
-    if (service.type !== 'infra' && service.port > 0 && (await probePort(service.port))) {
-      if (name === 'kiloclaw-docker-tcp') {
-        if (await probeDockerApi(service.port)) reusedHostServices.add(name);
-        else conflictingPorts.push(`${name}:${service.port}`);
-      } else {
-        conflictingPorts.push(`${name}:${service.port}`);
-      }
-    }
-  }
-  if (conflictingPorts.length > 0) {
-    throw new Error(
-      `Refusing to share occupied worktree service ports: ${conflictingPorts.join(', ')}. ` +
-        'Stop the owning worktree or set a distinct KILO_PORT_OFFSET.'
-    );
-  }
-
   // --- Check for socat when kiloclaw-docker-tcp is requested ---
   if (serviceNames.includes('kiloclaw-docker-tcp')) {
     try {
diff --git a/dev/local/docker-api-probe.test.ts b/dev/local/docker-api-probe.test.ts
index 2dbc67d5f3..1f37087152 100644
--- a/dev/local/docker-api-probe.test.ts
+++ b/dev/local/docker-api-probe.test.ts
@@ -33,6 +33,25 @@ test('does not identify an arbitrary TCP listener as the Docker API proxy', asyn
   }
 });
 
+test('retries a timed-out probe and reuses a Docker API that answers on the second attempt', async () => {
+  let requests = 0;
+  const server = http.createServer((request, response) => {
+    requests++;
+    if (requests === 1) return; // hold the first response past the probe timeout
+    assert.equal(request.url, '/_ping');
+    response.setHeader('Api-Version', '1.48');
+    response.end('OK');
+  });
+  const port = await listen(server);
+
+  try {
+    assert.equal(await probeDockerApi(port, 200), true);
+    assert.equal(requests, 2);
+  } finally {
+    await close(server);
+  }
+});
+
 test('identifies a ready Docker API listener by its ping response', async () => {
   const server = http.createServer((request, response) => {
     assert.equal(request.url, '/_ping');
diff --git a/dev/local/docker-api-probe.ts b/dev/local/docker-api-probe.ts
index 7101a67747..a2f25a894b 100644
--- a/dev/local/docker-api-probe.ts
+++ b/dev/local/docker-api-probe.ts
@@ -1,14 +1,28 @@
-export async function probeDockerApi(port: number, timeoutMs = 500): Promise<boolean> {
-  try {
-    const response = await fetch(`http://127.0.0.1:${port}/_ping`, {
-      signal: AbortSignal.timeout(timeoutMs),
-    });
-    return (
-      response.status === 200 &&
-      response.headers.has('api-version') &&
-      (await response.text()).trim() === 'OK'
-    );
-  } catch {
-    return false;
+const sleep = (ms: number) => new Promise<void>(resolve => setTimeout(resolve, ms));
+
+// A momentarily slow Docker daemon can miss a single probe window, which made
+// dev:start refuse the shared docker-tcp bridge as a foreign port. Retry
+// timeouts and connection errors before concluding the listener is not the
+// Docker API; a definitive HTTP response with the wrong content is not
+// retried — that listener is genuinely foreign.
+export async function probeDockerApi(
+  port: number,
+  timeoutMs = 500,
+  attempts = 3
+): Promise<boolean> {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/_ping`, {
+        signal: AbortSignal.timeout(timeoutMs),
+      });
+      return (
+        response.status === 200 &&
+        response.headers.has('api-version') &&
+        (await response.text()).trim() === 'OK'
+      );
+    } catch {
+      if (attempt >= attempts) return false;
+      await sleep(250);
+    }
   }
 }
diff --git a/dev/local/mobile-android-build.test.ts b/dev/local/mobile-android-build.test.ts
index a35a274a70..e3ac17e227 100644
--- a/dev/local/mobile-android-build.test.ts
+++ b/dev/local/mobile-android-build.test.ts
@@ -14,6 +14,7 @@ import {
   validateAndroidBuildClaim,
   type AndroidBuildDeps,
 } from './mobile-android-build';
+import { hashRootNativeInputs } from './mobile-native-build';
 
 const PACKAGE_ID = 'com.kilocode.kiloapp';
 
@@ -75,6 +76,20 @@ test('Android fingerprint skips only Expo extra beyond defaults', () => {
   assert.deepEqual(options.platforms, ['android']);
   assert.equal(options.silent, true);
   assert.notEqual(options.sourceSkips, 0);
+  assert.deepEqual(
+    options.extraSources.map(source => ({
+      type: source.type,
+      id: source.id,
+      contents: source.contents,
+    })),
+    [
+      {
+        type: 'contents',
+        id: 'repoRootNativeInputs',
+        contents: hashRootNativeInputs(path.resolve(import.meta.dirname, '..', '..')),
+      },
+    ]
+  );
 });
 
 test('Android compatibility key changes for every native toolchain dimension', () => {
diff --git a/dev/local/mobile-android-build.ts b/dev/local/mobile-android-build.ts
index 3bd5348557..e7bf6391dd 100644
--- a/dev/local/mobile-android-build.ts
+++ b/dev/local/mobile-android-build.ts
@@ -2,7 +2,9 @@ import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { DEFAULT_SOURCE_SKIPS, SourceSkips } from '@expo/fingerprint';
+import { DEFAULT_SOURCE_SKIPS, SourceSkips, type HashSourceContents } from '@expo/fingerprint';
+
+import { hashRootNativeInputs } from './mobile-native-build';
 
 const PACKAGE_ID = 'com.kilocode.kiloapp';
 const BUILD_MODE = 'debug-dev-client';
@@ -41,14 +43,26 @@ export type AndroidBuildDeps = {
   now: () => Date;
 };
 
+// Repo-root inputs that shape the native build but live outside
+// apps/mobile (pnpm patches, pnpm-workspace.yaml, pnpm-lock.yaml) are
+// mixed in as an extra source.
 export function buildAndroidFingerprintOptions(): {
   platforms: ['android'];
   sourceSkips: number;
+  extraSources: HashSourceContents[];
   silent: boolean;
 } {
   return {
     platforms: ['android'],
     sourceSkips: DEFAULT_SOURCE_SKIPS | SourceSkips.ExpoConfigExtraSection,
+    extraSources: [
+      {
+        type: 'contents',
+        id: 'repoRootNativeInputs',
+        contents: hashRootNativeInputs(path.resolve(import.meta.dirname, '..', '..')),
+        reasons: ['repo-root patches/, pnpm-workspace.yaml, and pnpm-lock.yaml'],
+      },
+    ],
     silent: true,
   };
 }
diff --git a/dev/local/mobile-ios-build.test.ts b/dev/local/mobile-ios-build.test.ts
index 2352524413..61901dccc6 100644
--- a/dev/local/mobile-ios-build.test.ts
+++ b/dev/local/mobile-ios-build.test.ts
@@ -4,6 +4,8 @@ import os from 'node:os';
 import path from 'node:path';
 import test from 'node:test';
 
+import { hashRootNativeInputs } from './mobile-native-build';
+
 import {
   buildCompatibilityKey,
   buildFingerprintOptions,
@@ -99,6 +101,20 @@ test('fingerprint options include iOS platform and only skip the Expo extra sect
   assert.equal(options.silent, true);
   // SourceSkips.ExpoConfigExtraSection === 4096
   assert.equal(options.sourceSkips & 4096, 4096);
+  assert.deepEqual(
+    options.extraSources.map(source => ({
+      type: source.type,
+      id: source.id,
+      contents: source.contents,
+    })),
+    [
+      {
+        type: 'contents',
+        id: 'repoRootNativeInputs',
+        contents: hashRootNativeInputs(path.resolve(import.meta.dirname, '..', '..')),
+      },
+    ]
+  );
 });
 
 // ── Compatibility key ────────────────────────────────────────────────
diff --git a/dev/local/mobile-ios-build.ts b/dev/local/mobile-ios-build.ts
index 98f746dc6b..3534d1ada0 100644
--- a/dev/local/mobile-ios-build.ts
+++ b/dev/local/mobile-ios-build.ts
@@ -4,9 +4,14 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
-import { createProjectHashAsync, DEFAULT_SOURCE_SKIPS, SourceSkips } from '@expo/fingerprint';
+import {
+  createProjectHashAsync,
+  DEFAULT_SOURCE_SKIPS,
+  SourceSkips,
+  type HashSourceContents,
+} from '@expo/fingerprint';
 
-import { withNativeBuildSemaphore } from './mobile-native-build';
+import { hashRootNativeInputs, withNativeBuildSemaphore } from './mobile-native-build';
 
 // Compatibility dimensions hashed into the cache key. Any change must
 // invalidate the key so cached artifacts are not reused for an
@@ -138,15 +143,26 @@ export type CliArgs =
 // Build the option bag used to compute the native project hash. Only
 // the Expo `extra` section is skipped beyond the library defaults —
 // versions, schemes, bundle ID, plugins, assets, permissions, and
-// optional native config all remain in the hash.
+// optional native config all remain in the hash. Repo-root inputs that
+// shape the native build but live outside apps/mobile (pnpm patches,
+// pnpm-workspace.yaml, pnpm-lock.yaml) are mixed in as an extra source.
 export function buildFingerprintOptions(): {
   platforms: ['ios'];
   sourceSkips: number;
+  extraSources: HashSourceContents[];
   silent: boolean;
 } {
   return {
     platforms: ['ios'],
     sourceSkips: DEFAULT_SOURCE_SKIPS | SourceSkips.ExpoConfigExtraSection,
+    extraSources: [
+      {
+        type: 'contents',
+        id: 'repoRootNativeInputs',
+        contents: hashRootNativeInputs(path.resolve(import.meta.dirname, '..', '..')),
+        reasons: ['repo-root patches/, pnpm-workspace.yaml, and pnpm-lock.yaml'],
+      },
+    ],
     silent: true,
   };
 }
diff --git a/dev/local/mobile-native-build.test.ts b/dev/local/mobile-native-build.test.ts
index 95606d8a7c..e7fa3b98e4 100644
--- a/dev/local/mobile-native-build.test.ts
+++ b/dev/local/mobile-native-build.test.ts
@@ -4,7 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import test from 'node:test';
 
-import { withNativeBuildSemaphore } from './mobile-native-build';
+import { hashRootNativeInputs, withNativeBuildSemaphore } from './mobile-native-build';
 
 test('serializes native producers across different platform builds', async () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-native-build-'));
@@ -175,6 +175,39 @@ test('publishes owner metadata before exposing the canonical native lock', async
   }
 });
 
+function writeRootNativeInputs(root: string): void {
+  fs.mkdirSync(path.join(root, 'patches'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'pnpm-workspace.yaml'), 'packages:\n  - apps/*\n');
+  fs.writeFileSync(path.join(root, 'pnpm-lock.yaml'), 'lockfileVersion: 9\n');
+  fs.writeFileSync(path.join(root, 'patches', 'react-native.patch'), 'original patch');
+}
+
+test('root native inputs hash is stable when nothing changes', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-root-inputs-'));
+  writeRootNativeInputs(root);
+  assert.equal(hashRootNativeInputs(root), hashRootNativeInputs(root));
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+test('root native inputs hash changes with patch, workspace, and lockfile edits', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-root-inputs-'));
+  writeRootNativeInputs(root);
+  const seen = [hashRootNativeInputs(root)];
+  const mutations: (() => void)[] = [
+    () => fs.writeFileSync(path.join(root, 'patches', 'react-native.patch'), 'edited patch'),
+    () => fs.writeFileSync(path.join(root, 'patches', 'expo-server-sdk.patch'), 'new patch'),
+    () => fs.writeFileSync(path.join(root, 'pnpm-workspace.yaml'), 'packages:\n  - services/*\n'),
+    () => fs.writeFileSync(path.join(root, 'pnpm-lock.yaml'), 'lockfileVersion: 10\n'),
+  ];
+  for (const mutate of mutations) {
+    mutate();
+    const next = hashRootNativeInputs(root);
+    assert.equal(seen.includes(next), false);
+    seen.push(next);
+  }
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
 test('enforces the wait timeout before reclaiming an incomplete lock', async () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-native-build-'));
   fs.writeFileSync(path.join(root, 'native-build.lock'), '{');
diff --git a/dev/local/mobile-native-build.ts b/dev/local/mobile-native-build.ts
index f6d0f9124b..f46b6efcb9 100644
--- a/dev/local/mobile-native-build.ts
+++ b/dev/local/mobile-native-build.ts
@@ -1,4 +1,5 @@
 import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 
@@ -56,6 +57,46 @@ export async function withNativeBuildSemaphore<T>(args: NativeBuildSemaphoreArgs
   }
 }
 
+// Root-level inputs that change the native build but live outside
+// apps/mobile, so @expo/fingerprint never sees them: pnpm patches and
+// the workspace/lockfile that pin dependency resolution. Hashed as
+// sorted relative paths plus contents so the result is deterministic.
+export function hashRootNativeInputs(repoRoot: string): string {
+  const hash = createHash('sha256');
+  const add = (label: string, filePath: string): void => {
+    hash.update(label);
+    hash.update('\0');
+    try {
+      hash.update(fs.readFileSync(filePath));
+    } catch (error) {
+      if (!hasCode(error, 'ENOENT')) throw error;
+      hash.update('<missing>');
+    }
+    hash.update('\0');
+  };
+  add('pnpm-workspace.yaml', path.join(repoRoot, 'pnpm-workspace.yaml'));
+  add('pnpm-lock.yaml', path.join(repoRoot, 'pnpm-lock.yaml'));
+  const patchesRoot = path.join(repoRoot, 'patches');
+  for (const relativePath of listFilesRecursively(patchesRoot)) {
+    add(`patches/${relativePath}`, path.join(patchesRoot, relativePath));
+  }
+  return hash.digest('hex');
+}
+
+function listFilesRecursively(root: string): string[] {
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(root, { recursive: true, withFileTypes: true });
+  } catch (error) {
+    if (hasCode(error, 'ENOENT')) return [];
+    throw error;
+  }
+  return entries
+    .filter(entry => entry.isFile())
+    .map(entry => path.relative(root, path.join(entry.parentPath, entry.name)))
+    .sort();
+}
+
 function acquire(
   lockPath: string,
   processIdentity: (pid: number) => string | undefined
diff --git a/dev/local/services.test.ts b/dev/local/services.test.ts
index a672c2e096..4313c40f18 100644
--- a/dev/local/services.test.ts
+++ b/dev/local/services.test.ts
@@ -1,12 +1,18 @@
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import test from 'node:test';
 
 import {
+  applyPortOffset,
+  candidatePortOffsets,
   computePortOffset,
+  findFreePortOffset,
   getAlwaysOnGroupIds,
   getService,
   portOffset,
+  readPersistedPortOffset,
   resolveGroups,
   resolveSessionNextAuthUrl,
   resolveTargets,
@@ -31,6 +37,84 @@ test('honors an explicit port offset', () => {
   assert.equal(computePortOffset({ explicit: '1200', isPrimary: false, slug: 'anything' }), 1200);
 });
 
+test('prefers the persisted manifest offset over the slug hash', () => {
+  assert.equal(
+    computePortOffset({
+      explicit: undefined,
+      persisted: 700,
+      isPrimary: false,
+      slug: 'mobile-context-info',
+    }),
+    700
+  );
+  // Stability beats reshuffling: a probed offset sticks for the primary too.
+  assert.equal(
+    computePortOffset({ explicit: undefined, persisted: 700, isPrimary: true, slug: 'cloud' }),
+    700
+  );
+});
+
+test('an explicit port offset beats the persisted manifest offset', () => {
+  assert.equal(
+    computePortOffset({ explicit: '1200', persisted: 700, isPrimary: false, slug: 'anything' }),
+    1200
+  );
+});
+
+test('reads the persisted offset back from the running-stack manifest', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-manifest-'));
+  try {
+    const manifestPath = path.join(dir, 'dev', 'logs', 'manifest.json');
+    fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+    fs.writeFileSync(
+      manifestPath,
+      JSON.stringify({ session: 'kilo-dev', portOffset: 700, services: [] })
+    );
+    assert.equal(readPersistedPortOffset(dir), 700);
+
+    fs.writeFileSync(manifestPath, '{"portOffset":"garbage"}');
+    assert.equal(readPersistedPortOffset(dir), undefined);
+
+    assert.equal(readPersistedPortOffset(path.join(dir, 'missing')), undefined);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('candidate offsets step by 100 and wrap within the valid range', () => {
+  const candidates = candidatePortOffsets(4900);
+  assert.equal(candidates[0], 5000);
+  assert.equal(candidates[1], 100);
+  assert.equal(candidates.length, 49);
+  assert.ok(!candidates.includes(4900));
+  assert.ok(!candidates.includes(0));
+});
+
+test('applies the first free candidate offset when ports collide', async () => {
+  const original = portOffset;
+  const candidates = candidatePortOffsets(original);
+  const occupiedOffsets = new Set([original, candidates[0], candidates[1]]);
+  try {
+    const chosen = await findFreePortOffset(async () => occupiedOffsets.has(portOffset));
+    assert.equal(chosen, candidates[2]);
+    assert.equal(portOffset, candidates[2]);
+    const worker = getService('auto-routing');
+    assert.equal(worker.port, 8810 + candidates[2]);
+    assert.ok(worker.command.includes(String(worker.port)));
+  } finally {
+    applyPortOffset(original);
+  }
+});
+
+test('restores the original offset when every candidate is occupied', async () => {
+  const original = portOffset;
+  const originalPort = getService('auto-routing').port;
+  const chosen = await findFreePortOffset(async () => true);
+  assert.equal(chosen, undefined);
+  assert.equal(portOffset, original);
+  assert.equal(getService('auto-routing').port, originalPort);
+});
+
 test('points NEXTAUTH_URL at the offset port when the web app runs without a tunnel', () => {
   const url = resolveSessionNextAuthUrl({
     portOffset: 2900,
diff --git a/dev/local/services.ts b/dev/local/services.ts
index 9630cd7412..b9165aed8f 100644
--- a/dev/local/services.ts
+++ b/dev/local/services.ts
@@ -274,10 +274,11 @@ function isPrimaryWorktree(): boolean {
 
 export function computePortOffset(args: {
   explicit: string | undefined;
+  persisted?: number;
   isPrimary: boolean;
   slug: string;
 }): number {
-  const { explicit, isPrimary, slug } = args;
+  const { explicit, persisted, isPrimary, slug } = args;
   if (explicit !== undefined && explicit !== 'auto') {
     const value = Number(explicit);
     if (!Number.isInteger(value) || value < 0) {
@@ -285,6 +286,11 @@ export function computePortOffset(args: {
     }
     return value;
   }
+  // A previously started stack persisted the offset it actually used; keep it
+  // so every later port-computing command agrees without a KILO_PORT_OFFSET
+  // prefix. Stability beats reshuffling — dev:start re-probes only when these
+  // ports turn out to be foreign-occupied.
+  if (persisted !== undefined) return persisted;
   if (isPrimary) return 0;
   let hash = 0;
   for (let i = 0; i < slug.length; i++) {
@@ -294,16 +300,33 @@ export function computePortOffset(args: {
   return (bucket === 0 ? 50 : bucket) * 100;
 }
 
+// Offset persisted by dev:start alongside the running-stack manifest. Reading
+// it back keeps dev:restart, dev:env, dev:status, and the dev:start reuse path
+// on the ports of the stack that was actually started, even when dev:start
+// auto-probed away from the hash default.
+export function readPersistedPortOffset(repoRoot: string): number | undefined {
+  try {
+    const raw = JSON.parse(
+      fs.readFileSync(path.join(repoRoot, 'dev', 'logs', 'manifest.json'), 'utf-8')
+    );
+    const value = raw?.portOffset;
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 function getPortOffset(): number {
   const root = execSync('git rev-parse --show-toplevel', { encoding: 'utf-8' }).trim();
   return computePortOffset({
     explicit: process.env.KILO_PORT_OFFSET,
+    persisted: readPersistedPortOffset(root),
     isPrimary: isPrimaryWorktree(),
     slug: path.basename(root),
   });
 }
 
-export const portOffset = getPortOffset();
+export let portOffset = getPortOffset();
 
 function getNextjsTargetPort(): number {
   const explicit = process.env.PORT;
@@ -317,7 +340,7 @@ function getNextjsTargetPort(): number {
   return port;
 }
 
-const nextjsTargetPort = getNextjsTargetPort();
+let nextjsTargetPort = getNextjsTargetPort();
 
 // When a port offset is active the web app binds to a non-3000 port, but
 // .env.local still hardcodes NEXTAUTH_URL=http://localhost:3000, so NextAuth
@@ -621,7 +644,7 @@ function buildServiceDefs(): ServiceDef[] {
   return defs;
 }
 
-const serviceDefs = buildServiceDefs();
+let serviceDefs = buildServiceDefs();
 
 export const services = new Map<string, ServiceDef>(serviceDefs.map(s => [s.name, s]));
 
@@ -640,6 +663,46 @@ export const shortcuts: Record<string, string[]> = {
   all: serviceDefs.map(s => s.name),
 };
 
+// Rebuild every port-derived service definition (ports, commands) for a new
+// offset. Used by the dev:start collision re-probe; ESM live bindings keep
+// importers of portOffset and services current.
+export function applyPortOffset(offset: number): void {
+  portOffset = offset;
+  nextjsTargetPort = getNextjsTargetPort();
+  serviceDefs = buildServiceDefs();
+  services.clear();
+  for (const def of serviceDefs) services.set(def.name, def);
+  shortcuts.all = serviceDefs.map(s => s.name);
+}
+
+// Successive +100 candidate offsets through the same (0, 5000] range the slug
+// hash draws from, wrapping around and excluding the starting offset.
+export function candidatePortOffsets(start: number): number[] {
+  const startBucket = Math.floor(start / 100);
+  const candidates: number[] = [];
+  for (let step = 1; step <= 50; step++) {
+    const bucket = (startBucket + step) % 50;
+    const offset = bucket === 0 ? 5000 : bucket * 100;
+    if (offset !== start) candidates.push(offset);
+  }
+  return candidates;
+}
+
+// Probe candidate offsets until one whose full computed port set is free is
+// found, applying it via applyPortOffset and returning it. Restores the
+// starting offset and returns undefined when every candidate is occupied.
+export async function findFreePortOffset(
+  hasConflicts: () => Promise<boolean>
+): Promise<number | undefined> {
+  const start = portOffset;
+  for (const candidate of candidatePortOffsets(start)) {
+    applyPortOffset(candidate);
+    if (!(await hasConflicts())) return candidate;
+  }
+  applyPortOffset(start);
+  return undefined;
+}
+
 export function resolveTransitiveDeps(targets: string[]): string[] {
   const result = new Set<string>();
   const stack = [...targets];

From e4f9471cce7b5657efdb71cc61044a82bf014d41 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Wed, 29 Jul 2026 15:15:50 +0200
Subject: [PATCH 05/34] fix(workflow): harden the scripts per round-2 review

Slot lifecycle: exclusive mkdir-based release transition, teardown failures
keep the slot, emulator session killed before claims drop with console-port
verification, acquire deadline (45 min) + state-dir validation + owner-last
writes, explicit release refused for live sessions. Dispatch/await: wrapper-
owned .exit file replaces the spoofable in-log marker, repro vs verify
sentinel contracts (--mode repro), role-definition existence and run-id slug
checks, machine-global 3s launch-spacing gate (also in launch-interactive,
where --log is now mandatory). slice-diff --check judges rounds itself and
the spec shows the exact commands. baseline.sh refuses re-snapshots and
in-repo dirs, publishes atomically, reports all divergence. pr-gate: thread
enumeration failures fail the gate, exact bot login + waiver detection,
--assignee/--label/--wait. pr-threads close is retry-safe and repo-checked.
pick-reviewers propagates API failures. maestro.sh keeps its lock trap. New
init-section.sh replaces the hand-assembled section setup. Planner runs two
parallel plan-reviewers per round and overlaps the repro gate with drafting;
E2E follow-ups carry cumulative coverage; slots adopt existing stacks;
runbook launches emulators on explicit probed ports. Five more graduated
learnings deleted.
---
 .kilo/agent/e2e-verifier.md                   |   4 +-
 .kilo/agent/starter.md                        |   2 +-
 .kilo_workflow/README.md                      |   5 +-
 .kilo_workflow/WORKFLOW.md                    |  44 ++++---
 .kilo_workflow/await-role.sh                  |  81 +++++++-----
 .kilo_workflow/baseline.sh                    |  27 +++-
 .kilo_workflow/dispatch-role.sh               |  59 +++++++--
 .kilo_workflow/e2e-slot.sh                    | 123 +++++++++++++-----
 .kilo_workflow/init-section.sh                |  51 ++++++++
 .kilo_workflow/launch-interactive.sh          |  30 ++++-
 ...v-start-docker-tcp-refusal-is-transient.md |   7 -
 ...kilo-edit-tool-blocks-kilo-config-paths.md |   7 -
 .../kilo-run-startup-crash-transient.md       |   7 +-
 .../mobile-android-emulator-claims.md         |  19 ---
 .../mobile-pr-review-entry-github-seed.md     |   7 -
 .../worktree-port-offset-airplay-collision.md |  10 --
 .kilo_workflow/pick-reviewers.sh              |  29 +++--
 .kilo_workflow/pr-gate.sh                     |  80 +++++++++---
 .kilo_workflow/pr-threads.sh                  |  36 ++---
 apps/mobile/e2e/AGENTS.md                     |  21 +--
 apps/mobile/e2e/maestro.sh                    |  15 ++-
 21 files changed, 437 insertions(+), 227 deletions(-)
 create mode 100755 .kilo_workflow/init-section.sh
 delete mode 100644 .kilo_workflow/learnings/dev-start-docker-tcp-refusal-is-transient.md
 delete mode 100644 .kilo_workflow/learnings/kilo-edit-tool-blocks-kilo-config-paths.md
 delete mode 100644 .kilo_workflow/learnings/mobile-android-emulator-claims.md
 delete mode 100644 .kilo_workflow/learnings/mobile-pr-review-entry-github-seed.md
 delete mode 100644 .kilo_workflow/learnings/worktree-port-offset-airplay-collision.md

diff --git a/.kilo/agent/e2e-verifier.md b/.kilo/agent/e2e-verifier.md
index b162778ba1..896d8c8f6c 100644
--- a/.kilo/agent/e2e-verifier.md
+++ b/.kilo/agent/e2e-verifier.md
@@ -22,7 +22,7 @@ Before testing:
 
 1. Read the learnings — the worktree's `.kilo_workflow/learnings/` plus the main checkout's `~/Projects/cloud/.kilo_workflow/learnings/system/` — then the surface-specific runbook, and follow it exactly for services, device claiming, builds, login, automation drivers, prompts, and cleanup — mobile: `apps/mobile/e2e/AGENTS.md`; extension: `apps/extension/AGENTS.md`; web and services: `DEVELOPMENT.md` and the repository dev runner. Never bypass a helper script's preflight, install unvalidated builds, or guess selectors.
 2. Translate the plan's goals and acceptance criteria into observable flows; for user-facing features, cover the happy, retryable-unhappy, non-retryable-unhappy, and empty states. Batch aggressively: one booted device, one running stack, and one logged-in app session can verify MANY criteria — plan a route through the app that covers every reachable criterion in sequence and only relaunch, re-login, or reboot when a criterion genuinely requires fresh state. Separate runs per scenario burn device time and slot hours for nothing.
-3. Record pre-existing services, listeners, devices, and tmux sessions so cleanup removes only resources you created. Never use a device claimed by another worktree.
+3. Record pre-existing services, listeners, devices, and tmux sessions so cleanup removes only resources you created — this protects FOREIGN resources (other worktrees' stacks, devices you did not claim). Your own worktree's already-running stack is different: acquiring the slot adopts it, and slot release will stop it. Never use a device claimed by another worktree.
 4. Immediately before starting a stack, booting a simulator or emulator, or running a native build — and only then, never while you are still reading or planning — acquire the machine device slot: `.kilo_workflow/e2e-slot.sh acquire` (no argument — it resolves your own tmux session and refuses to run outside one; if it refuses, stop and report a test-environment blocker rather than passing a guessed name). This is mandatory on every run — the machine is shared and unslotted device work overloads it. The command blocks until a slot frees; blocking is correct behavior, never a wedge to work around, and never a reason to proceed unslotted.
 5. Before any temporary edit, record the baseline: `.kilo_workflow/baseline.sh snapshot <worktree> $SCRATCH/baseline` (one per in-scope worktree, always outside every repository). Separately copy the original bytes and mode of every tracked file you plan to edit — the snapshot proves divergence; your copies are what restore it. Temporary edits may touch only paths that are clean and tracked at baseline, or brand-new paths — never a pre-existing modified, staged, or untracked path.
 
@@ -50,7 +50,7 @@ Classify every failure as exactly one of:
 
 Attempt one reasonable recovery for a test-environment failure. Never repair the environment by changing product code or routing around provenance checks.
 
-Before returning, for any reason, in this order: stop the processes you started that the slot does not own — recorders, log followers, relays, stub servers, emulators you launched; then `.kilo_workflow/e2e-slot.sh release`, which stops the worktree's dev stack and hands back every claimed device (never `simctl shutdown` a claimed device or `dev:stop` the stack yourself — the slot owns both); then delete every temporary path you created and restore every edited tracked file byte-for-byte with its original mode. Prove the restore with `.kilo_workflow/baseline.sh check <worktree> $SCRATCH/baseline` — anything but `OK` is a verification failure: report every diverging file it prints and do not claim acceptance passed.
+Before returning, for any reason, in this order: stop the processes you started that the slot does not own — recorders, log followers, relays, stub servers; then `.kilo_workflow/e2e-slot.sh release`, which stops the worktree's dev stack, hands back every claimed device, and kills the worktree's emulator session (never `simctl shutdown` a claimed device, kill the emulator session, or `dev:stop` the stack yourself — the slot owns all of it); then delete every temporary path you created and restore every edited tracked file byte-for-byte with its original mode. Prove the restore with `.kilo_workflow/baseline.sh check <worktree> $SCRATCH/baseline` — anything but `OK` is a verification failure: report every diverging file it prints and do not claim acceptance passed.
 
 Return:
 
diff --git a/.kilo/agent/starter.md b/.kilo/agent/starter.md
index 7fd7528570..f39203adf4 100644
--- a/.kilo/agent/starter.md
+++ b/.kilo/agent/starter.md
@@ -9,6 +9,6 @@ permission:
     "*": allow
 ---
 
-You are the starter defined in `.kilo_workflow/WORKFLOW.md` (section 1 and everything it references). Read that document first and follow it exactly: collect the work and the mode (`hands on` / `hands off`), explore the codebase, interrogate the requirements toward the simplest solution — challenge the request itself — divide the work into disjoint sections, create each section's worktree and scratch directory, write its brief, launch its planner, then monitor per Monitor Mode until every section reaches a terminal state.
+You are the starter defined in `.kilo_workflow/WORKFLOW.md` (section 1 and everything it references). Read that document first and follow it exactly: collect the work and the mode (`hands on` / `hands off`), explore the codebase, interrogate the requirements toward the simplest solution — challenge the request itself — divide the work into disjoint sections, run `.kilo_workflow/init-section.sh` for each, write its brief, launch its planner, then monitor per Monitor Mode until every section reaches a terminal state.
 
 No model is pinned here — the user picks your model at launch (`--model`, prefer SOTA). Your permissions are pinned so you run unattended on any machine. You launch planners with the kilo CLI (or the user's chosen harness) per the workflow's section 1 — never with a `task` tool.
diff --git a/.kilo_workflow/README.md b/.kilo_workflow/README.md
index a6d298678a..6863b902f6 100644
--- a/.kilo_workflow/README.md
+++ b/.kilo_workflow/README.md
@@ -12,7 +12,7 @@ A multi-agent delivery workflow for this repository (and siblings like `~/Projec
 
 A run ends in one of two states:
 
-- **Complete** — an open PR, CI green, Kilobot-reviewed, assigned to you, awaiting your review. The workflow never approves or merges its own PR; a PR waiting on human review is the deliverable, not a stall.
+- **Complete** — an open PR, CI green, Kilobot-reviewed (or Kilobot's absence explicitly waived after two failed retriggers, noted on the PR), assigned to you, awaiting your review. The workflow never approves or merges its own PR; a PR waiting on human review is the deliverable, not a stall.
 - **BLOCKED** — a precise blocker report (in the PR or the section's final report) saying exactly what a human must do. It does not guess past blockers or fake completion.
 
 ## What happens inside
@@ -27,7 +27,7 @@ Pipeline: **starter → planner → orchestrator → implementer/reviewer loops
 | Implementer / impl-reviewer | Cheap-model pairs: implement a slice, then a fresh reviewer re-derives the diff's correctness; loop until findings dry up |
 | E2E verifier | Boots the real local stack (simulator, browser, services — real LLM calls, no mocks) and verifies the plan's goals behave, not just compile |
 
-Each section works in its own worktree under `~/Projects/.worktrees/` — never a primary checkout — and cleans up everything it started when it ends.
+Each section works in its own worktree under `~/Projects/.worktrees/` — never a primary checkout — and cleans up everything it started when it ends; the worktree itself is the one local artifact that stays until its PR closes.
 
 ## The trade: wall time for correctness, at a good price
 
@@ -44,6 +44,7 @@ A section routinely takes hours of unattended machine time. The human cost is mi
 | Path | Purpose |
 |---|---|
 | [`WORKFLOW.md`](WORKFLOW.md) | The canonical spec — roles, loops, gates, dispatch commands |
+| [`init-section.sh`](init-section.sh) | Creates a section: run id, worktrees, cloud prepare, scratch directory — prints the manifest |
 | [`dispatch-role.sh`](dispatch-role.sh) | Launches a kilo role agent in tmux with a clean environment and logged exit code |
 | [`await-role.sh`](await-role.sh) | Waits on a dispatched agent's log and reports the round's outcome: DONE with its verdict, VOID, STALLED, or RUNNING |
 | [`launch-interactive.sh`](launch-interactive.sh) | Launches an interactive session (planner, orchestrator) in tmux with a clean environment and a live TTY |
diff --git a/.kilo_workflow/WORKFLOW.md b/.kilo_workflow/WORKFLOW.md
index 7cde6c4c7b..a0157fb56c 100644
--- a/.kilo_workflow/WORKFLOW.md
+++ b/.kilo_workflow/WORKFLOW.md
@@ -13,15 +13,15 @@ These apply to every role. Later sections do not repeat them.
 - Every long-lived process — planner, orchestrator, dispatched role agents, local services — runs in tmux, with a unique descriptive window or session name; the launch scripts guarantee this. The one exception is the starter, which lives wherever the user invoked it (often a plain harness session outside tmux) — its launches still land in tmux via `launch-interactive.sh`.
 - Section names are lowercase slugs (`[a-z0-9-]` only — they become branch, tmux, and path names) carrying a short random run id: `<name>-$(openssl rand -hex 2)`, for example `billing-a7f3`. This keeps parallel runs from colliding on worktrees, branches, tmux names, or scratch paths.
 - All workflow tmux lives on the default tmux server — never a custom socket; slot reaping and monitoring key on the sessions one server can see.
-- Work only in dedicated worktrees, in every repository the plan touches — one worktree per repository, `~/Projects/.worktrees/<section>` for cloud and `~/Projects/.worktrees/<section>-<repo>` for siblings, all on the same branch name: `git fetch origin && git worktree add <path> -b <section> origin/main`, then run `pnpm dev:worktree:prepare` inside it (cloud repo only — sibling repositories follow their own `AGENTS.md` setup; `~/Projects/kilocode` uses bun, not pnpm). The cloud worktree always exists, even for sibling-only sections — role dispatches run from it. Never edit a primary or main checkout, with one exception: machine-local learnings under the main checkout's `.kilo_workflow/learnings/system/` (`mkdir -p` it if missing). Worktrees outlive the run; remove them (`git worktree remove <path>`) once their PR closes.
-- Each section gets a scratch directory outside every repository — `mktemp -d "${TMPDIR:-/tmp}/kilo-workflow-<section>.XXXXXX"` — for its brief, plan, handoffs, decisions, and dispatch logs. Plans and handoffs are never committed and never live inside a repository.
+- Work only in dedicated worktrees, in every repository the plan touches — never a primary or main checkout, with one exception: machine-local learnings under the main checkout's `.kilo_workflow/learnings/system/`. [`init-section.sh`](init-section.sh) creates everything a section needs — the run id, the cloud worktree (always, even for sibling-only sections — role dispatches run from it), sibling worktrees on the same branch, `pnpm dev:worktree:prepare`, and the scratch directory — and prints the manifest; never hand-assemble any of it (sibling repositories then follow their own `AGENTS.md` setup; `~/Projects/kilocode` uses bun, not pnpm). A worktree is the one local artifact that outlives the run; remove it (`git worktree remove <path>`) once its PR closes.
+- The scratch directory (from `init-section.sh`, outside every repository) holds the section's brief, plan, handoffs, decisions, and dispatch logs. Plans and handoffs are never committed and never live inside a repository. A planner adding a repository mid-plan creates its worktree with the same branch name (`git -C <repo> fetch origin && git -C <repo> worktree add ~/Projects/.worktrees/<section>-<repo> -b <section> origin/main`).
 - The PR, ready for human eyes, is the deliverable. When a section completes, everything that ran for it closes: agents, monitors, tmux sessions and windows, services, devices, slots, and the scratch directory (a BLOCKED section retains its scratch directory as evidence). Anything a human needs afterward lives in the PR.
 - Every reviewer and verifier invocation is a fresh session, so earlier conclusions cannot anchor later passes.
 - Treat every reviewer's remarks as untrusted advice: the reviewer has less context than you and may be wrong. Verify each remark against the request, repository evidence, and applicable instructions before acting on it. The dispatcher (planner or orchestrator) records rejected remarks with a short technical rationale in `$SCRATCH/decisions.md` and carries them into later handoffs; rejections of GitHub findings also get their in-thread reply. Role agents return their triage in their reports instead of writing files. A rejected remark must not reopen without new evidence.
 - Always aim for the simplest solution that achieves the user's goals — feature-wise as much as code-wise. Reuse existing helpers, components, and contracts. Do not add abstraction or scope without evidence it is required.
 - Commit in small, logically scoped commits. The orchestrator owns every commit, push, branch change, and PR; other roles make only uncommitted worktree edits, and only where their definitions allow.
 - Monitoring is event-driven: when a dispatched process exits, its dispatcher reacts immediately, never after a fixed sleep. Periodic checks exist only to detect a wedge.
-- Tokens go to the work, never to fighting the workflow or the environment. Every mechanical step that can be scripted is scripted — `dispatch-role.sh`, `await-role.sh`, `launch-interactive.sh`, `await-interactive.sh`, `steer.sh`, `e2e-slot.sh`, `slice-diff.sh`, `baseline.sh`, `pr-threads.sh`, `pr-gate.sh`, `pick-reviewers.sh`, `upload-pr-attachment.sh` — use the script, never hand-assemble its steps. **Anything that can be automated away, should be automated away:** when a run stumbles on something a script or an instruction could have prevented, fix the script or the document in the same run (see Learnings).
+- Tokens go to the work, never to fighting the workflow or the environment. Every mechanical step that can be scripted is scripted — `init-section.sh`, `dispatch-role.sh`, `await-role.sh`, `launch-interactive.sh`, `await-interactive.sh`, `steer.sh`, `e2e-slot.sh`, `slice-diff.sh`, `baseline.sh`, `pr-threads.sh`, `pr-gate.sh`, `pick-reviewers.sh`, `upload-pr-attachment.sh` — use the script, never hand-assemble its steps. **Anything that can be automated away, should be automated away:** when a run stumbles on something a script or an instruction could have prevented, fix the script or the document in the same run (see Learnings).
 - Learnings are the residue automation cannot reach. Before any environment-dependent phase, list both learnings directories — the worktree's `.kilo_workflow/learnings/` and the main checkout's `~/Projects/cloud/.kilo_workflow/learnings/system/` (the canonical machine-local set, which mid-run writes go to and worktree copies lag) — and read the entries whose names match your surface; filenames are symptom-keyed. When a tool or environment failure blocks you mid-run, grep both directories for the error text before debugging from scratch: a prior run has usually already paid for the answer.
 
 ### Models
@@ -73,7 +73,14 @@ Act on that line:
 - `VOID` — the run ended with no valid verdict for its role (kilo runs can die mid-stream and still exit 0). Never a pass: discard the round and dispatch a fresh session. If several consecutive rounds die at the same point, shrink the handoff rather than retrying it unchanged.
 - `STALLED` — the stall that never exits. Kill the round's tmux window/session, verify state from artifacts on disk (never the dead run's claims), and redispatch fresh with a continuation handoff.
 
-Two checks stay with the dispatcher, since only it knows the slice — both are one `slice-diff.sh` re-run (compare its `SNAPSHOT` line against the pre-round one): after a reviewer round the whole line must be identical — the reviewer never modifies the tree (other slices' implementers may legitimately be editing *their* paths); after an implementer round the head sha must be unchanged — the implementer never commits. A violation voids the round. Void rounds count toward the loop's round cap, and three consecutive void rounds are an infrastructure blocker (auth wedge, provider outage), never something to redispatch through.
+Two checks stay with the dispatcher, since only it knows the slice — both are one `slice-diff.sh --check` call, which judges the round itself and prints `OK` or `VIOLATION`:
+
+```bash
+.kilo_workflow/slice-diff.sh --check reviewer    "$SNAP" <worktree> "$SCRATCH/<slice>.diff" -- <owned paths>   # after a reviewer round: nothing may have changed
+.kilo_workflow/slice-diff.sh --check implementer "$SNAP" <worktree> "$SCRATCH/<slice>.diff" -- <owned paths>   # after an implementer round: no commit on the owned paths (edits expected)
+```
+
+`$SNAP` is the `SNAPSHOT=...` line the pre-round emit printed. A `VIOLATION` voids the round. Void rounds count toward the loop's round cap, and three consecutive void rounds are an infrastructure blocker (auth wedge, provider outage), never something to redispatch through.
 
 Role boundaries — reviewers never modify the tree, the implementer never commits, no role dispatches agents — are enforced by instruction, not permission. This is deliberate: permission deny lists caused void review rounds (a reviewer whose blocked command made it exit with no verdict, which read as a pass) and takeover churn. The single exception is `task: deny` in the definitions — blocking agent dispatch costs nothing and cannot void a round. The workflow otherwise trades enforcement for reliable rounds and accepts that a misbehaving agent can do what it was told not to; do not "fix" this by re-adding deny lists.
 
@@ -137,7 +144,7 @@ The session the user invokes the workflow from is the starter, running on the ha
 2. Explore the relevant parts of the codebase.
 3. Interrogate the requirements — in `hands on` mode by grilling the user one question at a time, in `hands off` mode by grilling itself and answering from repository evidence, recording material assumptions. Always drive toward the simplest solution that achieves the user's goals, and challenge the request itself: "should we even do this?", "why not do this instead?", "we could achieve the same thing simpler, like this".
 4. Divide the finalized work into related, **disjoint** sections — no two sections may touch the same files or contracts.
-5. For each section: create the dedicated worktree and scratch directory (Ground Rules), write the section brief to `$SCRATCH/brief.md` — the work, the mode, acceptance criteria and constraints gathered so far, the requesting human's GitHub handle for PR assignment, the worktree path, and the scratch path — and launch a planner on the planner harness and model with [`launch-interactive.sh`](launch-interactive.sh). The script encodes the launch traps (env strip, TTY, tmux targeting — details in its header), lands the window in your own session when you are inside tmux and a fresh session otherwise, prints the tmux target for `steer.sh` and `capture-pane`, and fails loudly if the command dies at launch:
+5. For each section: run `.kilo_workflow/init-section.sh <name> [sibling-repo...]` (Ground Rules) and use the manifest it prints, write the section brief to `$SCRATCH/brief.md` — the work, the mode, acceptance criteria and constraints gathered so far, the requesting human's GitHub handle for PR assignment, the worktree path, and the scratch path — and launch a planner on the planner harness and model with [`launch-interactive.sh`](launch-interactive.sh). The script encodes the launch traps (env strip, TTY, tmux targeting — details in its header), lands the window in your own session when you are inside tmux and a fresh session otherwise, prints the tmux target for `steer.sh` and `capture-pane`, and fails loudly if the command dies at launch:
 
 ```bash
 # kilo planner (the planner agent definition pins permissions; the model is the user's pick):
@@ -170,17 +177,16 @@ The planner writes the implementation plan for its section. The plan is consumed
 
 Steps:
 
-1. Read the learnings. Explore the relevant parts of the codebase. Define acceptance criteria, non-goals, and the feature-state matrix for any user-facing feature.
-2. For defect work, run the bug reproduction gate before writing the plan.
-3. Write the complete draft plan to `$SCRATCH/plan.md`.
-4. Loop, at most five rounds: dispatch a fresh `plan-reviewer`, verify its remarks (untrusted), fix valid ones, record rejected ones. Exit when a fresh reviewer returns `No findings.` If three consecutive rounds stay stuck on the same issue — or the five-round cap is hit — resolve the remaining findings directly, record each resolution in `$SCRATCH/decisions.md`, and dispatch one final fresh reviewer (outside the cap). If that final reviewer still objects, do not loop again: record the disagreement and proceed with the recorded resolution (hands-on: ask the user instead).
+1. Read the learnings. For defect work, dispatch the bug reproduction gate FIRST (below) — it runs on a device slot while you work, and the wait costs nothing when it overlaps exploration and drafting. Explore the relevant parts of the codebase. Define acceptance criteria, non-goals, and the feature-state matrix for any user-facing feature.
+2. Write the complete draft plan to `$SCRATCH/plan.md`. For defect work, do not finalize it before the repro verdict is in — the confirmed reproduction feeds the plan, and `CANNOT REPRODUCE.` stops it (see the gate).
+3. Loop, at most five rounds: dispatch TWO fresh `plan-reviewer`s in parallel (they cannot anchor each other — union their findings), verify the remarks (untrusted), fix valid ones, record rejected ones. Exit when a round returns `No findings.` from both. If three consecutive rounds stay stuck on the same issue — or the five-round cap is hit — resolve the remaining findings directly, record each resolution in `$SCRATCH/decisions.md`, and dispatch one final fresh reviewer (outside the cap). If that final reviewer still objects, do not loop again: record the disagreement and proceed with the recorded resolution (hands-on: ask the user instead).
    The planner ends its own run the same way the orchestrator does: a blocker it cannot pass (a failed repro gate, an unresolvable hands-off gap) is written to `$SCRATCH/final-report.md` with first line `BLOCKED` — never a silent stop.
-5. Hands-on: get explicit user approval of the plan. Hands-off: self-approve.
-6. Create a worktree for any repository the plan turned out to touch that lacks one (Ground Rules) — before orchestrator launch, every in-scope repository has a worktree path in the handoff. Write the sanitized orchestrator handoff to `$SCRATCH/handoff.md` (see Handoff Requirements, plus: the plan path, the scratch directory path, the final review result, any simpler-shape decision and its reasoning, and the completion gate with a direct instruction to continue until the PR is mergeable with green CI and an approving Kilobot summary). Launch the orchestrator, then switch to monitor mode.
+4. Hands-on: get explicit user approval of the plan. Hands-off: self-approve.
+5. Create a worktree for any repository the plan turned out to touch that lacks one (Ground Rules) — before orchestrator launch, every in-scope repository has a worktree path in the handoff. Write the sanitized orchestrator handoff to `$SCRATCH/handoff.md` (see Handoff Requirements, plus: the plan path, the scratch directory path, the final review result, any simpler-shape decision and its reasoning, and the completion gate with a direct instruction to continue until the PR is mergeable with green CI and an approving Kilobot summary). Launch the orchestrator, then switch to monitor mode.
 
 ### Bug Reproduction Gate
 
-For defect work, dispatch a fresh `e2e-verifier` in repro mode on the unmodified baseline before writing the draft plan. Repro mode is not a CLI flag: the dispatch is the normal `--agent e2e-verifier` dispatch (own tmux session, label `r0` — see Dispatching), and the handoff text assigns repro mode, which the verifier definition recognizes. Its assignment: reproduce the reported issue — fix nothing — and return exact reproduction steps, evidence, and a failure classification. A confirmed reproduction feeds the plan, and the confirmed repro flow passing becomes an acceptance criterion the final verifier must rerun.
+For defect work, dispatch a fresh `e2e-verifier` in repro mode on the unmodified baseline as the planner's FIRST act — it holds a device slot while the planner explores and drafts, so the wait overlaps work that had to happen anyway. Dispatch with `--mode repro` (label `r0`, own tmux session — see Dispatching); the flag pins the sentinel contract, and the handoff text assigns repro mode, which the verifier definition recognizes. Its assignment: reproduce the reported issue — fix nothing — and return exact reproduction steps, evidence, and a failure classification. A confirmed reproduction feeds the plan, and the confirmed repro flow passing becomes an acceptance criterion the final verifier must rerun.
 
 A `CANNOT REPRODUCE.` sentinel is a blocker, not a license to fix an unconfirmed bug. Hands-on: return the evidence to the user and ask how to proceed. Hands-off: stop with a BLOCKED report — no plan, no orchestrator.
 
@@ -210,7 +216,7 @@ After the handoff the planner stops all hands-on work. It has exactly one job 
 
 A monitor never kills a live dispatch on a judgment call, never edits the worktree, and never writes to another role's dispatch log — a forged `EXITCODE` line corrupts the dispatcher's void-round detection, the exact signal the contract keys on. Before concluding an orchestrator is misbehaving, read its evidence: its pane scrollback (`tmux capture-pane -t <window> -p -S -`), its scratch directory, and the git log. The orchestrator's handoff may route user questions to its own interactive session, so an answer the monitor never saw can exist there — a monitor once killed a healthy implementer and forged its `EXITCODE` line because it never read the scrollback where the user had already answered. The only kill-worthy states are the infrastructure failures named above.
 
-On `COMPLETED`, confirm the PR exists in gate state in **every** repository the section touched — `.kilo_workflow/pr-gate.sh <owner/repo> <pr>` per repository (find the PR with `gh pr view <section> --repo <owner>/<repo>`; never bare `gh pr view`, which only checks the cloud branch). A missing PR means it was not a completion — treat it as a crash.
+On `COMPLETED`, confirm the PR exists in gate state in **every** repository the section touched — `.kilo_workflow/pr-gate.sh <owner/repo> <pr> --assignee <requesting-handle> --label human-ready` per repository (find the PR with `gh pr view <section> --repo <owner>/<repo>`; never bare `gh pr view`, which only checks the cloud branch). A missing PR or a failing gate means it was not a completion — treat it as a crash.
 
 On `QUIET`, read the pane (`tmux capture-pane -pJ -t <target>`) before acting. A session waiting on a hands-on user answer is not wedged, and neither is one holding queued steers (see Steering a Live Interactive Session). Real wedge evidence: a provider or stream error in the pane, a frozen build timer, a repeated hard SDK error. Long kilo runs die on provider stream stalls, and `--interactive` sessions can wedge on provider errors — kill only on that evidence.
 
@@ -232,7 +238,7 @@ The orchestrator drives the plan to completion. It is the expensive model steeri
 .kilo_workflow/slice-diff.sh <worktree> "$SCRATCH/slice-api.diff" -- <owned paths>   # prints SNAPSHOT=<head>:<hash>
 ```
 
-   Keep the `SNAPSHOT` line and re-run the same command after the round — after a reviewer round the whole line must be identical, after an implementer round the head part must be (see the dispatcher checks under Dispatching). Triage remarks (untrusted), route valid ones through a repair dispatch. Exit the loop when a fresh reviewer returns `No findings.`, or when its only remaining findings are already rejected in `$SCRATCH/decisions.md` and cite no evidence the rejection did not consider. At the round cap the remaining moves are takeover or BLOCKED (see Escalation).
+   Keep the `SNAPSHOT` line; after the round, `slice-diff.sh --check reviewer|implementer` judges it (see the dispatcher checks under Dispatching). Triage remarks (untrusted), route valid ones through a repair dispatch. Exit the loop when a fresh reviewer returns `No findings.`, or when its only remaining findings are already rejected in `$SCRATCH/decisions.md` and cite no evidence the rejection did not consider. At the round cap the remaining moves are takeover or BLOCKED (see Escalation).
 4. Create small logical commits at slice boundaries, staging only the slice's owned paths (`git add -- <owned paths>`, never `git add -A` while other slices are mid-flight). Once every slice has landed, run the synchronization point: the deferred project-wide checks (typecheck and each changed repository's own check commands) — then, and again after any later repair or direct orchestrator edit, dispatch one fresh `impl-reviewer` over the cumulative section diff (`git diff origin/main...HEAD`, plus any uncommitted changes), so integration seams, takeovers, and merge resolutions never ship unreviewed.
 5. Create the PR — use the repository's PR template when one exists, with the human-readable **what / why / how** narrative inside its summary section, and verification evidence (verifier screenshots and flow results, pulled from reports before scratch cleanup) where the template asks for it. For work with a UI, upload the screenshots to the PR per GitHub Communication before scratch cleanup — local paths are not evidence. Assign the PR to the requesting human, and pick the reviewers yourself (see Picking Reviewers). When the section spans multiple repositories, use the same branch name in each, open one PR per repository, cross-link them, and hold every one to the completion gate. CI and Kilobot start running concurrently with E2E.
 6. Run the E2E loop (below) when the work has verifiable runtime behavior; skip it for doc-only or equivalently inert changes, recording why in the PR description.
@@ -258,12 +264,12 @@ Request the top one or two names it prints: `gh pr edit <number> --add-reviewer
 
 1. Dispatch a fresh `e2e-verifier` with the plan goals and acceptance criteria, in its own uniquely named tmux session (see Dispatching). Never dispatch one while implementers are active or uncommitted changes sit in an in-scope worktree — the verifier's byte-identical baseline restore turns concurrent edits into false failures. The verifier acquires its own device slot under that session name and releases it the moment its device phase ends; the orchestrator never holds a slot on the verifier's behalf. If a verifier round dies or is killed, clean up its leftovers per the runbook's cleanup section before redispatching — a crashed verifier never ran its own.
 2. Act on the sentinel: `VERIFICATION FAILED.` → triage each remark (untrusted) and run the implementer → impl-reviewer loop to fix it, commit and push. `VERIFICATION BLOCKED.` → one environment recovery attempt and a fresh dispatch; if it blocks again, the section is BLOCKED.
-3. Re-verify — a follow-up verifier round re-tests only the touched behavior, not the whole plan.
-4. Exit when a fresh verifier returns `VERIFICATION PASSED.` for the plan's goals. After five rounds without one, the remaining moves are takeover or BLOCKED (see Escalation).
+3. Re-verify — a follow-up round tests the repaired behavior plus every criterion no completed prior round has already proven; its handoff lists what earlier rounds proved (round, criterion, evidence) so proven criteria are cited, not re-run. A criterion no round ever exercised is not covered by anyone's `VERIFICATION PASSED.`
+4. Exit when a fresh verifier returns `VERIFICATION PASSED.` and the rounds together cover every criterion. After five rounds without that, the remaining moves are takeover or BLOCKED (see Escalation).
 
 ### Kilobot Loop
 
-1. Wait for Kilobot to review the latest head (`gh pr view <n> --json statusCheckRollup,mergeable,mergeStateStatus`; thread state is GraphQL-only — list, reply to, and resolve threads with [`pr-threads.sh`](pr-threads.sh), never hand-written GraphQL). Kilobot can crash: after about 20 minutes without a review, retrigger it (`git commit --allow-empty -m "chore: retrigger review" && git push`, or a `(bot) @kilocode-bot please review` PR comment), then resume waiting. After two failed retriggers, stop waiting: post `(bot) Kilobot posted no approving summary on this head after two retriggers` on the PR and treat the gate's Kilobot item as waived — the pending human review covers it. A green `Kilo Code Review` check only says the review finished; it carries no verdict. The clean state is a Kilobot summary comment on the current head that approves it (`gh pr view <n> --json comments` — read the verdict the comment states, do not match an exact string; bot wording drifts) plus zero **unresolved** review threads. A green check with no approving summary is not a clean head: keep waiting, then retrigger.
+1. Wait for Kilobot to review the latest head — `pr-gate.sh <owner/repo> <n> --wait 1200` blocks until a bot summary (or waiver) postdates the head commit, then prints the whole mechanical picture; thread state is GraphQL-only — list, reply to, and resolve threads with [`pr-threads.sh`](pr-threads.sh), never hand-written GraphQL. Kilobot can crash: if the wait expires with no summary, retrigger it (`git commit --allow-empty -m "chore: retrigger review" && git push`, or a `(bot) @kilocode-bot please review` PR comment), then resume waiting. After two failed retriggers, stop waiting: post `(bot) Kilobot posted no approving summary on this head after two retriggers` on the PR and treat the gate's Kilobot item as waived — the pending human review covers it. A green `Kilo Code Review` check only says the review finished; it carries no verdict. The clean state is a Kilobot summary comment on the current head that approves it (`gh pr view <n> --json comments` — read the verdict the comment states, do not match an exact string; bot wording drifts) plus zero **unresolved** review threads. A green check with no approving summary is not a clean head: keep waiting, then retrigger.
 2. For each comment: verify it (untrusted), then route valid findings through the implementer → impl-reviewer loop; commit, push, then `pr-threads.sh close <owner/repo> <thread-id> "<what was done>"` — it replies in-thread and resolves in one step. Invalid finding: `close` with the technical evidence and do not change correct code. A fix without its in-thread reply and thread resolution is not done. Follow the repository-root `AGENTS.md` "Kilobot Review Remarks" contract.
 3. Comments already posted by other reviewers — bots or humans — get the same triage flow, but never wait for anyone except Kilobot to review or re-review.
 4. CI failures are findings too: route the fix through the implementer loop; rerun a flaky check once (`gh run rerun <id> --failed`); a check still failing after two fix rounds makes the section BLOCKED.
@@ -326,7 +332,7 @@ The machine is shared by parallel workflows, and unslotted device or stack work
 
 `acquire` and `release` resolve the caller's own tmux session themselves (and refuse to run outside one — a slot owner must be a live session so a dead holder can be reclaimed). Pass a session name only when releasing on behalf of a holder that is already dead.
 
-**A slot, a dev stack, and a claimed device are the same resource.** The slot is what entitles a worktree to run a stack and claim a simulator, and neither may outlive it: `release` stops the releasing worktree's stack *and* releases every simulator that worktree claimed, and reclaiming a dead holder's slot does the same for it. So a later round re-acquires, starts a fresh stack, and claims a device again rather than inheriting either — that restart is the price of the cap. A stack up with no slot is a defect, not a shortcut; `stacks` lists them and `stacks --reap` reaps the workflow-owned ones (a stack with no section run id in its name was started by hand and is only reported). Five live stacks on this host drove the load average past 300 and made every emulator boot and native build time out, which reads as flaky devices rather than as over-subscription.
+**A slot, a dev stack, and a claimed device are the same resource.** The slot is what entitles a worktree to run a stack and claim a simulator, and neither may outlive it: `release` stops the releasing worktree's stack *and* releases every simulator that worktree claimed, and reclaiming a dead holder's slot does the same for it. Acquiring a slot ADOPTS any stack already running for that worktree — cleanup ownership transfers to the slot, and release will stop it even though this run did not start it; the preserve-pre-existing-resources rule covers foreign resources (other worktrees' stacks, devices you did not claim), never your own worktree's stack. So a later round re-acquires, starts a fresh stack, and claims a device again rather than inheriting either — that restart is the price of the cap. A stack up with no slot is a defect, not a shortcut; `stacks` lists them and `stacks --reap` reaps the workflow-owned ones (a stack with no section run id in its name was started by hand and is only reported). Five live stacks on this host drove the load average past 300 and made every emulator boot and native build time out, which reads as flaky devices rather than as over-subscription.
 
 Teardown is the slot's job, never the agent's memory: the claim records whether it booted the device, and release powers off only what its own claim booted — a device already running before the claim is never shut down. Never hand-roll device teardown around the wrapper.
 
@@ -364,7 +370,7 @@ Environment blockers and their fixes — broken local stacks, credential traps,
 - **Graduation:** a learning is a workaround waiting for a fix. When the blocker can be prevented by a script change (a flag, a guard, a wrapper) or by a line where agents already look (this document, a runbook, a role definition), make that change instead of — or in the same PR as — writing the learning, and delete any learning the change supersedes. Keep as learnings only what genuinely cannot be automated or folded away: environment trivia, one-off incident evidence, niche device quirks.
 - Every role records blockers it resolves, immediately after resolving them.
 - Never keep a workflow learning only in a harness's private memory; it belongs in these folders so runs on other harnesses can use it.
-- The same rule applies to this document: when a run stumbles on something `WORKFLOW.md` could have prevented — a missing command, an ambiguous rule, a wrong assumption — the orchestrator fixes the document in the same run and ships the fix with the PR. Role-definition fixes from a kilo session go through shell (`cat > .kilo/agent/<name>.md <<'EOF'`) because kilo's edit tool blocks `.kilo/` paths (see `learnings/kilo-edit-tool-blocks-kilo-config-paths.md`). Mistakes that recur are workflow bugs, not agent bugs.
+- The same rule applies to this document: when a run stumbles on something `WORKFLOW.md` could have prevented — a missing command, an ambiguous rule, a wrong assumption — the orchestrator fixes the document in the same run and ships the fix with the PR. Role-definition fixes from a kilo session go through shell (`cat > .kilo/agent/<name>.md <<'EOF'`) because kilo's edit tool blocks `.kilo/` paths (the bash tool is not config-gated; `.kilo_workflow/` paths are unaffected). Mistakes that recur are workflow bugs, not agent bugs.
 
 ## GitHub Communication
 
diff --git a/.kilo_workflow/await-role.sh b/.kilo_workflow/await-role.sh
index a5a0a9e560..409a6250b8 100755
--- a/.kilo_workflow/await-role.sh
+++ b/.kilo_workflow/await-role.sh
@@ -3,16 +3,17 @@
 # .kilo_workflow/WORKFLOW.md. This replaces hand-rolled wait loops: exit codes
 # lie (kilo runs die mid-stream and still exit 0), grepping a whole log for a
 # sentinel false-passes when the agent quoted one, and a stalled run can sit
-# forever without ever writing its EXITCODE marker.
+# forever without ever writing its marker.
 #
 #   await-role.sh <log> [--timeout <sec>] [--stall <sec>]
 #
-# Reads the `<log>.meta` sidecar dispatch-role.sh writes (role + tmux target):
-# the sentinel must belong to THAT role's contract — an implementer ending
-# with `No findings.` is a crashed contract, not a pass — and a dead tmux
-# target with no EXITCODE marker is pronounced VOID immediately instead of
-# waiting out the stall window. Without a sidecar it falls back to accepting
-# any known sentinel and log-only liveness.
+# Completion is proven by the wrapper-owned `<log>.exit` file dispatch-role.sh
+# writes — never by text in the log, which the agent also writes. The
+# `<log>.meta` sidecar (role, mode, tmux target) picks the sentinel contract:
+# an implementer ending with `No findings.` — or a final verifier ending with
+# `REPRODUCED.` — is a crashed contract, not a pass. A missing or corrupt
+# sidecar is VOID: every legitimate dispatch goes through dispatch-role.sh.
+# A dead tmux target with no exit file is VOID immediately.
 #
 # Blocks up to --timeout (default 480s — safely under harness command
 # timeouts), then reports. Re-invoke while it prints RUNNING. Prints exactly
@@ -21,15 +22,15 @@
 #   DONE <sentinel>   exit 0  round finished with a real verdict; act on it
 #   VOID ...          exit 2  finished without a valid verdict — a crashed
 #                             run, never a pass; discard and dispatch fresh
-#   STALLED <sec>s    exit 3  no EXITCODE and the log has been quiet past the
+#   STALLED <sec>s    exit 3  no exit file and the log has been quiet past the
 #                             stall threshold (default 1200s) — kill the tmux
 #                             window/session, verify state, redispatch fresh
 #   RUNNING           exit 4  still working; invoke again
 #
-# The sentinel is the line above the EXITCODE marker — the only place a
-# verdict counts. `STOPPED EARLY.` reports as DONE: not void, not success;
-# re-dispatch with a continuation handoff. A quiet log is judged by mtime, so
-# any tool output the agent produces (builds included) counts as liveness.
+# The sentinel is the log's last line. `STOPPED EARLY.` reports as DONE: not
+# void, not success; re-dispatch with a continuation handoff. A quiet log is
+# judged by mtime, so any tool output the agent produces (builds included)
+# counts as liveness.
 set -euo pipefail
 
 LOG=${1:?usage: await-role.sh <log> [--timeout <sec>] [--stall <sec>]}
@@ -45,19 +46,25 @@ while [ $# -gt 0 ]; do
 done
 
 ROLE=""
+MODE=""
 TMUX_TARGET=""
 if [ -f "$LOG.meta" ]; then
   ROLE=$(sed -n 's/^role=//p' "$LOG.meta" | head -1)
+  MODE=$(sed -n 's/^mode=//p' "$LOG.meta" | head -1)
   TMUX_TARGET=$(sed -n 's/^tmux=//p' "$LOG.meta" | head -1)
 fi
 
 # FINDINGS requires a count of at least 1 — `FINDINGS: 0` contradicts itself
 # (zero findings is spelled `No findings.`) and signals a broken report.
-case $ROLE in
-  plan-reviewer | impl-reviewer) SENTINELS='^(No findings\.|FINDINGS: [1-9][0-9]*|STOPPED EARLY\.)$' ;;
-  implementer) SENTINELS='^(SLICE COMPLETE\.|STOPPED EARLY\.)$' ;;
-  e2e-verifier) SENTINELS='^(VERIFICATION (PASSED|FAILED|BLOCKED)\.|REPRODUCED\.|CANNOT REPRODUCE\.|STOPPED EARLY\.)$' ;;
-  *) SENTINELS='^(No findings\.|FINDINGS: [1-9][0-9]*|STOPPED EARLY\.|SLICE COMPLETE\.|VERIFICATION (PASSED|FAILED|BLOCKED)\.|REPRODUCED\.|CANNOT REPRODUCE\.)$' ;;
+case "$ROLE/$MODE" in
+  plan-reviewer/* | impl-reviewer/*) SENTINELS='^(No findings\.|FINDINGS: [1-9][0-9]*|STOPPED EARLY\.)$' ;;
+  implementer/*) SENTINELS='^(SLICE COMPLETE\.|STOPPED EARLY\.)$' ;;
+  e2e-verifier/repro) SENTINELS='^(REPRODUCED\.|CANNOT REPRODUCE\.|VERIFICATION BLOCKED\.|STOPPED EARLY\.)$' ;;
+  e2e-verifier/*) SENTINELS='^(VERIFICATION (PASSED|FAILED|BLOCKED)\.|STOPPED EARLY\.)$' ;;
+  *)
+    echo "VOID missing or corrupt $LOG.meta — dispatch through dispatch-role.sh; discard the round"
+    exit 2
+    ;;
 esac
 
 mtime() { stat -f %m "$1" 2>/dev/null || stat -c %Y "$1" 2>/dev/null || echo 0; }
@@ -69,32 +76,34 @@ target_dead() {
 START=$(date +%s)
 while :; do
   NOW=$(date +%s)
-  if [ -f "$LOG" ]; then
-    LAST=$(tail -1 "$LOG" 2>/dev/null || true)
-    if [[ "$LAST" =~ ^EXITCODE=([0-9]+) ]]; then
-      CODE=${BASH_REMATCH[1]}
-      # Strip trailing whitespace; roles must end their report with the bare
-      # sentinel as the last line before the marker.
-      SENTINEL=$(tail -2 "$LOG" | head -1 | sed 's/[[:space:]]*$//')
-      if [[ "$SENTINEL" =~ $SENTINELS ]]; then
-        echo "DONE $SENTINEL"
-        exit 0
-      fi
-      echo "VOID exit=$CODE — no valid ${ROLE:-role} sentinel; discard the round and dispatch a fresh session"
-      exit 2
+  if [ -f "$LOG.exit" ]; then
+    CODE=$(cat "$LOG.exit" 2>/dev/null || echo "?")
+    SENTINEL=$(tail -1 "$LOG" 2>/dev/null | sed 's/^EXITCODE=[0-9]*$//;s/[[:space:]]*$//')
+    # The human-facing EXITCODE marker is the true last line; the sentinel is
+    # the line above it. Tolerate either ordering in case the marker write
+    # raced the exit-file write.
+    if [ -z "$SENTINEL" ]; then
+      SENTINEL=$(tail -2 "$LOG" 2>/dev/null | head -1 | sed 's/[[:space:]]*$//')
+    fi
+    if [[ "$SENTINEL" =~ $SENTINELS ]]; then
+      echo "DONE $SENTINEL"
+      exit 0
     fi
+    echo "VOID exit=$CODE — no valid $ROLE${MODE:+/$MODE} sentinel; discard the round and dispatch a fresh session"
+    exit 2
+  fi
+  if [ -f "$LOG" ]; then
     if target_dead; then
-      # The pane is gone but the marker never landed; give the redirect a
-      # moment to flush, then re-check the tail once before pronouncing.
+      # The pane is gone but the exit file never landed; give the final
+      # writes a moment to flush, then re-check once before pronouncing.
       sleep 5
-      LAST=$(tail -1 "$LOG" 2>/dev/null || true)
-      [[ "$LAST" =~ ^EXITCODE= ]] && continue
-      echo "VOID tmux target $TMUX_TARGET is gone with no EXITCODE — the run was killed; discard and dispatch fresh"
+      [ -f "$LOG.exit" ] && continue
+      echo "VOID tmux target $TMUX_TARGET is gone with no exit file — the run was killed; discard and dispatch fresh"
       exit 2
     fi
     AGE=$(( NOW - $(mtime "$LOG") ))
     if [ "$AGE" -gt "$STALL" ]; then
-      echo "STALLED ${AGE}s quiet, no EXITCODE — kill the round's tmux window/session, verify state on disk, redispatch fresh"
+      echo "STALLED ${AGE}s quiet, no exit file — kill the round's tmux window/session, verify state on disk, redispatch fresh"
       exit 3
     fi
   elif target_dead || [ $(( NOW - START )) -gt 90 ]; then
diff --git a/.kilo_workflow/baseline.sh b/.kilo_workflow/baseline.sh
index 137703d7b6..7dd78bc3c9 100755
--- a/.kilo_workflow/baseline.sh
+++ b/.kilo_workflow/baseline.sh
@@ -17,7 +17,19 @@ set -euo pipefail
 CMD=${1:?usage: baseline.sh snapshot|check <worktree> <baseline-dir>}
 WT=${2:?worktree} DIR=${3:?baseline dir}
 [ -d "$WT" ] || { echo "baseline: no such worktree: $WT" >&2; exit 1; }
-case "$DIR" in "$WT"/*) echo "baseline: the baseline dir must live outside the repository" >&2; exit 1 ;; esac
+# Canonicalize before comparing — a relative or symlinked path must not smuggle
+# the baseline into the repository (or make the repository the baseline).
+WT=$(cd "$WT" && pwd -P)
+CREATED=0
+[ -d "$DIR" ] || { mkdir -p "$DIR"; CREATED=1; }
+DIR=$(cd "$DIR" && pwd -P)
+case "$DIR" in
+  "$WT" | "$WT"/*)
+    [ "$CREATED" -eq 1 ] && rmdir "$DIR" 2>/dev/null
+    echo "baseline: the baseline dir must live outside the repository ($WT)" >&2
+    exit 1
+    ;;
+esac
 
 capture() {
   local out=$1
@@ -43,7 +55,15 @@ capture() {
 
 case $CMD in
   snapshot)
-    capture "$DIR"
+    # Refuse to re-snapshot: a verifier that re-runs the checklist after its
+    # temporary edits would otherwise bless the dirty state as the baseline.
+    [ ! -f "$DIR/head" ] || { echo "baseline: $DIR already holds a snapshot — check against it; never re-baseline mid-run" >&2; exit 1; }
+    # Capture to a sibling temp dir and publish atomically, so a killed
+    # snapshot can never pass for a complete one.
+    TMP=$(mktemp -d "$DIR.tmp.XXXXXX")
+    capture "$TMP"
+    rmdir "$DIR" 2>/dev/null || { echo "baseline: $DIR exists and is not empty — refusing to overwrite" >&2; rm -rf "$TMP"; exit 1; }
+    mv "$TMP" "$DIR"
     echo "baseline recorded in $DIR"
     ;;
   check)
@@ -60,7 +80,8 @@ case $CMD in
         head) echo "DIVERGED head: $(cat "$DIR/$f") -> $(cat "$NOW/$f")" ;;
         untracked.tsv)
           echo "DIVERGED untracked files (hash/mode/link or presence):"
-          diff "$DIR/$f" "$NOW/$f" | grep '^[<>]' | sed 's/^</  baseline only:/; s/^>/  now:/'
+          # diff exits 1 on difference — normal here, must not abort the report.
+          { diff "$DIR/$f" "$NOW/$f" || true; } | { grep '^[<>]' || true; } | sed 's/^</  baseline only:/; s/^>/  now:/'
           ;;
         *) echo "DIVERGED $f (run: diff $DIR/$f $NOW/$f)" ;;
       esac
diff --git a/.kilo_workflow/dispatch-role.sh b/.kilo_workflow/dispatch-role.sh
index c2c31509b7..8cf1c7e2f5 100755
--- a/.kilo_workflow/dispatch-role.sh
+++ b/.kilo_workflow/dispatch-role.sh
@@ -27,18 +27,31 @@ case $ROLE in
   plan-reviewer | implementer | impl-reviewer | e2e-verifier) ;;
   *) echo "dispatch-role: unknown role '$ROLE' (plan-reviewer|implementer|impl-reviewer|e2e-verifier)" >&2; exit 1 ;;
 esac
-[[ "$SECTION" =~ ^[a-z0-9-]+$ ]] || { echo "dispatch-role: section must be a lowercase slug: '$SECTION'" >&2; exit 1; }
+[[ "$SECTION" =~ ^[a-z0-9-]+-[0-9a-f]{4}$ ]] || { echo "dispatch-role: section must be a lowercase slug ending in its 4-hex run id (see init-section.sh): '$SECTION'" >&2; exit 1; }
 [[ "$LABEL" =~ ^[A-Za-z0-9._-]+$ ]] || { echo "dispatch-role: bad label '$LABEL'" >&2; exit 1; }
 [ -d "$WT" ] || { echo "dispatch-role: no such worktree: $WT" >&2; exit 1; }
+[ -f "$WT/.kilo/agent/$ROLE.md" ] || { echo "dispatch-role: $WT has no .kilo/agent/$ROLE.md — the worktree must be the CLOUD worktree (role definitions are only discovered there)" >&2; exit 1; }
 [ -d "$SCRATCH" ] || { echo "dispatch-role: no such scratch dir: $SCRATCH" >&2; exit 1; }
-# Only repeated `--file <existing path>` may follow — anything else (a --model
-# override, a typo) silently disagrees with the pinned role definition.
+# Only `--mode repro` (e2e-verifier repro gate) and repeated `--file
+# <existing path>` may follow — anything else (a --model override, a typo)
+# silently disagrees with the pinned role definition.
 FILES=()
+MODE=verify
 while [ $# -gt 0 ]; do
-  [ "$1" = "--file" ] || { echo "dispatch-role: only --file <path> is accepted after the message, got '$1'" >&2; exit 1; }
-  [ -f "${2:-}" ] || { echo "dispatch-role: --file path does not exist: '${2:-}'" >&2; exit 1; }
-  FILES+=("--file" "$2")
-  shift 2
+  case $1 in
+    --mode)
+      [ "${2:-}" = "repro" ] || { echo "dispatch-role: --mode takes only 'repro'" >&2; exit 1; }
+      [ "$ROLE" = "e2e-verifier" ] || { echo "dispatch-role: --mode repro is only for the e2e-verifier" >&2; exit 1; }
+      MODE=repro
+      shift 2
+      ;;
+    --file)
+      [ -f "${2:-}" ] || { echo "dispatch-role: --file path does not exist: '${2:-}'" >&2; exit 1; }
+      FILES+=("--file" "$2")
+      shift 2
+      ;;
+    *) echo "dispatch-role: only --mode repro and --file <path> are accepted after the message, got '$1'" >&2; exit 1 ;;
+  esac
 done
 
 NAME="$SECTION-$ROLE-$LABEL"
@@ -55,7 +68,10 @@ STRIP='$(env | grep -oE "^(KILO|OPENCODE)[A-Za-z0-9_]*" | sed "s/^/-u /" | tr "\
 # the terminal only, never into the log, so the EXITCODE contract is untouched.
 CMD="echo $(printf '%q' "$NAME: output goes to $LOG — this pane stays blank by design; watch with: tail -f $LOG") && cd $(printf '%q' "$WT") && env $STRIP kilo run $(printf '%q' "$MSG") --agent $(printf '%q' "$ROLE") --title $(printf '%q' "$NAME")"
 for arg in "${FILES[@]+"${FILES[@]}"}"; do CMD+=" $(printf '%q' "$arg")"; done
-CMD+=" > $(printf '%q' "$LOG") 2>&1; echo EXITCODE=\$? >> $(printf '%q' "$LOG")"
+# The wrapper-owned exit file is what proves the run ENDED: the in-log
+# EXITCODE marker is convenient for humans but shares the stream with agent
+# stdout, and an agent quoting "EXITCODE=0" mid-run must not read as done.
+CMD+=" > $(printf '%q' "$LOG") 2>&1; EC=\$?; echo \"EXITCODE=\$EC\" >> $(printf '%q' "$LOG"); echo \"\$EC\" > $(printf '%q' "$LOG.exit")"
 
 # Resolve the caller's session through this pane. An untargeted
 # `tmux display-message -p '#S'` answers with the SERVER's current session —
@@ -68,6 +84,25 @@ if [ -n "${TMUX_PANE:-}" ]; then
   CALLER_SESSION=$(tmux display-message -p -t "$TMUX_PANE" '#S' 2>/dev/null || true)
 fi
 
+# Machine-global launch spacing: concurrent kilo startups race the shared
+# SQLite credential/session stores and crash (void rounds). ~3s apart is
+# enough; the mkdir mutex makes the read-modify-write of the timestamp safe.
+GATE="$HOME/.cache/kilo-launch-gate"
+mkdir -p "$GATE"
+while :; do
+  if mkdir "$GATE/lock" 2>/dev/null; then
+    NOW=$(date +%s)
+    LAST=$(cat "$GATE/last" 2>/dev/null || echo 0)
+    if [ $(( NOW - LAST )) -ge 3 ]; then
+      echo "$NOW" > "$GATE/last"
+      rmdir "$GATE/lock"
+      break
+    fi
+    rmdir "$GATE/lock"
+  fi
+  sleep 1
+done
+
 if [ "$ROLE" = "e2e-verifier" ] || [ -z "$CALLER_SESSION" ]; then
   tmux new-session -d -s "$NAME" "$CMD"
   TARGET=$NAME
@@ -79,8 +114,8 @@ else
   # index N in use".
   TARGET=$(tmux new-window -d -P -F '#{session_name}:#{window_index}' -t "$CALLER_SESSION:" -n "$NAME" "$CMD")
 fi
-# Sidecar for await-role.sh: which sentinel contract applies and which tmux
-# target to pronounce dead. Same path plus .meta, so dispatchers only ever
-# hand around the log path.
-printf 'role=%s\ntmux=%s\n' "$ROLE" "$TARGET" > "$LOG.meta"
+# Sidecar for await-role.sh: which sentinel contract applies (role + repro
+# vs verify for the e2e-verifier) and which tmux target to pronounce dead.
+# Same path plus .meta, so dispatchers only ever hand around the log path.
+printf 'role=%s\nmode=%s\ntmux=%s\n' "$ROLE" "$MODE" "$TARGET" > "$LOG.meta"
 echo "$LOG"
diff --git a/.kilo_workflow/e2e-slot.sh b/.kilo_workflow/e2e-slot.sh
index 25656d5363..620bf570d2 100755
--- a/.kilo_workflow/e2e-slot.sh
+++ b/.kilo_workflow/e2e-slot.sh
@@ -35,7 +35,11 @@ set -uo pipefail
 DIR="$HOME/.cache/kilo-e2e-slots"
 TOTAL=3
 POLL=60
-mkdir -p "$DIR"
+# 45 minutes, per WORKFLOW.md: a blocked acquire past this is a foreign wedge
+# to report, not a queue to keep waiting in.
+ACQUIRE_DEADLINE=2700
+mkdir -p "$DIR" || { echo "cannot create slot state dir $DIR" >&2; exit 1; }
+[ -w "$DIR" ] || { echo "slot state dir $DIR is not writable" >&2; exit 1; }
 
 # The worktree that owns this copy of the script — recorded at acquire time so
 # release and reap know which stack belongs to the slot.
@@ -65,7 +69,7 @@ stack_is_covered() {
     # A slot mid-release no longer entitles its worktree to anything — without
     # this, a release would see its own still-present slot as coverage and
     # skip the teardown it exists to perform.
-    [ -f "$s/releasing" ] && continue
+    [ -e "$s/releasing" ] && continue
     wt=$(cat "$s/worktree" 2>/dev/null || echo)
     [ -n "$wt" ] && [ "$(stack_session "$wt")" = "$sess" ] && return 0
     owner=$(cat "$s/owner" 2>/dev/null || echo)
@@ -94,24 +98,40 @@ release_worktree_resources() {
   # only powers off devices its own claims booted.
   echo "releasing simulators claimed by $wt"
   (cd "$wt" && pnpm dev:mobile:simulator release-all) || rc=1
-  # Android claims are per-serial files; drop this worktree's so dead sections
-  # never wedge a serial.
-  for c in "${TMPDIR:-/tmp}/kilo-mobile-android-claims"/*.json; do
-    [ -f "$c" ] || continue
-    grep -qF "\"worktreeRoot\":\"$wt\"" "$c" 2>/dev/null || continue
-    serial=$(basename "$c" .json)
-    echo "releasing android claim $serial held by $wt"
-    (cd "$wt" && pnpm dev:mobile:android release "$serial") || rc=1
-  done
   # The runbook launches every emulator inside this worktree's dedicated tmux
   # session — the session name IS the boot provenance, so killing it powers
   # off exactly the emulators this worktree started and never a foreign one.
-  local android_sess
+  # Kill it BEFORE dropping the claims: a serial must never sit unclaimed
+  # while the emulator behind it is still dying.
+  local android_sess port
   android_sess="kilo-e2e-android-$(basename "$wt")"
   if tmux has-session -t "$android_sess" 2>/dev/null; then
     echo "killing emulator session $android_sess"
     tmux kill-session -t "$android_sess" || rc=1
   fi
+  # Android claims are per-serial files; drop this worktree's so dead sections
+  # never wedge a serial. Before each drop, verify nothing still answers on
+  # the serial's console port — a qemu that survived the session kill (or a
+  # foreign emulator this worktree merely claimed) is reported, not killed:
+  # there is no boot provenance beyond the session, and powering off a device
+  # we may not have booted is worse than reporting one.
+  for c in "${TMPDIR:-/tmp}/kilo-mobile-android-claims"/*.json; do
+    [ -f "$c" ] || continue
+    grep -qF "\"worktreeRoot\":\"$wt\"" "$c" 2>/dev/null || continue
+    serial=$(basename "$c" .json)
+    port=${serial#emulator-}
+    if [[ "$port" =~ ^[0-9]+$ ]]; then
+      for _ in 1 2 3 4 5; do
+        lsof -nP -iTCP:"$port" -sTCP:LISTEN >/dev/null 2>&1 || break
+        sleep 2
+      done
+      if lsof -nP -iTCP:"$port" -sTCP:LISTEN >/dev/null 2>&1; then
+        echo "warning: an emulator still answers on $serial after teardown — it was not booted by this worktree's session; leaving it" >&2
+      fi
+    fi
+    echo "releasing android claim $serial held by $wt"
+    (cd "$wt" && pnpm dev:mobile:android release "$serial") || rc=1
+  done
   return "$rc"
 }
 
@@ -136,13 +156,21 @@ reap() {
     fi
     if ! printf '%s\n' "$alive" | grep -qxF -- "$owner"; then
       # The owner is gone, so the slot and everything it entitled — stack and
-      # claimed devices — are all reclaimable. Tear down BEFORE freeing the
-      # slot (the `releasing` marker takes it out of coverage), so a new
-      # acquirer can never run alongside the dead holder's still-live stack.
+      # claimed devices — are all reclaimable. `mkdir releasing` is the
+      # exclusive transition (an atomic marker two concurrent reapers cannot
+      # both win), it takes the slot out of coverage so the teardown runs,
+      # and the still-occupied slot keeps a new acquirer out until the dead
+      # holder's resources are actually gone. On teardown failure the slot is
+      # kept (marker removed) so the next reap retries instead of freeing
+      # capacity over a live stack.
       wt=$(cat "$s/worktree" 2>/dev/null || echo)
-      touch "$s/releasing"
-      release_worktree_resources "$wt" || true
-      rm -rf "$s"
+      mkdir "$s/releasing" 2>/dev/null || continue
+      if release_worktree_resources "$wt"; then
+        rm -rf "$s"
+      else
+        echo "reap: teardown failed for $s ($wt) — keeping the slot for retry" >&2
+        rmdir "$s/releasing" 2>/dev/null || true
+      fi
     fi
   done
 }
@@ -188,19 +216,28 @@ case "${1:?usage: acquire|release|status|stacks [tmux-session]}" in
         exit 1
       fi
     fi
-    # already holding one? idempotent.
+    # already holding one? idempotent — but only a COMPLETE record counts
+    # (owner is written last, so its presence proves the rest is there).
     for s in "$DIR"/slot-*; do
-      [ -d "$s" ] && [ "$(cat "$s/owner" 2>/dev/null)" = "$who" ] && { echo "already holding $(basename "$s")"; exit 0; }
+      [ -d "$s" ] || continue
+      [ "$(cat "$s/owner" 2>/dev/null)" = "$who" ] || continue
+      [ -e "$s/releasing" ] && continue
+      echo "already holding $(basename "$s")"
+      exit 0
     done
+    DEADLINE=$(( $(date +%s) + ACQUIRE_DEADLINE ))
     while :; do
       reap
       for i in $(seq 1 "$TOTAL"); do
         if mkdir "$DIR/slot-$i" 2>/dev/null; then
           # A partially written slot is worse than no slot: the reaper would
-          # hand it to someone else while this caller drives a device.
-          if printf '%s' "$who" > "$DIR/slot-$i/owner" &&
-             printf '%s' "$SELF_WORKTREE" > "$DIR/slot-$i/worktree" &&
-             date -u +%Y-%m-%dT%H:%M:%SZ > "$DIR/slot-$i/since"; then
+          # hand it to someone else while this caller drives a device. The
+          # owner file goes LAST — its presence is what marks the record
+          # complete, and an interrupted write leaves an ownerless orphan the
+          # reaper clears instead of a live session holding a broken slot.
+          if printf '%s' "$SELF_WORKTREE" > "$DIR/slot-$i/worktree" &&
+             date -u +%Y-%m-%dT%H:%M:%SZ > "$DIR/slot-$i/since" &&
+             printf '%s' "$who" > "$DIR/slot-$i/owner"; then
             echo "acquired slot-$i for ${SELF_WORKTREE:-unknown worktree}"
             exit 0
           fi
@@ -209,6 +246,12 @@ case "${1:?usage: acquire|release|status|stacks [tmux-session]}" in
           exit 1
         fi
       done
+      if [ "$(date +%s)" -ge "$DEADLINE" ]; then
+        echo "acquire: no slot freed in ${ACQUIRE_DEADLINE}s — a foreign holder is likely wedged; current holders:" >&2
+        "$0" status >&2 || true
+        echo "report a blocker instead of waiting further (never kill another session to free a slot)" >&2
+        exit 1
+      fi
       echo "all $TOTAL device slots busy; retrying in ${POLL}s: $(ls -1 "$DIR" 2>/dev/null | tr '\n' ' ')" >&2
       sleep "$POLL"
     done
@@ -216,22 +259,34 @@ case "${1:?usage: acquire|release|status|stacks [tmux-session]}" in
   release)
     who=${2:-$(self_session)}
     [ -n "$who" ] || { echo "not inside tmux and no session name given" >&2; exit 1; }
+    # An explicit name is for cleaning up after a DEAD holder only. Releasing
+    # a live foreign session's slot would stop a running verifier's stack and
+    # devices out from under it.
+    if [ -n "${2:-}" ] && [ "$2" != "$(self_session)" ] && tmux has-session -t "$2" 2>/dev/null; then
+      echo "release: session '$2' is still alive — a live holder releases its own slot; refusing" >&2
+      exit 1
+    fi
     fail=0
     for s in "$DIR"/slot-*; do
       [ -d "$s" ] || continue
       [ "$(cat "$s/owner" 2>/dev/null)" = "$who" ] || continue
       wt=$(cat "$s/worktree" 2>/dev/null || echo)
-      # Tear down first, free the slot last: the `releasing` marker takes this
-      # slot out of coverage so the teardown runs, while the still-occupied
-      # slot directory keeps a new acquirer from starting a stack alongside
-      # the one being stopped. The stack and the claimed devices go with the
-      # slot; a later round acquires, starts, and claims fresh.
-      touch "$s/releasing"
-      release_worktree_resources "$wt" || fail=1
-      rm -rf "$s"
-      echo "released $(basename "$s")"
+      # Tear down first, free the slot last: `mkdir releasing` (atomic, so a
+      # concurrent reaper cannot double-teardown) takes this slot out of
+      # coverage so the teardown runs, while the still-occupied slot directory
+      # keeps a new acquirer from starting a stack alongside the one being
+      # stopped. On teardown failure the slot is kept so capacity is never
+      # freed over a live stack — fix the error and release again.
+      mkdir "$s/releasing" 2>/dev/null || { echo "$(basename "$s") is already being released elsewhere" >&2; continue; }
+      if release_worktree_resources "$wt"; then
+        rm -rf "$s"
+        echo "released $(basename "$s")"
+      else
+        rmdir "$s/releasing" 2>/dev/null || true
+        echo "release: teardown failed for $(basename "$s") ($wt) — slot kept; fix the error above and run release again" >&2
+        fail=1
+      fi
     done
-    [ "$fail" -eq 0 ] || echo "release: teardown reported errors above — verify with status and dev:status" >&2
     exit "$fail"
     ;;
   status)
diff --git a/.kilo_workflow/init-section.sh b/.kilo_workflow/init-section.sh
new file mode 100755
index 0000000000..8589accb28
--- /dev/null
+++ b/.kilo_workflow/init-section.sh
@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+# Create everything a new section needs, per .kilo_workflow/WORKFLOW.md Ground
+# Rules — run id, worktrees, cloud preparation, scratch directory — so no
+# starter or planner hand-assembles the ritual (and none can reuse a stale
+# branch, skip the cloud worktree, or put scratch inside a repository).
+#
+#   init-section.sh <name> [sibling-repo-path...]
+#
+#   name     lowercase slug WITHOUT the run id, e.g. `billing`; the script
+#            appends `-<4 hex>` itself
+#   sibling  optional absolute path(s) to sibling repositories the plan
+#            touches (e.g. ~/Projects/kilocode); each gets its own worktree
+#            on the same branch. The cloud worktree is always created.
+#
+# Prints a manifest, one `key=value` per line: section, cloud worktree,
+# scratch, and one line per sibling worktree. Sibling repositories follow
+# their own AGENTS.md setup afterwards (kilocode uses bun, not pnpm).
+set -euo pipefail
+
+NAME=${1:?usage: init-section.sh <name> [sibling-repo-path...]}
+shift
+[[ "$NAME" =~ ^[a-z0-9-]+$ ]] || { echo "init-section: name must be a lowercase slug ([a-z0-9-]): '$NAME'" >&2; exit 1; }
+[[ "$NAME" =~ -[0-9a-f]{4}$ ]] && { echo "init-section: pass the bare name — the run id is appended here" >&2; exit 1; }
+
+CLOUD_REPO=$(cd "$(dirname "$0")/.." && pwd -P)
+WT_ROOT="$HOME/Projects/.worktrees"
+mkdir -p "$WT_ROOT"
+
+SECTION="$NAME-$(openssl rand -hex 2)"
+
+add_worktree() {
+  local repo=$1 path=$2
+  git -C "$repo" fetch origin
+  git -C "$repo" worktree add "$path" -b "$SECTION" origin/main
+}
+
+CLOUD_WT="$WT_ROOT/$SECTION"
+add_worktree "$CLOUD_REPO" "$CLOUD_WT"
+(cd "$CLOUD_WT" && pnpm dev:worktree:prepare)
+
+SCRATCH=$(mktemp -d "${TMPDIR:-/tmp}/kilo-workflow-$SECTION.XXXXXX")
+
+echo "section=$SECTION"
+echo "cloud_worktree=$CLOUD_WT"
+echo "scratch=$SCRATCH"
+for repo in "$@"; do
+  [ -d "$repo/.git" ] || [ -f "$repo/.git" ] || { echo "init-section: not a git repository: $repo" >&2; exit 1; }
+  SIB_WT="$WT_ROOT/$SECTION-$(basename "$repo")"
+  add_worktree "$repo" "$SIB_WT"
+  echo "sibling_worktree=$SIB_WT"
+done
diff --git a/.kilo_workflow/launch-interactive.sh b/.kilo_workflow/launch-interactive.sh
index d6907bf5b1..26c1542414 100755
--- a/.kilo_workflow/launch-interactive.sh
+++ b/.kilo_workflow/launch-interactive.sh
@@ -15,7 +15,7 @@
 #   - The window target carries a trailing colon so tmux cannot prefix-match a
 #     window name and fail with "create window failed: index N in use".
 #
-#   launch-interactive.sh <name> <worktree> [--log <file>] <command> [args...]
+#   launch-interactive.sh <name> <worktree> --log <file> <command> [args...]
 #
 #   name      tmux window/session name, e.g. <section>-planner
 #   worktree  working directory for the session
@@ -29,10 +29,32 @@ set -euo pipefail
 
 NAME=${1:?name} WT=${2:?worktree}
 shift 2
-LOGFILE=""
-if [ "${1:-}" = "--log" ]; then LOGFILE=${2:?log file}; shift 2; fi
+# --log is mandatory: Monitor Mode diagnoses wedges from transcript
+# stagnation, and a session without one cannot be told apart from work.
+[ "${1:-}" = "--log" ] || { echo "launch-interactive: --log <file> is required (monitors need the transcript)" >&2; exit 1; }
+LOGFILE=${2:?log file}
+shift 2
 [ $# -gt 0 ] || { echo "launch-interactive: no command given" >&2; exit 1; }
 [ -d "$WT" ] || { echo "launch-interactive: no such worktree: $WT" >&2; exit 1; }
+touch "$LOGFILE" 2>/dev/null || { echo "launch-interactive: cannot write log file $LOGFILE" >&2; exit 1; }
+
+# Machine-global launch spacing: concurrent kilo startups race the shared
+# SQLite credential/session stores and crash. Same gate as dispatch-role.sh.
+GATE="$HOME/.cache/kilo-launch-gate"
+mkdir -p "$GATE"
+while :; do
+  if mkdir "$GATE/lock" 2>/dev/null; then
+    NOW=$(date +%s)
+    LAST=$(cat "$GATE/last" 2>/dev/null || echo 0)
+    if [ $(( NOW - LAST )) -ge 3 ]; then
+      echo "$NOW" > "$GATE/last"
+      rmdir "$GATE/lock"
+      break
+    fi
+    rmdir "$GATE/lock"
+  fi
+  sleep 1
+done
 
 STRIP='$(env | grep -oE "^(KILO|OPENCODE)[A-Za-z0-9_]*" | sed "s/^/-u /" | tr "\n" " " || true)'
 CMD="env $STRIP"
@@ -50,7 +72,7 @@ else
   TARGET=$NAME
 fi
 
-[ -n "$LOGFILE" ] && tmux pipe-pane -t "$TARGET" -o "cat >> $(printf '%q' "$LOGFILE")"
+tmux pipe-pane -t "$TARGET" -o "cat >> $(printf '%q' "$LOGFILE")"
 
 # A command that dies instantly (bad flag, missing binary) closes its pane;
 # report that as a failure instead of handing back a dead target. list-panes,
diff --git a/.kilo_workflow/learnings/dev-start-docker-tcp-refusal-is-transient.md b/.kilo_workflow/learnings/dev-start-docker-tcp-refusal-is-transient.md
deleted file mode 100644
index 4d66b008bc..0000000000
--- a/.kilo_workflow/learnings/dev-start-docker-tcp-refusal-is-transient.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# `dev:start` refuses on `kiloclaw-docker-tcp:23750` even though the shared bridge is healthy — retry once
-
-Symptom: `pnpm dev:start` fails with `Refusing to share occupied worktree service ports: kiloclaw-docker-tcp:23750`, while `curl http://127.0.0.1:23750/_ping` (and even `/v1.44/_ping`) returns `OK` with an `Api-Version` header — the exact thing the runner's own probe requires.
-
-Cause: the reuse branch in `dev/local/cli.ts` only runs when `probeDockerApi(23750)` (`dev/local/docker-api-probe.ts`) succeeds inside a 500 ms window. A momentarily slow Docker daemon or a freshly (re)started `socat` makes that one probe time out, and the runner then reads the occupied port as a foreign conflict instead of a reusable bridge. The port is host-wide and offset-independent, so no `KILO_PORT_OFFSET` change can clear this refusal.
-
-Fix: retry the same `dev:start` command once — the probe is re-run and the second attempt typically prints `Reusing host kiloclaw-docker-tcp on 23750` and proceeds. Only if the refusal repeats, investigate the bridge itself per `kiloclaw-docker-tcp-absent-from-worktree-status.md` (`curl` the unversioned `/_ping`, check `lsof -iTCP:23750`); never kill a foreign-owned `socat`, and never "fix" this by picking another offset.
diff --git a/.kilo_workflow/learnings/kilo-edit-tool-blocks-kilo-config-paths.md b/.kilo_workflow/learnings/kilo-edit-tool-blocks-kilo-config-paths.md
deleted file mode 100644
index 89e4fe4c49..0000000000
--- a/.kilo_workflow/learnings/kilo-edit-tool-blocks-kilo-config-paths.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# kilo's edit/write tools block .kilo/ and .kilocode/ paths
-
-Symptom: a kilo session (any role) trying to edit a file under `.kilo/` — for example a role agent definition in `.kilo/agent/` — gets a config-protection permission ask; in a non-interactive `kilo run` it is auto-rejected and the agent burns steps retrying.
-
-Cause: kilo's edit and write tools treat `.kilo/` and `.kilocode/` (at any depth) plus root `kilo.json`/`AGENTS.md` as protected config paths that always require approval (`packages/opencode/src/kilocode/permission/config-paths.ts`). `.kilo/plans/` is exempt. `.kilo_workflow/` is NOT matched — learnings and workflow-doc edits work normally from kilo sessions.
-
-Fix: route agent-definition changes through a non-kilo harness, a human, or shell commands (`cat > .kilo/agent/x.md <<'EOF'` — the bash tool is not config-gated). Never let a role agent sit retrying a `.kilo/` edit.
diff --git a/.kilo_workflow/learnings/kilo-run-startup-crash-transient.md b/.kilo_workflow/learnings/kilo-run-startup-crash-transient.md
index 773ffc6e79..f983eee67d 100644
--- a/.kilo_workflow/learnings/kilo-run-startup-crash-transient.md
+++ b/.kilo_workflow/learnings/kilo-run-startup-crash-transient.md
@@ -16,9 +16,10 @@ Cause: startup races on the machine-local SQLite stores, under contention from p
 workflows. Transient; unrelated to the prompt, model, flags, or agent definition.
 
 Fix: discard the void round and dispatch a fresh session — the identical redispatch typically
-succeeds immediately. It still counts toward the loop's round cap. When dispatching a fan-out of
-agents at once, stagger the launches by a few seconds; the crash clusters when several CLIs
-start together.
+succeeds immediately. It still counts toward the loop's round cap. The launch scripts
+(`dispatch-role.sh`, `launch-interactive.sh`) space concurrent launches ~3s apart through a
+machine-global gate, which keeps fan-outs from clustering into this crash; a hand launch gets
+no such protection.
 
 Before redispatching, rule out the look-alikes that will NOT clear on retry:
 
diff --git a/.kilo_workflow/learnings/mobile-android-emulator-claims.md b/.kilo_workflow/learnings/mobile-android-emulator-claims.md
deleted file mode 100644
index 34a77fc1ef..0000000000
--- a/.kilo_workflow/learnings/mobile-android-emulator-claims.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# Android emulator claims: claim at adb visibility, boot on an explicit free port
-
-adb serials are host-global and every worktree shares them, so claims race and collide.
-Three rules, each learned from a real incident:
-
-1. **Claim the moment the serial is adb-visible, before waiting for boot.** The old order
-   (launch → wait for `sys.boot_completed` → claim) leaves a window in which a concurrent
-   worktree's polling loop claims your freshly launched emulator. If you lose that race, do NOT
-   drive the device (never use a device claimed by another worktree) and do NOT kill it even if
-   your own qemu process owns it — boot a different AVD/serial instead.
-2. **Boot on an explicit free even console port so your serial starts unclaimed:**
-   `pnpm dev:mobile:android emulator -avd <avd> -port 5558 -no-snapshot-save -no-boot-anim -gpu host`
-   → serial `emulator-5558`, then `claim emulator-5558`. A live foreign emulator on a default
-   serial (5554/5556) blocks your boot there; claims from dead emulators self-clear (they record
-   the guest kernel boot id), but never delete another worktree's claim file yourself. Record
-   the port in the round handoff so the next round reuses the same serial.
-3. **A fresh worktree may lack `apps/mobile/android/`** even when `doctor` passes — run
-   `npx expo prebuild --platform android` in `apps/mobile` before `dev:mobile:android build`
-   (the directory is git-ignored codegen). A cached-APK build then installs in seconds.
diff --git a/.kilo_workflow/learnings/mobile-pr-review-entry-github-seed.md b/.kilo_workflow/learnings/mobile-pr-review-entry-github-seed.md
deleted file mode 100644
index f901a6ea68..0000000000
--- a/.kilo_workflow/learnings/mobile-pr-review-entry-github-seed.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# mobile: PR-review entry URL input is gated behind GitHub connection; seeding pitfalls
-
-Symptom: deep-linking to `/(app)/pr-review` shows the "Connect GitHub" empty state instead of the URL input; `githubApps.devSeedUserGithubToken` then fails with a raw drizzle "Failed query: insert into user_github_app_tokens" (duplicate key on `UQ_user_github_app_tokens_github_user_app`).
-
-Cause: (1) the entry screen only renders the URL input once the user has a GitHub token row; (2) all worktrees share ONE postgres database (named `postgres`, not `postgres-N` — check `pg_database`, sibling rows from other worktrees are visible), so the runbook's "stable fake githubUserId 999001" is usually already taken by a sibling's kilo_user_id; the upsert's ON CONFLICT target is (kilo_user_id, github_app_type), so a fresh user's INSERT collides on the github_user_id unique index and errors instead of returning `false`.
-
-Fix: authenticate curl against nextjs via next-auth credentials fake-login as the mobile E2E user (GET /api/auth/csrf → POST /api/auth/callback/fake-login with csrfToken + email + json=true, cookie jar), then POST /api/trpc/githubApps.devSeedUserGithubToken with a FRESH githubUserId (e.g. 999002 — any unused value; the stub does not validate it). Relaunch the app afterwards so the connection query refetches.
diff --git a/.kilo_workflow/learnings/worktree-port-offset-airplay-collision.md b/.kilo_workflow/learnings/worktree-port-offset-airplay-collision.md
deleted file mode 100644
index 28cfb9b38e..0000000000
--- a/.kilo_workflow/learnings/worktree-port-offset-airplay-collision.md
+++ /dev/null
@@ -1,10 +0,0 @@
-# Worktree slug-hash port offset collides — with macOS AirPlay Receiver (5000/7000) or another worktree's live stack
-
-Symptom: `pnpm dev:start` fails with `Refusing to share occupied worktree service ports: …`. Two observed occupants of the hash-chosen offset:
-
-1. Offset 2000 (nextjs 5000) — `lsof -iTCP:5000` shows `ControlCe` (macOS AirPlay Receiver), which also holds 7000, even with no other dev stack running.
-2. Offset 2400 — another worktree's live `kilo-dev-*` stack legitimately holds the ports; nothing is wrong with the machine, the hash just bucketed two worktrees onto the same offset.
-
-Cause: `computePortOffset` derives the offset from the worktree slug hash (`KILO_PORT_OFFSET=auto` uses the same hash — it does not probe for free ports); a slug that buckets to 20 lands nextjs on 3000+2000=5000 permanently, and two slugs can bucket to the same offset. Only `dev:status` reads the offset back from the manifest, so `dev:start`/`dev:restart`/`dev:env` all recompute from the environment.
-
-Fix: prefix every port-computing dev command with an explicit collision-free offset, e.g. `KILO_PORT_OFFSET=2100 pnpm dev:start ...` (2100 clears AirPlay: nextjs 5100, metro 10181, wrangler 10889+); 2900 is probe-verified against the same full service-port set (nextjs 5900, metro 10981, kiloclaw 11695, kilo-chat 11708, event-service 11709, session-ingest 11700). Probe before committing to an offset: compute every service port from it and check `lsof` — do not probe only the one port that errored. Per-command prefix only — never `export` it; `apps/mobile/e2e/AGENTS.md` forbids the export because stale shell values select the wrong bundle endpoints, and that rule stands. `dev:status`/`dev:seed`/`login.sh` are manifest- or DB-driven and need no prefix. Restate the prefix rule in every device-phase handoff; a `dev:restart` without it silently recomputes ports at the hash offset and breaks the stack's URL wiring.
diff --git a/.kilo_workflow/pick-reviewers.sh b/.kilo_workflow/pick-reviewers.sh
index c408543cf5..8d8eb995e6 100755
--- a/.kilo_workflow/pick-reviewers.sh
+++ b/.kilo_workflow/pick-reviewers.sh
@@ -35,16 +35,19 @@ PRS=$(
 )
 
 [ -n "$PRS" ] || exit 0
-RESULT=$(
-  for n in $PRS; do
-    # One vote per login per PR — several review submissions on one PR are
-    # still one relationship. Failures propagate; a half-counted ranking is
-    # worse than none.
-    gh pr view "$n" --repo "$REPO" --json reviews \
-      --jq '[.reviews[].author.login] | unique | .[]'
-  done \
-    | grep -viE '(^|[-_/])bot([-_[]|$)|\[bot\]$' \
-    | grep -vixF -- "$HANDLE" \
-    | sort | uniq -c | sort -rn | awk '{print $1, $2}' || true
-)
-[ -z "$RESULT" ] || echo "$RESULT"
+# One vote per login per PR — several review submissions on one PR are still
+# one relationship. A failed lookup aborts the run: a half-counted ranking is
+# worse than none, and only the filters below may legitimately come up empty.
+VOTES=""
+for n in $PRS; do
+  V=$(gh pr view "$n" --repo "$REPO" --json reviews \
+    --jq '[.reviews[].author.login] | unique | .[]') || { echo "pick-reviewers: failed to read reviews of PR #$n" >&2; exit 1; }
+  VOTES+="$V"$'\n'
+done
+# The filters (not the API) may legitimately leave nothing — that is the
+# promised empty success, not an error.
+printf '%s' "$VOTES" \
+  | { grep -viE '(^|[-_/])bot([-_[]|$)|\[bot\]$' || true; } \
+  | { grep -vixF -- "$HANDLE" || true; } \
+  | { grep . || true; } \
+  | sort | uniq -c | sort -rn | awk '{print $1, $2}'
diff --git a/.kilo_workflow/pr-gate.sh b/.kilo_workflow/pr-gate.sh
index 5ec6fe88b8..3d90de7e44 100755
--- a/.kilo_workflow/pr-gate.sh
+++ b/.kilo_workflow/pr-gate.sh
@@ -6,22 +6,51 @@
 # the comment actually approve, are the screenshots real — stay with the
 # agent; this script pins the facts to one head SHA.
 #
-#   pr-gate.sh <owner/repo> <pr>
+#   pr-gate.sh <owner/repo> <pr> [--assignee <handle>] [--label <name>] [--bot <login>] [--wait <sec>]
+#
+#   --assignee   gate-fail unless this handle is among the assignees
+#   --label      gate-fail unless this label is present (monitors: human-ready)
+#   --bot        the reviewing bot's exact login (default kilo-code-bot);
+#                substring 'bot' matching would let any bot vouch for the head
+#   --wait       poll every 120s up to this budget for the bot summary (or
+#                waiver) to appear before reporting; retriggering stays the
+#                orchestrator's move — this only waits
 #
 # Prints the facts, then `GATE FAIL: ...` lines for every mechanical item
 # that does not hold (exit 1), or `GATE OK (mechanical items)` (exit 0).
-# Kilobot comments are printed only when they postdate the head commit —
-# read the newest one's verdict yourself; wording drifts, never string-match.
+# Bot comments are printed only when they postdate the head commit — read the
+# newest one's verdict yourself; wording drifts, never string-match it. A
+# `(bot) Kilobot posted no approving summary...` waiver comment posted after
+# the head satisfies the bot-summary item per the Kilobot loop's waiver rule.
 set -euo pipefail
 
 REPO=${1:?owner/repo} PR=${2:?pr number}
+shift 2
 [[ "$REPO" =~ ^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$ ]] || { echo "repository must be owner/repo" >&2; exit 1; }
+ASSIGNEE="" LABEL="" BOT="kilo-code-bot" WAIT=0
+while [ $# -gt 0 ]; do
+  case $1 in
+    --assignee) ASSIGNEE=${2:?}; shift 2 ;;
+    --label) LABEL=${2:?}; shift 2 ;;
+    --bot) BOT=${2:?}; shift 2 ;;
+    --wait) WAIT=${2:?}; shift 2 ;;
+    *) echo "pr-gate: unknown option $1" >&2; exit 1 ;;
+  esac
+done
 
-DATA=$(gh pr view "$PR" --repo "$REPO" \
-  --json headRefOid,mergeable,mergeStateStatus,statusCheckRollup,assignees,labels,comments)
-
-HEAD_OID=$(jq -r '.headRefOid' <<<"$DATA")
-HEAD_TIME=$(gh api "repos/$REPO/commits/$HEAD_OID" --jq '.commit.committer.date')
+DEADLINE=$(( $(date +%s) + WAIT ))
+while :; do
+  DATA=$(gh pr view "$PR" --repo "$REPO" \
+    --json headRefOid,mergeable,mergeStateStatus,statusCheckRollup,assignees,labels,comments)
+  HEAD_OID=$(jq -r '.headRefOid' <<<"$DATA")
+  HEAD_TIME=$(gh api "repos/$REPO/commits/$HEAD_OID" --jq '.commit.committer.date')
+  BOTCOMMENTS=$(jq -r --arg t "$HEAD_TIME" --arg bot "$BOT" \
+    '[.comments[] | select((.author.login == $bot or (.body | startswith("(bot) "))) and .createdAt > $t)
+      | "\(.author.login) @ \(.createdAt): \(.body | gsub("\\s+"; " ") | .[0:200])"] | .[]' <<<"$DATA")
+  [ -n "$BOTCOMMENTS" ] && break
+  [ "$(date +%s)" -ge "$DEADLINE" ] && break
+  sleep 120
+done
 
 echo "head=$HEAD_OID ($HEAD_TIME)"
 echo "mergeable=$(jq -r '.mergeable' <<<"$DATA") mergeStateStatus=$(jq -r '.mergeStateStatus' <<<"$DATA")"
@@ -34,15 +63,20 @@ BAD_CHECKS=$(jq -r '[.statusCheckRollup[]? | select((.conclusion // .state // "P
   | "\(.name // .context): \(.conclusion // .state // "PENDING")"] | .[]' <<<"$DATA")
 [ -n "$BAD_CHECKS" ] && { echo "checks not green:"; sed 's/^/  /' <<<"$BAD_CHECKS"; } || echo "checks: all green"
 
-UNRESOLVED=$("$(dirname "$0")/pr-threads.sh" unresolved "$REPO" "$PR" | grep -c . || true)
+# Any failure to ENUMERATE threads must fail the gate — a half-paginated
+# thread list reading as "0 unresolved" is exactly the false pass to avoid.
+THREADS_OK=1
+if UNRESOLVED_LIST=$("$(dirname "$0")/pr-threads.sh" unresolved "$REPO" "$PR"); then
+  UNRESOLVED=$(grep -c . <<<"$UNRESOLVED_LIST" || true)
+else
+  THREADS_OK=0
+  UNRESOLVED="?"
+fi
 echo "unresolved_threads=$UNRESOLVED"
 
-KILOBOT=$(jq -r --arg t "$HEAD_TIME" \
-  '[.comments[] | select((.author.login | test("bot"; "i")) and .createdAt > $t)
-    | "\(.author.login) @ \(.createdAt): \(.body | gsub("\\s+"; " ") | .[0:200])"] | .[]' <<<"$DATA")
-if [ -n "$KILOBOT" ]; then
-  echo "bot comments after head commit:"
-  sed 's/^/  /' <<<"$KILOBOT"
+if [ -n "$BOTCOMMENTS" ]; then
+  echo "bot comments after head commit (read the newest verdict yourself):"
+  sed 's/^/  /' <<<"$BOTCOMMENTS"
 else
   echo "bot comments after head commit: NONE"
 fi
@@ -56,8 +90,18 @@ case $MERGEABLE in
   *) gate_fail "not mergeable ($MERGEABLE — resolve conflicts by merging origin/main)" ;;
 esac
 [ -z "$BAD_CHECKS" ] || gate_fail "CI checks not green on head"
-[ "$UNRESOLVED" -eq 0 ] || gate_fail "$UNRESOLVED unresolved review thread(s)"
-[ "$(jq -r '.assignees | length' <<<"$DATA")" -gt 0 ] || gate_fail "no assignee"
-[ -n "$KILOBOT" ] || gate_fail "no bot summary comment postdating the head commit (wait, retrigger, or waive per the Kilobot loop)"
+[ "$THREADS_OK" -eq 1 ] || gate_fail "could not enumerate review threads — fix that before trusting any thread count"
+[ "$THREADS_OK" -eq 1 ] && [ "$UNRESOLVED" != "0" ] && gate_fail "$UNRESOLVED unresolved review thread(s)"
+if [ -n "$ASSIGNEE" ]; then
+  jq -e --arg a "$ASSIGNEE" '.assignees[].login | select(. == $a)' <<<"$DATA" >/dev/null \
+    || gate_fail "not assigned to $ASSIGNEE"
+else
+  [ "$(jq -r '.assignees | length' <<<"$DATA")" -gt 0 ] || gate_fail "no assignee"
+fi
+if [ -n "$LABEL" ]; then
+  jq -e --arg l "$LABEL" '.labels[].name | select(. == $l)' <<<"$DATA" >/dev/null \
+    || gate_fail "label '$LABEL' missing"
+fi
+[ -n "$BOTCOMMENTS" ] || gate_fail "no $BOT summary (or waiver) postdating the head commit — wait, retrigger, or waive per the Kilobot loop"
 [ "$FAIL" -eq 0 ] && echo "GATE OK (mechanical items — verdict wording, screenshots, and learnings are still yours to judge)"
 exit "$FAIL"
diff --git a/.kilo_workflow/pr-threads.sh b/.kilo_workflow/pr-threads.sh
index 035c3ba9c3..c702c2301c 100755
--- a/.kilo_workflow/pr-threads.sh
+++ b/.kilo_workflow/pr-threads.sh
@@ -57,26 +57,30 @@ read_body() {
   printf '%s' "$body"
 }
 
-# The REST reply endpoint wants the thread's FIRST top-level comment id;
-# resolve wants the GraphQL thread id. Look the comment id up from the thread
-# id so callers only ever juggle one identifier.
-first_comment_id() {
+# One lookup answers everything about a thread: its repository (verified
+# against the caller's, so a global node id cannot cross repositories), its PR
+# number (for the REST reply URL), its first top-level comment id (the only
+# valid REST reply target), and its existing comment bodies (so a retried
+# `close` never posts the same reply twice).
+thread_info() {
   gh api graphql -f query='query($id:ID!){node(id:$id){
-    ... on PullRequestReviewThread{comments(first:1){nodes{databaseId}}}}}' \
-    -f id="$1" --jq '.data.node.comments.nodes[0].databaseId'
-}
-
-# The thread's PR number, needed for the REST reply URL.
-thread_pr() {
-  gh api graphql -f query='query($id:ID!){node(id:$id){
-    ... on PullRequestReviewThread{pullRequest{number}}}}' \
-    -f id="$1" --jq '.data.node.pullRequest.number'
+    ... on PullRequestReviewThread{
+      pullRequest{number}
+      repository{nameWithOwner}
+      comments(first:100){nodes{databaseId body}}}}}' -f id="$1"
 }
 
 do_reply() {
-  local thread=$1 body=$2 pr comment
-  pr=$(thread_pr "$thread")
-  comment=$(first_comment_id "$thread")
+  local thread=$1 body=$2 info repo pr comment
+  info=$(thread_info "$thread")
+  repo=$(jq -r '.data.node.repository.nameWithOwner' <<<"$info")
+  [ "$repo" = "$REPO" ] || { echo "pr-threads: thread $thread belongs to $repo, not $REPO" >&2; exit 1; }
+  pr=$(jq -r '.data.node.pullRequest.number' <<<"$info")
+  comment=$(jq -r '.data.node.comments.nodes[0].databaseId' <<<"$info")
+  if jq -e --arg b "$body" '.data.node.comments.nodes[] | select(.body == $b)' <<<"$info" >/dev/null; then
+    echo "reply already posted; not repeating it"
+    return 0
+  fi
   gh api "repos/$REPO/pulls/$pr/comments/$comment/replies" -f body="$body" --jq '.html_url'
 }
 
diff --git a/apps/mobile/e2e/AGENTS.md b/apps/mobile/e2e/AGENTS.md
index fb1dbae563..9175b5c57c 100644
--- a/apps/mobile/e2e/AGENTS.md
+++ b/apps/mobile/e2e/AGENTS.md
@@ -50,7 +50,7 @@ pnpm dev:status --json
 
 Rules:
 
-- Do not export `KILO_PORT_OFFSET` or source `apps/mobile/.env`; stale shell values select the wrong bundle endpoints. Secondary worktrees get an isolated port offset automatically, and startup injects this worktree's LAN URLs before Metro starts. If the automatic offset lands on an occupied port, use a per-command prefix — see `.kilo_workflow/learnings/worktree-port-offset-airplay-collision.md`.
+- Do not export `KILO_PORT_OFFSET` or source `apps/mobile/.env`; stale shell values select the wrong bundle endpoints. Secondary worktrees get an isolated port offset automatically, and startup injects this worktree's LAN URLs before Metro starts. When the automatic offset lands on occupied ports (AirPlay on 5000/7000, another worktree's stack), `dev:start` probes for a free offset itself and persists it in the manifest; later `dev:restart`/`dev:env` reuse the persisted value, so no manual prefix is needed. A per-command `KILO_PORT_OFFSET=<n>` prefix still overrides everything when you must pin one — never `export` it.
 - The `dev:env` step creates the JWT Secrets Store binding. Without it, session-ingest looks healthy but rejects every session request.
 - Secrets Store state is local to each Worker directory. `dev:start` refreshes every source-backed secret for its service graph before launching Workers; a secret-creation failure is fatal, not something to retry past.
 - `event-service` is required for presence and notification behavior.
@@ -84,12 +84,12 @@ pnpm dev:capture mobile
 PR-review E2E needs a local GitHub API instead of `api.github.com`. Three steps, all reversible:
 
 1. Set `GITHUB_API_BASE_URL` in the **worktree root** `.env.local` to the stub's base URL (for example `http://127.0.0.1:<port>`). Next.js reads it via `apps/web/src/lib/github-pr-review/client.ts` (the web `dev` script symlinks root `.env.local` into `apps/web/` when that file is missing). Remove the variable after the run.
-2. Seed a GitHub user token with the dev-only tRPC mutation `githubApps.devSeedUserGithubToken`. Any non-empty token string works. Use a FRESH random `githubUserId` (e.g. `9$(date +%s | tail -c 6)` — the stub never validates it): all worktrees share one postgres, `github_user_id` is unique, and the upsert's conflict target is `(kilo_user_id, github_app_type)`, so reusing a sibling's id errors with a raw drizzle duplicate-key insert instead of returning `false` (see `.kilo_workflow/learnings/mobile-pr-review-entry-github-seed.md`).
+2. Seed a GitHub user token with the dev-only tRPC mutation `githubApps.devSeedUserGithubToken` (the PR-review entry screen only shows the URL input once the user has a token row). Authenticate curl as the E2E user via next-auth fake-login with a cookie jar: `GET /api/auth/csrf`, then `POST /api/auth/callback/fake-login` with `csrfToken`, `email`, and `json=true`, then `POST /api/trpc/githubApps.devSeedUserGithubToken` with the jar. Any non-empty token string works. Use a FRESH random `githubUserId` (e.g. `9$(date +%s | tail -c 6)` — the stub never validates it): all worktrees share one postgres, `github_user_id` is unique, and the upsert's conflict target is `(kilo_user_id, github_app_type)`, so reusing a sibling's id errors with a raw drizzle duplicate-key insert instead of returning `false`. Relaunch the app afterwards so the connection query refetches.
 3. Start the stub in a `kilo-e2e-*` tmux session, for example:
    `tmux new-session -d -s "kilo-e2e-github-stub-$(basename "$PWD")" -c "$PWD/apps/mobile/e2e/github-api-stub" "node server.mjs <port>"`.
    Stop that session when finished. Request logs go to `GITHUB_STUB_LOG` or `./github-api-stub-requests.log` under the process cwd — keep them out of the tree (temp dir) and delete them after the run.
 
-Pinned surface only: REST pull/repo/check-runs/statuses plus GraphQL ops `PrReviewDecision`, `PrReviewThreads`, `PrReviewThreadComments`, `PrReviewConversationComments`. Fixture identities: `kilo-stub/discussion-mixed#1`, `kilo-stub/discussion-conversation-only#2`, `kilo-stub/discussion-empty#3`.
+Pinned surface only: REST pull/repo/check-runs/statuses/`pulls/{n}/files` (paginated via `page`/`per_page`) plus GraphQL ops `PrReviewDecision`, `PrReviewThreads`, `PrReviewThreadComments`, `PrReviewConversationComments`. Fixture identities: `kilo-stub/discussion-mixed#1`, `kilo-stub/discussion-conversation-only#2`, `kilo-stub/discussion-empty#3`.
 
 ## iOS Simulator
 
@@ -154,7 +154,7 @@ When editing the flows, preserve these device-tested constraints:
 - Pass `EMAIL` and `OTP` with `-e`; flow-level defaults override `-e` values in the installed Maestro version.
 - Target the email field by its placeholder `you@example.com`, and tap `Verify code` without trying to dismiss the number pad.
 - The email field is uncontrolled, so a login page left on screen by an earlier run still holds its address, and `inputText` inserts at the caret the tap just dropped mid-string. Erase the field first and assert the typed address before submitting; without that, two attempts interleave into one malformed address and the flow dies 15s later on a missing `Verify code`.
-- Keep every control a flow taps clear of the keyboard. Maestro taps an element's centre, and iOS hands a touch inside `UIRemoteKeyboardWindow` to the keyboard while Maestro still logs the tap `COMPLETED` — a silent no-op. Verify with `maestro --device <udid> hierarchy`: the control's centre must be above the keyboard window's top bound. See `.kilo_workflow/learnings/maestro-tap-swallowed-by-ios-keyboard.md`.
+- Keep every control a flow taps clear of the keyboard. Maestro taps an element's centre, and iOS hands a touch inside `UIRemoteKeyboardWindow` to the keyboard while Maestro still logs the tap `COMPLETED` — a silent no-op. Verify with `e2e/maestro.sh <udid> hierarchy`: the control's centre must be above the keyboard window's top bound. See `.kilo_workflow/learnings/maestro-tap-swallowed-by-ios-keyboard.md`.
 - The native sign-out confirmation is the first case-insensitive `Sign Out` match (`index: 0`).
 
 Seed only when needed. `pnpm dev:seed` with no arguments lists every topic and its usage:
@@ -171,7 +171,7 @@ pnpm dev:seed app:api-token <email>              # mint a bearer token (used by
 One-time machine setup: `brew install maestro`. For MCP, use stdio command `maestro mcp`, then restart the agent session so its tools appear.
 
 - Maestro is the primary automation driver on both iOS and Android. Fall back to `xcrun simctl` (iOS) or repository-wrapped ADB (Android) only when Maestro cannot inspect or operate a native state, or when low-level device control is required. Setup still uses `simctl`/ADB for boot, install, dev-client URL reconnection, screenshots, shutdown, and cleanup.
-- With more than one simulator booted (parallel worktrees), always target by UDID: `maestro --device <udid>` — without it Maestro picks an arbitrary booted simulator and taps silently land on another worktree's device. The Maestro MCP tools mis-target the same way; prefer the CLI plus `simctl` screenshots when several simulators are up.
+- With more than one simulator booted (parallel worktrees), always target by UDID and go through `e2e/maestro.sh <udid> ...` — it serializes per device (the driver is single-tenant) and without an explicit device Maestro picks an arbitrary booted simulator, so taps silently land on another worktree’s device. The Maestro MCP tools mis-target the same way; prefer the CLI plus `simctl` screenshots when several simulators are up.
 - Inspect the screen before selecting elements; re-inspect after UI changes.
 - Never guess a selector from a visible label or screenshot. Copy the exact `txt` or `a11y` value from `maestro_inspect_screen` (`a11y` maps to Maestro `text:`). Maestro text matching is full-string regex, not substring.
 - Tab buttons expose React Navigation's full accessibility labels, not the visible uppercase text. Current iOS labels: `Home, tab, 1 of 4`, `KiloClaw, tab, 2 of 4`, `Agents, tab, 3 of 4`, `Profile, tab, 4 of 4`. `tapOn: 'Agents'` is wrong. Inspect again before relying on these examples; the count and labels can change.
@@ -224,7 +224,7 @@ Do not conclude Android is unavailable from `command -v adb` or the inherited `P
 pnpm dev:mobile:android doctor
 ```
 
-Use the wrappers for all Android tooling, including the Expo/Gradle build, so the resolved SDK/JDK environment is applied. Ordered glue: acquire e2e slot → launch emulator → `claim` at first adb visibility → bounded boot wait → `build` → `login.sh`. Claim the moment the serial is visible, before waiting for boot — adb serials are host-global, and a concurrent worktree's polling loop can claim your fresh emulator during the boot wait (see `mobile-android-emulator-claims.md`). Never unbounded `adb wait-for-device`. Never put manual `adb reverse` or dev-client `am start` on the primary path — `login.sh` preflight does both.
+Use the wrappers for all Android tooling, including the Expo/Gradle build, so the resolved SDK/JDK environment is applied. Ordered glue: acquire e2e slot → launch emulator → `claim` at first adb visibility → bounded boot wait → `build` → `login.sh`. Claim the moment the serial is visible, before waiting for boot — adb serials are host-global, and a concurrent worktree's polling loop can claim your fresh emulator during the boot wait (a lost race means: never drive that device, never kill it, boot another port). Never unbounded `adb wait-for-device`. Never put manual `adb reverse` or dev-client `am start` on the primary path — `login.sh` preflight does both.
 
 ### Launch and GPU policy
 
@@ -235,16 +235,21 @@ Two launch attempts total, then a test-environment blocker with the tail of `$EM
 ANDROID_SESSION="kilo-e2e-android-$(basename "$PWD")"
 EMULATOR_LOG="/tmp/${ANDROID_SESSION}.log"
 GPU_FLAG=host   # attempt 2: swiftshader_indirect only after process death; else host again
+# Explicit free even console port, so YOUR emulator's serial is known up front
+# (emulator-$PORT) and a parallel worktree's launch can never be confused with it.
+PORT=5554; while lsof -nP -iTCP:"$PORT" -sTCP:LISTEN >/dev/null 2>&1; do PORT=$((PORT + 2)); done
 tmux new-session -d -s "$ANDROID_SESSION" -c "$PWD" \
-  "pnpm dev:mobile:android emulator -avd <avd-name> -no-snapshot-save -no-boot-anim -gpu $GPU_FLAG 2>&1 | tee \"$EMULATOR_LOG\""
+  "pnpm dev:mobile:android emulator -avd <avd-name> -port $PORT -no-snapshot-save -no-boot-anim -gpu $GPU_FLAG 2>&1 | tee \"$EMULATOR_LOG\""
 ```
 
+Emulators always launch inside `$ANDROID_SESSION` — the session name is the boot provenance `e2e-slot.sh release` uses to power off exactly the emulators this worktree started. Record `$PORT` in the round handoff so the next round reuses the same serial. Never drive or kill a device claimed by another worktree, and never delete a foreign claim file — if your serial is taken, pick the next free port instead.
+
 ### Bounded boot wait
 
 From the moment of launch, poll about every 15 s until the envelope expires. Cold boot on an idle host ≈ 1–3 minutes; under parallel-workflow load allow up to 8 minutes before declaring the attempt failed (relaunch-rule bounds, not SLAs). Each poll, check in order:
 
 1. **Liveness** — `pgrep -f "qemu.*<avd-name>"` still prints a PID. If empty, the attempt failed with the process-death signal.
-2. **Visibility** — device appears with state `device` in `pnpm dev:mobile:android adb devices -l` (this is where the serial is discovered; a single local emulator is `emulator-5554`). Claim it immediately: `pnpm dev:mobile:android claim <serial>` — do not wait for readiness first.
+2. **Visibility** — `emulator-$PORT` appears with state `device` in `pnpm dev:mobile:android adb devices -l` (poll for YOUR serial, never "the first emulator"). Claim it immediately: `pnpm dev:mobile:android claim emulator-$PORT` — do not wait for readiness first; adb serials are host-global and a concurrent worktree's polling loop can otherwise claim your fresh emulator during the boot wait.
 3. **Readiness** — once visible, `pnpm dev:mobile:android adb -s <serial> shell getprop sys.boot_completed` prints `1`.
 
 Device visibility is not readiness. Never gate on `adb devices` output alone, and never wait on any one stage without the liveness check.
diff --git a/apps/mobile/e2e/maestro.sh b/apps/mobile/e2e/maestro.sh
index dc37d99786..235bdea01a 100755
--- a/apps/mobile/e2e/maestro.sh
+++ b/apps/mobile/e2e/maestro.sh
@@ -9,9 +9,8 @@
 #   e.g. maestro.sh <udid> test -e EMAIL=x flows/login-request-code.yaml
 #
 # Lock: atomic mkdir under ${TMPDIR:-/tmp}/kilo-maestro-locks/<device>, holder
-# PID recorded inside. exec preserves our PID, so the recorded PID is the live
-# maestro process; when it exits, the next waiter reclaims via the dead-PID
-# check. A held lock with a live holder is polled every 2s.
+# PID recorded inside, released by the EXIT trap when maestro ends. A held
+# lock with a live holder is polled every 2s; a dead holder's is reclaimed.
 set -euo pipefail
 
 DEVICE="${1:?usage: maestro.sh <device> <maestro-args...>}"
@@ -33,6 +32,10 @@ done
 trap 'rm -rf "$LOCK"' EXIT
 echo $$ >"$LOCK/pid"
 
-# exec replaces this shell (dropping the trap) but keeps the PID, so the lock
-# is held for exactly maestro's lifetime and reclaimed by the next waiter.
-exec maestro --device "$DEVICE" "$@"
+# Run maestro as a child (no exec): the EXIT trap then releases the lock the
+# moment maestro ends, instead of leaving a dead-PID lock for the next waiter
+# to reclaim — which PID reuse could make look live forever.
+set +e
+maestro --device "$DEVICE" "$@"
+rc=$?
+exit "$rc"

From 359d10fed62d91eb388a1e16639428c5b511c4d5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Wed, 29 Jul 2026 23:20:22 +0200
Subject: [PATCH 06/34] refactor(workflow): idiot-proof the workflow end to end

Ponytail pass over .kilo_workflow plus its dev/local and e2e support code:
split the e2e slot state machine into take/free/status/start/stop scripts,
prune and dedupe learnings, fail loudly on wrong usage everywhere, and act
on three kimi-k3 review rounds (remote-cli required email, slot-status
always-exit-0, pick-reviewers wrong-repo refusal, arg-forwarding wrappers,
slot-aware recovery hint, unknown-subcommand refusal, repo-absolute tsx in
log pipes). Move kilo-design to .agents/skills/kilo-design-cloud and vendor
the grilling skill the workflow references.
---
 .agents/skills/kilo-design-cloud/SKILL.md     |  82 +++
 .agents/skills/kilo-design-cloud/overlay.md   |  72 ++
 .../patterns/cloud-web/primary-actions.md     |  44 ++
 .../patterns/cloud-web/tabs.md                |  41 ++
 .../kilo-design-cloud/reference/brand.md      |  48 ++
 .../reference/interaction-quality.md          |  56 ++
 .../reference/product-judgment.md             |  40 ++
 .../reference/token-architecture.md           |  39 ++
 .../kilo-design-cloud/reference/voice.md      |  33 +
 .kilo/agent/e2e-verifier.md                   |  20 +-
 .kilo/command/kilo-design.md                  |  13 +-
 .kilo/skills/grilling/SKILL.md                |   8 +
 .kilo/skills/kilo-design/AGENTS.md            |  27 -
 .kilo/skills/kilo-design/NOTICE.md            |  46 --
 .kilo/skills/kilo-design/SKILL.md             | 154 -----
 .../reference/color-and-contrast.md           | 178 -----
 .../reference/interaction-design.md           | 278 --------
 .../kilo-design/reference/kilo-brand.md       | 238 -------
 .../kilo-design/reference/motion-design.md    | 197 ------
 .../reference/responsive-design.md            | 202 ------
 .../kilo-design/reference/spatial-design.md   | 190 -----
 .../kilo-design/reference/typography.md       | 180 -----
 .../kilo-design/reference/ux-writing.md       | 253 -------
 .kilo/skills/repository-verification/SKILL.md |   2 +-
 .kilo_workflow/.e2e-slot-state.sh             | 138 ++++
 .kilo_workflow/README.md                      |  17 +-
 .kilo_workflow/WORKFLOW.md                    |  83 +--
 .kilo_workflow/baseline.sh                    |  61 +-
 .kilo_workflow/dispatch-role.sh               |  52 +-
 .kilo_workflow/e2e-free-slot.sh               |   3 +
 .kilo_workflow/e2e-slot-status.sh             |  50 ++
 .kilo_workflow/e2e-slot.sh                    | 338 ---------
 .kilo_workflow/e2e-start-resource.sh          |  21 +
 .kilo_workflow/e2e-stop-resource.sh           |  21 +
 .kilo_workflow/e2e-take-slot.sh               |   3 +
 .kilo_workflow/init-section.sh                | 126 +++-
 .kilo_workflow/launch-gate.sh                 |  26 +
 .kilo_workflow/launch-interactive.sh          |  22 +-
 ...mserver-restart-systemui-anr-under-load.md |  12 +-
 ...roid-picker-tap-races-and-toast-capture.md |  12 +-
 ...v-stack-died-mid-round-restart-in-place.md |  13 +-
 ...-docker-tcp-absent-from-worktree-status.md |   4 +-
 .../maestro-tap-swallowed-by-ios-keyboard.md  |   2 +-
 ...android-dev-client-cold-start-deep-link.md |   5 +-
 .../mobile-android-edge-to-edge-ime-insets.md |   2 +-
 .../mobile-android-global-render-wedge.md     |   2 +-
 .../mobile-android-maestro-flow-pitfalls.md   |   8 +-
 ...-attachments-capability-gate-blocks-e2e.md |   4 -
 ...tro-ios-driver-timeout-stale-xcodebuild.md |   6 +-
 ...-session-ingest-log-empty-use-pipe-pane.md |  14 -
 .../mobile-simulator-claim-killed-mid-boot.md |   6 +-
 .kilo_workflow/pick-reviewers.sh              |  42 +-
 .kilo_workflow/pr-gate.sh                     |  18 +-
 .kilo_workflow/pr-threads.sh                  |  36 +-
 .kilo_workflow/slice-diff.sh                  |   4 +
 AGENTS.md                                     |   4 +-
 CONTRIBUTING.md                               |   5 +-
 DEVELOPMENT.md                                |   5 +-
 apps/mobile/e2e/AGENTS.md                     | 122 ++--
 apps/mobile/e2e/flows/login-request-code.yaml |   2 +-
 apps/mobile/e2e/flows/login-verify-code.yaml  |   2 +-
 apps/mobile/e2e/flows/logout.yaml             |   2 +-
 apps/mobile/e2e/login.sh                      |  48 +-
 apps/mobile/e2e/logout.sh                     |   5 +-
 apps/mobile/e2e/maestro.sh                    |  63 +-
 apps/mobile/e2e/remote-cli.sh                 |  28 +-
 apps/web/AGENTS.md                            |   4 +-
 dev/local/cli.ts                              | 386 +++++++++--
 dev/local/maestro-wrapper.test.ts             |  38 +
 dev/local/mobile-android.test.ts              | 122 ++++
 dev/local/mobile-android.ts                   | 360 +++++++++-
 dev/local/mobile-simulator.ts                 |   7 +-
 dev/local/mobile-workflow.test.ts             |  16 +-
 dev/local/port-offset-lease.test.ts           | 191 ++++++
 dev/local/process-lock.test.ts                |  32 +
 dev/local/process-lock.ts                     |  93 +++
 dev/local/runner.ts                           |  12 +-
 dev/local/services.test.ts                    |  56 +-
 dev/local/services.ts                         |  41 +-
 dev/local/tmux.test.ts                        |  58 +-
 dev/local/tmux.ts                             |  11 +
 dev/local/workflow-scripts.test.ts            | 648 ++++++++++++++++++
 package.json                                  |   7 +-
 skills-lock.json                              |   6 +
 84 files changed, 3187 insertions(+), 2779 deletions(-)
 create mode 100644 .agents/skills/kilo-design-cloud/SKILL.md
 create mode 100644 .agents/skills/kilo-design-cloud/overlay.md
 create mode 100644 .agents/skills/kilo-design-cloud/patterns/cloud-web/primary-actions.md
 create mode 100644 .agents/skills/kilo-design-cloud/patterns/cloud-web/tabs.md
 create mode 100644 .agents/skills/kilo-design-cloud/reference/brand.md
 create mode 100644 .agents/skills/kilo-design-cloud/reference/interaction-quality.md
 create mode 100644 .agents/skills/kilo-design-cloud/reference/product-judgment.md
 create mode 100644 .agents/skills/kilo-design-cloud/reference/token-architecture.md
 create mode 100644 .agents/skills/kilo-design-cloud/reference/voice.md
 create mode 100644 .kilo/skills/grilling/SKILL.md
 delete mode 100644 .kilo/skills/kilo-design/AGENTS.md
 delete mode 100644 .kilo/skills/kilo-design/NOTICE.md
 delete mode 100644 .kilo/skills/kilo-design/SKILL.md
 delete mode 100644 .kilo/skills/kilo-design/reference/color-and-contrast.md
 delete mode 100644 .kilo/skills/kilo-design/reference/interaction-design.md
 delete mode 100644 .kilo/skills/kilo-design/reference/kilo-brand.md
 delete mode 100644 .kilo/skills/kilo-design/reference/motion-design.md
 delete mode 100644 .kilo/skills/kilo-design/reference/responsive-design.md
 delete mode 100644 .kilo/skills/kilo-design/reference/spatial-design.md
 delete mode 100644 .kilo/skills/kilo-design/reference/typography.md
 delete mode 100644 .kilo/skills/kilo-design/reference/ux-writing.md
 create mode 100755 .kilo_workflow/.e2e-slot-state.sh
 create mode 100755 .kilo_workflow/e2e-free-slot.sh
 create mode 100755 .kilo_workflow/e2e-slot-status.sh
 delete mode 100755 .kilo_workflow/e2e-slot.sh
 create mode 100755 .kilo_workflow/e2e-start-resource.sh
 create mode 100755 .kilo_workflow/e2e-stop-resource.sh
 create mode 100755 .kilo_workflow/e2e-take-slot.sh
 create mode 100755 .kilo_workflow/launch-gate.sh
 delete mode 100644 .kilo_workflow/learnings/mobile-session-ingest-log-empty-use-pipe-pane.md
 create mode 100644 dev/local/maestro-wrapper.test.ts
 create mode 100644 dev/local/port-offset-lease.test.ts
 create mode 100644 dev/local/process-lock.test.ts
 create mode 100644 dev/local/workflow-scripts.test.ts

diff --git a/.agents/skills/kilo-design-cloud/SKILL.md b/.agents/skills/kilo-design-cloud/SKILL.md
new file mode 100644
index 0000000000..9e3c0f8efa
--- /dev/null
+++ b/.agents/skills/kilo-design-cloud/SKILL.md
@@ -0,0 +1,82 @@
+---
+name: kilo-design-cloud
+description: Kilo Cloud web UI overlay and pilot pattern recipes. Use when editing or reviewing Kilo Cloud UI paths such as apps/web/src/**, or when the Cloud repo path-scoped trigger requests Kilo design guidance.
+---
+
+# Kilo Design Cloud
+
+This is the first agent-facing adapter for the Kilo design system. It covers Kilo Cloud's web app and the first Cloud pattern recipes.
+
+## Run Order
+
+1. If the task has a target Cloud file, read it first. For components, also read the matching primitive in `apps/web/src/components/ui/`.
+2. If the task asks for a standalone mockup, prototype, or self-contained HTML with no target Cloud file, use Standalone Generation Mode.
+3. Load `overlay.md` for all Cloud UI work.
+4. Load one internal reference only when the task needs it: product judgment, brand, token architecture, voice, or interaction quality.
+5. Load at most one matching recipe unless the task clearly spans multiple patterns.
+6. If no recipe exists, use the overlay plus current Cloud code and report a coverage gap.
+7. Keep broad product cleanup out of focused tasks.
+8. Do not use playground specimen UI as a Cloud Canonical Example.
+
+Completion criterion: the answer or change names the loaded overlay/recipe, follows real Cloud code, and does not normalize unrelated UI.
+
+## Token Contract
+
+- Cloud's generated token artifact is `src/tokens.cloud.ts`.
+- Cloud UI code maps token values through `apps/web/src/app/globals.css` and semantic roles such as `--primary`, `--background`, and `--ring`.
+- Do not use `src/tokens.landing.css` or `src/tokens.extension-host-map.md` as Cloud UI sources.
+
+## Recipe Router
+
+| Prompt or file signal | Load |
+| --- | --- |
+| primary action, CTA, button hierarchy, blue button drift | `patterns/cloud-web/primary-actions.md` |
+| tabs, segmented navigation, Radix tabs, active tab state | `patterns/cloud-web/tabs.md` |
+| tokens, globals.css, semantic mapping | `reference/token-architecture.md`; record that Cloud token adoption is `VVV-130` |
+| copy, empty states, labels, errors, confirmations | `reference/voice.md` |
+| forms, focus, keyboard, overlays, responsive layout, touch targets, loading, disabled, motion | `reference/interaction-quality.md` |
+| badges, alerts, dialogs, sidebar, empty states | `overlay.md`; report coverage gap if a rule is missing |
+| standalone mockup, prototype, generated HTML, arena pass, no target Cloud file | Standalone Generation Mode |
+| login, auth, workspace slug, returning team, security status | `reference/brand.md`; `reference/voice.md`; `reference/token-architecture.md`; `reference/interaction-quality.md`; `patterns/cloud-web/primary-actions.md` |
+
+## Standalone Generation Mode
+
+Use this mode only when the task asks for generated UI without a real Cloud source file to read. The goal is a product-faithful Kilo Cloud surface, not a generic SaaS screen with Kilo labels.
+
+Load these before designing:
+
+1. `overlay.md`
+2. `reference/brand.md`
+3. `reference/voice.md`
+4. `reference/token-architecture.md`
+5. `reference/interaction-quality.md` when the surface includes forms, auth, overlays, responsive behavior, loading, disabled, error, or success states
+6. One matching pattern recipe when available
+
+Allowed read-only product artifact: `src/tokens.cloud.ts` when exact token values are needed.
+
+Generated standalone HTML should:
+
+- Define semantic CSS roles such as `--background`, `--foreground`, `--card`, `--muted-foreground`, `--primary`, `--primary-foreground`, `--border`, `--input`, and `--ring`.
+- Resolve `--primary` to Kilo brand primary and `--primary-foreground` to Kilo brand foreground when writing self-contained CSS.
+- Use Kilo Cloud product nouns from the prompt: workspaces, teams, agent runs, tool calls, changed files, billing, subscriptions, KiloClaw, security, or operational status.
+- Stay compact, dark-first, technical, and task-oriented.
+- Keep generated product UI free of guidance notes, gap reports, arena labels, skill labels, or comparison text.
+
+## Non-Goals
+
+- Do not build Landing, Editor, Console, Mobile, JetBrains, or CLI guidance here.
+- Do not recreate a Cloud `DESIGN.md`.
+- Do not migrate every hardcoded blue button unless the task is `primary-actions` implementation.
+- Do not invent recipes without a real Canonical Example in shipped Cloud code.
+- Do not copy UI structures from `playground/`; it previews token behavior only.
+
+## Reference Map
+
+- `overlay.md`: Cloud product overlay and known drift.
+- `reference/product-judgment.md`: modes, authority order, and coverage gaps.
+- `reference/brand.md`: Cloud use of Kilo brand language.
+- `reference/token-architecture.md`: how Cloud agents should read product-facing token artifacts.
+- `reference/voice.md`: Kilo Cloud UI copy rules.
+- `reference/interaction-quality.md`: interaction states, form behavior, overlays, responsive checks, touch, and motion.
+- `patterns/cloud-web/primary-actions.md`: primary CTA and button hierarchy recipe.
+- `patterns/cloud-web/tabs.md`: Cloud tab recipe.
diff --git a/.agents/skills/kilo-design-cloud/overlay.md b/.agents/skills/kilo-design-cloud/overlay.md
new file mode 100644
index 0000000000..cb13d8e529
--- /dev/null
+++ b/.agents/skills/kilo-design-cloud/overlay.md
@@ -0,0 +1,72 @@
+# Kilo Cloud Overlay
+
+Cloud is the pilot product for Kilo's agent-consumable design system. It is a dense, dark-first infrastructure console built with Next.js, React, Tailwind, shadcn/ui, Radix, and `lucide-react`.
+
+## Product Intent
+
+- Help teams understand workspaces, billing, subscriptions, KiloClaw, and operational status without marketing noise.
+- Stay compact and task-oriented. Cloud can be visually polished, but it should not feel like a landing page.
+- Make one action obvious per surface. Surrounding actions should be secondary, ghost, outline, or links.
+
+## Code Sources To Read First
+
+| Concern | Cloud path |
+| --- | --- |
+| Base theme and Tailwind tokens | `apps/web/src/app/globals.css` |
+| Font variables | `apps/web/src/app/layout.tsx` |
+| shadcn config | `apps/web/components.json` |
+| UI primitives | `apps/web/src/components/ui/*.tsx` |
+| Legacy button drift | `apps/web/src/components/Button.tsx` |
+
+## Token Mapping
+
+Use semantic roles, not raw values:
+
+| Role | Cloud token |
+| --- | --- |
+| Page background | `--background` / `bg-background` |
+| Default text | `--foreground` / `text-foreground` |
+| Raised surface | `--card`, `--popover` |
+| Secondary surface | `--secondary`, `--muted`, `--accent` |
+| Muted text | `--muted-foreground` |
+| Primary action | `--primary` / `bg-primary` |
+| Primary action text | `--primary-foreground` / `text-primary-foreground` |
+| Border and focus | `--border`, `--input`, `--ring` |
+
+Known drift: Cloud token adoption is tracked by `VVV-130`. Until that lands, recipe guidance should still point agents at semantic roles, not hardcoded replacements.
+
+## Cloud Rhythm
+
+- Controls are compact: `h-8`, `h-9`, `h-10`; icons are usually `size-4`.
+- Cards and dialogs use existing shadcn primitives before custom containers.
+- Prefer `gap-*` and grouped spacing over dividers between every row.
+- Keep status color as small signals: badges, inline text, rings, or charts. Do not let status hues become the UI palette.
+- Use Inter for UI and Roboto Mono for code, identifiers, token names, and tabular data.
+- Treat focus, disabled, loading, error, and responsive states as part of the surface, not follow-up polish.
+
+## Cloud Anti-Patterns
+
+- Blue button fills as primary actions.
+- Yellow-green applied to multiple unrelated controls.
+- Equal-card dashboard grids when the task has one focal action.
+- New component libraries or new design primitives when shadcn/Radix already exists.
+- Marketing copy, fake slogans, avatars, decorative AI stars, glass panels, or gradient text inside product UI.
+- Hover-only required actions, missing focus-visible states, or custom overlay behavior that bypasses Radix.
+- Large implementation sweeps before the matching recipe exists.
+
+## Current Coverage
+
+Covered now:
+
+- Primary actions.
+- Tabs.
+
+Known gaps:
+
+- Status badges.
+- Alerts and feedback banners.
+- Dialogs and destructive confirmations.
+- Sidebar/topbar chrome.
+- Empty states.
+
+When a gap appears in real work, use the nearest shipped code and report the missing recipe instead of adding broad rules.
diff --git a/.agents/skills/kilo-design-cloud/patterns/cloud-web/primary-actions.md b/.agents/skills/kilo-design-cloud/patterns/cloud-web/primary-actions.md
new file mode 100644
index 0000000000..41446d7891
--- /dev/null
+++ b/.agents/skills/kilo-design-cloud/patterns/cloud-web/primary-actions.md
@@ -0,0 +1,44 @@
+# Cloud Web Pattern: Primary Actions
+
+Pattern ID: `cloud-web.primary-actions`
+
+## When To Use
+
+Use this recipe when a Cloud surface has a main CTA, button hierarchy, primary button drift, or hardcoded blue button background.
+
+## Rule
+
+Each surface gets one primary action. It uses the semantic primary action role, not a color name. Secondary choices use secondary, outline, ghost, destructive, or link variants.
+
+## Canonical Example
+
+Real code to copy:
+
+- `apps/web/src/components/ui/button.tsx`
+- The current shared `Button` primitive and its current variant source in the Cloud repo.
+- Primary action styling should resolve to semantic `primary` and `primary-foreground` tokens.
+
+Before adopting this recipe in Cloud, verify the exact current variant file and class string from the active Cloud branch. Do not copy legacy color variants when building new Cloud UI.
+
+## Implementation Rules
+
+- Use `<Button>` with the default variant for the primary action.
+- Use `variant="secondary"`, `variant="outline"`, `variant="ghost"`, or `variant="link"` for lower-emphasis actions.
+- Use `variant="destructive"` only for destructive actions.
+- Do not create new color variants for one-off product needs.
+- Do not use blue backgrounds for CTAs. Blue is acceptable for inline links and legacy drift only.
+- Keep labels specific: `Create workspace`, `Save changes`, `Delete project`.
+- Include disabled, loading, focus-visible, and responsive behavior when the surrounding component owns those states.
+
+## Review Checklist
+
+- Is there only one primary action in the visible decision area?
+- Does the primary action use semantic `primary` tokens?
+- Are secondary actions visually subordinate?
+- Are hardcoded blue CTA fills removed or explicitly called out as drift?
+- Does the label name the action and object?
+
+## Known Drift
+
+- Legacy Cloud button variants may still exist outside the shared primitive; verify on the active Cloud branch before migration.
+- Cloud token adoption in `globals.css` is tracked separately by `VVV-130`.
diff --git a/.agents/skills/kilo-design-cloud/patterns/cloud-web/tabs.md b/.agents/skills/kilo-design-cloud/patterns/cloud-web/tabs.md
new file mode 100644
index 0000000000..c192c7e0dd
--- /dev/null
+++ b/.agents/skills/kilo-design-cloud/patterns/cloud-web/tabs.md
@@ -0,0 +1,41 @@
+# Cloud Web Pattern: Tabs
+
+Pattern ID: `cloud-web.tabs`
+
+## When To Use
+
+Use this recipe for Cloud tab bars, segmented navigation, Radix tab groups, and active tab state review.
+
+## Rule
+
+Use the Cloud shadcn/Radix tabs primitive. Tabs are compact, neutral, and structural. They should not compete with the page's primary action.
+
+## Canonical Example
+
+Real code to copy:
+
+- `apps/web/src/components/ui/tabs.tsx`
+- `TabsList`: `bg-muted text-muted-foreground inline-flex h-9 ... rounded-lg p-1`
+- `TabsTrigger`: compact trigger with active `text-foreground`, border, transparent fill, and shadow
+
+## Implementation Rules
+
+- Import `Tabs`, `TabsList`, `TabsTrigger`, and `TabsContent` from `@/components/ui/tabs`.
+- Do not hand-roll tabs with buttons, anchors, or custom state when Radix tabs fit.
+- Keep tab lists compact: `h-9`, `p-1`, `rounded-lg`.
+- Use neutral active states. Do not use brand primary or status colors for normal active tabs.
+- Keep labels short and scannable. Avoid invented category names.
+- Preserve keyboard behavior by using the Radix wrapper.
+- Keep tab content spacing connected to the tab list; do not turn every panel into a nested card.
+
+## Review Checklist
+
+- Does the surface use the shared tabs primitive?
+- Is the active state neutral and readable?
+- Is keyboard behavior preserved?
+- Are tab labels short and concrete?
+- Is the tab group subordinate to the page's main task?
+
+## Known Drift
+
+The current primitive is the Canonical Example. If a future Cloud surface needs a different tab density or orientation, record the need as a coverage gap before creating another tab style.
diff --git a/.agents/skills/kilo-design-cloud/reference/brand.md b/.agents/skills/kilo-design-cloud/reference/brand.md
new file mode 100644
index 0000000000..de321fcf0a
--- /dev/null
+++ b/.agents/skills/kilo-design-cloud/reference/brand.md
@@ -0,0 +1,48 @@
+# Kilo Brand For Cloud
+
+Kilo Cloud is dark-first, precise, calm, technical, and compact. It should feel like engineering infrastructure software, not a marketing page.
+
+## Shared Defaults
+
+- Dark-only surfaces: near-black canvas, raised charcoal panels, muted gray secondary text.
+- Typography: Inter for UI, Roboto Mono for code and identifiers.
+- Shape: compact radii, rounded controls, existing shadcn/Radix primitives.
+- Motion: short and functional. Brand flourish is punctuation, not a default.
+- Primary action: one semantic primary action per visible decision area.
+
+## Brand Primary
+
+`tokens.json` defines the source values:
+
+```text
+color.brand.primary = #F7F586
+color.brand.foreground = #1F1F1F
+```
+
+In daily Cloud work, say `primary action token`, not `#F7F586`, unless editing token source or generated artifact docs.
+
+In standalone generated HTML, define the semantic primary role from these values:
+
+```text
+--primary = #F7F586
+--primary-foreground = #1F1F1F
+```
+
+## Product Signals
+
+Kilo Cloud should be recognizable through product structure, not decorative branding.
+
+- Use real Cloud nouns when relevant: workspace, team, agent run, tool call, changed files, token usage, billing, subscription, security status, KiloClaw.
+- Treat workspace identifiers, slugs, run IDs, file paths, and usage numbers as technical data; use monospace sparingly for those values.
+- Keep the brand mark compact and utilitarian. Do not make a large logo lockup the main composition.
+- Primary actions use the brand primary token. Secondary actions stay neutral.
+- Status colors stay small: badges, inline text, rings, or compact indicators.
+
+## Reject
+
+- Neutral or gray primary actions.
+- Blue button fills used as primary CTAs.
+- Yellow-green applied to many unrelated controls.
+- Purple gradient heroes, glass panels, glossy surfaces, or decorative AI sparkle language.
+- New font families outside Cloud's contract.
+- Light-mode-only Cloud designs.
diff --git a/.agents/skills/kilo-design-cloud/reference/interaction-quality.md b/.agents/skills/kilo-design-cloud/reference/interaction-quality.md
new file mode 100644
index 0000000000..2bd77cd6f5
--- /dev/null
+++ b/.agents/skills/kilo-design-cloud/reference/interaction-quality.md
@@ -0,0 +1,56 @@
+# Interaction Quality
+
+This reference is for Cloud UI tasks where behavior, accessibility, responsive layout, forms, overlays, touch, or motion are part of the change.
+
+## Load When
+
+- The task touches forms, inputs, validation, focus, keyboard behavior, overlays, dialogs, dropdowns, popovers, tabs, tooltips, or sheets.
+- The task changes responsive layout, touch behavior, loading states, disabled states, error states, success states, or animation.
+- A review asks whether a surface feels usable, shippable, accessible, or polished.
+
+## Interactive States
+
+Changed interactive controls account for the states they can enter: default, hover, focus-visible, active, disabled, loading, error, and success.
+
+- Hover is never the only way to reach a required action.
+- Disabled and loading states preserve layout and explain blocked progress when the reason is not obvious.
+- Focus-visible states use the existing ring/token system. Do not remove browser or Radix focus behavior to make a design look cleaner.
+- Icon-only controls need an `aria-label` that names the action.
+
+## Forms
+
+- Use visible labels. Placeholder text is not a label.
+- Put field errors next to the field and connect help or error text with `aria-describedby` where the component supports it.
+- Validate on blur for ordinary fields. Password strength can update while typing.
+- Use the correct input type and autocomplete attributes for common fields.
+- Error copy says what failed, why if knowable, and what to try next.
+
+## Overlays
+
+- Use existing shadcn/Radix wrappers for dialogs, dropdowns, popovers, selects, tabs, tooltips, and sheets.
+- Do not hand-roll positioning, focus traps, Escape behavior, outside-click behavior, or arrow-key navigation.
+- Preserve Radix keyboard semantics when styling trigger, content, and item states.
+- Destructive confirmations are for irreversible or high-stakes actions. Prefer undoable feedback for reversible actions.
+
+## Responsive And Touch
+
+- Check at least 375px, 768-1024px, and 1440px+ when the task changes layout.
+- Long workspace names, emails, plan names, token labels, and billing values must wrap, truncate, or collapse intentionally.
+- Cards, forms, and tables reflow before hiding important controls.
+- Touch targets should reach 44px even when the visual control is compact.
+- Use the existing Cloud sidebar and navigation behavior before inventing a mobile-specific nav.
+
+## Motion
+
+- Product motion is short and functional: 100-200ms for direct feedback, 200-300ms for larger state changes.
+- Prefer opacity and transform. Do not casually animate width, height, top, left, or grid placement.
+- Respect `prefers-reduced-motion` for anything beyond trivial hover or focus feedback.
+- Do not add bouncy, elastic, or playful easing to infrastructure UI.
+- Do not hand-animate Radix overlays when the existing primitive already handles entry and exit behavior.
+
+## Layout Discipline
+
+- Use 4px-aligned spacing and `gap-*` before ad hoc margins.
+- Do not nest cards inside cards. Use spacing, headings, dividers, or muted sections to separate related content.
+- Use surface roles for dark-mode depth, not heavy shadows.
+- Use tabular numbers for billing, usage, quota, and table values.
diff --git a/.agents/skills/kilo-design-cloud/reference/product-judgment.md b/.agents/skills/kilo-design-cloud/reference/product-judgment.md
new file mode 100644
index 0000000000..2eaa1b84ac
--- /dev/null
+++ b/.agents/skills/kilo-design-cloud/reference/product-judgment.md
@@ -0,0 +1,40 @@
+# Product Judgment
+
+This reference is for agent behavior inside Cloud UI work. It is not product code guidance by itself.
+
+## Modes
+
+| Mode | Do | Done when |
+| --- | --- | --- |
+| Shape | Clarify a flow, hierarchy, states, and tradeoffs. Do not edit. | The recommendation is concrete enough to implement. |
+| Implement | Make the smallest coherent Cloud code change. | Changed code matches the overlay or recipe, or calls out a gap. |
+| Review | Inspect code/screens and report findings. Do not edit. | Findings cite paths, severity, rule, fix, and relevant interaction or responsive gaps. |
+| Copy | Improve labels, empty states, errors, and confirmations. | Copy says what happened and what to do next. |
+
+## Authority Order
+
+Use this order when sources disagree:
+
+1. User's explicit goal.
+2. Real Cloud behavior and constraints.
+3. Product-facing assets: `tokens.json`, generated `src/` artifacts, and host map.
+4. This skill's Cloud overlay.
+5. Matching Pattern Recipe.
+6. Canonical Example in shipped Cloud code.
+7. Nearby shipped UI.
+8. General interface heuristics.
+
+Token values are prescriptive. Shipped Cloud code that disagrees with `tokens.json` is Drift.
+
+The playground is not in the authority order for Cloud implementation. Its specimens can help spot token problems, but they are not product code and must not be cited as Canonical Examples.
+
+## Coverage Gaps
+
+If no overlay rule or recipe exists:
+
+- Use current Cloud code and product-facing assets for the smallest safe choice.
+- Say which guidance is missing.
+- Do not invent a new recipe unless repeated drift proves the need.
+- Do not block unrelated work because a recipe is missing.
+
+For UI reviews, include interaction quality only when relevant to the changed surface: focus-visible behavior, keyboard behavior, responsive breakpoints, reduced motion, and loading, disabled, error, or success states.
diff --git a/.agents/skills/kilo-design-cloud/reference/token-architecture.md b/.agents/skills/kilo-design-cloud/reference/token-architecture.md
new file mode 100644
index 0000000000..572fada6b4
--- /dev/null
+++ b/.agents/skills/kilo-design-cloud/reference/token-architecture.md
@@ -0,0 +1,39 @@
+# Token Architecture
+
+The design-system core for products is the token source and generated artifacts, not this skill.
+
+## Layers
+
+1. `tokens.json` stores raw/source values.
+2. `src/tokens.landing.css`, `src/tokens.cloud.ts`, and `src/tokens.extension-host-map.md` expose values per target.
+3. Cloud maps generated values to semantic UI roles in `apps/web/src/app/globals.css`.
+4. Recipes tell agents which semantic roles to use for repeated Cloud patterns.
+5. Component tokens wait until repeated drift proves they are needed.
+
+The playground sits outside this product-consumption path. It previews and edits token values, but Cloud implementation decisions still come from Cloud code, semantic roles, and recipes.
+
+## Agent Rules
+
+- Prefer semantic roles over raw values in Cloud code.
+- Do not hardcode hex unless the task explicitly accepts legacy debt.
+- Do not rename token concepts for local convenience.
+- Do not add component tokens before repeated drift proves the need.
+- Treat primitive or semantic value changes as high risk.
+
+## Product Artifact Names
+
+| Product surface | Generated artifact |
+| --- | --- |
+| Cloud | `src/tokens.cloud.ts` |
+| Landing | `src/tokens.landing.css` |
+| VS Code, JetBrains, CLI/ANSI | `src/tokens.extension-host-map.md` |
+
+## Naming Discipline
+
+| Prefer | Avoid |
+| --- | --- |
+| primary action | yellow button |
+| muted foreground | gray text |
+| raised surface | dark card |
+| danger feedback | red alert |
+| focus ring | green glow |
diff --git a/.agents/skills/kilo-design-cloud/reference/voice.md b/.agents/skills/kilo-design-cloud/reference/voice.md
new file mode 100644
index 0000000000..80b3bacfd9
--- /dev/null
+++ b/.agents/skills/kilo-design-cloud/reference/voice.md
@@ -0,0 +1,33 @@
+# Kilo Cloud Voice
+
+Kilo Cloud voice is clear, technical, calm, and direct.
+
+## Rules
+
+- Use concrete verbs and specific nouns.
+- Use verb + object for actions: `Create workspace`, `Save changes`, `Delete project`.
+- Use one term per concept and keep it across a surface.
+- Destructive labels name the action and object. Bulk destructive labels include the count when available.
+- Errors answer what happened, why if knowable, and what to try next.
+- Loading copy names the operation: `Creating workspace...`, not `Loading...`.
+- Long waits set expectations with time, phase, or next checkpoint when the product can know it.
+- Empty states acknowledge the empty state, explain value, and offer one action.
+- Link text stands on its own. Do not use `Click here`.
+
+## Avoid
+
+- `OK`, `Submit`, `Yes`, `No`, and `Click here` as action labels.
+- `Oops`, `Whoops`, jokes, or emoji in errors.
+- Hype words: powerful, seamless, effortless, revolutionary, magical, unlock.
+- User-facing stack traces or `Error:` prefixes.
+
+## Examples
+
+| Weak | Better |
+| --- | --- |
+| Submit | Create workspace |
+| OK | Save changes |
+| Yes | Delete project |
+| Delete | Delete 3 workspaces |
+| No invoices | No invoices yet. Your first invoice appears after your trial ends. |
+| Invalid input | Email must include an @ symbol. Example: you@example.com |
diff --git a/.kilo/agent/e2e-verifier.md b/.kilo/agent/e2e-verifier.md
index 896d8c8f6c..89c6f1f738 100644
--- a/.kilo/agent/e2e-verifier.md
+++ b/.kilo/agent/e2e-verifier.md
@@ -9,12 +9,11 @@ permission:
   task: deny
   bash:
     "*": allow
-  maestro_*: allow
 ---
 
-You are an independent final E2E verifier for an approved change (see `.kilo_workflow/WORKFLOW.md`). You verify that the goals of the plan have been met by the new implementation: you start local services, point local clients (apps, simulators, emulators, browsers, CLIs) at them, and exercise the accepted behavior. Everything is verified fully locally. You verify only; you must be a fresh invocation.
+You are an independent final E2E verifier for an approved change (see `.kilo_workflow/WORKFLOW.md`). You verify that the goals of the plan have been met by the new implementation: use the local services and clients assigned in the handoff and exercise the accepted behavior. Everything is verified fully locally. You verify only; you must be a fresh invocation.
 
-Repro mode: when the handoff assigns repro mode, no fix exists yet. You run on the unmodified baseline, and success means demonstrating the reported failing behavior: exact reproduction steps, evidence, and a failure classification. `CANNOT REPRODUCE.` is an honest outcome — report it with evidence of every attempt. Never force a reproduction, and never fix or route around the defect. Every setup, safety, temporary-edit, and cleanup rule below still applies.
+Repro mode: when the handoff assigns repro mode, no fix exists yet. You run on the unmodified baseline, and success means demonstrating the reported failing behavior: exact reproduction steps, evidence, and a failure classification. `CANNOT REPRODUCE.` is an honest outcome — report it with evidence of every attempt. A test-environment failure or inconclusive result is `VERIFICATION BLOCKED.` in repro mode too. Never force a reproduction, and never fix or route around the defect. Every setup, safety, temporary-edit, and cleanup rule below still applies.
 
 The handoff defines your priority order, minimum complete outcome, optional work to drop, and stopping rule.
 
@@ -22,18 +21,21 @@ Before testing:
 
 1. Read the learnings — the worktree's `.kilo_workflow/learnings/` plus the main checkout's `~/Projects/cloud/.kilo_workflow/learnings/system/` — then the surface-specific runbook, and follow it exactly for services, device claiming, builds, login, automation drivers, prompts, and cleanup — mobile: `apps/mobile/e2e/AGENTS.md`; extension: `apps/extension/AGENTS.md`; web and services: `DEVELOPMENT.md` and the repository dev runner. Never bypass a helper script's preflight, install unvalidated builds, or guess selectors.
 2. Translate the plan's goals and acceptance criteria into observable flows; for user-facing features, cover the happy, retryable-unhappy, non-retryable-unhappy, and empty states. Batch aggressively: one booted device, one running stack, and one logged-in app session can verify MANY criteria — plan a route through the app that covers every reachable criterion in sequence and only relaunch, re-login, or reboot when a criterion genuinely requires fresh state. Separate runs per scenario burn device time and slot hours for nothing.
-3. Record pre-existing services, listeners, devices, and tmux sessions so cleanup removes only resources you created — this protects FOREIGN resources (other worktrees' stacks, devices you did not claim). Your own worktree's already-running stack is different: acquiring the slot adopts it, and slot release will stop it. Never use a device claimed by another worktree.
-4. Immediately before starting a stack, booting a simulator or emulator, or running a native build — and only then, never while you are still reading or planning — acquire the machine device slot: `.kilo_workflow/e2e-slot.sh acquire` (no argument — it resolves your own tmux session and refuses to run outside one; if it refuses, stop and report a test-environment blocker rather than passing a guessed name). This is mandatory on every run — the machine is shared and unslotted device work overloads it. The command blocks until a slot frees; blocking is correct behavior, never a wedge to work around, and never a reason to proceed unslotted.
-5. Before any temporary edit, record the baseline: `.kilo_workflow/baseline.sh snapshot <worktree> $SCRATCH/baseline` (one per in-scope worktree, always outside every repository). Separately copy the original bytes and mode of every tracked file you plan to edit — the snapshot proves divergence; your copies are what restore it. Temporary edits may touch only paths that are clean and tracked at baseline, or brand-new paths — never a pre-existing modified, staged, or untracked path.
+3. Confirm the handoff names the live slot-bundle owner, worktree services, and your assigned devices. The planner owns a repro bundle; the orchestrator owns a verification bundle. Never take another slot or start, stop, or replace its resources. Stop immediately with `VERIFICATION BLOCKED.` if the handoff omits ownership or an assigned resource is not ready.
+4. Record pre-existing services, listeners, devices, and tmux sessions. Never stop another worktree's stack or use a device claimed by another worktree.
+5. Before any temporary edit, set `WT` to each in-scope worktree and record its own baseline: `.kilo_workflow/baseline.sh snapshot "$WT" "$SCRATCH/baseline-$(basename "$WT")" --include .env.local --include apps/mobile/.env.local` (always outside every repository). Add another repeatable `--include <repo-relative-path>` for any other ignored file the handoff permits. Use the identical directory and include flags for the final `check`. Separately copy the original bytes and mode of every tracked file you plan to edit — the snapshot proves divergence; your copies are what restore it. Temporary edits may touch only paths that are clean and tracked at baseline, or brand-new paths — never a pre-existing modified, staged, or untracked path.
 
 Output discipline — long verification runs die when their session payload grows too large. Cap every shell command's output (`| tail -c 1500` or `| tail -5`); write hierarchies, captures, and service logs to files and print only greps or counts; never re-read screenshots into context; keep your final report bounded.
 
 During verification:
 
 - Exercise every applicable flow and feature state that can be produced safely and deterministically. Never silently skip one; report each skip with a rationale.
+- Fail fast on the first confirmed product failure in your assigned platform scope: capture enough evidence to classify and reproduce it, mark every later case unrun, clean up, and return `VERIFICATION FAILED.` Do not keep testing after the verdict is inevitable. A sibling platform verifier already running in parallel continues its own scope.
+- In a follow-up round, run the repaired failing case first, then every previously passed case in the same page, flow, component, or shared-dependency area, plus every case no completed round has proved. A handoff may carry forward a previously passed case only when it names that case and gives concrete changed-file or dependency evidence that the fix cannot affect it; independently reject a weak rationale and run the case. Carried-forward proof is not a skip.
 - Retryable and empty states: a meaningful message plus a CTA that performs the expected recovery or next step. Non-retryable states: a meaningful message with no CTA at all.
 - Inspect backend or service logs when a flow crosses those boundaries.
 - Capture concise evidence: screenshots, exact visible state, and bounded log excerpts. Never credentials.
+- Run every Maestro command through `apps/mobile/e2e/maestro.sh <device> ...`; do not use Maestro MCP tools, which bypass the device mutex.
 - Never create proxies, redirects, tunnels, NAT rules, or listeners to compensate for stale client or bundler state — with any tool.
 - Never dispatch agents, and never commit, push, or create or update a PR. Permissions restrict nothing except agent dispatch (`task`); this boundary is the instruction — the orchestrator owns all Git and PR actions.
 - Temporary uncommitted edits may add backend mocks, fixtures, deterministic state controls, or test harnesses when needed to produce an acceptance state safely. Use the smallest localized change and record every touched file.
@@ -50,16 +52,16 @@ Classify every failure as exactly one of:
 
 Attempt one reasonable recovery for a test-environment failure. Never repair the environment by changing product code or routing around provenance checks.
 
-Before returning, for any reason, in this order: stop the processes you started that the slot does not own — recorders, log followers, relays, stub servers; then `.kilo_workflow/e2e-slot.sh release`, which stops the worktree's dev stack, hands back every claimed device, and kills the worktree's emulator session (never `simctl shutdown` a claimed device, kill the emulator session, or `dev:stop` the stack yourself — the slot owns all of it); then delete every temporary path you created and restore every edited tracked file byte-for-byte with its original mode. Prove the restore with `.kilo_workflow/baseline.sh check <worktree> $SCRATCH/baseline` — anything but `OK` is a verification failure: report every diverging file it prints and do not claim acceptance passed.
+Before returning, delete every temporary path you created and restore every edited tracked file byte-for-byte with its original mode. Never stop or free the dispatcher's slot bundle; it remains the dispatcher's cleanup responsibility even when this verifier fails or crashes. For each `WT`, prove the restore with `.kilo_workflow/baseline.sh check "$WT" "$SCRATCH/baseline-$(basename "$WT")" --include .env.local --include apps/mobile/.env.local` plus the same extra includes used at snapshot — anything but `OK` is a verification failure: report every diverging file it prints and do not claim acceptance passed.
 
 Return:
 
 - Resource manifest: worktree path, service status and ports, claimed devices, and every intentionally retained process or listener with its cleanup owner
 - Flows exercised and platform
-- Pass, fail, or skipped for every acceptance criterion and applicable feature state, with a rationale for each skip
+- Pass, fail, unrun after fail-fast, carried forward, or skipped for every acceptance criterion and applicable feature state; cite the prior round's evidence and the concrete disjoint-impact rationale for every carried-forward case, and give a rationale for each skip
 - Failure classification, exact reproduction steps, and evidence
 - Cleanup performed, plus evidence that the final Git state exactly matches the pre-verification baseline
 - Learnings written or updated, if any
 - If stopping early: completed work, remaining work, failures, resources touched, checks run or deferred, and the safest next action
 
-End your report with exactly one sentinel line — and the sentinel must follow from the report, never precede it: `VERIFICATION PASSED.` only when every required criterion and feature state passed and the cleanup baseline matched; a product failure is `VERIFICATION FAILED.`; a skipped required state, test-environment failure, inconclusive classification, or baseline mismatch is `VERIFICATION BLOCKED.`; otherwise `STOPPED EARLY.` In repro mode, `REPRODUCED.` or `CANNOT REPRODUCE.` Your dispatcher treats a log without a sentinel as a void round — a crashed run, never a pass.
+End your report with exactly one sentinel line — and the sentinel must follow from the report, never precede it: `VERIFICATION PASSED.` only when every criterion and feature state in your assigned scope either passed in this round or has accepted carried-forward proof, and the cleanup baseline matched; a product failure is `VERIFICATION FAILED.`; a skipped required state, test-environment failure, inconclusive classification, or baseline mismatch is `VERIFICATION BLOCKED.`; otherwise `STOPPED EARLY.` A weak carry-forward rationale means run the case; it blocks only when the required case itself cannot be run. In repro mode, use `REPRODUCED.`, `CANNOT REPRODUCE.`, or `VERIFICATION BLOCKED.` under the same environment/inconclusive rule. Your dispatcher treats a log without a sentinel as a void round — a crashed run, never a pass.
diff --git a/.kilo/command/kilo-design.md b/.kilo/command/kilo-design.md
index 76d271f68e..50e4306e5c 100644
--- a/.kilo/command/kilo-design.md
+++ b/.kilo/command/kilo-design.md
@@ -2,15 +2,8 @@
 description: Apply Kilo-specific design guidance to UI work
 ---
 
-Use the `kilo-design` skill for this request.
-
-Apply Kilo Cloud's project-local design guidance from `.kilo/skills/kilo-design/`:
-
-1. Load `.kilo/skills/kilo-design/SKILL.md`.
-2. Load `.kilo/skills/kilo-design/reference/kilo-brand.md` before making design decisions.
-3. If the request focuses on typography, color, spacing, motion, interaction, responsive behavior, or UX writing, load the matching reference file from `.kilo/skills/kilo-design/reference/`.
-4. If the request is broad design review, polish, critique, or redesign work, use all focused reference files.
-5. Inspect the relevant app, mobile, or Storybook files before proposing or editing UI.
-6. Prefer existing Kilo tokens, shadcn/Radix primitives, fonts, spacing, and component conventions over new one-off styles.
+For `apps/web` UI, load the `kilo-design-cloud` skill synced from
+`Kilo-Org/kilo-design` into `.agents/skills/` and follow its router. For every
+other surface, follow its nearest `AGENTS.md` and existing components.
 
 Use this guidance for: $ARGUMENTS
diff --git a/.kilo/skills/grilling/SKILL.md b/.kilo/skills/grilling/SKILL.md
new file mode 100644
index 0000000000..e409b59260
--- /dev/null
+++ b/.kilo/skills/grilling/SKILL.md
@@ -0,0 +1,8 @@
+---
+name: grilling
+description: Interview the user relentlessly about a plan or design. Use when the user wants to stress-test a plan before building, or uses any grill trigger phrase.
+---
+
+Interview the user about the plan until you share an understanding. Resolve dependent decisions one at a time. For each question, give your recommended answer.
+
+Ask one question at a time and wait for the answer. If the codebase can answer it, inspect the codebase instead of asking.
diff --git a/.kilo/skills/kilo-design/AGENTS.md b/.kilo/skills/kilo-design/AGENTS.md
deleted file mode 100644
index f6e1048918..0000000000
--- a/.kilo/skills/kilo-design/AGENTS.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# Kilo Design Skill Maintenance
-
-## Purpose
-
-Keep frontend design work aligned with root `DESIGN.md` while translating its contract into practical web, mobile, Storybook, accessibility, responsive, interaction, motion, and UX-writing guidance.
-
-## How the skill works
-
-1. `SKILL.md` loads root `DESIGN.md` first.
-2. `reference/kilo-brand.md` maps the contract to repository implementation.
-3. Concern-specific references add focused guidance without redefining tokens.
-4. Existing CSS and components are implementation evidence, not higher-priority sources. Differences from `DESIGN.md` are drift.
-
-## Validation
-
-After changing this skill:
-
-- Search all skill Markdown for retired token values and stale implementation claims.
-- Check compact Markdown table padding with `bun run script/check-md-table-padding.ts`.
-- Run `git diff --check` for changed skill files.
-
-## Change guidelines
-
-- Update root `DESIGN.md` before changing canonical token names, values, domain mappings, typography metrics, radius, or spacing.
-- Keep exact token values in `DESIGN.md`; references should link roles to implementation and avoid duplicating the full contract.
-- Preserve Kilo-specific defaults: dark-first product UI, one primary CTA per surface, six-role surface ladder, fixed status domains, Inter/Roboto Mono roles, compact rhythm, Radix/shadcn primitives, restrained motion, and direct UX copy.
-- When implementation migrates, remove stale warnings immediately. Do not preserve resolved issues as historical guidance.
diff --git a/.kilo/skills/kilo-design/NOTICE.md b/.kilo/skills/kilo-design/NOTICE.md
deleted file mode 100644
index 05fe0c03c7..0000000000
--- a/.kilo/skills/kilo-design/NOTICE.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# NOTICE
-
-This skill contains content adapted from the Impeccable project.
-
-## Upstream Attribution
-
-- **Project**: [`pbakaus/impeccable`](https://github.com/pbakaus/impeccable)
-- **License**: Apache License, Version 2.0
-- **Copyright**: Copyright 2025 Paul Bakaus
-- **Source commit**: `9a5d0e71a9011def4fbd011d5fca33360880b409` (fetched 2026-04-28)
-
-## Adapted Reference Files
-
-The following files under `reference/` are derivative works based on
-corresponding files in `pbakaus/impeccable` at `source/skills/impeccable/reference/`:
-
-| Local file | Upstream source |
-|---|---|
-| `reference/typography.md` | https://github.com/pbakaus/impeccable/blob/main/source/skills/impeccable/reference/typography.md |
-| `reference/color-and-contrast.md` | https://github.com/pbakaus/impeccable/blob/main/source/skills/impeccable/reference/color-and-contrast.md |
-| `reference/spatial-design.md` | https://github.com/pbakaus/impeccable/blob/main/source/skills/impeccable/reference/spatial-design.md |
-| `reference/motion-design.md` | https://github.com/pbakaus/impeccable/blob/main/source/skills/impeccable/reference/motion-design.md |
-| `reference/interaction-design.md` | https://github.com/pbakaus/impeccable/blob/main/source/skills/impeccable/reference/interaction-design.md |
-| `reference/responsive-design.md` | https://github.com/pbakaus/impeccable/blob/main/source/skills/impeccable/reference/responsive-design.md |
-| `reference/ux-writing.md` | https://github.com/pbakaus/impeccable/blob/main/source/skills/impeccable/reference/ux-writing.md |
-
-Each of these files has been modified to:
-
-- Add a `Kilo application` section at the top that re-grounds the guidance in
-  the Kilo Code brand, product tokens, and component system.
-- Remove or soften instructions that conflict with Kilo's existing product UI
-  conventions (dark-first shadcn surfaces, compact app rhythm, restrained
-  brand accent use).
-- Shorten some passages so the files remain load-friendly for an agent.
-
-`reference/kilo-brand.md` and `SKILL.md` are original Kilo content and are
-not derivative works.
-
-## License Summary
-
-The adapted files continue to be made available under the terms of the
-Apache License, Version 2.0. You may obtain a copy of the License at
-http://www.apache.org/licenses/LICENSE-2.0.
-
-Files modified from the upstream source are marked by the "Kilo application"
-section at the top of each adapted reference.
diff --git a/.kilo/skills/kilo-design/SKILL.md b/.kilo/skills/kilo-design/SKILL.md
deleted file mode 100644
index 1626f84daf..0000000000
--- a/.kilo/skills/kilo-design/SKILL.md
+++ /dev/null
@@ -1,154 +0,0 @@
----
-name: kilo-design
-description: Use when designing, reviewing, polishing, adapting, or implementing Kilo Code frontend UI. Applies the DESIGN.md token contract, Kilo brand rules, shadcn/Radix component conventions, exact color tokens, Inter/Roboto Mono/JetBrains Mono typography, compact product rhythm, restrained motion, and Kilo voice guidelines. Triggers on web app screens (apps/web), Storybook components, React Native mobile surfaces (apps/mobile), marketing/landing pages, onboarding, empty states, forms, dialogs, dashboards, billing, sidebar, theming, accessibility, and visual QA. Triggers on terms like "design", "redesign", "polish", "critique", "audit", "typeset", "typography", "fonts", "color", "palette", "brand", "spacing", "layout", "grid", "motion", "animate", "transitions", "interaction", "forms", "focus", "responsive", "mobile", "breakpoints", "UX copy", "microcopy", "error states", "empty states", "on-brand", "Kilo voice". Not for backend-only work.
-license: Apache 2.0 derivative of pbakaus/impeccable, adapted for Kilo Code. See NOTICE.md.
----
-
-# Kilo Design
-
-Design guidance for the Kilo Code frontend. Use this skill whenever the
-task involves how something looks, how it behaves, how it reads, or how
-it adapts.
-
-## Canonical rule: design contract first
-
-Root `DESIGN.md` is the source of truth for token names, exact values, domain mappings, typography roles, radius, and spacing. `reference/kilo-brand.md` explains how to apply that contract. When guidance, existing CSS, or a component conflicts with `DESIGN.md`, treat it as implementation drift rather than precedent.
-
-Load `DESIGN.md` and `reference/kilo-brand.md` on every invocation before picking tokens, typography, layout, or motion. Together they define:
-
-- Kilo's dark-first web theme and six-role surface ladder.
-- Brand yellow-green `primary` token as the primary CTA color, used once per surface.
-- Fixed status-domain mappings, syntax colors, and diff colors.
-- Inter / Roboto Mono typography roles and editor-only JetBrains Mono usage.
-- Spacing, radius, component, and motion conventions.
-- Kilo-specific anti-patterns to reject on sight.
-
-## Register
-
-Identify the register of the surface before designing:
-
-- **Product UI** — web app, dashboards, settings, billing, admin,
-  Storybook components, mobile app screens. Calm, compact,
-  task-oriented. Fixed type scale. Restrained accent use.
-- **Brand / Marketing** — landing pages, docs, pricing, hero surfaces,
-  campaign moments. More visual expression permitted (hero type,
-  animation, committed color, imagery) while still using Kilo tokens.
-
-When unclear, treat the surface as Product UI.
-
-## Routing
-
-Given a user prompt that invokes this skill:
-
-1. Always load root `DESIGN.md`, then `reference/kilo-brand.md`.
-2. Identify the dominant concern from the prompt and load the matching
-   reference(s):
-
-| Prompt signal | Load |
-|---|---|
-| typography, fonts, type scale, hierarchy, readability | `reference/typography.md` |
-| color, palette, contrast, accent, theming, gradient, a11y colors | `reference/color-and-contrast.md` |
-| spacing, layout, grid, rhythm, padding, alignment, cards | `reference/spatial-design.md` |
-| motion, animation, transitions, easing, micro-interactions | `reference/motion-design.md` |
-| forms, focus, hover, states, dialog, dropdown, keyboard nav | `reference/interaction-design.md` |
-| responsive, mobile, breakpoints, touch, tablet, adapt | `reference/responsive-design.md` |
-| copy, microcopy, error messages, labels, empty state copy | `reference/ux-writing.md` |
-| audit / critique / polish / general redesign | all references above |
-
-3. If the prompt targets a specific file, component, or route, **read
-   that file first** before proposing or making changes. Do not guess
-   what the current code looks like.
-
-4. When the user asks for implementation, produce code; when the user
-   asks for a review, produce a diff-ready report with file paths,
-   line references, specific token/utility suggestions, and a short
-   rationale per finding.
-
-## Operating rules
-
-Follow these on every task:
-
-1. **Inspect before editing.** Open root `DESIGN.md`, `apps/web/src/app/globals.css`, the relevant component under `apps/web/src/components/`, and any Storybook story before proposing visual changes.
-2. **Prefer compliant tokens, utilities, and components.** Reuse existing implementation only when it maps to `DESIGN.md`. If it differs, report or fix the drift instead of copying it.
-3. **Do not rename or restructure the shadcn UI layer** unless the user
-   explicitly asks for a design-system refactor.
-4. **Use the `primary` token for primary CTAs.** The product primary is the
-   Kilo brand yellow-green. Blue is reserved for links and legacy drift
-   that should be migrated when touched.
-5. **Do not add new motion libraries.** `motion/react` and
-   `tw-animate-css` are already available.
-6. **Respect `prefers-reduced-motion`** on any motion change beyond
-   trivial opacity/transform hover feedback.
-7. **Design all interactive states:** default, hover, focus-visible,
-   active, disabled, loading, error, success — whichever are relevant.
-8. **Check responsive behavior** for any visual change: mobile (~375px),
-   tablet/laptop (~768–1024px), wide desktop (~1440px+).
-9. **Use Kilo voice** (see `reference/ux-writing.md`) for any copy you
-   add or rewrite.
-10. **Surface conflicts.** If the user's ask conflicts with `DESIGN.md`, raise the conflict and propose a path forward before silently overriding the design contract.
-
-## Implementing code changes
-
-When producing code:
-
-- Use Tailwind utilities that map to semantic tokens before hex: `bg-background`, `text-foreground`, `border-border`, `bg-primary`, and `text-primary-foreground` for broad semantics; `bg-surface-inset`, `bg-surface-raised`, `bg-surface-overlay`, `bg-surface-hover`, and `bg-surface-selected` for exact surface roles; syntax, diff, and status utilities for those domains.
-- Extend `cva` variants in existing `ui/` primitives rather than cloning.
-- Icons: `lucide-react`, typically `size-4`, inheriting `currentColor`; use `size-icon-sm` for canonical 14px compact/status icons.
-- Add `aria-label` to icon-only buttons.
-- Use Radix + shadcn wrappers for overlays (dialog, dropdown, popover,
-  tooltip, sheet) — do not hand-roll positioning.
-- Match compact rhythm: `h-8` / `h-control-default` / `h-10` controls, `h-14` topbar, and `p-6` cards. Use `h-control-touch` or `size-control-touch` where touch targets need 44px.
-- Prefer `gap-*` over ad-hoc margins.
-
-## Running a design review
-
-When producing a review:
-
-- Reference code locations as `file_path:line_number`.
-- Group findings by severity: **Blocker** (accessibility failure, brand
-  violation, broken behavior), **Improvement** (inconsistency,
-  refinement opportunity), **Nit** (optional polish).
-- Propose specific Tailwind utilities, tokens, or components for each
-  fix.
-- Call out responsive, reduced-motion, keyboard, and screen-reader gaps
-  explicitly — they're the most commonly missed.
-
-## Mobile surfaces
-
-`apps/mobile/` uses React Native + NativeWind, with its own shadcn-style
-setup in `apps/mobile/src/global.css` and `apps/mobile/components.json`.
-Web Tailwind patterns do not always translate:
-
-- CSS-variable theme colors do not compose with Tailwind opacity
-  modifiers (`/40`) in NativeWind.
-- `env(safe-area-inset-*)` is web-only; mobile uses react-native safe
-  area tooling.
-- Hover states do not apply. Design the `pressed` state instead.
-
-Consult `apps/mobile/AGENTS.md` (if present) and existing components
-before styling.
-
-## Non-goals
-
-This skill is intentionally scoped. It does **not**:
-
-- Run automated anti-pattern scans.
-- Run or expose Impeccable's "live mode."
-- Generate or redefine root `DESIGN.md`; it must still enforce the existing contract.
-- Migrate every legacy hardcoded blue CTA unless the owning surface is being updated. Broad migrations belong in separate design-system-scoped PRs.
-
-## Reference map
-
-| File | What it covers |
-|---|---|
-| Root `DESIGN.md` | Canonical token contract and application rules. Load first, always. |
-| `reference/kilo-brand.md` | Kilo-specific implementation guidance. Load after `DESIGN.md`, always. |
-| `reference/typography.md` | Inter/mono usage, hierarchy, tabular nums, OpenType polish. |
-| `reference/color-and-contrast.md` | Exact palette, brand vs action color, dark-first contrast rules. |
-| `reference/spatial-design.md` | Spacing, radius scale, grid patterns, optical alignment. |
-| `reference/motion-design.md` | Durations, easings, reduced motion, Kilo brand flourishes. |
-| `reference/interaction-design.md` | Focus, forms, overlays, destructive actions, keyboard nav. |
-| `reference/responsive-design.md` | Breakpoints, input-method queries, safe areas, images. |
-| `reference/ux-writing.md` | Kilo voice, labels, error copy, empty states, i18n. |
-
-See `NOTICE.md` for Impeccable attribution and licensing.
diff --git a/.kilo/skills/kilo-design/reference/color-and-contrast.md b/.kilo/skills/kilo-design/reference/color-and-contrast.md
deleted file mode 100644
index 777771d1e9..0000000000
--- a/.kilo/skills/kilo-design/reference/color-and-contrast.md
+++ /dev/null
@@ -1,178 +0,0 @@
-# Color & Contrast
-
-> Adapted from Impeccable's `color-and-contrast.md` (Apache 2.0). See
-> `NOTICE.md` for attribution and upstream source.
-
-## Kilo application
-
-Kilo's exact hex palette is defined in root `DESIGN.md` and implemented as CSS variables. Do not introduce a parallel palette or derive replacement values in another color space.
-
-### Use tokens, not hex
-
-Prefer Tailwind utilities that map to Kilo's semantic tokens
-(`bg-background`, `bg-card`, `text-foreground`, `text-muted-foreground`,
-`border-border`, `ring-ring`, `bg-destructive`, `bg-sidebar`, etc.) over
-raw hex. The token layer is in `apps/web/src/app/globals.css`; the
-Tailwind bindings are in the `@theme inline` block.
-
-### Primary and brand accent use
-
-`--brand-primary` / `text-brand-primary` / `bg-brand-primary` (`#F7F586`) is the same swatch as the semantic `primary` token. It is both brand and primary action color. Hold it under
-10% of pixel weight on any given surface. Reserve for:
-
-- Logo, wordmark, and logo-adjacent affordances.
-- The single primary CTA on a surface.
-- Focus rings on branded hero controls (see `HeaderLogo.tsx`).
-- Intentional glow moments (see `animate-pulse-once` in `globals.css`).
-- A small number of brand-defining selected / "on" toggles.
-
-Do **not** use yellow-green as:
-
-- Multiple competing CTAs on the same surface.
-- Body or link text color.
-- Chart series color (the `chart-*` tokens exist for that).
-- Border color on product surfaces.
-
-### Primary action token
-
-The primary product CTA is the brand yellow-green semantic token:
-
-- Background `primary` / `--brand-primary`: `#F7F586`
-- Foreground `primary-foreground`: `#1F1F1F`
-- Hover `primary-hover`: `#E6E475`
-- Focus ring `ring` / `brand-primary-ring`: `#F7F58659`
-
-Hardcoded blue buttons (`#2B6AD2`, Tailwind `blue-*` fills) are legacy drift.
-Migrate them to `primary` when touching the owning component or flow. Blue is
-reserved for inline links and historical references, not action fills.
-
-### Palette structure (how Kilo's tokens map)
-
-| Role | Purpose | Kilo tokens |
-|---|---|---|
-| Brand | Rare, load-bearing accent | `brand-primary` |
-| Action | Primary CTAs in product/marketing | `primary` / `primary-foreground` |
-| Neutral | Text, backgrounds, borders | `background`, `foreground`, `muted`, `accent`, `secondary`, `card`, `popover`, `border`, `input`, `ring`, `kilo-gray` |
-| Semantic | Destructive, success pills | `destructive`, badge variants `beta`/`new` |
-| Surface | Sidebar, charts, Kilo gray | `sidebar-*`, `chart-1`..`chart-5`, `kilo-gray` |
-
-### Theming discipline
-
-The web app is dark-first — `:root` sets `color-scheme: dark`. Do not
-"add light mode" to a web surface on a whim. Mobile follows
-`prefers-color-scheme`. If a redesign needs light-mode behavior, verify
-both modes' tokens resolve and that existing components in the affected
-tree actually react to theme changes.
-
-### Absolute rejects in Kilo UI
-
-- Pure `#000` or `#fff` backgrounds/text. Use tokens.
-- Purple / pink / cyan gradient heroes.
-- Gradient text (`background-clip: text` + gradient).
-- Glassmorphism as a default, decorative effect.
-- Rainbow accent palettes introduced just because the screen felt
-  monochromatic.
-- Yellow-green on body copy, sidebar surfaces, or form fields.
-- Blue button backgrounds for new primary actions.
-
----
-
-## Color-space discipline
-
-The canonical palette uses exact hex values. Do not convert tokens to OKLCH, HSL, or generated shades during feature work: conversion and interpolation can alter contract values. Color-space experiments belong in an explicit design-system change that updates `DESIGN.md` first.
-
-## Building Functional Palettes
-
-### Neutral surfaces
-
-Use the six exact surface tokens rather than deriving tinted neutrals: inset `#101010`, background `#151515`, raised `#202020`, overlay `#333333`, hover `#3A3A3A`, and selected `#454545`. `kilo-gray` aliases exist for compatibility, not as permission to invent additional neutrals.
-
-### Palette structure
-
-Kilo's complete system already provides:
-
-| Role | Purpose | Example |
-|---|---|---|
-| **Brand** | Rare, voice-carrying accent | 1 color, 1–2 shades |
-| **Action** | Primary call-to-action | 1 color, 3 states |
-| **Neutral** | Text, backgrounds, borders | 9–11 shade scale |
-| **Semantic** | Fixed status domains | Eight families, four shades each |
-| **Surface** | Inset, canvas, cards, overlays, interaction states | Six fixed roles |
-
-Do not extend this structure from a feature component. Update `DESIGN.md` first when a genuinely new role is required.
-
-### The 60-30-10 Rule (Applied Correctly)
-
-This is **visual weight**, not pixel count:
-
-- **60%** — Neutral backgrounds, whitespace, base surfaces
-- **30%** — Secondary colors: text, borders, inactive states
-- **10%** — Accent: CTAs, highlights, focus states
-
-Accent colors work _because_ they are rare. Overuse kills their power.
-In Kilo, the primary CTA and brand accent share the same yellow-green swatch.
-That shared role should still stay near 10% visual weight.
-
-## Contrast & Accessibility
-
-### WCAG Requirements
-
-| Content type | AA minimum | AAA target |
-|---|---|---|
-| Body text | 4.5:1 | 7:1 |
-| Large text (18px+ or 14px bold) | 3:1 | 4.5:1 |
-| UI components, icons | 3:1 | 4.5:1 |
-
-Placeholder text still needs 4.5:1. Check `placeholder:text-muted-foreground` against canonical `bg-input-background`; do not apply another opacity modifier to the already translucent input background.
-
-### Dangerous Color Combinations
-
-- Light gray on white (the #1 accessibility fail)
-- Gray text on colored backgrounds (looks washed out)
-- Red on green, blue on red (vibrates, colorblind hazards)
-- Yellow on white (fails almost always)
-- Thin light text on images (unpredictable contrast)
-
-### Never Use Pure Gray or Pure Black
-
-Pure gray and pure black do not exist in nature. Even a chroma of 0.005
-is enough to feel natural. Kilo already honors this with `kilo-gray`.
-
-### Testing
-
-Don't trust your eyes. Use:
-
-- WebAIM Contrast Checker
-- Browser DevTools → Rendering → Emulate vision deficiencies
-
-## Theming: Light & Dark Mode
-
-### Dark Mode Is Not Inverted Light Mode
-
-Kilo is dark-first for a reason. If you design something for light mode first and "flip" it, you'll introduce bad shadows, under-contrast accents, and oversaturated hues. Design on the exact `surface.background`, `surface.raised`, `surface.overlay`, `surface.hover`, and `surface.selected` roles, not on `#fff`.
-
-| Light mode principle | Dark mode behavior |
-|---|---|
-| Shadows for depth | Lighter surfaces for depth (no shadows) |
-| Dark text on light | Light text on dark (reduce font weight) |
-| Vibrant accents | Desaturate accents slightly |
-| White backgrounds | Never pure black — dark gray (OKLCH 12–18%) |
-
-Depth in dark mode comes from surface roles, not shadow: `surface.inset` → `surface.background` → `surface.raised` → `surface.overlay`, with `surface.hover` and `surface.selected` reserved for interaction states.
-
-### Token Hierarchy
-
-Use two layers: contract primitives such as `--status-blue-500` and semantic aliases such as `--primary`, `--card`, and `--popover`. Tailwind mappings live in `@theme inline`. Components consume semantic or role-specific utilities; they never redefine primitives locally.
-
-## Alpha Is A Design Smell
-
-Heavy use of transparency (`rgba`, `hsla`) usually means an incomplete
-palette. Alpha creates unpredictable contrast, performance overhead, and
-inconsistency. Define explicit overlay colors for each context instead.
-Kilo's `border.default` (`#FFFFFF1A`) and `border.strong` (`#FFFFFF2E`) use deliberate alpha. Do not stack additional alpha layers on top.
-
----
-
-**Avoid**: Relying on color alone to convey information. Creating
-palettes without clear roles. Using pure black (`#000`) for large
-surfaces. Skipping color-blindness testing.
diff --git a/.kilo/skills/kilo-design/reference/interaction-design.md b/.kilo/skills/kilo-design/reference/interaction-design.md
deleted file mode 100644
index a259ad9da7..0000000000
--- a/.kilo/skills/kilo-design/reference/interaction-design.md
+++ /dev/null
@@ -1,278 +0,0 @@
-# Interaction Design
-
-> Adapted from Impeccable's `interaction-design.md` (Apache 2.0). See
-> `NOTICE.md` for attribution and upstream source.
-
-## Kilo application
-
-Kilo is dark-first and relies on **shadcn/ui + Radix**. Before building
-any interactive control from scratch, check these locations first:
-
-- `apps/web/src/components/ui/` — shadcn primitives (button, input,
-  dialog, dropdown-menu, select, tabs, tooltip, sheet, popover,
-  skeleton, table, sidebar, badge).
-- `apps/web/src/components/` — higher-level composed components.
-- `apps/web/components.json` — shadcn config (style `new-york`, neutral
-  base, lucide icons).
-
-### Kilo-specific rules
-
-- **Use Radix + shadcn for overlays.** Dialog, dropdown, popover, tooltip,
-  sheet, and select already handle focus trapping, escape-to-close,
-  outside-click dismissal, ARIA roles, and stacking. Do not hand-roll.
-- **Focus rings.** Use `focus-visible:ring-ring` (semantic) or the
-  explicit brand ring for branded controls (see `HeaderLogo.tsx` which
-  uses `focus:ring-brand-primary focus:ring-3`). Never strip the ring
-  without a replacement.
-- **Button variants are authoritative.** Use the semantic `primary` token /
-  primary variant for the single yellow CTA on a surface,
-  `variant="destructive"` for red destructive actions, `variant="outline"`
-  or `variant="secondary"` for secondary actions, and `variant="ghost"` for
-  bare actions. Don't invent new variants per feature.
-- **Forms use visible labels.** Placeholders are not labels. Pair inputs
-  with `<Label>` (shadcn) and use `aria-describedby` for help/error text.
-- **Validate on blur**, not every keystroke (password strength is an
-  exception).
-- **Destructive actions prefer undo toasts** over confirmation dialogs
-  for reversible operations. Reserve confirm dialogs for truly
-  irreversible actions (account deletion, workspace deletion, bulk
-  destructive ops).
-- **Icon-only buttons need `aria-label`.** Lucide icons inherit color —
-  don't hand-color them unless a variant demands it.
-- **Touch targets:** visual control can be `h-8`/`h-9`, but the tap
-  target should reach 44px on touch surfaces via padding or `::before`
-  (see `spatial-design.md`).
-
-### Absolute rejects in Kilo UI
-
-- Custom focus-ring removal without a replacement.
-- Reimplementing dialog, dropdown, tooltip, select, popover, or sheet
-  positioning instead of using the shadcn wrappers.
-- Placeholder-as-label in forms.
-- Generic "Submit" / "OK" button labels (see `ux-writing.md`).
-- Confirmation dialog for "are you sure you want to save" style prompts.
-- Custom keyboard handlers that override native form submit / Escape /
-  arrow navigation on shadcn components.
-
----
-
-## The Eight Interactive States
-
-Every interactive element needs these states designed:
-
-| State | When | Visual treatment |
-|---|---|---|
-| **Default** | At rest | Base styling |
-| **Hover** | Pointer over (not touch) | Subtle lift, color shift |
-| **Focus** | Keyboard / programmatic focus | Visible ring (see below) |
-| **Active** | Being pressed | Pressed in, darker |
-| **Disabled** | Not interactive | Reduced opacity, no pointer |
-| **Loading** | Processing | Spinner, skeleton |
-| **Error** | Invalid state | Red border, icon, message |
-| **Success** | Completed | Green check, confirmation |
-
-Common miss: designing hover without focus, or vice versa. Keyboard users
-never see hover states.
-
-## Focus Rings: Do Them Right
-
-Never `outline: none` without a replacement. Use `:focus-visible` to show
-focus only for keyboard users:
-
-```css
-/* Hide focus ring for mouse/touch */
-button:focus {
-  outline: none;
-}
-
-/* Show focus ring for keyboard */
-button:focus-visible {
-  outline: 2px solid var(--color-accent);
-  outline-offset: 2px;
-}
-```
-
-In Kilo:
-
-- Default shadcn primitives already do this correctly
-  (`focus-visible:ring-ring/50`, `focus-visible:ring-[3px]`).
-- Branded interactive moments may use `focus:ring-brand-primary`.
-
-Focus ring design:
-
-- High contrast (3:1 minimum against adjacent colors).
-- 2–3px thick.
-- Offset from element (not inside it).
-- Consistent across all interactive elements of the same type.
-
-## Form Design
-
-- **Placeholders aren't labels** — they disappear on input. Always use
-  visible `<Label>`.
-- **Validate on blur**, not on every keystroke (password strength is an
-  exception).
-- **Errors go below the field** with `aria-describedby` connecting them.
-- **Autocomplete is free accessibility.** Set `autocomplete="email"`,
-  `autocomplete="current-password"`, `autocomplete="one-time-code"`,
-  etc. — browsers fill in correctly and screen readers benefit.
-- **Input types matter.** `type="email"`, `type="tel"`, `type="number"`,
-  `type="url"` trigger appropriate mobile keyboards.
-
-## Loading States
-
-- **Optimistic updates.** Show success immediately, rollback on failure.
-  Use for low-stakes actions (toggles, likes, saves in a session). Never
-  for payments or destructive operations.
-- **Skeleton screens > spinners.** They preview content shape and feel
-  faster than generic spinners. Kilo ships a `Skeleton` primitive.
-- **Set expectations.** For long waits, say "This usually takes 30
-  seconds" instead of an unbounded spinner.
-
-## Modals: The Inert Approach
-
-Focus trapping in modals used to require complex JavaScript. Modern
-options:
-
-```html
-<!-- When modal is open, make everything else inert -->
-<main inert>
-  <!-- Content behind modal can't be focused or clicked -->
-</main>
-<dialog open>
-  <h2>Modal Title</h2>
-</dialog>
-```
-
-Or use the native `<dialog>` element:
-
-```ts
-const dialog = document.querySelector('dialog');
-dialog.showModal(); // Opens with focus trap, closes on Escape
-```
-
-In Kilo, **use `Dialog` from `@/components/ui/dialog`** — Radix already
-handles this correctly.
-
-## The Popover API
-
-For tooltips, dropdowns, and non-modal overlays, native popovers work:
-
-```html
-<button popovertarget="menu">Open menu</button>
-<div id="menu" popover>
-  <button>Option 1</button>
-  <button>Option 2</button>
-</div>
-```
-
-**In Kilo**, use `@/components/ui/popover`, `@/components/ui/dropdown-menu`,
-or `@/components/ui/tooltip` — those already provide light-dismiss,
-correct stacking, and accessibility.
-
-## Dropdown & Overlay Positioning
-
-Dropdowns rendered with `position: absolute` inside a container that has
-`overflow: hidden` or `overflow: auto` will be clipped. The single most
-common dropdown bug in generated code.
-
-### CSS Anchor Positioning
-
-Modern solution ties an overlay to its trigger without JavaScript:
-
-```css
-.trigger {
-  anchor-name: --menu-trigger;
-}
-
-.dropdown {
-  position: fixed;
-  position-anchor: --menu-trigger;
-  position-area: block-end span-inline-end;
-  margin-top: 4px;
-}
-
-@position-try --flip-above {
-  position-area: block-start span-inline-end;
-  margin-bottom: 4px;
-}
-```
-
-`position: fixed` escapes overflow clipping. `@position-try` handles
-viewport edges. Browser support: Chrome 125+, Edge 125+ — use a fallback
-for Firefox/Safari.
-
-### Portal / Teleport Pattern
-
-In component frameworks, render the dropdown at the document root and
-position it from the trigger's `getBoundingClientRect()`. Radix and
-shadcn already do this. Do not replace it with `position: absolute`
-inside a scroll container.
-
-### Anti-Patterns
-
-- `position: absolute` inside `overflow: hidden` — the dropdown clips.
-  Use `position: fixed` or the top layer.
-- Arbitrary z-index like `z-index: 9999` — use a semantic z-index scale
-  (dropdown 100 → sticky 200 → modal-backdrop 300 → modal 400 → toast
-  500 → tooltip 600). In Kilo, Radix handles stacking; do not override
-  its layers.
-- Rendering dropdown markup inline without an escape hatch from the
-  parent's stacking context. Use `popover`, a portal, or `position: fixed`.
-
-## Destructive Actions: Undo > Confirm
-
-Undo beats confirmation dialogs for reversible operations — users click
-through confirmations mindlessly. Remove from UI immediately, show undo
-toast, actually delete after the toast expires.
-
-Use confirmation for:
-
-- Truly irreversible actions (account deletion, workspace deletion).
-- High-cost actions (paid plan downgrade).
-- Bulk operations where the blast radius is unclear.
-
-Confirmation labels name the action. `Delete workspace` / `Keep editing`,
-not `Yes` / `No`.
-
-## Keyboard Navigation Patterns
-
-### Roving Tabindex
-
-For component groups (tabs, menu items, radio groups), one item is
-tabbable; arrow keys move within:
-
-```html
-<div role="tablist">
-  <button role="tab" tabindex="0">Tab 1</button>
-  <button role="tab" tabindex="-1">Tab 2</button>
-  <button role="tab" tabindex="-1">Tab 3</button>
-</div>
-```
-
-Arrow keys move `tabindex="0"` between items. Tab moves to the next
-component entirely. In Kilo, `@/components/ui/tabs` already does this.
-
-### Skip Links
-
-Provide `<a href="#main-content">Skip to main content</a>` for keyboard
-users to jump past navigation. Hide off-screen, show on focus.
-
-## Gesture Discoverability
-
-Swipe-to-delete and similar gestures are invisible. Hint at their
-existence:
-
-- **Partially reveal** — show the delete button peeking from the edge.
-- **Onboarding** — coach marks on first use.
-- **Alternative** — always provide a visible fallback (a menu with
-  "Delete").
-
-Don't rely on gestures as the only way to perform actions. In React
-Native (`apps/mobile/`), use accessible gesture patterns from the
-existing component library.
-
----
-
-**Avoid**: Removing focus indicators without alternatives. Placeholder
-text as labels. Touch targets <44×44px. Generic error messages. Custom
-controls without ARIA / keyboard support. Reimplementing Radix primitives.
diff --git a/.kilo/skills/kilo-design/reference/kilo-brand.md b/.kilo/skills/kilo-design/reference/kilo-brand.md
deleted file mode 100644
index ccae4ecf23..0000000000
--- a/.kilo/skills/kilo-design/reference/kilo-brand.md
+++ /dev/null
@@ -1,238 +0,0 @@
-# Kilo Brand
-
-Canonical application overlay for every other reference in this skill. Root `DESIGN.md` wins for token contracts; this document wins when general references conflict on Kilo-specific application guidance.
-
-Root `DESIGN.md` owns exact token values and roles. This reference explains how to apply that contract in the Kilo Code codebase so changes stay coherent instead of drifting into generic AI-flavored "modern SaaS." If implementation differs from `DESIGN.md`, treat it as drift.
-
-## Sources of Truth
-
-Before changing tokens, colors, type, radius, or animation, consult these
-files directly:
-
-| Concern | File |
-|---|---|
-| Canonical token contract | `DESIGN.md` |
-| Web token implementation | `apps/web/src/app/globals.css` |
-| Font loading & variables | `apps/web/src/app/layout.tsx` |
-| shadcn config | `apps/web/components.json` |
-| Core UI primitives | `apps/web/src/components/ui/*.tsx` |
-| Brand lockup | `apps/web/src/components/HeaderLogo.tsx` |
-| Storybook canvas | `apps/storybook/.storybook/preview.ts` and `storybook.css` |
-| Mobile tokens | `apps/mobile/src/global.css` |
-
-If a compliant token or component already exists, **use it**. Do not reintroduce a parallel system. If existing code conflicts with `DESIGN.md`, report or fix the drift rather than copying it.
-
-## Register
-
-Kilo has two surfaces with slightly different design rules. Identify which
-one you are designing for before picking colors, type scale, or motion.
-
-| Register | Scope |
-|---|---|
-| **Product UI** | Web app, dashboards, settings, billing, admin, Storybook components, mobile app screens |
-| **Brand / Marketing** | Landing pages, docs, pricing, hero surfaces, on-brand campaign moments |
-
-Both use the same tokens and fonts. Brand permits more visual expression
-(hero type, animation, committed color, imagery). Product UI stays calm,
-compact, and task-oriented.
-
-## Theme
-
-Kilo's web app is **dark-first**. `:root` in `apps/web/src/app/globals.css`
-forces `color-scheme: dark`. Mobile's `apps/mobile/src/global.css` defines
-light tokens in `:root` and dark tokens under `prefers-color-scheme`. Design
-web surfaces with dark as the default; check mobile surfaces in both system
-themes.
-
-Do not "add a light mode" speculatively. If asked to work in light, check
-that the surface actually participates in theme switching and that the
-tokens you need are defined for both modes.
-
-## Color Primitives
-
-### Semantic (use these first)
-
-These are declared as CSS variables in `globals.css` and surfaced to
-Tailwind via `@theme inline`. Prefer the Tailwind utility that maps to the
-token (e.g. `bg-background`, `text-foreground`, `border-border`) over hex.
-
-| Token | Role |
-|---|---|
-| `background` | Alias of `surface.background` (`#151515`) for the page/body canvas. |
-| `foreground` | Alias of `foreground.default` (`#FAFAFA`). |
-| `card` | Alias of `surface.raised` (`#202020`). |
-| `popover` | Alias of `surface.overlay` (`#333333`). |
-| `card-foreground`, `popover-foreground` | Default foreground on those surfaces. |
-| `primary` | Brand yellow-green primary CTA token (`#F7F586`). |
-| `primary-foreground` | Near-black text on primary (`#1F1F1F`). |
-| `secondary` | Alias of `surface.overlay`; neutral action surface. |
-| `muted` | Alias of `surface.raised`; de-emphasized region. |
-| `accent` | Alias of `surface.hover`; interaction hover state. |
-| `muted-foreground` | Alias of `foreground.muted` (`#A3A3A3`). |
-| `border`, `input`, `ring` | Default border, strong input border, and brand focus ring. |
-| `destructive` | Red error/danger state. |
-| `sidebar-*` | Sidebar app-shell tokens. |
-| `chart-1`..`chart-5` | Data viz palette. |
-
-### Kilo-specific primitives
-
-| Token | Value | Use |
-|---|---|---|
-| `--brand-primary` / `brand-primary` | `#F7F586` | Alias of primary for brand roles |
-| `--brand-primary-hover` | `#E6E475` | Primary hover |
-| `--brand-primary-ring` | `#F7F58659` | Brand focus ring |
-| `--color-kilo-gray` | `surface.raised` (`#202020`) | Compatibility alias |
-| `--color-kilo-gray-lighter` | `surface.overlay` (`#333333`) | Compatibility alias |
-| `--ease-out-strong` | `cubic-bezier(0.23, 1, 0.32, 1)` | Preferred easing for transitions |
-
-### Primary action color
-
-The product primary CTA is the Kilo brand yellow-green, exposed through the
-semantic `primary` token and `--brand-primary` alias:
-
-| Role | Value |
-|---|---|
-| Background | `#F7F586` via `primary` / `brand-primary` |
-| Hover | `#E6E475` via `primary-hover` / `brand-primary-hover` |
-| Text | `#1F1F1F` via `primary-foreground` |
-| Focus ring | `#F7F58659` via `ring` / `brand-primary-ring` |
-
-Use it for the main action on a surface, exactly once. Blue is no longer a
-primary CTA color; treat hardcoded `#2B6AD2` buttons as legacy drift and
-migrate them to semantic `primary` when the owning surface is updated. Blue
-remains acceptable for inline links and historical references only.
-
-## Surface and Domain Tokens
-
-Use the six-role surface ladder exactly: `surface.inset` for terminal and recessed regions, `surface.background` for canvas, `surface.raised` for cards and persistent chrome, `surface.overlay` for floating UI, `surface.hover` for hover, and `surface.selected` for selected neutral states.
-
-Status domain assignments are fixed: Cloud blue, VS Code purple, CLI gray, Slack teal, Agent Manager orange, success green, warning yellow, destructive red. Do not rename teal to emerald or gray to zinc. Use syntax tokens only on code-oriented surfaces and dedicated diff text/surface pairs with non-color `+`/`-` cues.
-
-## Brand Accent Discipline
-
-The yellow-green primary is load-bearing precisely because it is rare.
-Reserve it for:
-
-- The Kilo logo and wordmark.
-- The primary CTA, once per surface.
-- Focus rings on branded / hero controls.
-- Confirmation glow on intentional brand moments (see
-  `animate-pulse-once` / `pulse-glow` in `globals.css`).
-- Selected / "on" state for a small number of brand-critical toggles.
-
-Avoid:
-
-- Using it for every button.
-- Using it as a default text color.
-- Pairing it with long body copy (contrast and reading feel drop fast).
-- Decorative use on dense product UI.
-
-## Typography
-
-Font loading is in `apps/web/src/app/layout.tsx`:
-
-| Family | CSS variable | Use |
-|---|---|---|
-| Inter | `--font-sans-loaded` / Tailwind `font-sans` | Default UI text |
-| Roboto Mono | `--font-mono-loaded` / Tailwind `font-mono` | Code, identifiers, metadata |
-| JetBrains Mono | `--font-jetbrains` | Terminal-like and code-editor surfaces (`.font-jetbrains`) |
-
-`globals.css` maps Tailwind font tokens to the variables loaded by `layout.tsx`. Do not add per-component font fallbacks.
-
-Type scale rules for product UI:
-
-- Prefer canonical utilities: `type-title`, `type-heading`, `type-body-lg`, `type-body`, `type-label`, `type-eyebrow`, and `type-code`.
-- Do not stack near-duplicate sizes or replace exact typography roles with arbitrary Tailwind combinations.
-- Use `type-label` for buttons and controls, `type-title` for top-level page titles, and existing lockup styling for logos.
-- Use `tabular-nums` for billing, usage counters, metrics, and anything
-  that aligns in columns.
-
-## Shape and Radius
-
-Use the exact radius contract:
-
-| Token | Value | Typical use |
-|---|---|---|
-| `--radius-sm` | `4px` | Tight inline chips |
-| `--radius-md` | `8px` | Buttons, inputs |
-| `--radius-lg` | `10px` | Popovers, medium containers |
-| `--radius-xl` | `14px` | Cards, dialogs |
-| (pill) | `rounded-full` | Badges, avatars, status pills |
-
-Follow existing shadcn primitives. Buttons/inputs `rounded-md`, cards
-`rounded-xl`, badges full-pill. Do not introduce new radius values.
-
-## Spacing Rhythm
-
-The app-shell rhythm in the current codebase:
-
-- Controls are compact: `h-8` (sm), `h-control-default` / 36px (default), `h-10` (lg). Touch surfaces use `h-control-touch` or `size-control-touch` for 44px targets.
-- Icons in controls are usually `size-4`; compact/status icons use `size-icon-sm` (14px).
-- Topbars are `h-14`.
-- Cards use `p-6` for header/content/footer, `gap-1.5` between title and
-  description.
-- Sidebars have their own token set (`sidebar-*`).
-- Prefer Tailwind's 4pt-aligned scale (`gap-2`, `gap-3`, `gap-4`, `gap-6`,
-  `gap-8`). Avoid one-off spacing.
-
-## Components
-
-The design system is shadcn/ui in the **New York** style, neutral base
-color, CSS variables enabled (`apps/web/components.json`). Icons come from
-`lucide-react`.
-
-Work inside this system:
-
-- Before building a new control, check `apps/web/src/components/ui/` for a
-  primitive. Extend variants before creating new files.
-- Radix primitives back most overlays (dialog, dropdown, popover, select,
-  tabs, tooltip, sheet). Use them — do not hand-roll positioning.
-- Mobile uses a sibling shadcn setup in `apps/mobile/`. React Native does
-  not accept every Tailwind pattern; check `apps/mobile/AGENTS.md` (if
-  present) and the components there before styling across mobile surfaces.
-
-## Motion
-
-Current conventions:
-
-- `--ease-out-strong` is the preferred curve for most transitions.
-- `motion/react` is already in use (see `HeaderLogo.tsx`) for brand
-  interactions. `tw-animate-css` is imported in `globals.css` for small
-  utility animations.
-- Brand moments can use `animate-pulse-once` (see `globals.css`) or the
-  logo hover flourish. Treat these as branded punctuation, not defaults.
-- Respect `prefers-reduced-motion`. Product motion should be short and
-  functional.
-
-## Iconography
-
-- `lucide-react` is the default set.
-- `size-4` inside controls, inheriting `currentColor`.
-- Icon-only buttons need an `aria-label`.
-- Do not mix icon packs without a strong reason.
-
-## Anti-Patterns To Reject On Sight
-
-These hurt Kilo specifically, on top of general anti-slop rules:
-
-- **Yellow everywhere.** If the screen screams yellow, keep yellow to the
-  single primary action plus real brand moments.
-- **Blue button backgrounds.** Blue is for inline links and legacy drift,
-  not primary action fills.
-- **Inventing a new primary color** instead of using the `primary` token.
-- **Purple gradient heroes, gradient text, glassmorphism defaults.**
-- **Nested cards** (card inside card). Use hierarchy and spacing instead.
-- **New font families** beyond Inter / Roboto Mono / JetBrains Mono.
-- **New radius values** outside the token set above.
-- **Ignoring the sidebar tokens** and hand-coloring sidebar surfaces.
-- **Light-mode-only designs** that ignore Kilo's dark-first app.
-
-## How Agents Should Use This File
-
-- Load `kilo-brand.md` whenever a design change touches Kilo's UI.
-- When producing code, prefer existing tokens, utilities, and components
-  before writing new ones.
-- When producing review/critique output, cite specific tokens, files, and
-  components by path.
-- When a user's request conflicts with these rules, surface the conflict
-  first. Do not quietly override the brand system.
diff --git a/.kilo/skills/kilo-design/reference/motion-design.md b/.kilo/skills/kilo-design/reference/motion-design.md
deleted file mode 100644
index 13718006a0..0000000000
--- a/.kilo/skills/kilo-design/reference/motion-design.md
+++ /dev/null
@@ -1,197 +0,0 @@
-# Motion Design
-
-> Adapted from Impeccable's `motion-design.md` (Apache 2.0). See
-> `NOTICE.md` for attribution and upstream source.
-
-## Kilo application
-
-Kilo motion is **purposeful and subtle** in product UI, with occasional
-**branded flourishes** at specific hero/logo moments.
-
-### Libraries and tokens
-
-- `motion/react` (formerly `framer-motion`) is already in use.
-  `HeaderLogo.tsx` is the canonical example of a branded interaction.
-- `tw-animate-css` is imported in `apps/web/src/app/globals.css` for
-  small utility animations.
-- Preferred easing: `--ease-out-strong` → `cubic-bezier(0.23, 1, 0.32, 1)`.
-  It is defined as a Tailwind token via `@theme inline`.
-- Named brand keyframes already live in `globals.css`:
-  `pulse-glow` / `animate-pulse-once`, `pulse-opacity`,
-  `pulse-opacity-dim`. Reuse these instead of inventing new glow/pulse
-  effects.
-- Brand glow uses `--brand-primary-ring` (`#F7F58659`) or alpha derived from `--brand-primary` (`#F7F586`). Never copy legacy `rgba(237, 255, 0, ...)` values.
-
-### Kilo-specific motion rules
-
-- **Product UI should feel calm.** Default to opacity/transform fades
-  (100–200ms) for hover, focus, and state changes. Resist adding motion
-  to every element.
-- **Brand moments are opt-in.** The logo hover rotation, the pulse-glow
-  CTA, Lottie logo swap — these are branded punctuation, not templates
-  to copy elsewhere.
-- **Never animate layout properties casually** (`width`, `height`, `top`,
-  `left`, `margin`). Use `transform`, `opacity`, `filter` or layout
-  libraries (Framer Motion's `layout` prop, FLIP, `grid-template-rows`).
-- **Respect `prefers-reduced-motion`.** For anything more than a small
-  hover transform, provide a reduced fallback. Browsers with
-  reduced-motion preference get functional behavior only.
-- **No bouncy/elastic curves** on product UI. Ease-out exponential
-  (`--ease-out-strong`) and short durations are the house style.
-- **Do not animate modals/dropdowns by hand.** Radix + shadcn already
-  ship well-tuned enter/exit transitions; configure them with
-  Tailwind's `data-[state=open]` utilities.
-
-### Durations
-
-| Duration | Use | Examples |
-|---|---|---|
-| 100–150ms | Instant feedback | Button press, toggle, color shift |
-| 200–300ms | State changes | Menu open, tooltip, hover, focus bloom |
-| 300–500ms | Layout changes | Accordion, drawer open, sheet open |
-| 500–800ms | Entrance animations (brand surfaces) | Hero reveal, first-paint choreography |
-
-Exit animations are faster than entrances (≈75% of enter duration).
-
-### Absolute rejects in Kilo UI
-
-- Animated gradients on product surfaces.
-- Long (≥ 800ms) transitions in app UIs.
-- `ease` (the CSS default) as the only easing on important motion.
-- Bounce/elastic on buttons.
-- Hover-only affordances on touch-capable surfaces (see
-  `responsive-design.md`).
-- Animating `will-change` globally or preemptively.
-
----
-
-## Duration: The 100/300/500 Rule
-
-Timing matters more than easing. These durations feel right for most UI:
-
-| Duration | Use | Examples |
-|---|---|---|
-| 100–150ms | Instant feedback | Button press, toggle, color change |
-| 200–300ms | State changes | Menu open, tooltip, hover states |
-| 300–500ms | Layout changes | Accordion, modal, drawer |
-| 500–800ms | Entrance animations | Page load, hero reveals |
-
-Exit animations are faster than entrances — use ~75% of enter duration.
-
-## Easing: Pick the Right Curve
-
-Don't use `ease` — it's a compromise that's rarely optimal. Instead:
-
-| Curve | Use for | CSS |
-|---|---|---|
-| **ease-out** | Elements entering | `cubic-bezier(0.16, 1, 0.3, 1)` |
-| **ease-in** | Elements leaving | `cubic-bezier(0.7, 0, 0.84, 0)` |
-| **ease-in-out** | State toggles (there → back) | `cubic-bezier(0.65, 0, 0.35, 1)` |
-
-For micro-interactions, exponential curves feel natural (friction,
-deceleration):
-
-```css
-/* Quart out — smooth, refined (Kilo's --ease-out-strong is close) */
---ease-out-quart: cubic-bezier(0.25, 1, 0.5, 1);
-
-/* Quint out — slightly more dramatic */
---ease-out-quint: cubic-bezier(0.22, 1, 0.36, 1);
-
-/* Expo out — snappy, confident */
---ease-out-expo: cubic-bezier(0.16, 1, 0.3, 1);
-```
-
-**Avoid bounce and elastic curves.** They feel tacky and amateurish. Real
-objects don't bounce when they stop — they decelerate smoothly.
-
-## Premium Motion Materials
-
-Transform and opacity are reliable defaults, not the whole palette.
-Premium interfaces often need atmospheric properties: blur reveals,
-backdrop-filter panels, saturation or brightness shifts, shadow bloom,
-SVG filters, masks, clip paths, gradient-position movement, and variable
-font or shader-driven effects.
-
-Use the right material for the effect:
-
-- **Transform / opacity** — movement, press feedback, simple reveals,
-  list choreography.
-- **Blur / filter / backdrop-filter** — focus pulls, depth, glass/lens
-  effects, softened entrances, atmospheric transitions.
-- **Clip path / masks** — wipes, reveals, editorial cropping, product-
-  like transitions.
-- **Shadow / glow / color filters** — energy, affordance, focus, warmth,
-  active state.
-- **Grid-template rows or FLIP-style transforms** — expanding and
-  reflowing layout without animating `height` directly.
-
-Avoid animating layout-driving properties casually (`width`, `height`,
-`top`, `left`, margins). Keep expensive effects bounded to small or
-isolated areas, and verify in-browser that the result is smooth on
-target viewports.
-
-## Staggered Animations
-
-Use CSS custom properties for cleaner stagger:
-`animation-delay: calc(var(--i, 0) * 50ms)` with `style="--i: 0"` on each
-item. **Cap total stagger time** — 10 items × 50ms = 500ms total. For
-many items, reduce per-item delay or cap staggered count.
-
-## Reduced Motion
-
-Not optional. Vestibular disorders affect ~35% of adults over 40.
-
-```css
-/* Define animations normally */
-.card {
-  animation: slide-up 500ms ease-out;
-}
-
-/* Provide alternative for reduced motion */
-@media (prefers-reduced-motion: reduce) {
-  .card {
-    animation: fade-in 200ms ease-out;
-  }
-}
-
-/* Or disable entirely */
-@media (prefers-reduced-motion: reduce) {
-  *,
-  *::before,
-  *::after {
-    animation-duration: 0.01ms !important;
-    transition-duration: 0.01ms !important;
-  }
-}
-```
-
-Preserve functional animations: progress bars, loading spinners (slowed),
-focus indicators.
-
-## Perceived Performance
-
-Nobody cares how fast your site is — only how fast it feels.
-
-- **80ms threshold.** Anything under ~80ms feels instant. Target this
-  for micro-interactions.
-- **Active vs passive time.** Passive waiting (staring at a spinner)
-  feels longer than active engagement. Preemptive transitions, early
-  completion, and optimistic UI shift the balance.
-- **Easing affects perceived duration.** Ease-in toward a task's end
-  compresses perceived time.
-- **Caution.** Instantaneous responses can decrease perceived value
-  for complex operations — a brief delay can signal "real work."
-
-## Performance
-
-Don't use `will-change` preemptively — only when animation is imminent
-(`:hover`, `.animating`). For scroll-triggered animations, use
-Intersection Observer, and `unobserve()` after animating once. Create
-motion tokens for consistency (Kilo already has `--ease-out-strong`).
-
----
-
-**Avoid**: Animating everything (animation fatigue is real). >500ms for
-UI feedback. Ignoring `prefers-reduced-motion`. Using animation to hide
-slow loading. Reinventing Radix primitives' transitions.
diff --git a/.kilo/skills/kilo-design/reference/responsive-design.md b/.kilo/skills/kilo-design/reference/responsive-design.md
deleted file mode 100644
index e5b59b28dc..0000000000
--- a/.kilo/skills/kilo-design/reference/responsive-design.md
+++ /dev/null
@@ -1,202 +0,0 @@
-# Responsive Design
-
-> Adapted from Impeccable's `responsive-design.md` (Apache 2.0). See
-> `NOTICE.md` for attribution and upstream source.
-
-## Kilo application
-
-Kilo has two parallel responsive surfaces:
-
-1. **Web** (`apps/web/`) — Next.js + Tailwind v4. Responsive tooling is
-   Tailwind breakpoints + container queries + `env(safe-area-inset-*)`.
-2. **Mobile** (`apps/mobile/`) — React Native + NativeWind. Tailwind
-   breakpoints do **not** map to RN components the same way; use the
-   device conventions already in that app.
-
-### Kilo-specific rules
-
-- **Design mobile-first** for web flows that appear on both marketing
-  and the app shell. Add complexity at `md:` / `lg:` / `xl:` breakpoints,
-  not the other way around.
-- **Do not rely on hover for required functionality.** Hover is
-  supplementary. Touch users can't use it.
-- **Cards and forms should reflow**, not clip. Long labels, long email
-  addresses, long plan names are the norm, not the edge case.
-- **Sidebar rules.** The app shell sidebar has its own mobile behavior
-  via `@/components/ui/sidebar`. Don't reinvent mobile nav — wrap into
-  the existing sidebar state or use `Sheet` from shadcn.
-- **Respect safe areas** on mobile web (iPhone notches, rounded corners).
-  Use `max(…, env(safe-area-inset-*))` on fixed bottom/top bars.
-- **Test at least three widths** for any visual change:
-  - A narrow mobile viewport (~375px).
-  - A tablet or narrow laptop (~768–1024px).
-  - A wide desktop (~1440px+).
-- **React Native + NativeWind caveat:** opacity modifiers (`bg-card/40`)
-  do not work on CSS-variable theme colors. Verify with the component in
-  `apps/mobile/` before assuming a utility composes the same way it does
-  on web.
-
-### Absolute rejects in Kilo UI
-
-- Hover-only required actions.
-- Fixed-pixel widths that break at mobile widths without reflow.
-- Device-user-agent sniffing instead of feature queries.
-- Separate mobile/desktop component trees built from scratch when a
-  shared responsive component would work.
-- Hiding content on mobile (`hidden md:block`) just because the layout
-  is inconvenient. If information matters at desktop, it matters on
-  mobile — reshape it.
-
----
-
-## Mobile-First: Write It Right
-
-Start with base styles for mobile, use `min-width` queries to layer
-complexity. Desktop-first (`max-width`) means mobile loads unnecessary
-styles first. In Tailwind this is the default behavior: unprefixed
-utilities apply at the smallest viewport, and `md:`, `lg:`, `xl:` add
-complexity upward.
-
-## Breakpoints: Content-Driven
-
-Don't chase device sizes — let content tell you where to break. Start
-narrow, stretch until the design breaks, and add a breakpoint there.
-Three breakpoints usually suffice (the Tailwind `md` 768, `lg` 1024,
-`xl` 1280 defaults work). Use `clamp()` for fluid values without
-breakpoints — but only on marketing/brand pages (see `typography.md`).
-
-## Detect Input Method, Not Just Screen Size
-
-Screen size doesn't tell you input method. A laptop with a touchscreen,
-a tablet with a keyboard — use pointer and hover queries:
-
-```css
-/* Fine pointer (mouse, trackpad) */
-@media (pointer: fine) {
-  .button {
-    padding: 8px 16px;
-  }
-}
-
-/* Coarse pointer (touch, stylus) */
-@media (pointer: coarse) {
-  .button {
-    padding: 12px 20px;
-  } /* Larger touch target */
-}
-
-/* Device supports hover */
-@media (hover: hover) {
-  .card:hover {
-    transform: translateY(-2px);
-  }
-}
-
-/* Device doesn't support hover (touch) */
-@media (hover: none) {
-  /* No hover state — use active instead */
-}
-```
-
-**Critical**: Don't rely on hover for functionality. Touch users can't
-hover. In Tailwind, `hover:` + `@media (hover: hover)` wrapping via the
-`hocus` pattern / `@custom-variant` is fine, but design the no-hover
-path first.
-
-## Safe Areas: Handle the Notch
-
-Modern phones have notches, rounded corners, and home indicators. Use
-`env()`:
-
-```css
-body {
-  padding-top: env(safe-area-inset-top);
-  padding-bottom: env(safe-area-inset-bottom);
-  padding-left: env(safe-area-inset-left);
-  padding-right: env(safe-area-inset-right);
-}
-
-/* With fallback */
-.footer {
-  padding-bottom: max(1rem, env(safe-area-inset-bottom));
-}
-```
-
-Enable `viewport-fit` in your meta tag:
-
-```html
-<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
-```
-
-`apps/web/src/app/layout.tsx` sets a Next.js `viewport` object — align
-additions there, not via manual meta tags.
-
-## Responsive Images: Get It Right
-
-### srcset with Width Descriptors
-
-```html
-<img
-  src="hero-800.jpg"
-  srcset="hero-400.jpg 400w, hero-800.jpg 800w, hero-1200.jpg 1200w"
-  sizes="(max-width: 768px) 100vw, 50vw"
-  alt="Hero image"
-/>
-```
-
-How it works:
-
-- `srcset` lists available images with actual widths (`w` descriptors).
-- `sizes` tells the browser how wide the image will display.
-- Browser picks the best file based on viewport width AND device pixel
-  ratio.
-
-In Kilo, prefer Next.js `<Image>` — it produces correct srcset, sizes,
-and lazy loading automatically.
-
-### Picture Element for Art Direction
-
-When you need different crops/compositions (not just resolutions):
-
-```html
-<picture>
-  <source media="(min-width: 768px)" srcset="wide.jpg" />
-  <source media="(max-width: 767px)" srcset="tall.jpg" />
-  <img src="fallback.jpg" alt="..." />
-</picture>
-```
-
-## Layout Adaptation Patterns
-
-- **Navigation.** Three stages — hamburger/sheet on mobile, horizontal
-  compact on tablet, full with labels on desktop. In Kilo, the
-  `Sidebar` primitive + `Sheet` covers this.
-- **Tables.** Transform to cards on mobile using `display: block` and
-  `data-label` attributes. For simple tables, horizontal scroll with a
-  fade mask is acceptable — Kilo already uses this pattern in a few
-  billing/admin views.
-- **Progressive disclosure.** Use `<details>/<summary>` or shadcn's
-  `Accordion` / `Collapsible` for content that can collapse on mobile.
-
-## Testing: Don't Trust DevTools Alone
-
-DevTools device emulation is useful for layout but misses:
-
-- Actual touch interactions.
-- Real CPU/memory constraints.
-- Network latency patterns.
-- Font rendering differences.
-- Browser chrome / keyboard appearances.
-
-Test on at least one real iPhone, one real Android, a tablet if relevant.
-Cheap Android phones reveal performance issues you'll never see on
-simulators. For Kilo's mobile app, use a dev build / dev client on a real
-device before shipping significant UI changes. Do not use Expo Go; the app
-does not support it.
-
----
-
-**Avoid**: Desktop-first design. Device detection instead of feature
-detection. Separate mobile/desktop codebases grown by accident. Ignoring
-tablet and landscape. Assuming all mobile devices are powerful.
-Mobile-hostile `hidden` instead of reshaping content.
diff --git a/.kilo/skills/kilo-design/reference/spatial-design.md b/.kilo/skills/kilo-design/reference/spatial-design.md
deleted file mode 100644
index a412cf6ef6..0000000000
--- a/.kilo/skills/kilo-design/reference/spatial-design.md
+++ /dev/null
@@ -1,190 +0,0 @@
-# Spatial Design
-
-> Adapted from Impeccable's `spatial-design.md` (Apache 2.0). See
-> `NOTICE.md` for attribution and upstream source.
-
-## Kilo application
-
-Kilo's product UI is **compact and task-oriented**. Do not redesign the
-app shell with marketing-scale spacing.
-
-### Spacing
-
-- Use Tailwind's 4pt-aligned scale: `gap-1`, `gap-2`, `gap-3`, `gap-4`,
-  `gap-6`, `gap-8`. Avoid arbitrary `gap-[19px]`.
-- Prefer `gap` over margins. It eliminates margin collapse and is
-  consistent with flex/grid in the codebase.
-- Cards use `p-6` for header/content/footer, `gap-1.5` between card title
-  and description (`apps/web/src/components/ui/card.tsx`).
-- App topbars run at `h-14`; avoid arbitrary topbar heights.
-- Controls stay compact: `h-8` (sm), `h-control-default` / 36px (default), `h-10` (lg). Use `h-control-touch` or `size-control-touch` for 44px touch targets.
-- Mobile (React Native) has its own safe-area behavior — use the tokens
-  in `apps/mobile/`, not web-only `env(safe-area-inset-*)`.
-
-### Radius
-
-Kilo defines a radius scale:
-
-| Token | Value | Use |
-|---|---|---|
-| `--radius-sm` | `4px` | Tight inline chips |
-| `--radius-md` | `8px` | Buttons, inputs |
-| `--radius-lg` | `10px` | Popovers, medium containers |
-| `--radius-xl` | `14px` | Cards, dialogs |
-| (full) | `rounded-full` | Badges, avatars, status pills |
-
-Do not introduce new radius values.
-
-### Hierarchy
-
-- **Never nest a Card inside a Card.** If you need sub-grouping, use
-  dividers, spacing, headings, or muted backgrounds — not another card.
-- Use Kilo's sidebar tokens for sidebar-adjacent surfaces; don't hand-paint
-  a second sidebar.
-- Use spacing + typography to build hierarchy before reaching for shadows.
-  Dark-mode depth comes from lighter surfaces, not shadows.
-
-### Absolute rejects in Kilo UI
-
-- Arbitrary spacing values outside Tailwind's scale.
-- Nested cards.
-- Uniform padding everywhere (variety creates rhythm).
-- Hand-drawn z-index values like `z-[9999]`. Use semantic layering
-  (`z-10` for sticky, Radix overlays for modals/menus — Radix handles
-  stacking).
-- Reintroducing one-off popover/tooltip/drawer positioning when Radix
-  primitives already exist in `apps/web/src/components/ui/`.
-
----
-
-## Spacing Systems
-
-### Use 4pt Base
-
-4pt systems give you 12px between 8 and 16. Tailwind's scale is 4pt-aligned;
-use it. Name tokens semantically (`--space-sm`, `--space-lg`), not by value
-(`--spacing-8`). In Kilo this usually means Tailwind utilities.
-
-## Grid Systems
-
-### The Self-Adjusting Grid
-
-Use `repeat(auto-fit, minmax(280px, 1fr))` for responsive grids without
-breakpoints. Columns are at least 280px, as many as fit per row, leftovers
-stretch.
-
-For complex layouts, use named `grid-template-areas` and redefine at
-breakpoints. Kilo's app shell already uses sidebar + content layouts with
-`sidebar-*` tokens; reuse those structural utilities before building new
-ones.
-
-## Visual Hierarchy
-
-### The Squint Test
-
-Blur your eyes or screenshot + blur. Can you still identify:
-
-- The most important element?
-- The second most important?
-- Clear groupings?
-
-If everything looks the same weight blurred, you have a hierarchy problem.
-
-### Hierarchy Through Multiple Dimensions
-
-Do not rely on size alone. Combine:
-
-| Tool | Strong hierarchy | Weak hierarchy |
-|---|---|---|
-| **Size** | 3:1 ratio or more | <2:1 ratio |
-| **Weight** | Bold vs Regular | Medium vs Regular |
-| **Color** | High contrast | Similar tones |
-| **Position** | Top / left (primary) | Bottom / right |
-| **Space** | Surrounded by whitespace | Crowded |
-
-The best hierarchy uses 2–3 dimensions at once: a heading that's larger,
-bolder, AND has more space above it.
-
-### Cards Are Not Required
-
-Cards are overused. Spacing and alignment create visual grouping naturally.
-Use cards only when:
-
-- Content is truly distinct and actionable.
-- Items need visual comparison in a grid.
-- Content needs clear interaction boundaries.
-
-**Never nest cards inside cards.** Use spacing, typography, and subtle
-dividers for hierarchy within a card.
-
-## Container Queries
-
-Viewport queries are for page layouts. **Container queries are for
-components:**
-
-```css
-.card-container {
-  container-type: inline-size;
-}
-
-.card {
-  display: grid;
-  gap: var(--space-md);
-}
-
-/* Card layout changes based on its container, not the viewport */
-@container (min-width: 400px) {
-  .card {
-    grid-template-columns: 120px 1fr;
-  }
-}
-```
-
-A card in a narrow sidebar stays compact while the same card in a main
-content area expands — automatically, no viewport hacks.
-
-## Optical Adjustments
-
-Text at `margin-left: 0` looks indented due to letterform whitespace; use
-negative margin (`-0.05em`) to optically align. Geometrically centered
-icons often look off-center; play icons shift right, arrows shift toward
-their direction.
-
-### Touch Targets vs Visual Size
-
-Buttons can look small but need large touch targets (44px minimum). Use
-padding or pseudo-elements:
-
-```css
-.icon-button {
-  width: 24px;
-  height: 24px;
-  position: relative;
-}
-
-.icon-button::before {
-  content: '';
-  position: absolute;
-  inset: -10px;
-}
-```
-
-In Kilo, `h-9 w-9` icon buttons (`button.tsx` `size: "icon"`) sit just
-below the 44px touch target. On mobile-facing surfaces, stretch the tap
-area via padding or `::before`, not by enlarging the visual control.
-
-## Depth & Elevation
-
-Create semantic z-index scales (`dropdown → sticky → modal-backdrop →
-modal → toast → tooltip`) rather than arbitrary numbers. In Kilo, Radix
-primitives already manage stacking for overlays — don't fight them with
-`z-[99999]`.
-
-Shadows should be subtle — if you can clearly see them, they're too
-strong. Dark-mode Kilo depth comes from surface elevation, not shadow.
-
----
-
-**Avoid**: Arbitrary spacing values outside your scale. Making all spacing
-equal (variety creates hierarchy). Creating hierarchy through size alone.
-Nested cards. Rewriting positioning for overlays when Radix already solves it.
diff --git a/.kilo/skills/kilo-design/reference/typography.md b/.kilo/skills/kilo-design/reference/typography.md
deleted file mode 100644
index 760f585cc0..0000000000
--- a/.kilo/skills/kilo-design/reference/typography.md
+++ /dev/null
@@ -1,180 +0,0 @@
-# Typography
-
-> Adapted from Impeccable's `typography.md` (Apache 2.0). See `NOTICE.md` for
-> attribution and upstream source.
-
-## Kilo application
-
-Kilo's fonts are already chosen and loaded. Do not introduce new families.
-
-| Family | CSS variable | Use |
-|---|---|---|
-| Inter | `--font-sans` | Default product UI, buttons, labels, body |
-| Roboto Mono | `--font-mono` | Code tokens, identifiers, metadata |
-| JetBrains Mono | `--font-jetbrains` | Terminal and code-editor surfaces (class `font-jetbrains`) |
-
-Kilo-specific rules:
-
-- **Product UI uses a fixed type scale.** No fluid `clamp()` sizing inside
-  the app shell, dashboards, billing, settings, or Storybook components.
-  App UIs need spatial predictability.
-- **Marketing/brand pages may use `clamp()` for hero headlines** only. Body
-  copy stays fixed.
-- **Use `tabular-nums`** on anything numeric that aligns in columns:
-  billing, usage counters, tables, KPIs, timers.
-- **Disable code ligatures** (`font-variant-ligatures: none;`) only on
-  surfaces where glyph-accurate code matters (terminals, diff views).
-- **Use exact role metrics.** `type-title`, `type-heading`, `type-body-lg`, `type-body`, `type-label`, `type-eyebrow`, and `type-code` implement `DESIGN.md`; do not independently bump line-height or weight.
-- Page titles use `type-title` (`1.5rem / 600 / 1.2`). Logo lockups may retain their existing brand-specific styling.
-- `globals.css` maps `font-sans` and `font-mono` to the variables loaded by `layout.tsx`. Do not add per-component font fallbacks.
-
-Absolute rejects in Kilo product UI:
-
-- New font families outside the three listed above.
-- Gradient text.
-- ALL-CAPS body copy (short labels/eyebrows OK with added tracking).
-- Font sizes outside canonical `type-*` utilities or an approved brand/marketing scale.
-- Fluid `clamp()` in product UI.
-
----
-
-## Classic Typography Principles
-
-### Vertical Rhythm
-
-Your line-height should be the base unit for ALL vertical spacing. If body
-text has `line-height: 1.5` on 16px type (24px), spacing values should be
-multiples of 24px. This creates subconscious harmony between text and space.
-
-### Modular Scale & Hierarchy
-
-The common mistake: too many font sizes that are too close together (14, 15,
-16, 18). Muddy hierarchy.
-
-**Use fewer sizes with more contrast.** A five-size system covers most
-product UI:
-
-| Role | Typical ratio | Kilo Tailwind | Use case |
-|---|---|---|---|
-| xs | 0.75rem | `text-xs` | Captions, legal, helper |
-| sm | 0.875rem | `text-sm` | Secondary UI, metadata |
-| base | 1rem | `text-base` | Body text |
-| lg | 1.125–1.25rem | `text-lg` | Subheadings, lead text |
-| xl+ | 1.5rem and up | `text-xl`+ | Page titles, hero |
-
-Pick a ratio (1.25 major third, 1.333 perfect fourth, 1.5 perfect fifth)
-and commit. Do not mix multiple scales.
-
-### Readability & Measure
-
-Cap body width in the 45–75ch band (`max-width: 65ch`). Narrow columns need
-tighter leading; wide columns need more.
-
-**Dark mode compensation.** Light text on dark can read lighter than dark on light. Kilo's canonical type roles already account for product density. Do not alter their line-height, tracking, or weight per component; propose a contract change if readability testing shows a systemic issue.
-
-**Paragraph rhythm.** Use either space between paragraphs or first-line
-indent. Never both. Product UI uses space.
-
-## Font Selection & Pairing
-
-Kilo does not select new fonts per project. If a brand surface justifies a
-genuine display face for a hero, treat it as a design decision that needs
-approval, not a reflex.
-
-### Pairing principles
-
-One well-chosen family in multiple weights usually beats two competing
-typefaces. Kilo already runs Inter + Roboto Mono + JetBrains Mono; that is
-enough. If a second typeface appears on a marketing page, it contrasts on
-multiple axes (serif + sans, geometric + humanist, condensed + wide), never
-two similar sans-serifs side by side.
-
-### Web font loading
-
-Fonts are loaded in `apps/web/src/app/layout.tsx` via `next/font/google`,
-which handles `font-display: swap` and preload. Do not reintroduce manual
-`@font-face` declarations or competing loaders.
-
-## Modern Web Typography
-
-### Fluid type — limited in Kilo
-
-`clamp(min, preferred, max)` is allowed on marketing hero headlines and
-long-form content where the type dominates the layout. It is **not** used
-for product UI, dashboards, tools, or tables. Material, Polaris, Primer,
-and Carbon all use fixed scales for the same reason: spatial predictability
-matters more than viewport-scaled type in dense surfaces.
-
-Bound your `clamp()`: `max-size ≤ ~2.5 × min-size`.
-
-### OpenType features
-
-```css
-/* Tabular numbers for data alignment */
-.data-table {
-  font-variant-numeric: tabular-nums;
-}
-
-/* Proper fractions */
-.recipe-amount {
-  font-variant-numeric: diagonal-fractions;
-}
-
-/* Small caps for abbreviations */
-abbr {
-  font-variant-caps: all-small-caps;
-}
-
-/* Disable ligatures in code */
-code,
-.font-jetbrains {
-  font-variant-ligatures: none;
-}
-
-/* Explicit kerning */
-body {
-  font-kerning: normal;
-}
-```
-
-### Rendering polish
-
-```css
-/* Even out heading line lengths */
-h1,
-h2,
-h3 {
-  text-wrap: balance;
-}
-
-/* Reduce orphans and ragged endings in long prose */
-article p {
-  text-wrap: pretty;
-}
-
-/* Pick the right optical-size master automatically */
-body {
-  font-optical-sizing: auto;
-}
-```
-
-ALL-CAPS short labels need 5–12% letter-spacing (`letter-spacing: 0.05em`
-to `0.12em`).
-
-## Typography System Architecture
-
-Name tokens semantically, not by value. In Kilo product UI, prefer canonical `type-*` utilities. Use `font-sans`, `font-mono`, or `.font-jetbrains` only when a complete role utility does not apply.
-
-## Accessibility
-
-- **Never disable zoom.** `user-scalable=no` breaks accessibility.
-- **Use `rem`/`em` for font sizes.** Never `px` for body text.
-- **Mobile readability.** Use the `type-body-lg` utility for long-form mobile reading. Keep form controls at 16px where needed to prevent browser zoom. The canonical compact product `body` role remains 14px.
-- **Adequate touch targets.** Text links need padding or line-height that
-  yields a 44px+ tap target.
-
----
-
-**Avoid**: More than three font families (Kilo already uses three; no
-fourth). Skipping fallback font definitions. Decorative fonts for body
-text. Fluid type in product UI.
diff --git a/.kilo/skills/kilo-design/reference/ux-writing.md b/.kilo/skills/kilo-design/reference/ux-writing.md
deleted file mode 100644
index 7c1cc5ce62..0000000000
--- a/.kilo/skills/kilo-design/reference/ux-writing.md
+++ /dev/null
@@ -1,253 +0,0 @@
-# UX Writing
-
-> Adapted from Impeccable's `ux-writing.md` (Apache 2.0). See `NOTICE.md`
-> for attribution and upstream source.
-
-## Kilo application
-
-Kilo voice is **clear, technical, calm, and direct**. Engineering-literate
-audience. No hype, no cutesy error copy, no vague productivity slogans.
-
-### Kilo voice in one paragraph
-
-Kilo talks to developers and team leads. Say what the product does, what
-the user needs to do next, and what will happen if they do it. Skip
-adjectives like "powerful," "seamless," "effortless," and "revolutionary."
-Prefer concrete verbs and specific nouns.
-
-### Terminology to pick and keep
-
-Pick one term per concept and hold it across web, mobile, docs, and UI:
-
-| Use | Not |
-|---|---|
-| Sign in / Sign out | Log in, Log out, Enter, Exit |
-| Delete | Remove, Trash, Clear (for destructive ops) |
-| Settings | Preferences, Options, Configuration |
-| Create | Add, New (for creating a persistent thing) |
-| Workspace | Team, Account, Org (if "workspace" is what the product calls it) |
-| Kilo Code | KiloCode, kilo-code (product name) |
-
-If this repo has a newer glossary, prefer that. Do not invent synonyms
-to add variety.
-
-### Button labels
-
-Use verb + object. Specific over generic. Kilo-flavored examples:
-
-| Bad | Good |
-|---|---|
-| OK | Save changes |
-| Submit | Create workspace |
-| Yes | Delete project |
-| Cancel | Keep editing |
-| Click here | View billing history |
-
-For destructive actions, name the destruction and the count:
-
-- "Delete 5 invites"
-- "Delete workspace permanently"
-- "Remove member from team"
-
-### Error copy
-
-Every error should answer: (1) what happened, (2) why (if knowable),
-(3) what to try next.
-
-Kilo-flavored patterns:
-
-- `Can't reach Stripe. Check your connection and try again.`
-- `Invalid token. Sign in again to refresh your session.`
-- `Email must include an @ symbol. Example: you@example.com`
-- `You don't have access to this workspace. Ask an admin for an invite.`
-- `Something went wrong on our end. Our team has been notified. Try again in a minute.`
-
-Do **not**:
-
-- Blame the user: "You entered an invalid date" → "Please enter a date as
-  MM/DD/YYYY".
-- Use humor in errors — users are already frustrated.
-- Emit stack traces in user-facing copy.
-- Use `Error: ` prefixes in user-facing messages (the UI treatment already
-  signals an error).
-
-### Empty states
-
-Acknowledge, explain value, provide a clear action. Examples:
-
-- `No workspaces yet. Create one to invite your team and start billing.`
-- `No invoices yet. Your first invoice will appear after your trial ends.`
-- `No API keys. Create one to connect Kilo Code to your IDE.`
-
-### Loading copy
-
-Be specific. `Creating workspace…` beats `Loading…`. For long waits, set
-expectations: `Provisioning machine. This usually takes 30–60 seconds.`
-
-### Confirmation copy
-
-Confirm only for truly irreversible or high-stakes actions. Name the
-action in both buttons:
-
-- `Delete workspace permanently?`
-  Primary: `Delete workspace` (destructive variant).
-  Secondary: `Keep workspace`.
-
-### Accessibility copy
-
-- Link text must stand alone: `View pricing plans`, not `Click here`.
-- Alt text describes information, not the image:
-  `Revenue increased 40% in Q4`, not `Chart`.
-- Use `alt=""` for decorative images.
-- Icon-only buttons need `aria-label`.
-
-### Translation / i18n
-
-- German and Finnish can be ~30% longer than English. Plan layout for
-  expansion.
-- Keep full sentences as single strings; word order changes between
-  languages.
-- Avoid abbreviations (`5 minutes ago`, not `5m ago`) unless space is
-  actually constrained.
-- When adding new strings, structure them to allow a translator context.
-
-### Absolute rejects in Kilo copy
-
-- "Submit" / "OK" / "Yes/No" as primary labels.
-- "Oops!" / "Whoops" / "Uh oh" in any user-facing error.
-- Emoji in error messages.
-- Em dashes "—" in UI copy. Use commas, colons, semicolons, or
-  parentheses. Also not `--`.
-- "Powerful," "seamless," "revolutionary," "unlock" as adjectives.
-- Undifferentiated terminology: using `delete` / `remove` / `trash`
-  interchangeably in the same product surface.
-
----
-
-## The Button Label Problem
-
-Never use `OK`, `Submit`, or `Yes`/`No`. Use specific verb + object:
-
-| Bad | Good | Why |
-|---|---|---|
-| OK | Save changes | Says what will happen |
-| Submit | Create account | Outcome-focused |
-| Yes | Delete message | Confirms the action |
-| Cancel | Keep editing | Clarifies what "cancel" means |
-| Click here | Download PDF | Describes the destination |
-
-For destructive actions, name the destruction:
-
-- `Delete`, not `Remove` (delete is permanent; remove implies
-  recoverable).
-- `Delete 5 items`, not `Delete selected` (show the count).
-
-## Error Messages: The Formula
-
-Every error should answer: (1) what happened, (2) why, (3) how to fix it.
-`Email address isn't valid. Please include an @ symbol.` beats
-`Invalid input`.
-
-### Error message templates
-
-| Situation | Template |
-|---|---|
-| Format error | "[Field] needs to be [format]. Example: [example]" |
-| Missing required | "Please enter [what's missing]" |
-| Permission denied | "You don't have access to [thing]. [What to do instead]" |
-| Network error | "We couldn't reach [thing]. Check your connection and [action]" |
-| Server error | "Something went wrong on our end. We're looking into it." |
-
-### Don't blame the user
-
-Reframe errors: `Please enter a date in MM/DD/YYYY format` not
-`You entered an invalid date`.
-
-## Empty States Are Opportunities
-
-Empty states are onboarding moments:
-
-1. Acknowledge briefly.
-2. Explain the value of filling it.
-3. Provide a clear action.
-
-`No projects yet. Create your first one to get started.` not just
-`No items`.
-
-## Voice vs Tone
-
-**Voice** is your brand's personality — consistent everywhere. **Tone**
-adapts to the moment.
-
-| Moment | Tone shift |
-|---|---|
-| Success | Celebratory, brief: "Done! Your changes are live." |
-| Error | Empathetic, helpful: "That didn't work. Here's what to try…" |
-| Loading | Reassuring: "Saving your work…" |
-| Destructive confirm | Serious, clear: "Delete this project? This can't be undone." |
-
-Never use humor for errors.
-
-## Writing for Accessibility
-
-- **Link text** must have standalone meaning — `View pricing plans`, not
-  `Click here`.
-- **Alt text** describes information, not the image — `Revenue increased
-40% in Q4`, not `Chart`.
-- Use `alt=""` for decorative images.
-- **Icon buttons** need `aria-label` for screen reader context.
-
-## Writing for Translation
-
-### Plan for expansion
-
-German text is ~30% longer than English. Allocate space:
-
-| Language | Expansion |
-|---|---|
-| German | +30% |
-| French | +20% |
-| Finnish | +30–40% |
-| Chinese | -30% (fewer chars, same width) |
-
-### Translation-friendly patterns
-
-- Keep numbers separate (`New messages: 3`, not `You have 3 new
-messages`).
-- Use full sentences as single strings (word order varies by language).
-- Avoid abbreviations (`5 minutes ago`, not `5 mins ago`).
-- Give translators context about where strings appear.
-
-## Consistency: The Terminology Problem
-
-Pick one term and stick with it. Build a terminology glossary and
-enforce it. Variety creates confusion.
-
-## Avoid Redundant Copy
-
-If the heading explains it, the intro is redundant. If the button is
-clear, don't explain it again. Say it once, say it well.
-
-## Loading States
-
-Be specific: `Saving your draft…`, not `Loading…`. For long waits, set
-expectations (`This usually takes 30 seconds`) or show progress.
-
-## Confirmation Dialogs: Use Sparingly
-
-Most confirmation dialogs are design failures — consider undo instead.
-When you must confirm: name the action, explain consequences, use
-specific button labels (`Delete project` / `Keep project`, not
-`Yes` / `No`).
-
-## Form Instructions
-
-Show format with placeholders, not instructions. For non-obvious fields,
-explain why you're asking.
-
----
-
-**Avoid**: Jargon without explanation. Blaming users
-(`You made an error` → `This field is required`). Vague errors
-(`Something went wrong`). Varying terminology for variety. Humor for
-errors.
diff --git a/.kilo/skills/repository-verification/SKILL.md b/.kilo/skills/repository-verification/SKILL.md
index c0d9d84e1f..ac6f9b7922 100644
--- a/.kilo/skills/repository-verification/SKILL.md
+++ b/.kilo/skills/repository-verification/SKILL.md
@@ -13,7 +13,7 @@ Read root and relevant package `package.json` files before selecting commands. P
 |---|---|
 | `pnpm typecheck` | Runs `scripts/typecheck-all.sh`. |
 | `pnpm lint` | Runs `scripts/lint-all.sh`. |
-| `pnpm test` | Runs web tests, then `test:web-env`; it does not run every package suite. |
+| `pnpm test` | Runs web, `test:web-env`, and `test:dev-local`; it does not run every package suite. |
 | `pnpm validate` | Runs root typecheck, lint, and test scripts. |
 | `pnpm format` | Formats supported files with `oxfmt`. |
 | `pnpm format:check` | Lists supported files that differ from `oxfmt`. |
diff --git a/.kilo_workflow/.e2e-slot-state.sh b/.kilo_workflow/.e2e-slot-state.sh
new file mode 100755
index 0000000000..227c06c6ed
--- /dev/null
+++ b/.kilo_workflow/.e2e-slot-state.sh
@@ -0,0 +1,138 @@
+#!/usr/bin/env bash
+# Internal state engine. Agents use the five public E2E lifecycle scripts.
+set -uo pipefail
+
+DIR="$HOME/.cache/kilo-e2e-slots"
+TOTAL=3
+POLL=10
+ACQUIRE_DEADLINE=2700
+mkdir -p "$DIR" || { echo "cannot create slot state dir $DIR" >&2; exit 1; }
+[ -w "$DIR" ] || { echo "slot state dir $DIR is not writable" >&2; exit 1; }
+command -v tmux >/dev/null || { echo "tmux is required" >&2; exit 1; }
+
+self_session() {
+  [ -n "${TMUX_PANE:-}" ] || return 0
+  tmux display-message -p -t "$TMUX_PANE" '#S' 2>/dev/null || true
+}
+
+session_live() {
+  tmux has-session -t "=$1" 2>/dev/null
+}
+
+reap() {
+  local now slot owner modified age
+  now=$(date +%s)
+  for slot in "$DIR"/slot-*; do
+    [ -d "$slot" ] || continue
+    owner=$(cat "$slot/owner" 2>/dev/null || true)
+    if [ -n "$owner" ]; then
+      if ! session_live "$owner"; then
+        rm -rf "$slot"
+        echo "reclaimed $(basename "$slot") from dead session $owner" >&2
+      fi
+      continue
+    fi
+
+    # mkdir wins the slot before acquire publishes its owner. Only clear an
+    # ownerless directory once it is old enough to be an interrupted acquire.
+    modified=$(stat -f %m "$slot" 2>/dev/null || stat -c %Y "$slot" 2>/dev/null || echo "$now")
+    age=$((now - modified))
+    [ "$age" -gt 60 ] && rm -rf "$slot"
+  done
+}
+
+case "${1:?internal usage: $0 acquire|release|status|_held}" in
+  _held)
+    owner=$(self_session)
+    [ -n "$owner" ] || exit 1
+    for slot in "$DIR"/slot-*; do
+      [ -d "$slot" ] || continue
+      [ "$(cat "$slot/owner" 2>/dev/null)" = "$owner" ] || continue
+      echo "$slot"
+      exit 0
+    done
+    exit 1
+    ;;
+  acquire)
+    [ -z "${2:-}" ] || {
+      echo "acquire takes no session name; run it inside the tmux session that owns the work" >&2
+      exit 1
+    }
+    owner=$(self_session)
+    [ -n "$owner" ] || {
+      echo "not inside tmux; a live tmux session must own the slot" >&2
+      exit 1
+    }
+    session_live "$owner" || {
+      echo "tmux session '$owner' is not live" >&2
+      exit 1
+    }
+
+    for slot in "$DIR"/slot-*; do
+      [ -d "$slot" ] || continue
+      [ "$(cat "$slot/owner" 2>/dev/null)" = "$owner" ] || continue
+      echo "already holding $(basename "$slot")"
+      exit 0
+    done
+
+    deadline=$(($(date +%s) + ACQUIRE_DEADLINE))
+    while :; do
+      reap
+      for number in $(seq 1 "$TOTAL"); do
+        slot="$DIR/slot-$number"
+        if mkdir "$slot" 2>/dev/null; then
+          worktree=$(git rev-parse --show-toplevel 2>/dev/null || pwd -P)
+          if printf '%s' "$worktree" > "$slot/worktree" &&
+             date -u +%Y-%m-%dT%H:%M:%SZ > "$slot/since" &&
+             printf '%s' "$owner" > "$slot/owner"; then
+            echo "acquired slot-$number"
+            exit 0
+          fi
+          rm -rf "$slot"
+          echo "failed to record slot ownership in $DIR" >&2
+          exit 1
+        fi
+      done
+      if [ "$(date +%s)" -ge "$deadline" ]; then
+        echo "no slot freed in ${ACQUIRE_DEADLINE}s; current holders:" >&2
+        "$0" status >&2 || true
+        exit 1
+      fi
+      echo "all $TOTAL E2E slots busy; retrying in ${POLL}s" >&2
+      sleep "$POLL"
+    done
+    ;;
+  release)
+    [ -z "${2:-}" ] || { echo "release takes no arguments" >&2; exit 1; }
+    owner=$(self_session)
+    [ -n "$owner" ] || { echo "not inside tmux" >&2; exit 1; }
+    found=0
+    for slot in "$DIR"/slot-*; do
+      [ -d "$slot" ] || continue
+      [ "$(cat "$slot/owner" 2>/dev/null)" = "$owner" ] || continue
+      name=$(basename "$slot")
+      rm -rf "$slot"
+      echo "released $name"
+      found=1
+    done
+    [ "$found" -eq 1 ] || echo "no slot held by $owner"
+    ;;
+  status)
+    [ -z "${2:-}" ] || { echo "status takes no arguments" >&2; exit 1; }
+    reap
+    held=0
+    for slot in "$DIR"/slot-*; do
+      [ -d "$slot" ] || continue
+      owner=$(cat "$slot/owner" 2>/dev/null || echo '<acquiring>')
+      since=$(cat "$slot/since" 2>/dev/null || echo '<pending>')
+      worktree=$(cat "$slot/worktree" 2>/dev/null || echo '<unknown>')
+      echo "$(basename "$slot"): $owner since $since [$worktree]"
+      held=$((held + 1))
+    done
+    echo "$held/$TOTAL held"
+    ;;
+  *)
+    echo "internal usage: $0 acquire|release|status|_held" >&2
+    exit 1
+    ;;
+esac
diff --git a/.kilo_workflow/README.md b/.kilo_workflow/README.md
index 6863b902f6..b5ee0ec032 100644
--- a/.kilo_workflow/README.md
+++ b/.kilo_workflow/README.md
@@ -29,28 +29,35 @@ Pipeline: **starter → planner → orchestrator → implementer/reviewer loops
 
 Each section works in its own worktree under `~/Projects/.worktrees/` — never a primary checkout — and cleans up everything it started when it ends; the worktree itself is the one local artifact that stays until its PR closes.
 
-## The trade: wall time for correctness, at a good price
+## Fast without trading correctness
 
-The workflow is deliberately slow in wall-clock hours and cheap in both dollars and human minutes:
+The workflow minimizes wall time while preserving independent review and live verification:
 
 - **Expensive models only where judgment concentrates** (planning); high-volume implementation and review runs on cheaper models that follow an explicit plan.
+- **Independent work runs in parallel.** Slices, reviewers, checks, and iOS/Android E2E shards overlap when their files and resources do not conflict; synchronization gates only the points that need a complete diff.
 - **Nothing ships on one opinion.** Every artifact — plan, slice, cumulative diff, runtime behavior, PR — is checked by a *fresh* session with no memory of earlier rounds, so conclusions can't anchor. Loops repeat until a fresh reviewer finds nothing.
 - **Verification is empirical.** Bugs must be reproduced before they're fixed; features must pass a live E2E round against real services before the gate opens.
+- **Doomed E2E rounds stop early.** A verifier stops at the first confirmed product failure; after the fix, it runs that case first, every same-area regression case, and every unproven case. Only proven cases with a concrete disjoint-impact reason carry forward.
 
-A section routinely takes hours of unattended machine time. The human cost is minutes at the edges: state the request, optionally approve the plan, review the final PR. That is the intended trade — burn agent time and cheap tokens to make the one expensive resource (your review attention) arrive at an already-verified PR.
+A section can still take hours of unattended machine time when builds or live E2E dominate. The human cost is minutes at the edges: state the request, optionally approve the plan, review the final PR.
 
 ## What's in this directory
 
 | Path | Purpose |
 |---|---|
 | [`WORKFLOW.md`](WORKFLOW.md) | The canonical spec — roles, loops, gates, dispatch commands |
-| [`init-section.sh`](init-section.sh) | Creates a section: run id, worktrees, cloud prepare, scratch directory — prints the manifest |
+| [`init-section.sh`](init-section.sh) | Creates a section or adds a mid-plan repository: run id, worktrees, cloud prepare, scratch directory — prints the manifest |
 | [`dispatch-role.sh`](dispatch-role.sh) | Launches a kilo role agent in tmux with a clean environment and logged exit code |
 | [`await-role.sh`](await-role.sh) | Waits on a dispatched agent's log and reports the round's outcome: DONE with its verdict, VOID, STALLED, or RUNNING |
 | [`launch-interactive.sh`](launch-interactive.sh) | Launches an interactive session (planner, orchestrator) in tmux with a clean environment and a live TTY |
+| [`launch-gate.sh`](launch-gate.sh) | Spaces Kilo CLI startups through a recoverable machine-global lock |
 | [`await-interactive.sh`](await-interactive.sh) | Watches an interactive session for the monitor: COMPLETED, BLOCKED, DEAD, QUIET, or RUNNING |
 | [`steer.sh`](steer.sh) | Delivers a message to a running interactive session (starter, planner, orchestrator) and confirms it was submitted |
-| [`e2e-slot.sh`](e2e-slot.sh) | Machine-global semaphore (default 3) capping concurrent device/stack E2E phases; agents are never capped |
+| [`e2e-take-slot.sh`](e2e-take-slot.sh) | Takes one of three machine-global E2E bundle slots (stack + iOS + Android + other resources) |
+| [`e2e-start-resource.sh`](e2e-start-resource.sh) | Starts a stack, iOS simulator, Android emulator, or explicit custom resource after proving the caller holds a slot |
+| [`e2e-stop-resource.sh`](e2e-stop-resource.sh) | Stops the matching resource through its repository wrapper |
+| [`e2e-free-slot.sh`](e2e-free-slot.sh) | Frees the caller's slot after its resources are stopped |
+| [`e2e-slot-status.sh`](e2e-slot-status.sh) | Reclaims dead owners and reports live slots plus known resources with no slot |
 | [`slice-diff.sh`](slice-diff.sh) | Emits one slice's diff for review plus a snapshot fingerprint; `--check` judges the round for violations |
 | [`baseline.sh`](baseline.sh) | Records a worktree's exact git state and later proves the E2E verifier's byte-identical restore |
 | [`pr-gate.sh`](pr-gate.sh) | Checks the completion gate's mechanical items against one head SHA (CI, threads, assignee, bot summary) |
diff --git a/.kilo_workflow/WORKFLOW.md b/.kilo_workflow/WORKFLOW.md
index a0157fb56c..2fee42b74d 100644
--- a/.kilo_workflow/WORKFLOW.md
+++ b/.kilo_workflow/WORKFLOW.md
@@ -11,17 +11,17 @@ The definitions for every kilo CLI role live in the repository root `.kilo/agent
 These apply to every role. Later sections do not repeat them.
 
 - Every long-lived process — planner, orchestrator, dispatched role agents, local services — runs in tmux, with a unique descriptive window or session name; the launch scripts guarantee this. The one exception is the starter, which lives wherever the user invoked it (often a plain harness session outside tmux) — its launches still land in tmux via `launch-interactive.sh`.
-- Section names are lowercase slugs (`[a-z0-9-]` only — they become branch, tmux, and path names) carrying a short random run id: `<name>-$(openssl rand -hex 2)`, for example `billing-a7f3`. This keeps parallel runs from colliding on worktrees, branches, tmux names, or scratch paths.
+- Section names are lowercase slugs (`[a-z0-9-]` only — they become branch, tmux, and path names). `init-section.sh` appends the four-hex run id, for example `billing-a7f3`, so parallel runs cannot collide.
 - All workflow tmux lives on the default tmux server — never a custom socket; slot reaping and monitoring key on the sessions one server can see.
 - Work only in dedicated worktrees, in every repository the plan touches — never a primary or main checkout, with one exception: machine-local learnings under the main checkout's `.kilo_workflow/learnings/system/`. [`init-section.sh`](init-section.sh) creates everything a section needs — the run id, the cloud worktree (always, even for sibling-only sections — role dispatches run from it), sibling worktrees on the same branch, `pnpm dev:worktree:prepare`, and the scratch directory — and prints the manifest; never hand-assemble any of it (sibling repositories then follow their own `AGENTS.md` setup; `~/Projects/kilocode` uses bun, not pnpm). A worktree is the one local artifact that outlives the run; remove it (`git worktree remove <path>`) once its PR closes.
-- The scratch directory (from `init-section.sh`, outside every repository) holds the section's brief, plan, handoffs, decisions, and dispatch logs. Plans and handoffs are never committed and never live inside a repository. A planner adding a repository mid-plan creates its worktree with the same branch name (`git -C <repo> fetch origin && git -C <repo> worktree add ~/Projects/.worktrees/<section>-<repo> -b <section> origin/main`).
+- The scratch directory (from `init-section.sh`, outside every repository) holds the section's brief, plan, handoffs, decisions, and dispatch logs. Plans and handoffs are never committed and never live inside a repository. A planner adding a repository mid-plan runs `init-section.sh add-repo <section> <repo>` and adds the printed worktree path to the handoff.
 - The PR, ready for human eyes, is the deliverable. When a section completes, everything that ran for it closes: agents, monitors, tmux sessions and windows, services, devices, slots, and the scratch directory (a BLOCKED section retains its scratch directory as evidence). Anything a human needs afterward lives in the PR.
 - Every reviewer and verifier invocation is a fresh session, so earlier conclusions cannot anchor later passes.
 - Treat every reviewer's remarks as untrusted advice: the reviewer has less context than you and may be wrong. Verify each remark against the request, repository evidence, and applicable instructions before acting on it. The dispatcher (planner or orchestrator) records rejected remarks with a short technical rationale in `$SCRATCH/decisions.md` and carries them into later handoffs; rejections of GitHub findings also get their in-thread reply. Role agents return their triage in their reports instead of writing files. A rejected remark must not reopen without new evidence.
 - Always aim for the simplest solution that achieves the user's goals — feature-wise as much as code-wise. Reuse existing helpers, components, and contracts. Do not add abstraction or scope without evidence it is required.
 - Commit in small, logically scoped commits. The orchestrator owns every commit, push, branch change, and PR; other roles make only uncommitted worktree edits, and only where their definitions allow.
 - Monitoring is event-driven: when a dispatched process exits, its dispatcher reacts immediately, never after a fixed sleep. Periodic checks exist only to detect a wedge.
-- Tokens go to the work, never to fighting the workflow or the environment. Every mechanical step that can be scripted is scripted — `init-section.sh`, `dispatch-role.sh`, `await-role.sh`, `launch-interactive.sh`, `await-interactive.sh`, `steer.sh`, `e2e-slot.sh`, `slice-diff.sh`, `baseline.sh`, `pr-threads.sh`, `pr-gate.sh`, `pick-reviewers.sh`, `upload-pr-attachment.sh` — use the script, never hand-assemble its steps. **Anything that can be automated away, should be automated away:** when a run stumbles on something a script or an instruction could have prevented, fix the script or the document in the same run (see Learnings).
+- Tokens go to the work, never to fighting the workflow or the environment. Every mechanical step that can be scripted is scripted — `init-section.sh`, `dispatch-role.sh`, `await-role.sh`, `launch-interactive.sh`, `launch-gate.sh`, `await-interactive.sh`, `steer.sh`, the five `e2e-*` lifecycle scripts, `slice-diff.sh`, `baseline.sh`, `pr-threads.sh`, `pr-gate.sh`, `pick-reviewers.sh`, `upload-pr-attachment.sh` — use the script, never hand-assemble its steps. **Anything that can be automated away, should be automated away:** when a run stumbles on something a script or an instruction could have prevented, fix the script or the document in the same run (see Learnings).
 - Learnings are the residue automation cannot reach. Before any environment-dependent phase, list both learnings directories — the worktree's `.kilo_workflow/learnings/` and the main checkout's `~/Projects/cloud/.kilo_workflow/learnings/system/` (the canonical machine-local set, which mid-run writes go to and worktree copies lag) — and read the entries whose names match your surface; filenames are symptom-keyed. When a tool or environment failure blocks you mid-run, grep both directories for the error text before debugging from scratch: a prior run has usually already paid for the answer.
 
 ### Models
@@ -56,7 +56,7 @@ The cwd/worktree is always the **cloud** worktree, even when the slice edits a s
 
 What the script encodes (details in its header comments):
 
-- tmux wrapping — harness command timeouts kill bare long runs. The `e2e-verifier` gets its **own tmux session** (E2E slots are owned and auto-reclaimed by session name; a window-named owner leaks or shares slots); other roles run as windows in the dispatcher's session, resolved through `$TMUX_PANE`. A dispatcher that is not itself inside tmux has no such session, so its roles get their own sessions too — never a guessed one. Names are `<section>-<role>-<label>`, logs `$SCRATCH/<role>-<label>.log`.
+- tmux wrapping — harness command timeouts kill bare long runs. Roles run as windows in the dispatcher's session, resolved through `$TMUX_PANE`; a dispatcher outside tmux gives the role its own session. The script appends a unique dispatch id: names are `<section>-<role>-<label>-<id>`, logs `$SCRATCH/<role>-<label>-<id>.log`; parallel and repeated labels cannot share artifacts.
 - Full `KILO_*`/`OPENCODE*` env strip — a child kilo inheriting `KILO_*`/`OPENCODE*` (from a parent kilo or the tmux server environment) misattaches sessions and auth. If the tmux server itself is poisoned, clear it with `tmux set-environment -g -u <var>`.
 - Output redirected, never piped (`| tee` makes `$?` report the pipe's exit, not kilo's), with `EXITCODE=$?` appended as the log's last line.
 
@@ -68,7 +68,7 @@ Wait with [`await-role.sh`](await-role.sh) — never a hand-rolled loop (exit co
 
 Act on that line:
 
-- `DONE <sentinel>` — the round's verdict, taken from the only place a verdict counts (the line above the `EXITCODE` marker). Sentinels: reviewers `No findings.` / `FINDINGS: <n>`; implementer `SLICE COMPLETE.`; verifier `VERIFICATION PASSED.`/`VERIFICATION FAILED.`/`VERIFICATION BLOCKED.` (repro mode: `REPRODUCED.`/`CANNOT REPRODUCE.`); any role `STOPPED EARLY.` — not a failure but not success: re-dispatch with a continuation handoff, and it counts toward the loop's round cap.
+- `DONE <sentinel>` — the round's verdict, taken from the only place a verdict counts (the line above the `EXITCODE` marker). Sentinels: reviewers `No findings.` / `FINDINGS: <n>`; implementer `SLICE COMPLETE.`; verifier `VERIFICATION PASSED.`/`VERIFICATION FAILED.`/`VERIFICATION BLOCKED.` (repro mode: `REPRODUCED.`/`CANNOT REPRODUCE.`/`VERIFICATION BLOCKED.`); any role `STOPPED EARLY.` — not a failure but not success: re-dispatch with a continuation handoff, and it counts toward the loop's round cap.
 - `RUNNING` — invoke it again. Each re-invocation is also the moment to unstick **infrastructure failures only**: a wedged or crashed kilo CLI, a dead tmux window, a hung service the agent cannot restart itself. Product, logic, or review problems are never stuck states — route those through the escalation ladder.
 - `VOID` — the run ended with no valid verdict for its role (kilo runs can die mid-stream and still exit 0). Never a pass: discard the round and dispatch a fresh session. If several consecutive rounds die at the same point, shrink the handoff rather than retrying it unchanged.
 - `STALLED` — the stall that never exits. Kill the round's tmux window/session, verify state from artifacts on disk (never the dead run's claims), and redispatch fresh with a continuation handoff.
@@ -84,7 +84,6 @@ Two checks stay with the dispatcher, since only it knows the slice — both are
 
 Role boundaries — reviewers never modify the tree, the implementer never commits, no role dispatches agents — are enforced by instruction, not permission. This is deliberate: permission deny lists caused void review rounds (a reviewer whose blocked command made it exit with no verdict, which read as a pass) and takeover churn. The single exception is `task: deny` in the definitions — blocking agent dispatch costs nothing and cannot void a round. The workflow otherwise trades enforcement for reliable rounds and accepts that a misbehaving agent can do what it was told not to; do not "fix" this by re-adding deny lists.
 
-
 ### Steering a Live Interactive Session
 
 Worker roles are steered by re-dispatching them (see Escalation). The interactive sessions — starter, planner, orchestrator — are steered in place with [`steer.sh`](steer.sh), never with hand-assembled `tmux send-keys`:
@@ -127,7 +126,7 @@ Every dispatch to a role agent includes:
 - The mode; for hands-off, a direct instruction to never ask the user questions
 - Sanitized env values inline. Role agents must never read `.env`, `.env.*`, `.dev.vars`, or equivalent files; the handoff table is authoritative. Never place secrets or raw environment-file contents in a handoff.
 - The exact checks or flows expected for that stage
-- For any device or stack phase: the slot rule (see E2E Slots)
+- For any device or stack phase: the slot-bundle owner, resources, and cleanup owner (see E2E Slots)
 - Prior findings being addressed, including rejected findings that must not reopen without new evidence
 - Priority order, minimum complete outcome, optional work to drop, and a clean stopping rule before budget exhaustion (estimate roughly one step per planned tool call; when in doubt, split the task); on early stop, the required continuation state (completed work, remaining work, failures, files touched, checks run or deferred, safest next action)
 - For long tool-heavy phases: output discipline — cap every shell command's output (`| tail -c 1500` / `| tail -5`), write dumps and captures to files and print only greps or counts, bound the final report. Oversized session payloads kill kilo runs silently mid-task.
@@ -142,7 +141,7 @@ The session the user invokes the workflow from is the starter, running on the ha
 
 1. Collect the initial body of work from the user, and ask exactly one process question: is this run `hands on` or `hands off`? The mode governs every later role. Planner harness and model: whatever the user picked; absent an explicit pick, reuse the starter's own.
 2. Explore the relevant parts of the codebase.
-3. Interrogate the requirements — in `hands on` mode by grilling the user one question at a time, in `hands off` mode by grilling itself and answering from repository evidence, recording material assumptions. Always drive toward the simplest solution that achieves the user's goals, and challenge the request itself: "should we even do this?", "why not do this instead?", "we could achieve the same thing simpler, like this".
+3. Interrogate the requirements — in `hands on` mode, load the `grilling` skill and follow its contract: inspect the codebase instead of asking anything the repository can answer, then ask the user one remaining question at a time with a recommended answer. In `hands off` mode, apply the same questions to itself, answer from repository evidence, and record material assumptions. Always drive toward the simplest solution that achieves the user's goals, and challenge the request itself: "should we even do this?", "why not do this instead?", "we could achieve the same thing simpler, like this".
 4. Divide the finalized work into related, **disjoint** sections — no two sections may touch the same files or contracts.
 5. For each section: run `.kilo_workflow/init-section.sh <name> [sibling-repo...]` (Ground Rules) and use the manifest it prints, write the section brief to `$SCRATCH/brief.md` — the work, the mode, acceptance criteria and constraints gathered so far, the requesting human's GitHub handle for PR assignment, the worktree path, and the scratch path — and launch a planner on the planner harness and model with [`launch-interactive.sh`](launch-interactive.sh). The script encodes the launch traps (env strip, TTY, tmux targeting — details in its header), lands the window in your own session when you are inside tmux and a fresh session otherwise, prints the tmux target for `steer.sh` and `capture-pane`, and fails loudly if the command dies at launch:
 
@@ -156,11 +155,7 @@ The session the user invokes the workflow from is the starter, running on the ha
   claude "You are the planner in .kilo_workflow/WORKFLOW.md. Plan the work in the brief at $SCRATCH/brief.md."
 ```
 
-One planner per section; each section flows through its own planner, orchestrator, and PR. A single-section run launches a single planner. If the starter's own session already fits the planner role (right model, user agrees), it may become the single planner itself instead of launching one.
-
-### Starter Monitor Mode
-
-After launching planners the starter enters Monitor Mode (see Monitor Mode, which is written for the planner watching its orchestrator — the starter applies the same rules with planners as its dispatches and the brief as the handoff). The starter's duty ends when every section has reached a terminal state.
+One planner per section; each section flows through its own planner, orchestrator, and PR. A single-section run launches a single planner. If the starter's own session already fits the planner role (right model, user agrees), it may become the single planner itself instead of launching one. After launch, the starter follows Monitor Mode below for its planners until every section reaches a terminal state.
 
 ### Interaction Modes
 
@@ -177,7 +172,7 @@ The planner writes the implementation plan for its section. The plan is consumed
 
 Steps:
 
-1. Read the learnings. For defect work, dispatch the bug reproduction gate FIRST (below) — it runs on a device slot while you work, and the wait costs nothing when it overlaps exploration and drafting. Explore the relevant parts of the codebase. Define acceptance criteria, non-goals, and the feature-state matrix for any user-facing feature.
+1. Read the learnings. For defect work, dispatch the bug reproduction gate FIRST (below). Explore the relevant parts of the codebase. Define acceptance criteria, non-goals, and the feature-state matrix for any user-facing feature.
 2. Write the complete draft plan to `$SCRATCH/plan.md`. For defect work, do not finalize it before the repro verdict is in — the confirmed reproduction feeds the plan, and `CANNOT REPRODUCE.` stops it (see the gate).
 3. Loop, at most five rounds: dispatch TWO fresh `plan-reviewer`s in parallel (they cannot anchor each other — union their findings), verify the remarks (untrusted), fix valid ones, record rejected ones. Exit when a round returns `No findings.` from both. If three consecutive rounds stay stuck on the same issue — or the five-round cap is hit — resolve the remaining findings directly, record each resolution in `$SCRATCH/decisions.md`, and dispatch one final fresh reviewer (outside the cap). If that final reviewer still objects, do not loop again: record the disagreement and proceed with the recorded resolution (hands-on: ask the user instead).
    The planner ends its own run the same way the orchestrator does: a blocker it cannot pass (a failed repro gate, an unresolvable hands-off gap) is written to `$SCRATCH/final-report.md` with first line `BLOCKED` — never a silent stop.
@@ -186,9 +181,9 @@ Steps:
 
 ### Bug Reproduction Gate
 
-For defect work, dispatch a fresh `e2e-verifier` in repro mode on the unmodified baseline as the planner's FIRST act — it holds a device slot while the planner explores and drafts, so the wait overlaps work that had to happen anyway. Dispatch with `--mode repro` (label `r0`, own tmux session — see Dispatching); the flag pins the sentinel contract, and the handoff text assigns repro mode, which the verifier definition recognizes. Its assignment: reproduce the reported issue — fix nothing — and return exact reproduction steps, evidence, and a failure classification. A confirmed reproduction feeds the plan, and the confirmed repro flow passing becomes an acceptance criterion the final verifier must rerun.
+For defect work, the planner takes one slot and starts the whole required E2E bundle, then dispatches a fresh `e2e-verifier` in repro mode on the unmodified baseline as its FIRST act. The verifier runs while the planner explores and drafts. Dispatch with `--mode repro` (label `r0`; see Dispatching); the flag pins the sentinel contract, and the handoff names the planner as bundle owner. Its assignment: reproduce the reported issue — fix nothing — and return exact reproduction steps, evidence, and a failure classification. After the verdict, the planner stops every bundle resource and frees the slot. A confirmed reproduction feeds the plan, and the confirmed repro flow passing becomes an acceptance criterion the final verifier must rerun.
 
-A `CANNOT REPRODUCE.` sentinel is a blocker, not a license to fix an unconfirmed bug. Hands-on: return the evidence to the user and ask how to proceed. Hands-off: stop with a BLOCKED report — no plan, no orchestrator.
+A `CANNOT REPRODUCE.` sentinel is a blocker, not a license to fix an unconfirmed bug. Hands-on: return the evidence to the user and ask how to proceed. Hands-off: stop with a BLOCKED report — no plan, no orchestrator. `VERIFICATION BLOCKED.` means the environment prevented a verdict: make one reasonable environment recovery and dispatch one fresh repro verifier; a second blocked result makes the section BLOCKED.
 
 ### Launching the Orchestrator
 
@@ -214,7 +209,7 @@ After the handoff the planner stops all hands-on work. It has exactly one job 
 - `QUIET <sec>s` — the transcript stopped moving. Not a verdict: read the pane first (below) — a hands-on user question and queued steers look exactly like this.
 - `RUNNING` — invoke it again.
 
-A monitor never kills a live dispatch on a judgment call, never edits the worktree, and never writes to another role's dispatch log — a forged `EXITCODE` line corrupts the dispatcher's void-round detection, the exact signal the contract keys on. Before concluding an orchestrator is misbehaving, read its evidence: its pane scrollback (`tmux capture-pane -t <window> -p -S -`), its scratch directory, and the git log. The orchestrator's handoff may route user questions to its own interactive session, so an answer the monitor never saw can exist there — a monitor once killed a healthy implementer and forged its `EXITCODE` line because it never read the scrollback where the user had already answered. The only kill-worthy states are the infrastructure failures named above.
+A monitor never kills a live dispatch on a judgment call, edits the worktree, or writes to another role's dispatch log. Before concluding an orchestrator is misbehaving, read its pane scrollback (`tmux capture-pane -t <window> -p -S -`), scratch directory, and git log. The only kill-worthy states are the infrastructure failures named above.
 
 On `COMPLETED`, confirm the PR exists in gate state in **every** repository the section touched — `.kilo_workflow/pr-gate.sh <owner/repo> <pr> --assignee <requesting-handle> --label human-ready` per repository (find the PR with `gh pr view <section> --repo <owner>/<repo>`; never bare `gh pr view`, which only checks the cloud branch). A missing PR or a failing gate means it was not a completion — treat it as a crash.
 
@@ -262,10 +257,10 @@ Request the top one or two names it prints: `gh pr edit <number> --add-reviewer
 
 ### E2E Loop
 
-1. Dispatch a fresh `e2e-verifier` with the plan goals and acceptance criteria, in its own uniquely named tmux session (see Dispatching). Never dispatch one while implementers are active or uncommitted changes sit in an in-scope worktree — the verifier's byte-identical baseline restore turns concurrent edits into false failures. The verifier acquires its own device slot under that session name and releases it the moment its device phase ends; the orchestrator never holds a slot on the verifier's behalf. If a verifier round dies or is killed, clean up its leftovers per the runbook's cleanup section before redispatching — a crashed verifier never ran its own.
-2. Act on the sentinel: `VERIFICATION FAILED.` → triage each remark (untrusted) and run the implementer → impl-reviewer loop to fix it, commit and push. `VERIFICATION BLOCKED.` → one environment recovery attempt and a fresh dispatch; if it blocks again, the section is BLOCKED.
-3. Re-verify — a follow-up round tests the repaired behavior plus every criterion no completed prior round has already proven; its handoff lists what earlier rounds proved (round, criterion, evidence) so proven criteria are cited, not re-run. A criterion no round ever exercised is not covered by anyone's `VERIFICATION PASSED.`
-4. Exit when a fresh verifier returns `VERIFICATION PASSED.` and the rounds together cover every criterion. After five rounds without that, the remaining moves are takeover or BLOCKED (see Escalation).
+1. The orchestrator takes one slot and starts the whole E2E bundle: one stack, up to one iOS simulator, up to one Android emulator, and any other resources this round needs. Then dispatch a fresh `e2e-verifier` with the plan goals and acceptance criteria. When both iOS and Android are required, dispatch one verifier per platform in parallel; both share this one slot bundle and `apps/mobile/e2e/login.sh` gives them separate `-ios` and `-android` accounts. Each handoff names the orchestrator as bundle owner and gives the exact assigned device and services. `dispatch-role.sh` gives every verifier a unique `$SCRATCH`, so parallel shards and later rounds cannot share baselines or temporary files. After all shards return, the orchestrator stops every bundle resource and frees the slot. Serialize only a genuinely cross-platform flow or a test that needs shared mutable fixtures or temporary worktree edits. Never dispatch while implementers are active or uncommitted changes sit in an in-scope worktree — the verifier's byte-identical baseline restore turns concurrent edits into false failures. If a verifier round dies or is killed, the orchestrator still owns and cleans the bundle before redispatching.
+2. Each verifier fails fast on the first confirmed product failure in its platform scope after capturing reproducible evidence; later cases in that scope are intentionally unrun. A sibling platform verifier already running continues its independent scope. Collect every in-flight shard's sentinel and wait for all of them to return before editing, committing, or dispatching an implementer. If every parallel shard passed, run any serialized cross-platform or shared-fixture cases now; otherwise leave them unrun for the follow-up. Then act on the union of sentinels: `VERIFICATION FAILED.` → triage the remarks (untrusted) and run the implementer → impl-reviewer loop to fix them, commit and push. `VERIFICATION BLOCKED.` → one environment recovery attempt and a fresh dispatch; if it blocks again, the section is BLOCKED.
+3. Re-verify with the repaired failing case first. Then rerun every prior case in the same page, flow, component, or shared-dependency area and every case no completed round has proved. Carry forward a prior pass only when the handoff names the case, cites its round and evidence, and gives concrete changed-file or dependency evidence that the fix cannot affect it — for example, a page-2-only fix may carry forward page-1 cases with no shared dependency. The fresh verifier independently rejects weak carry-forward claims and runs those cases.
+4. Exit when every platform shard returns `VERIFICATION PASSED.` and the current rounds plus explicitly justified carried-forward proof cover every criterion. After five rounds without that, the remaining moves are takeover or BLOCKED (see Escalation).
 
 ### Kilobot Loop
 
@@ -283,7 +278,7 @@ Integrate the base branch **only when GitHub reports an actual conflict** (`merg
 Check the mechanical half with [`pr-gate.sh`](pr-gate.sh) — it pins every fact to the current head SHA, so an approving comment from an older head can never vouch for this one:
 
 ```bash
-.kilo_workflow/pr-gate.sh <owner/repo> <pr>   # facts + GATE OK / GATE FAIL lines
+.kilo_workflow/pr-gate.sh <owner/repo> <pr> --assignee <requesting-handle>
 ```
 
 `GATE OK` covers mergeability, green CI, zero unresolved threads, assignee, and a bot summary postdating the head commit. The rest is yours to judge. The work is complete only when every item holds:
@@ -294,7 +289,7 @@ Check the mechanical half with [`pr-gate.sh`](pr-gate.sh) — it pins every fact
 - Changes are organized into small, coherent commits; format, typecheck, lint, and tests pass in every changed repository, using the check commands the nearest `AGENTS.md` or `package.json` defines for each changed package
 - The PR exists with what/why/how sections and is assigned to the requesting human
 - If any accepted task has a UI, the PR description renders screenshots of the final behavior from the latest head, uploaded to that repository as GitHub `user-attachments`; visual changes include before/after evidence when a meaningful before state exists. A non-UI PR records `Visual Changes: N/A`
-- Kilobot has posted an approving summary comment on the latest head and no actionable posted comment is unresolved — or Kilobot's absence after two retriggers is noted in a `(bot) ` PR comment
+- Kilobot has posted an approving summary comment on the latest head and no actionable posted comment is unresolved — or Kilobot's absence after two retriggers is noted with the exact waiver sentence from the Kilobot loop
 - All expected CI checks on the latest head are green, and GitHub reports the head mergeable with no conflicts
 - No generated fixture remains, tracked or untracked; every verifier temporary edit is restored
 - Every resource this run started is shut down or released; resources the run did not start stay running
@@ -303,46 +298,36 @@ Check the mechanical half with [`pr-gate.sh`](pr-gate.sh) — it pins every fact
 
 A PR waiting on required human review is COMPLETE — the workflow never approves or merges its own PR. A gate item that can never hold is BLOCKED (see step 8), never a reason to loop forever or fake completion.
 
-### 3.1 Implementer
-
-Implements one bounded slice per the plan and the handoff, runs narrow checks on what it changed, and never commits. See `.kilo/agent/implementer.md`.
-
-### 3.2 Impl Reviewer
-
-Independently reviews the slice diff against the plan's goals for that slice. Read-only. See `.kilo/agent/impl-reviewer.md`.
-
-### 3.3 E2E Verifier
-
-Verifies that the goals of the plan are met by the new implementation. It starts local services and points local clients at them, following the surface-specific runbook (mobile: `apps/mobile/e2e/AGENTS.md`; extension: `apps/extension/AGENTS.md`; web and services: `DEVELOPMENT.md` and the repository dev runner). Everything is verified fully locally. It also writes learnings (see Learnings). See `.kilo/agent/e2e-verifier.md`.
-
-#### Real LLM Responses
+### Real LLM Responses
 
 Any step where an agent or LLM must actually respond — cloud-agent sessions, chat flows, acceptance states — uses real model calls on `kilo-auto/efficient` (the in-app id; `kilo/kilo-auto/*` are the same models as CLI ids), always. If an `efficient` call stalls or errors, retry on `efficient`; never switch models. LLM mocking (fake-llm or otherwise) is prohibited unless a real call cannot produce the required state; each use must be named and justified in the handoff and the PR. One standing exception qualifies: forcing a specific provider failure.
 
 ## E2E Slots
 
-The machine is shared by parallel workflows, and unslotted device or stack work overloads it. Only E2E runs are capped — agents themselves are never capped. Every phase that drives a simulator, emulator, local backend stack, browser fleet, or native build — the repro gate and every E2E round — runs inside a slot from [`e2e-slot.sh`](e2e-slot.sh) (default 3, machine-global):
+The machine is shared by parallel workflows, and unslotted E2E work overloads it. Only E2E bundles are capped — agents themselves are never capped. One slot permits one round's complete bundle: one dev stack, up to one iOS simulator, up to one Android emulator, and its remote CLIs, browsers, native builds, and other resources. A slot is not per resource or per verifier; parallel platform verifiers in one round share the same bundle.
+
+The planner owns the repro bundle. The orchestrator owns implementation-verification bundles. That owner follows this lifecycle plus status check (default 3 slots, machine-global):
 
 ```bash
-.kilo_workflow/e2e-slot.sh acquire          # from your own tmux session; blocks until a slot frees
-.kilo_workflow/e2e-slot.sh status           # holders, their worktrees, stack coverage
-.kilo_workflow/e2e-slot.sh release          # the moment the device phase ends
-.kilo_workflow/e2e-slot.sh stacks [--reap]  # stacks running with no slot
+.kilo_workflow/e2e-take-slot.sh
+.kilo_workflow/e2e-start-resource.sh stack <services...>  # or ios, android, command
+# run the E2E work
+.kilo_workflow/e2e-stop-resource.sh stack                 # stop every resource started above
+.kilo_workflow/e2e-free-slot.sh
+.kilo_workflow/e2e-slot-status.sh                         # live slots + stale/unaccounted checks
 ```
 
-`acquire` and `release` resolve the caller's own tmux session themselves (and refuse to run outside one — a slot owner must be a live session so a dead holder can be reclaimed). Pass a session name only when releasing on behalf of a holder that is already dead.
-
-**A slot, a dev stack, and a claimed device are the same resource.** The slot is what entitles a worktree to run a stack and claim a simulator, and neither may outlive it: `release` stops the releasing worktree's stack *and* releases every simulator that worktree claimed, and reclaiming a dead holder's slot does the same for it. Acquiring a slot ADOPTS any stack already running for that worktree — cleanup ownership transfers to the slot, and release will stop it even though this run did not start it; the preserve-pre-existing-resources rule covers foreign resources (other worktrees' stacks, devices you did not claim), never your own worktree's stack. So a later round re-acquires, starts a fresh stack, and claims a device again rather than inheriting either — that restart is the price of the cap. A stack up with no slot is a defect, not a shortcut; `stacks` lists them and `stacks --reap` reaps the workflow-owned ones (a stack with no section run id in its name was started by hand and is only reported). Five live stacks on this host drove the load average past 300 and made every emulator boot and native build time out, which reads as flaky devices rather than as over-subscription.
+The take/free scripts resolve the caller's own tmux session themselves and refuse to run outside one.
 
-Teardown is the slot's job, never the agent's memory: the claim records whether it booted the device, and release powers off only what its own claim booted — a device already running before the claim is never shut down. Never hand-roll device teardown around the wrapper.
+`e2e-take-slot.sh` atomically takes one of three tokens and `e2e-free-slot.sh` returns it. Start and stop resources through the paired scripts; `stack`, `ios`, and `android` dispatch to the repository wrappers, while `command` runs another explicit start/stop command. Stop every resource first, then free the slot. `e2e-slot-status.sh` reports live holders and known stacks/device records with no slot owner; it never kills them.
 
 - Slot state lives in `$HOME/.cache/kilo-e2e-slots`, machine-global by design: every copy of the script — any worktree, any repository — contends for the same slots, and the script has no overrides by design. When working in a repository without the script (a sibling like `~/Projects/kilocode`), invoke it by absolute path from a cloud worktree.
 - This holds on every run, not only when another workflow is visibly active, and a stack that is already up is not an exemption.
-- `acquire` blocking is correct behavior, never a wedge to route around and never a reason to start device work unslotted. If an acquire is still blocked after about 45 minutes, the dispatcher inspects `status` for a wedged foreign holder and reports a blocker instead of waiting forever.
+- A blocked `e2e-take-slot.sh` is correct behavior, never a wedge to route around and never a reason to start device work unslotted. If it is still blocked after about 45 minutes, inspect `e2e-slot-status.sh` for a wedged foreign holder and report a blocker instead of waiting forever.
 - The slot caps load, not data: postgres and redis containers are shared across worktrees. Keep test data keyed to this worktree's accounts (the runbooks' per-worktree defaults) and never wipe shared state.
-- Release immediately when the device/stack phase ends. Planning, implementation, review, checks, and CI waits are uncapped; never hold a slot through them — and since release takes the stack and the claimed devices with it, do not release mid-round while you still need the services or the simulator.
-- Slots are owned by tmux session name, record the worktree that took them, and are reclaimed automatically when the session dies. A holder that is alive but wedged belongs to its own workflow's monitor — never kill another session to free a slot; if the queue is starved by a foreign wedge, report a blocker to the user instead.
-- The orchestrator is accountable: every device-phase handoff states the slot rule, and a role agent that reports device work with no acquire gets re-dispatched.
+- Release immediately after cleaning up the resources used by the device/stack phase. Planning, implementation, review, checks, and CI waits are uncapped; never hold a slot through them.
+- Slots are owned by tmux session name and reclaimed automatically when the session dies. A holder that is alive but wedged belongs to its own workflow's monitor — never kill another session to free a slot; if the queue is starved by a foreign wedge, report a blocker to the user instead.
+- The bundle owner is accountable: every verifier handoff names it and the resources it owns. A verifier never takes another slot.
 
 ## Feature-State Matrix
 
diff --git a/.kilo_workflow/baseline.sh b/.kilo_workflow/baseline.sh
index 7dd78bc3c9..e28b2e75c6 100755
--- a/.kilo_workflow/baseline.sh
+++ b/.kilo_workflow/baseline.sh
@@ -5,17 +5,27 @@
 # destructive ritual a cheap model gets wrong; this does the mechanical part.
 # Restoring is still the agent's job — this tells it exactly what diverged.
 #
-#   baseline.sh snapshot <worktree> <baseline-dir>   # record the pre-run state
-#   baseline.sh check <worktree> <baseline-dir>      # compare; OK or the diverging files
+#   baseline.sh snapshot <worktree> <baseline-dir> [--include <ignored-path>]...
+#   baseline.sh check <worktree> <baseline-dir> [--include <ignored-path>]...
 #
-# <baseline-dir> must live OUTSIDE every repository (scratch). check prints
-# `OK` (exit 0) when the state matches byte-for-byte, otherwise one line per
-# divergence (exit 1) — any mismatch is a verification failure, never
-# something to claim past.
+# <baseline-dir> must live OUTSIDE every repository (scratch). A successful
+# check prints `OK`, consumes the snapshot, and exits 0. A mismatch prints one
+# line per divergence, retains both sides as evidence, and exits 1.
 set -euo pipefail
 
-CMD=${1:?usage: baseline.sh snapshot|check <worktree> <baseline-dir>}
+CMD=${1:?usage: baseline.sh snapshot|check <worktree> <baseline-dir> [--include <ignored-path>]...}
 WT=${2:?worktree} DIR=${3:?baseline dir}
+shift 3
+INCLUDES=()
+while [ $# -gt 0 ]; do
+  [ "$1" = "--include" ] || { echo "baseline: unknown option $1" >&2; exit 1; }
+  include=${2:?--include needs a repository-relative path}
+  case "$include" in
+    /* | .. | ../* | */../* | */..) echo "baseline: --include must stay inside the worktree: $include" >&2; exit 1 ;;
+  esac
+  INCLUDES+=("$include")
+  shift 2
+done
 [ -d "$WT" ] || { echo "baseline: no such worktree: $WT" >&2; exit 1; }
 # Canonicalize before comparing — a relative or symlinked path must not smuggle
 # the baseline into the repository (or make the repository the baseline).
@@ -32,7 +42,7 @@ case "$DIR" in
 esac
 
 capture() {
-  local out=$1
+  local out=$1 p hash
   mkdir -p "$out"
   git -C "$WT" rev-parse HEAD > "$out/head"
   git -C "$WT" status --porcelain=v2 -z --untracked-files=all > "$out/status.z"
@@ -51,6 +61,28 @@ capture() {
         "$(shasum -a 256 "$WT/$p" | cut -d' ' -f1)" "$p"
     fi
   done | sort > "$out/untracked.tsv"
+
+  # Git omits ignored files from every state above. Hash only the explicit
+  # ignored paths a verifier is allowed to edit; absence is state too.
+  : > "$out/included.tsv"
+  for p in "${INCLUDES[@]+"${INCLUDES[@]}"}"; do
+    if [ -L "$WT/$p" ]; then
+      printf 'link\t%s\t%s\n' "$(readlink "$WT/$p")" "$p"
+    elif [ -f "$WT/$p" ]; then
+      if command -v sha256sum >/dev/null; then
+        hash=$(sha256sum "$WT/$p" | cut -d' ' -f1)
+      else
+        hash=$(shasum -a 256 "$WT/$p" | cut -d' ' -f1)
+      fi
+      printf 'file\t%s\t%s\t%s\n' \
+        "$(stat -f %p "$WT/$p" 2>/dev/null || stat -c %a "$WT/$p")" "$hash" "$p"
+    elif [ -e "$WT/$p" ]; then
+      echo "baseline: --include supports files, symlinks, or absent paths, not $p" >&2
+      return 1
+    else
+      printf 'missing\t-\t%s\n' "$p"
+    fi
+  done | sort > "$out/included.tsv"
 }
 
 case $CMD in
@@ -73,21 +105,24 @@ case $CMD in
     trap '[ "${fail:-1}" -eq 0 ] && rm -rf "$NOW"' EXIT
     capture "$NOW"
     fail=0
-    for f in head status.z worktree.diff index.diff untracked.tsv; do
+    for f in head status.z worktree.diff index.diff untracked.tsv included.tsv; do
       cmp -s "$DIR/$f" "$NOW/$f" && continue
       fail=1
       case $f in
         head) echo "DIVERGED head: $(cat "$DIR/$f") -> $(cat "$NOW/$f")" ;;
-        untracked.tsv)
-          echo "DIVERGED untracked files (hash/mode/link or presence):"
+        untracked.tsv | included.tsv)
+          echo "DIVERGED ${f%.tsv} files (hash/mode/link or presence):"
           # diff exits 1 on difference — normal here, must not abort the report.
           { diff "$DIR/$f" "$NOW/$f" || true; } | { grep '^[<>]' || true; } | sed 's/^</  baseline only:/; s/^>/  now:/'
           ;;
         *) echo "DIVERGED $f (run: diff $DIR/$f $NOW/$f)" ;;
       esac
     done
-    [ "$fail" -eq 0 ] && echo "OK"
+    if [ "$fail" -eq 0 ]; then
+      rm -rf "$DIR"
+      echo "OK"
+    fi
     exit "$fail"
     ;;
-  *) echo "usage: baseline.sh snapshot|check <worktree> <baseline-dir>" >&2; exit 1 ;;
+  *) echo "usage: baseline.sh snapshot|check <worktree> <baseline-dir> [--include <ignored-path>]..." >&2; exit 1 ;;
 esac
diff --git a/.kilo_workflow/dispatch-role.sh b/.kilo_workflow/dispatch-role.sh
index 8cf1c7e2f5..6b620cb248 100755
--- a/.kilo_workflow/dispatch-role.sh
+++ b/.kilo_workflow/dispatch-role.sh
@@ -13,9 +13,8 @@
 # Prints the log path. Wait on it with await-role.sh, never a hand-rolled
 # loop — it reports DONE with the role's sentinel, VOID, STALLED, or RUNNING.
 #
-# The e2e-verifier gets its own tmux session (device slots are owned and
-# auto-reaped by session name); every other role runs as a window in the
-# caller's session, or in its own session when the caller is not inside tmux.
+# Roles run as windows in the caller's session, or in their own session when
+# the caller is not inside tmux.
 set -euo pipefail
 
 ROLE=${1:?role} SECTION=${2:?section} LABEL=${3:?label} WT=${4:?worktree} SCRATCH=${5:?scratch} MSG=${6:?message}
@@ -47,15 +46,27 @@ while [ $# -gt 0 ]; do
       ;;
     --file)
       [ -f "${2:-}" ] || { echo "dispatch-role: --file path does not exist: '${2:-}'" >&2; exit 1; }
-      FILES+=("--file" "$2")
+      FILE_PATH=$(cd "$(dirname "$2")" && pwd -P)/$(basename "$2")
+      FILES+=("--file" "$FILE_PATH")
       shift 2
       ;;
     *) echo "dispatch-role: only --mode repro and --file <path> are accepted after the message, got '$1'" >&2; exit 1 ;;
   esac
 done
 
-NAME="$SECTION-$ROLE-$LABEL"
-LOG="$SCRATCH/$ROLE-$LABEL.log"
+# The caller supplies a human round label; the script supplies the dispatch id.
+# That makes parallel reviewers and same-label retries mechanically distinct,
+# so an old .exit file can never vouch for a new run.
+TOKEN=$(mktemp "$SCRATCH/.dispatch-XXXXXX")
+DISPATCH_ID=${TOKEN##*-}
+rm "$TOKEN"
+NAME="$SECTION-$ROLE-$LABEL-$DISPATCH_ID"
+LOG="$SCRATCH/$ROLE-$LABEL-$DISPATCH_ID.log"
+ROLE_SCRATCH=$SCRATCH
+if [ "$ROLE" = "e2e-verifier" ]; then
+  ROLE_SCRATCH="$SCRATCH/e2e-$LABEL-$DISPATCH_ID"
+  mkdir "$ROLE_SCRATCH"
+fi
 # The strip list must be computed INSIDE the new pane, not here: tmux panes
 # inherit the tmux SERVER environment, so vars absent from this dispatcher's
 # env can still reach the child and poison a nested kilo run.
@@ -66,7 +77,7 @@ STRIP='$(env | grep -oE "^(KILO|OPENCODE)[A-Za-z0-9_]*" | sed "s/^/-u /" | tr "\
 # Redirection below means an attached pane shows nothing at all. Say so in the
 # pane itself — a blank window reads as a dead agent otherwise. This prints to
 # the terminal only, never into the log, so the EXITCODE contract is untouched.
-CMD="echo $(printf '%q' "$NAME: output goes to $LOG — this pane stays blank by design; watch with: tail -f $LOG") && cd $(printf '%q' "$WT") && env $STRIP kilo run $(printf '%q' "$MSG") --agent $(printf '%q' "$ROLE") --title $(printf '%q' "$NAME")"
+CMD="echo $(printf '%q' "$NAME: output goes to $LOG — this pane stays blank by design; watch with: tail -f $LOG") && cd $(printf '%q' "$WT") && env $STRIP SCRATCH=$(printf '%q' "$ROLE_SCRATCH") kilo run $(printf '%q' "$MSG") --agent $(printf '%q' "$ROLE") --title $(printf '%q' "$NAME") --auto"
 for arg in "${FILES[@]+"${FILES[@]}"}"; do CMD+=" $(printf '%q' "$arg")"; done
 # The wrapper-owned exit file is what proves the run ENDED: the in-log
 # EXITCODE marker is convenient for humans but shares the stream with agent
@@ -84,26 +95,9 @@ if [ -n "${TMUX_PANE:-}" ]; then
   CALLER_SESSION=$(tmux display-message -p -t "$TMUX_PANE" '#S' 2>/dev/null || true)
 fi
 
-# Machine-global launch spacing: concurrent kilo startups race the shared
-# SQLite credential/session stores and crash (void rounds). ~3s apart is
-# enough; the mkdir mutex makes the read-modify-write of the timestamp safe.
-GATE="$HOME/.cache/kilo-launch-gate"
-mkdir -p "$GATE"
-while :; do
-  if mkdir "$GATE/lock" 2>/dev/null; then
-    NOW=$(date +%s)
-    LAST=$(cat "$GATE/last" 2>/dev/null || echo 0)
-    if [ $(( NOW - LAST )) -ge 3 ]; then
-      echo "$NOW" > "$GATE/last"
-      rmdir "$GATE/lock"
-      break
-    fi
-    rmdir "$GATE/lock"
-  fi
-  sleep 1
-done
+"$(dirname "$0")/launch-gate.sh"
 
-if [ "$ROLE" = "e2e-verifier" ] || [ -z "$CALLER_SESSION" ]; then
+if [ -z "$CALLER_SESSION" ]; then
   tmux new-session -d -s "$NAME" "$CMD"
   TARGET=$NAME
 else
@@ -112,10 +106,12 @@ else
   # named <section> collides with the planner/orchestrator window named
   # <section>-planner — new-window then fails with "create window failed:
   # index N in use".
-  TARGET=$(tmux new-window -d -P -F '#{session_name}:#{window_index}' -t "$CALLER_SESSION:" -n "$NAME" "$CMD")
+  # Window indexes are renumbered when an earlier window exits. The stable
+  # @<window-id> keeps await/kill aimed at this dispatch for its whole life.
+  TARGET=$(tmux new-window -d -P -F '#{window_id}' -t "$CALLER_SESSION:" -n "$NAME" "$CMD")
 fi
 # Sidecar for await-role.sh: which sentinel contract applies (role + repro
 # vs verify for the e2e-verifier) and which tmux target to pronounce dead.
 # Same path plus .meta, so dispatchers only ever hand around the log path.
-printf 'role=%s\nmode=%s\ntmux=%s\n' "$ROLE" "$MODE" "$TARGET" > "$LOG.meta"
+printf 'role=%s\nmode=%s\ntmux=%s\nscratch=%s\n' "$ROLE" "$MODE" "$TARGET" "$ROLE_SCRATCH" > "$LOG.meta"
 echo "$LOG"
diff --git a/.kilo_workflow/e2e-free-slot.sh b/.kilo_workflow/e2e-free-slot.sh
new file mode 100755
index 0000000000..898702630d
--- /dev/null
+++ b/.kilo_workflow/e2e-free-slot.sh
@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+exec "$(dirname "$0")/.e2e-slot-state.sh" release "$@"
diff --git a/.kilo_workflow/e2e-slot-status.sh b/.kilo_workflow/e2e-slot-status.sh
new file mode 100755
index 0000000000..88f80832b2
--- /dev/null
+++ b/.kilo_workflow/e2e-slot-status.sh
@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+# Reap dead slot owners, list live holders, then report known resources whose
+# worktree has no slot. Reporting is read-only and always exits 0 — UNACCOUNTED
+# lines in the output are the finding; the owning workflow cleans up.
+set -euo pipefail
+HERE=$(dirname "$0")
+"$HERE/.e2e-slot-state.sh" status "$@"
+
+state="$HOME/.cache/kilo-e2e-slots"
+covered=$(mktemp)
+trap 'rm -f "$covered"' EXIT
+for slot in "$state"/slot-*; do
+  [ -d "$slot" ] || continue
+  cat "$slot/worktree" 2>/dev/null || true
+  echo
+done > "$covered"
+
+unaccounted=0
+while IFS= read -r session; do
+  slug=${session#kilo-dev-}
+  found=0
+  while IFS= read -r worktree; do
+    [ -n "$worktree" ] || continue
+    candidate=$(basename "$worktree" | tr -c 'A-Za-z0-9_\n-' '_')
+    [ "$candidate" = "$slug" ] && found=1
+  done < "$covered"
+  if [ "$found" -eq 0 ]; then
+    echo "UNACCOUNTED stack: $session"
+    unaccounted=1
+  fi
+done < <(tmux list-sessions -F '#{session_name}' 2>/dev/null | grep '^kilo-dev-' || true)
+
+for root in "${TMPDIR:-/tmp}/kilo-mobile-simulator-claims" \
+            "${TMPDIR:-/tmp}/kilo-mobile-android-claims" \
+            "${TMPDIR:-/tmp}/kilo-mobile-android-emulators"; do
+  [ -d "$root" ] || continue
+  for record in "$root"/*.json; do
+    [ -f "$record" ] || continue
+    worktree=$(sed -nE 's/.*"worktreeRoot"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/p' "$record" | head -1)
+    [ -n "$worktree" ] || continue
+    if ! grep -qxF -- "$worktree" "$covered"; then
+      echo "UNACCOUNTED resource: $record [$worktree]"
+      unaccounted=1
+    fi
+  done
+done
+
+if [ "$unaccounted" -eq 0 ]; then
+  echo "no unaccounted known resources"
+fi
diff --git a/.kilo_workflow/e2e-slot.sh b/.kilo_workflow/e2e-slot.sh
deleted file mode 100755
index 620bf570d2..0000000000
--- a/.kilo_workflow/e2e-slot.sh
+++ /dev/null
@@ -1,338 +0,0 @@
-#!/usr/bin/env bash
-# Device/stack slot semaphore for parallel workflows.
-#
-# A slot, a dev stack, and a claimed device are the same resource: a slot is
-# what entitles a worktree to run a stack, a device, or a native build. Neither
-# a stack nor a device may outlive the slot that started it — five live stacks
-# on a 14-core host push the load past the point where emulator boots and native
-# builds time out, which reads as flaky devices rather than as
-# over-subscription, and a simulator left booted keeps burning CPU under every
-# section that follows. Planning, implementation, review, and CI waits need
-# neither, and are unlimited.
-#
-#   e2e-slot.sh acquire                  # blocks until a slot is free, then holds it
-#   e2e-slot.sh release [tmux-session]   # frees the slot AND hands back the worktree's stack and devices
-#   e2e-slot.sh status                   # who holds what, for how long, with stack coverage
-#   e2e-slot.sh stacks [--reap]          # stacks with no slot; --reap stops them
-#
-# A slot is owned by a tmux session name and records the worktree that took it.
-# If that tmux session no longer exists the slot is stale and is reclaimed
-# automatically — no heartbeats to maintain.
-#
-# acquire/release resolve the CALLER'S OWN tmux session — through $TMUX_PANE,
-# never the untargeted `display-message -p '#S'`, which answers with the
-# server's most recently active session and hands your slot an owner that can
-# die while you still drive a device. acquire accepts no name at all; release
-# accepts one only so an operator can clean up after a holder that is already
-# dead.
-#
-# State is machine-global on purpose: every worktree's copy of this script must
-# contend for the same slots, so the state dir never lives next to the script.
-set -uo pipefail
-
-# The state dir and slot count are the machine-global contract — no env
-# overrides, or parallel pipelines split the semaphore and defeat the cap.
-DIR="$HOME/.cache/kilo-e2e-slots"
-TOTAL=3
-POLL=60
-# 45 minutes, per WORKFLOW.md: a blocked acquire past this is a foreign wedge
-# to report, not a queue to keep waiting in.
-ACQUIRE_DEADLINE=2700
-mkdir -p "$DIR" || { echo "cannot create slot state dir $DIR" >&2; exit 1; }
-[ -w "$DIR" ] || { echo "slot state dir $DIR is not writable" >&2; exit 1; }
-
-# The worktree that owns this copy of the script — recorded at acquire time so
-# release and reap know which stack belongs to the slot.
-SELF_WORKTREE=$(git -C "$(dirname "$0")" rev-parse --show-toplevel 2>/dev/null || echo)
-
-# Section slugs carry a random run id (`<name>-$(openssl rand -hex 2)`, see
-# WORKFLOW.md Ground Rules). Only those stacks are workflow-owned; a stack
-# started by hand in a personal worktree is reported, never stopped.
-is_section_slug() { [[ "$1" =~ -[0-9a-f]{4}$ ]]; }
-
-# `\n` stays in the preserved set on purpose: without it `tr` rewrites the
-# trailing newline `basename` emits into `_`, which `$(...)` can no longer
-# strip, and every session name comes back with a spurious trailing underscore.
-stack_session() { echo "kilo-dev-$(basename "$1" | tr -c 'A-Za-z0-9_-\n' '_')"; }
-
-# Is any held slot entitled to this stack session? The recorded worktree is the
-# real answer; the owner-name prefix is a fallback so slots written before
-# worktrees were recorded never make a live stack look abandoned.
-stack_is_covered() {
-  # Every name here is local: this function loops over slots reassigning `wt`,
-  # and its caller `release_worktree_resources` still needs its own `wt`
-  # afterwards to know which worktree to tear down. Without `local` the caller's
-  # value is clobbered and the wrong section's stack gets stopped.
-  local sess=$1 s wt owner
-  for s in "$DIR"/slot-*; do
-    [ -d "$s" ] || continue
-    # A slot mid-release no longer entitles its worktree to anything — without
-    # this, a release would see its own still-present slot as coverage and
-    # skip the teardown it exists to perform.
-    [ -e "$s/releasing" ] && continue
-    wt=$(cat "$s/worktree" 2>/dev/null || echo)
-    [ -n "$wt" ] && [ "$(stack_session "$wt")" = "$sess" ] && return 0
-    owner=$(cat "$s/owner" 2>/dev/null || echo)
-    case "$owner" in "${sess#kilo-dev-}"*) return 0 ;; esac
-  done
-  return 1
-}
-
-# Hand back everything a slot entitled a worktree to hold — its dev stack and
-# every simulator it claimed — but only once no remaining slot covers it: a
-# section can hold a second slot for a concurrent phase.
-release_worktree_resources() {
-  local wt=$1 sess rc=0 c serial
-  [ -n "$wt" ] && [ -d "$wt" ] || return 0
-  sess=$(stack_session "$wt")
-  stack_is_covered "$sess" && return 0
-  if tmux has-session -t "$sess" 2>/dev/null; then
-    echo "stopping dev stack for $wt"
-    (cd "$wt" && pnpm dev:stop) || rc=1
-  fi
-  # Devices go back whether or not a stack is up — a round can drive a claimed
-  # simulator without one. Doing it here rather than trusting the runbook's
-  # per-UDID `release` is the whole point: an agent that ends its device phase
-  # without releasing each simulator by hand used to leave them booted for the
-  # rest of the day. `release-all` only touches this worktree's own claims, and
-  # only powers off devices its own claims booted.
-  echo "releasing simulators claimed by $wt"
-  (cd "$wt" && pnpm dev:mobile:simulator release-all) || rc=1
-  # The runbook launches every emulator inside this worktree's dedicated tmux
-  # session — the session name IS the boot provenance, so killing it powers
-  # off exactly the emulators this worktree started and never a foreign one.
-  # Kill it BEFORE dropping the claims: a serial must never sit unclaimed
-  # while the emulator behind it is still dying.
-  local android_sess port
-  android_sess="kilo-e2e-android-$(basename "$wt")"
-  if tmux has-session -t "$android_sess" 2>/dev/null; then
-    echo "killing emulator session $android_sess"
-    tmux kill-session -t "$android_sess" || rc=1
-  fi
-  # Android claims are per-serial files; drop this worktree's so dead sections
-  # never wedge a serial. Before each drop, verify nothing still answers on
-  # the serial's console port — a qemu that survived the session kill (or a
-  # foreign emulator this worktree merely claimed) is reported, not killed:
-  # there is no boot provenance beyond the session, and powering off a device
-  # we may not have booted is worse than reporting one.
-  for c in "${TMPDIR:-/tmp}/kilo-mobile-android-claims"/*.json; do
-    [ -f "$c" ] || continue
-    grep -qF "\"worktreeRoot\":\"$wt\"" "$c" 2>/dev/null || continue
-    serial=$(basename "$c" .json)
-    port=${serial#emulator-}
-    if [[ "$port" =~ ^[0-9]+$ ]]; then
-      for _ in 1 2 3 4 5; do
-        lsof -nP -iTCP:"$port" -sTCP:LISTEN >/dev/null 2>&1 || break
-        sleep 2
-      done
-      if lsof -nP -iTCP:"$port" -sTCP:LISTEN >/dev/null 2>&1; then
-        echo "warning: an emulator still answers on $serial after teardown — it was not booted by this worktree's session; leaving it" >&2
-      fi
-    fi
-    echo "releasing android claim $serial held by $wt"
-    (cd "$wt" && pnpm dev:mobile:android release "$serial") || rc=1
-  done
-  return "$rc"
-}
-
-reap() {
-  # If tmux cannot answer (missing binary, no server, socket error), liveness
-  # cannot be judged — keep every slot rather than wipe live ones. Acquirers
-  # always run inside tmux, so the server is up whenever reaping matters.
-  local alive now s owner mtime age wt
-  alive=$(tmux list-sessions -F '#{session_name}' 2>/dev/null) || return 0
-  now=$(date +%s)
-  for s in "$DIR"/slot-*; do
-    [ -d "$s" ] || continue
-    owner=$(cat "$s/owner" 2>/dev/null || echo)
-    if [ -z "$owner" ]; then
-      # An ownerless slot may be mid-acquire (mkdir landed, owner write
-      # hasn't) — only reap it once it is old enough to be a real orphan.
-      # stat -f %m is BSD/macOS; stat -c %Y is GNU/Linux.
-      mtime=$(stat -f %m "$s" 2>/dev/null || stat -c %Y "$s" 2>/dev/null || echo "$now")
-      age=$(( now - mtime ))
-      [ "$age" -gt 60 ] && rm -rf "$s"
-      continue
-    fi
-    if ! printf '%s\n' "$alive" | grep -qxF -- "$owner"; then
-      # The owner is gone, so the slot and everything it entitled — stack and
-      # claimed devices — are all reclaimable. `mkdir releasing` is the
-      # exclusive transition (an atomic marker two concurrent reapers cannot
-      # both win), it takes the slot out of coverage so the teardown runs,
-      # and the still-occupied slot keeps a new acquirer out until the dead
-      # holder's resources are actually gone. On teardown failure the slot is
-      # kept (marker removed) so the next reap retries instead of freeing
-      # capacity over a live stack.
-      wt=$(cat "$s/worktree" 2>/dev/null || echo)
-      mkdir "$s/releasing" 2>/dev/null || continue
-      if release_worktree_resources "$wt"; then
-        rm -rf "$s"
-      else
-        echo "reap: teardown failed for $s ($wt) — keeping the slot for retry" >&2
-        rmdir "$s/releasing" 2>/dev/null || true
-      fi
-    fi
-  done
-}
-
-# Stacks are named after their worktree, so a stack with no slot recording that
-# worktree is uncovered — it outlived whatever entitled it to exist.
-uncovered_stacks() {
-  tmux list-sessions -F '#{session_name}' 2>/dev/null | grep '^kilo-dev-' | while read -r sess; do
-    stack_is_covered "$sess" || echo "$sess"
-  done
-}
-
-# The caller's own tmux session, resolved through its pane. Empty when not in
-# tmux — a process that cannot own a slot, because reclamation keys on the
-# owning session's liveness.
-self_session() {
-  [ -n "${TMUX_PANE:-}" ] || return 0
-  tmux display-message -p -t "$TMUX_PANE" '#S' 2>/dev/null || true
-}
-
-case "${1:?usage: acquire|release|status|stacks [tmux-session]}" in
-  acquire)
-    # No explicit owner, ever: a slot acquired under any session but the
-    # caller's own gets reclaimed on the wrong lifetime (or never), which is
-    # exactly the leak the self-resolution exists to prevent.
-    [ -z "${2:-}" ] || {
-      echo "acquire takes no session name — run it from the session that will own the slot; it resolves the name itself" >&2
-      exit 1
-    }
-    who=$(self_session)
-    [ -n "$who" ] || {
-      echo "not inside a tmux session — a slot owner must be a live tmux session so a dead holder can be reclaimed; run from your own session (your dispatcher should have launched you in one)" >&2
-      exit 1
-    }
-    # Reject an owner that is not a live session — a window name, or a session
-    # name misread from the untargeted `display-message -p '#S'`. Such a slot is
-    # reapable the moment it is written, so it gets handed to a second workflow
-    # while this one still drives a device, and the machine silently
-    # over-subscribes. Skip the check only when tmux cannot answer at all.
-    if alive=$(tmux list-sessions -F '#{session_name}' 2>/dev/null); then
-      if ! printf '%s\n' "$alive" | grep -qxF -- "$who"; then
-        echo "no live tmux session named '$who' — own the slot with your own session name, not a window name" >&2
-        exit 1
-      fi
-    fi
-    # already holding one? idempotent — but only a COMPLETE record counts
-    # (owner is written last, so its presence proves the rest is there).
-    for s in "$DIR"/slot-*; do
-      [ -d "$s" ] || continue
-      [ "$(cat "$s/owner" 2>/dev/null)" = "$who" ] || continue
-      [ -e "$s/releasing" ] && continue
-      echo "already holding $(basename "$s")"
-      exit 0
-    done
-    DEADLINE=$(( $(date +%s) + ACQUIRE_DEADLINE ))
-    while :; do
-      reap
-      for i in $(seq 1 "$TOTAL"); do
-        if mkdir "$DIR/slot-$i" 2>/dev/null; then
-          # A partially written slot is worse than no slot: the reaper would
-          # hand it to someone else while this caller drives a device. The
-          # owner file goes LAST — its presence is what marks the record
-          # complete, and an interrupted write leaves an ownerless orphan the
-          # reaper clears instead of a live session holding a broken slot.
-          if printf '%s' "$SELF_WORKTREE" > "$DIR/slot-$i/worktree" &&
-             date -u +%Y-%m-%dT%H:%M:%SZ > "$DIR/slot-$i/since" &&
-             printf '%s' "$who" > "$DIR/slot-$i/owner"; then
-            echo "acquired slot-$i for ${SELF_WORKTREE:-unknown worktree}"
-            exit 0
-          fi
-          rm -rf "$DIR/slot-$i"
-          echo "failed to record slot ownership in $DIR (disk full?)" >&2
-          exit 1
-        fi
-      done
-      if [ "$(date +%s)" -ge "$DEADLINE" ]; then
-        echo "acquire: no slot freed in ${ACQUIRE_DEADLINE}s — a foreign holder is likely wedged; current holders:" >&2
-        "$0" status >&2 || true
-        echo "report a blocker instead of waiting further (never kill another session to free a slot)" >&2
-        exit 1
-      fi
-      echo "all $TOTAL device slots busy; retrying in ${POLL}s: $(ls -1 "$DIR" 2>/dev/null | tr '\n' ' ')" >&2
-      sleep "$POLL"
-    done
-    ;;
-  release)
-    who=${2:-$(self_session)}
-    [ -n "$who" ] || { echo "not inside tmux and no session name given" >&2; exit 1; }
-    # An explicit name is for cleaning up after a DEAD holder only. Releasing
-    # a live foreign session's slot would stop a running verifier's stack and
-    # devices out from under it.
-    if [ -n "${2:-}" ] && [ "$2" != "$(self_session)" ] && tmux has-session -t "$2" 2>/dev/null; then
-      echo "release: session '$2' is still alive — a live holder releases its own slot; refusing" >&2
-      exit 1
-    fi
-    fail=0
-    for s in "$DIR"/slot-*; do
-      [ -d "$s" ] || continue
-      [ "$(cat "$s/owner" 2>/dev/null)" = "$who" ] || continue
-      wt=$(cat "$s/worktree" 2>/dev/null || echo)
-      # Tear down first, free the slot last: `mkdir releasing` (atomic, so a
-      # concurrent reaper cannot double-teardown) takes this slot out of
-      # coverage so the teardown runs, while the still-occupied slot directory
-      # keeps a new acquirer from starting a stack alongside the one being
-      # stopped. On teardown failure the slot is kept so capacity is never
-      # freed over a live stack — fix the error and release again.
-      mkdir "$s/releasing" 2>/dev/null || { echo "$(basename "$s") is already being released elsewhere" >&2; continue; }
-      if release_worktree_resources "$wt"; then
-        rm -rf "$s"
-        echo "released $(basename "$s")"
-      else
-        rmdir "$s/releasing" 2>/dev/null || true
-        echo "release: teardown failed for $(basename "$s") ($wt) — slot kept; fix the error above and run release again" >&2
-        fail=1
-      fi
-    done
-    exit "$fail"
-    ;;
-  status)
-    reap
-    n=0
-    for s in "$DIR"/slot-*; do
-      [ -d "$s" ] || continue
-      n=$((n + 1))
-      wt=$(cat "$s/worktree" 2>/dev/null || echo)
-      # No recorded worktree means the slot predates this script — say so rather
-      # than reporting a stack state that was never looked up.
-      if [ -z "$wt" ]; then
-        stack='worktree unrecorded, stack unknown'
-      elif tmux has-session -t "$(stack_session "$wt")" 2>/dev/null; then
-        stack="$wt stack=up"
-      else
-        stack="$wt stack=none"
-      fi
-      echo "$(basename "$s"): $(cat "$s/owner" 2>/dev/null) since $(cat "$s/since" 2>/dev/null) [$stack]"
-    done
-    echo "$n/$TOTAL held"
-    uncovered=$(uncovered_stacks)
-    if [ -n "$uncovered" ]; then
-      echo "uncovered stacks (up with no slot — run '$0 stacks --reap'): $(printf '%s ' $uncovered)" >&2
-    fi
-    ;;
-  stacks)
-    reap
-    uncovered=$(uncovered_stacks)
-    [ -z "$uncovered" ] && { echo "every running dev stack is covered by a slot"; exit 0; }
-    for sess in $uncovered; do
-      slug=${sess#kilo-dev-}
-      if [ "${2:-}" != "--reap" ]; then
-        echo "$sess: up with no slot"
-        continue
-      fi
-      if ! is_section_slug "$slug"; then
-        echo "$sess: no section run id in the name — started by hand, leaving it alone"
-        continue
-      fi
-      wt=$(git worktree list --porcelain | sed -n 's/^worktree //p' | while read -r p; do
-        [ "$(basename "$p")" = "$slug" ] && echo "$p"; done | head -1)
-      [ -n "$wt" ] || { echo "$sess: no worktree on disk, leaving its session alone"; continue; }
-      echo "reaping $sess ($wt)"
-      release_worktree_resources "$wt"
-    done
-    ;;
-  *) echo "usage: $0 acquire|release|status|stacks [tmux-session]" >&2; exit 1 ;;
-esac
diff --git a/.kilo_workflow/e2e-start-resource.sh b/.kilo_workflow/e2e-start-resource.sh
new file mode 100755
index 0000000000..06b8d39957
--- /dev/null
+++ b/.kilo_workflow/e2e-start-resource.sh
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# Start one resource while the caller owns an E2E slot.
+set -euo pipefail
+HERE=$(dirname "$0")
+"$HERE/.e2e-slot-state.sh" _held >/dev/null || {
+  echo "take a slot first: $HERE/e2e-take-slot.sh" >&2
+  exit 1
+}
+
+resource=${1:?usage: $0 stack [targets...] | ios [udid] | android <avd> [--gpu ...] | command <cmd> [args...]}
+shift
+case "$resource" in
+  stack) exec pnpm dev:start --no-attach --reuse-running "$@" ;;
+  ios) exec pnpm dev:mobile:simulator claim "$@" ;;
+  android) exec pnpm dev:mobile:android emulator-start "$@" ;;
+  command)
+    [ "$#" -gt 0 ] || { echo "command requires a command to run" >&2; exit 1; }
+    exec "$@"
+    ;;
+  *) echo "unknown resource '$resource'; expected stack, ios, android, or command" >&2; exit 1 ;;
+esac
diff --git a/.kilo_workflow/e2e-stop-resource.sh b/.kilo_workflow/e2e-stop-resource.sh
new file mode 100755
index 0000000000..ff3127b8b3
--- /dev/null
+++ b/.kilo_workflow/e2e-stop-resource.sh
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# Stop one resource before the caller frees its E2E slot.
+set -euo pipefail
+
+resource=${1:?usage: $0 stack | ios | android | command <cmd> [args...]}
+shift
+case "$resource" in
+  stack) exec pnpm dev:stop ;;
+  ios) exec pnpm dev:mobile:simulator release-all ;;
+  android)
+    failed=0
+    pnpm dev:mobile:android emulator-stop || failed=1
+    pnpm dev:mobile:android release-all || failed=1
+    exit "$failed"
+    ;;
+  command)
+    [ "$#" -gt 0 ] || { echo "command requires a command to run" >&2; exit 1; }
+    exec "$@"
+    ;;
+  *) echo "unknown resource '$resource'; expected stack, ios, android, or command" >&2; exit 1 ;;
+esac
diff --git a/.kilo_workflow/e2e-take-slot.sh b/.kilo_workflow/e2e-take-slot.sh
new file mode 100755
index 0000000000..a534225acf
--- /dev/null
+++ b/.kilo_workflow/e2e-take-slot.sh
@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+exec "$(dirname "$0")/.e2e-slot-state.sh" acquire "$@"
diff --git a/.kilo_workflow/init-section.sh b/.kilo_workflow/init-section.sh
index 8589accb28..6e64a16ac9 100755
--- a/.kilo_workflow/init-section.sh
+++ b/.kilo_workflow/init-section.sh
@@ -1,51 +1,111 @@
 #!/usr/bin/env bash
-# Create everything a new section needs, per .kilo_workflow/WORKFLOW.md Ground
-# Rules — run id, worktrees, cloud preparation, scratch directory — so no
-# starter or planner hand-assembles the ritual (and none can reuse a stale
-# branch, skip the cloud worktree, or put scratch inside a repository).
-#
-#   init-section.sh <name> [sibling-repo-path...]
-#
-#   name     lowercase slug WITHOUT the run id, e.g. `billing`; the script
-#            appends `-<4 hex>` itself
-#   sibling  optional absolute path(s) to sibling repositories the plan
-#            touches (e.g. ~/Projects/kilocode); each gets its own worktree
-#            on the same branch. The cloud worktree is always created.
-#
-# Prints a manifest, one `key=value` per line: section, cloud worktree,
-# scratch, and one line per sibling worktree. Sibling repositories follow
-# their own AGENTS.md setup afterwards (kilocode uses bun, not pnpm).
+# Create a section's run id, worktrees, prepared cloud checkout, and scratch
+# directory. `add-repo` adds a repository discovered during planning.
 set -euo pipefail
 
-NAME=${1:?usage: init-section.sh <name> [sibling-repo-path...]}
-shift
-[[ "$NAME" =~ ^[a-z0-9-]+$ ]] || { echo "init-section: name must be a lowercase slug ([a-z0-9-]): '$NAME'" >&2; exit 1; }
-[[ "$NAME" =~ -[0-9a-f]{4}$ ]] && { echo "init-section: pass the bare name — the run id is appended here" >&2; exit 1; }
-
 CLOUD_REPO=$(cd "$(dirname "$0")/.." && pwd -P)
 WT_ROOT="$HOME/Projects/.worktrees"
 mkdir -p "$WT_ROOT"
 
-SECTION="$NAME-$(openssl rand -hex 2)"
+CREATED_REPOS=()
+CREATED_PATHS=()
+SCRATCH=""
+SUCCESS=0
+cleanup() {
+  [ "$SUCCESS" -eq 1 ] && return
+  local i repo path
+  [ -z "$SCRATCH" ] || rm -rf "$SCRATCH"
+  for ((i=${#CREATED_PATHS[@]} - 1; i >= 0; i--)); do
+    repo=${CREATED_REPOS[$i]}
+    path=${CREATED_PATHS[$i]}
+    git -C "$repo" worktree remove --force "$path" >/dev/null 2>&1 || true
+    git -C "$repo" branch -D "$SECTION" >/dev/null 2>&1 || true
+  done
+}
+trap cleanup EXIT
+
+validate_section() {
+  [[ "$1" =~ ^[a-z0-9-]+-[0-9a-f]{4}$ ]] ||
+    { echo "init-section: section must be a lowercase slug ending in 4 hex characters: $1" >&2; exit 1; }
+}
+
+canonical_repo() {
+  local repo=$1
+  [ -d "$repo" ] || { echo "init-section: not a directory: $repo" >&2; exit 1; }
+  repo=$(cd "$repo" && pwd -P)
+  git -C "$repo" rev-parse --git-dir >/dev/null 2>&1 ||
+    { echo "init-section: not a git repository: $repo" >&2; exit 1; }
+  printf '%s\n' "$repo"
+}
+
+preflight_worktree() {
+  local repo=$1 path=$2
+  [ ! -e "$path" ] || { echo "init-section: target already exists: $path" >&2; exit 1; }
+  ! git -C "$repo" show-ref --verify --quiet "refs/heads/$SECTION" ||
+    { echo "init-section: branch already exists in $repo: $SECTION" >&2; exit 1; }
+}
 
 add_worktree() {
   local repo=$1 path=$2
-  git -C "$repo" fetch origin
-  git -C "$repo" worktree add "$path" -b "$SECTION" origin/main
+  git -C "$repo" worktree add "$path" -b "$SECTION" origin/main >&2
+  CREATED_REPOS+=("$repo")
+  CREATED_PATHS+=("$path")
 }
 
-CLOUD_WT="$WT_ROOT/$SECTION"
-add_worktree "$CLOUD_REPO" "$CLOUD_WT"
-(cd "$CLOUD_WT" && pnpm dev:worktree:prepare)
+if [ "${1:-}" = "add-repo" ]; then
+  SECTION=${2:?usage: init-section.sh add-repo <section> <repo>}
+  validate_section "$SECTION"
+  REPO=$(canonical_repo "${3:?repository path}")
+  TARGET="$WT_ROOT/$SECTION-$(basename "$REPO")"
+  preflight_worktree "$REPO" "$TARGET"
+  git -C "$REPO" fetch origin >&2
+  git -C "$REPO" rev-parse --verify origin/main >/dev/null
+  add_worktree "$REPO" "$TARGET"
+  echo "sibling_worktree=$TARGET"
+  SUCCESS=1
+  exit 0
+fi
 
+NAME=${1:?usage: init-section.sh <name> [sibling-repo-path...]}
+shift
+[[ "$NAME" =~ ^[a-z0-9-]+$ ]] ||
+  { echo "init-section: name must be a lowercase slug ([a-z0-9-]): '$NAME'" >&2; exit 1; }
+[[ "$NAME" =~ -[0-9a-f]{4}$ ]] &&
+  { echo "init-section: pass the bare name — the run id is appended here" >&2; exit 1; }
+SECTION="$NAME-$(openssl rand -hex 2)"
+
+REPOS=("$CLOUD_REPO")
+for repo in "$@"; do REPOS+=("$(canonical_repo "$repo")"); done
+
+PATHS=("$WT_ROOT/$SECTION")
+for ((i=1; i<${#REPOS[@]}; i++)); do
+  path="$WT_ROOT/$SECTION-$(basename "${REPOS[$i]}")"
+  for existing in "${PATHS[@]}"; do
+    [ "$existing" != "$path" ] ||
+      { echo "init-section: repositories share target basename: $path" >&2; exit 1; }
+  done
+  PATHS+=("$path")
+done
+
+# Validate every repository before the first write; fetches then run before any
+# worktree exists, so a bad remote cannot leave a half-created section.
+for ((i=0; i<${#REPOS[@]}; i++)); do
+  preflight_worktree "${REPOS[$i]}" "${PATHS[$i]}"
+done
+for repo in "${REPOS[@]}"; do
+  git -C "$repo" fetch origin >&2
+  git -C "$repo" rev-parse --verify origin/main >/dev/null
+done
+for ((i=0; i<${#REPOS[@]}; i++)); do
+  add_worktree "${REPOS[$i]}" "${PATHS[$i]}"
+done
+
+CLOUD_WT=${PATHS[0]}
+(cd "$CLOUD_WT" && pnpm dev:worktree:prepare) >&2
 SCRATCH=$(mktemp -d "${TMPDIR:-/tmp}/kilo-workflow-$SECTION.XXXXXX")
 
 echo "section=$SECTION"
 echo "cloud_worktree=$CLOUD_WT"
 echo "scratch=$SCRATCH"
-for repo in "$@"; do
-  [ -d "$repo/.git" ] || [ -f "$repo/.git" ] || { echo "init-section: not a git repository: $repo" >&2; exit 1; }
-  SIB_WT="$WT_ROOT/$SECTION-$(basename "$repo")"
-  add_worktree "$repo" "$SIB_WT"
-  echo "sibling_worktree=$SIB_WT"
-done
+for ((i=1; i<${#PATHS[@]}; i++)); do echo "sibling_worktree=${PATHS[$i]}"; done
+SUCCESS=1
diff --git a/.kilo_workflow/launch-gate.sh b/.kilo_workflow/launch-gate.sh
new file mode 100755
index 0000000000..5646b6e9f9
--- /dev/null
+++ b/.kilo_workflow/launch-gate.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Space machine-global kilo CLI launches so their shared SQLite stores do not
+# race. The repository process lock supplies live-owner heartbeats, stale-lock
+# recovery, and a bounded wait.
+set -euo pipefail
+
+ROOT=$(cd "$(dirname "$0")/.." && pwd -P)
+GATE="$HOME/.cache/kilo-launch-gate"
+LOCK_RUNNER="$ROOT/node_modules/.bin/tsx"
+LOCK_SCRIPT="$ROOT/dev/local/process-lock.ts"
+
+if [ "${1:-}" = "--locked" ]; then
+  mkdir -p "$GATE"
+  now=$(date +%s)
+  last=$(cat "$GATE/last" 2>/dev/null || echo 0)
+  remaining=$(( 3 - (now - last) ))
+  [ "$remaining" -le 0 ] || sleep "$remaining"
+  date +%s > "$GATE/last"
+  exit 0
+fi
+
+[ -x "$LOCK_RUNNER" ] || {
+  echo "launch-gate: missing $LOCK_RUNNER — prepare the cloud worktree before launching agents" >&2
+  exit 1
+}
+exec "$LOCK_RUNNER" "$LOCK_SCRIPT" --wait 60 "$GATE/lock" -- "$0" --locked
diff --git a/.kilo_workflow/launch-interactive.sh b/.kilo_workflow/launch-interactive.sh
index 26c1542414..ca081aab8c 100755
--- a/.kilo_workflow/launch-interactive.sh
+++ b/.kilo_workflow/launch-interactive.sh
@@ -38,23 +38,7 @@ shift 2
 [ -d "$WT" ] || { echo "launch-interactive: no such worktree: $WT" >&2; exit 1; }
 touch "$LOGFILE" 2>/dev/null || { echo "launch-interactive: cannot write log file $LOGFILE" >&2; exit 1; }
 
-# Machine-global launch spacing: concurrent kilo startups race the shared
-# SQLite credential/session stores and crash. Same gate as dispatch-role.sh.
-GATE="$HOME/.cache/kilo-launch-gate"
-mkdir -p "$GATE"
-while :; do
-  if mkdir "$GATE/lock" 2>/dev/null; then
-    NOW=$(date +%s)
-    LAST=$(cat "$GATE/last" 2>/dev/null || echo 0)
-    if [ $(( NOW - LAST )) -ge 3 ]; then
-      echo "$NOW" > "$GATE/last"
-      rmdir "$GATE/lock"
-      break
-    fi
-    rmdir "$GATE/lock"
-  fi
-  sleep 1
-done
+"$(dirname "$0")/launch-gate.sh"
 
 STRIP='$(env | grep -oE "^(KILO|OPENCODE)[A-Za-z0-9_]*" | sed "s/^/-u /" | tr "\n" " " || true)'
 CMD="env $STRIP"
@@ -66,7 +50,9 @@ if [ -n "${TMUX_PANE:-}" ]; then
 fi
 
 if [ -n "$CALLER_SESSION" ]; then
-  TARGET=$(tmux new-window -d -P -F '#{session_name}:#{window_index}' -t "$CALLER_SESSION:" -n "$NAME" -c "$WT" "$CMD")
+  # Window indexes are renumbered when an earlier window exits. The stable
+  # @<window-id> keeps monitoring and steering aimed at this session.
+  TARGET=$(tmux new-window -d -P -F '#{window_id}' -t "$CALLER_SESSION:" -n "$NAME" -c "$WT" "$CMD")
 else
   tmux new-session -d -s "$NAME" -c "$WT" "$CMD"
   TARGET=$NAME
diff --git a/.kilo_workflow/learnings/android-emulator-systemserver-restart-systemui-anr-under-load.md b/.kilo_workflow/learnings/android-emulator-systemserver-restart-systemui-anr-under-load.md
index 729e3aa1cb..9a2e9cc088 100644
--- a/.kilo_workflow/learnings/android-emulator-systemserver-restart-systemui-anr-under-load.md
+++ b/.kilo_workflow/learnings/android-emulator-systemserver-restart-systemui-anr-under-load.md
@@ -2,7 +2,7 @@
 
 Observed on attach-oom-11fd r2 while 3 slots were active (host load avg spiked to ~168):
 
-**Symptom chain:** mid-run `adb shell input tap` fails with `Broken pipe (32)` then `Can't find service: input`;
+**Symptom chain:** mid-run wrapped ADB `shell input tap` fails with `Broken pipe (32)` then `Can't find service: input`;
 `sys.boot_completed` still reads 1; `uiautomator dump` returns `Killed` (RC=137); qemu process stays alive.
 Cause: the guest's system_server restarted under memory/CPU pressure — treat those adb signatures as
 "guest rebooting", poll `getprop sys.boot_completed` (bounded loop) instead of assuming an adb wedge.
@@ -12,9 +12,9 @@ Cause: the guest's system_server restarted under memory/CPU pressure — treat t
 `mCurrentFocus=... Application Not Responding: com.android.systemui`, SystemUI in S state, and a shell-user
 `kill <pid>` silently does nothing (PID unchanged).
 
-**Recovery (confirmed):** `adb root` works on the kilo AVDs (`restarting adbd as root`), then
-`adb shell kill -9 <systemui-pid>`; system_server restarts SystemUI in ~20 s, the ANR dialog clears, and the
+**Recovery (confirmed):** `pnpm dev:mobile:android adb -s <serial> root` works on the kilo AVDs
+(`restarting adbd as root`), then `pnpm dev:mobile:android adb -s <serial> shell kill -9
+<systemui-pid>`; system_server restarts SystemUI in ~20 s, the ANR dialog clears, and the
 app process, adb reverse mappings, login session, and conversation state all survive. No emulator relaunch
-(never consume a launch attempt for this). Afterwards Maestro, which also wedges under the load
-(`maestro hierarchy` empty/timing out, `maestro test` never writing its first log line), works again.
-
+(never consume a launch attempt for this). Afterwards the repository Maestro wrapper, which also wedges
+under the load (hierarchy empty/timing out, test never writing its first log line), works again.
diff --git a/.kilo_workflow/learnings/android-picker-tap-races-and-toast-capture.md b/.kilo_workflow/learnings/android-picker-tap-races-and-toast-capture.md
index 0a29149046..592dfa9b7a 100644
--- a/.kilo_workflow/learnings/android-picker-tap-races-and-toast-capture.md
+++ b/.kilo_workflow/learnings/android-picker-tap-races-and-toast-capture.md
@@ -3,12 +3,12 @@
 Two Android-emulator techniques confirmed on attach-oom-11fd (2026-07-28):
 
 1. `uiautomator dump` bounds can describe a view the picker has already left (a tap aimed at them hit the wrong
-   Recent row). Before an `adb input tap`, cross-check the same node's bounds in a fresh
-   `maestro --device <serial> hierarchy` — only tap when both agree. Prefer Maestro flows for navigation and
-   reserve adb taps for the final pick when sub-second screenshot timing matters.
-2. `sonner-native` toasts are catchable deterministically with an adb tap immediately followed by burst
-   screencaps at +0.5s/+1.2s/+2.2s/+3.5s (`adb exec-out screencap -p > f.png`). A `maestro test` flow's
+   Recent row). Before a `pnpm dev:mobile:android adb -s <serial> shell input tap`, cross-check
+   the same node's bounds with `apps/mobile/e2e/maestro.sh <serial> hierarchy` — only tap when
+   both agree. Prefer Maestro flows for navigation and reserve ADB taps for the final pick when sub-second screenshot timing matters.
+2. `sonner-native` toasts are catchable deterministically with a wrapped ADB tap immediately followed by burst
+   screencaps at +0.5s/+1.2s/+2.2s/+3.5s (`pnpm dev:mobile:android adb -s <serial> exec-out screencap -p > f.png`). A Maestro flow's
    teardown latency (seconds) is too slow — the toast dismisses before the shell regains control. The first
    burst frame usually still shows the picker; the second (+1.2s) reliably showed the toast.
-3. Files `adb push`ed to /sdcard/Download appear in the picker's Downloads root immediately, but only enter its
+3. Files pushed with `pnpm dev:mobile:android adb -s <serial> push` to /sdcard/Download appear in the picker's Downloads root immediately, but only enter its
    Recent view after being picked once — do not rely on Recent containing a freshly pushed fixture.
diff --git a/.kilo_workflow/learnings/dev-stack-died-mid-round-restart-in-place.md b/.kilo_workflow/learnings/dev-stack-died-mid-round-restart-in-place.md
index 3c1976252d..dc67e1fbdd 100644
--- a/.kilo_workflow/learnings/dev-stack-died-mid-round-restart-in-place.md
+++ b/.kilo_workflow/learnings/dev-stack-died-mid-round-restart-in-place.md
@@ -1,18 +1,15 @@
-# Dev stack died mid-round (killed externally or by a stale slot script) — restart in place, don't re-verify from scratch
+# Dev stack died mid-round — restart in place, don't re-verify from scratch
 
 Symptom: mid-E2E, `pnpm dev:status` suddenly prints "No dev session running", the dev client
 loses Metro, and flows start failing on connection errors — with your slot still held and no
-crash logs of your own. Usual culprits: another section's stale pre-fix `e2e-slot.sh` copy
-stopping the wrong worktree's stack on release, or a slot-covering placeholder session dying and
-the reaper stopping the now-uncovered stack.
+crash logs of your own. A sibling process or manual cleanup stopped the stack.
 
 Cause: the stack was stopped out from under you; nothing about your worktree, data, or device is
 wrong. Postgres rows, Durable Object storage, and local D1 files all survive a `dev:stop`.
 
-Fix (verified twice): while the slot is still held, restart the stack in place with the same
-port offset and service group from your handoff — `KILO_PORT_OFFSET=<n> pnpm dev:start
---no-attach <services>` (ports are deterministic per worktree, so everything comes back on the
-same URLs). Then restore what rode on it: restart the CLI relay if the round uses one
+Fix (verified twice): while the slot is still held, restart the stack in place with
+`.kilo_workflow/e2e-start-resource.sh stack <services>`; the runner reuses the selected offset it persisted
+before startup, so everything comes back on the same URLs. Then restore what rode on it: restart the CLI relay if the round uses one
 (`apps/mobile/e2e/remote-cli.sh exec remote` → `Remote connection enabled.`), re-anchor the dev
 client with the deep link, and re-run only the iteration that was in flight — completed
 iterations' device-local measurements stay valid. Classify the interruption as environment
diff --git a/.kilo_workflow/learnings/kiloclaw-docker-tcp-absent-from-worktree-status.md b/.kilo_workflow/learnings/kiloclaw-docker-tcp-absent-from-worktree-status.md
index a2d91a6bbd..99208ce3f8 100644
--- a/.kilo_workflow/learnings/kiloclaw-docker-tcp-absent-from-worktree-status.md
+++ b/.kilo_workflow/learnings/kiloclaw-docker-tcp-absent-from-worktree-status.md
@@ -4,6 +4,6 @@ Symptom: `pnpm dev:status --json` for a worktree whose stack started cleanly lis
 
 Cause: `kiloclaw-docker-tcp` is a stateless loopback `socat` proxy to the shared Docker socket on `127.0.0.1:23750` — the one host-wide shared port the runbook allows. When another worktree (or an earlier stack) already owns that listener, this worktree's runner reuses it and records no service row of its own.
 
-Fix: gate on the bridge, not the row: `curl http://127.0.0.1:23750/v1.44/_ping` must print `OK`. Only if that fails, start the bridge yourself per `services/kiloclaw/README.md` (`socat TCP-LISTEN:23750,bind=127.0.0.1,reuseaddr,fork UNIX-CONNECT:/var/run/docker.sock`). Never kill a `socat` owned by another worktree (runbook, Host Networking Safety) — `lsof -iTCP:23750` shows the owning PID and it is shared by every docker-local instance on the host, not just yours.
+Fix: gate on the bridge, not the row: `curl http://127.0.0.1:23750/v1.44/_ping` must print `OK`. If it fails, rerun `.kilo_workflow/e2e-start-resource.sh stack kiloclaw`; the runner probes and recreates the bridge. Never start or kill `socat` by hand — the listener is shared by every docker-local instance on the host.
 
-Related: a plain `pnpm dev:stop` tears the shared bridge down (even when `e2e-slot.sh release` printed "Leaving Docker infrastructure running"). After a cleanup, 23750 having no listener is expected — the next `dev:start` recreates it on demand; do not "repair" it by hand. The KiloClaw sandbox container itself survives both release and `dev:stop`.
+Related: `.kilo_workflow/e2e-stop-resource.sh stack` runs `pnpm dev:stop`, which tears the shared bridge down. After cleanup, 23750 having no listener is expected — the next resource start recreates it on demand; do not "repair" it by hand. The KiloClaw sandbox container itself survives `dev:stop`.
diff --git a/.kilo_workflow/learnings/maestro-tap-swallowed-by-ios-keyboard.md b/.kilo_workflow/learnings/maestro-tap-swallowed-by-ios-keyboard.md
index 80cd3947fd..e9de535ad5 100644
--- a/.kilo_workflow/learnings/maestro-tap-swallowed-by-ios-keyboard.md
+++ b/.kilo_workflow/learnings/maestro-tap-swallowed-by-ios-keyboard.md
@@ -7,7 +7,7 @@ Cause: Maestro taps an element's **centre**, and iOS delivers any touch inside `
 Verify it in two commands, both cheap:
 
 ```bash
-maestro --device <udid> hierarchy        # control centre vs the keyboard window's top bound
+apps/mobile/e2e/maestro.sh <udid> hierarchy  # control centre vs the keyboard window's top bound
 grep -E "Tapping [0-9]" ~/.maestro/tests/<run>/<flow>/logs/device-xctest.log
 grep -A2 "Sending UIEvent" ~/.maestro/tests/<run>/<flow>/logs/device-simulator.log
 ```
diff --git a/.kilo_workflow/learnings/mobile-android-dev-client-cold-start-deep-link.md b/.kilo_workflow/learnings/mobile-android-dev-client-cold-start-deep-link.md
index 3715f40987..699742bee3 100644
--- a/.kilo_workflow/learnings/mobile-android-dev-client-cold-start-deep-link.md
+++ b/.kilo_workflow/learnings/mobile-android-dev-client-cold-start-deep-link.md
@@ -1,6 +1,6 @@
 # Android dev client: cold starts need the deep link, and the reload outlasts flow budgets
 
-Symptom: after `adb shell am force-stop com.kilocode.kiloapp`, relaunching with
+Symptom: after wrapped ADB `shell am force-stop com.kilocode.kiloapp`, relaunching with
 `am start -n com.kilocode.kiloapp/.MainActivity` lands on the Expo dev-client launcher
 ("Development Build", server URL list) instead of the app; `monkey -p ... LAUNCHER 1` fails
 outright. Separately, `apps/mobile/e2e/login.sh <serial>` fails its settle assert
@@ -18,7 +18,8 @@ status-bar clock.
 
 Fix:
 
-- Always relaunch via the deep link, with `adb reverse tcp:$API_PORT` / `tcp:$METRO_PORT` set
+- Always relaunch via the deep link, with the repository wrapper's `adb -s <serial> reverse
+  tcp:$API_PORT` / `tcp:$METRO_PORT` set
   first. A blank white screen + zero-text dump within ~60s of a cold start means LOADING, not a
   rendering defect — wait and re-dump before classifying (contrast: the iOS transparency defect
   shows static text on screen while the interactive subtree is missing for 60s+).
diff --git a/.kilo_workflow/learnings/mobile-android-edge-to-edge-ime-insets.md b/.kilo_workflow/learnings/mobile-android-edge-to-edge-ime-insets.md
index da9a6965cd..62c96a22b3 100644
--- a/.kilo_workflow/learnings/mobile-android-edge-to-edge-ime-insets.md
+++ b/.kilo_workflow/learnings/mobile-android-edge-to-edge-ime-insets.md
@@ -19,7 +19,7 @@ already up observes 0 and wrongly concludes the spacer is inert.
 
 How to verify (no code changes):
 
-- `adb shell dumpsys window windows` (the single-subcommand form — full `dumpsys window`
+- `pnpm dev:mobile:android adb -s <serial> shell dumpsys window windows` (the single-subcommand form — full `dumpsys window`
   abbreviates per-window entries and omits `Frames:`/`mFullConfiguration`). Compare the
   app's `winConfig={ mBounds / mAppBounds }` before/after IME: identical rects = no OS resize.
 - `dumpsys window | grep "type=ime frame"` gives the authoritative keyboard top/height
diff --git a/.kilo_workflow/learnings/mobile-android-global-render-wedge.md b/.kilo_workflow/learnings/mobile-android-global-render-wedge.md
index 85948b3939..5b42df8ee6 100644
--- a/.kilo_workflow/learnings/mobile-android-global-render-wedge.md
+++ b/.kilo_workflow/learnings/mobile-android-global-render-wedge.md
@@ -13,6 +13,6 @@ Metro process (restarted; serves android bundle 200 10.3MB to host curl).
 
 Suspected: serving-side dev-handshake/bundle state regression on a shared machine with a
 concurrent verifier active ("Cannot connect to Expo CLI" seen in ReactNativeJS near a Metro
-restart). If it recurs: capture `adb logcat -s ReactNativeJS` for the Expo CLI warning, curl
+restart). If it recurs: capture `pnpm dev:mobile:android adb -s <serial> logcat -s ReactNativeJS` for the Expo CLI warning, curl
 localhost:<metro>/status, and compare against an iOS control app before burning hours on
 emulator-level recoveries — none of them work.
diff --git a/.kilo_workflow/learnings/mobile-android-maestro-flow-pitfalls.md b/.kilo_workflow/learnings/mobile-android-maestro-flow-pitfalls.md
index a9f977d348..42adab9705 100644
--- a/.kilo_workflow/learnings/mobile-android-maestro-flow-pitfalls.md
+++ b/.kilo_workflow/learnings/mobile-android-maestro-flow-pitfalls.md
@@ -5,8 +5,8 @@ code does not reveal.
 
 Cause/fix (three independent traps, all hit in the hermes-mem baseline round):
 1. `maestro test` exits 0 even when a flow assertion FAILED (observed on
-   maestro 2.7.0, Android). Never trust the exit code; grep the log for
-   `FAILED` after every run.
+   maestro 2.7.0, Android). `apps/mobile/e2e/maestro.sh` checks the JUnit result
+   and returns nonzero; always use it.
 2. Maestro text matching is full-string regex: the Agents list search field is
    `Search sessions...` (with ellipsis), so `visible: 'Search sessions'` never
    matches. Use `Search sessions.*` (and generally re-dump and copy exact
@@ -19,6 +19,6 @@ Cause/fix (three independent traps, all hit in the hermes-mem baseline round):
    after settle, and 60-120 s waits for list/transcript asserts. `dumpsys
    meminfo` itself can hit its 10 s service timeout under load — retry it.
 
-Screenshots: `adb exec-out screencap -p > "$SCRATCH/shot.png"` writes wherever
-you point it — no `~/.maestro/tests` hunt like on iOS
+Screenshots: `pnpm dev:mobile:android adb -s <serial> exec-out screencap -p >
+"$SCRATCH/shot.png"` writes wherever you point it — no `~/.maestro/tests` hunt like on iOS
 (`maestro-takescreenshot-output-dir.md`).
diff --git a/.kilo_workflow/learnings/mobile-kilochat-attachments-capability-gate-blocks-e2e.md b/.kilo_workflow/learnings/mobile-kilochat-attachments-capability-gate-blocks-e2e.md
index bd40137185..aefa09a54e 100644
--- a/.kilo_workflow/learnings/mobile-kilochat-attachments-capability-gate-blocks-e2e.md
+++ b/.kilo_workflow/learnings/mobile-kilochat-attachments-capability-gate-blocks-e2e.md
@@ -28,7 +28,3 @@ survives the request-bot-status escalation (e.g. seed the KILOCLAW_INSTANCE DO s
 `deliverChatWebhook` does not throw definitively, or a fake-bot harness answering
 `bot.status_request`). Report the criterion unverified with evidence; never the tool-card
 viewer as a proxy.
-
-If the stack gets stopped out from under a round (a foreign release, a reaped slot), recover
-per `dev-stack-died-mid-round-restart-in-place.md` — DO state persists, so the seeded rows
-survive a restart.
diff --git a/.kilo_workflow/learnings/mobile-maestro-ios-driver-timeout-stale-xcodebuild.md b/.kilo_workflow/learnings/mobile-maestro-ios-driver-timeout-stale-xcodebuild.md
index 2d578f2fc8..8291337db2 100644
--- a/.kilo_workflow/learnings/mobile-maestro-ios-driver-timeout-stale-xcodebuild.md
+++ b/.kilo_workflow/learnings/mobile-maestro-ios-driver-timeout-stale-xcodebuild.md
@@ -2,8 +2,8 @@
 
 Symptom: every Maestro command against a claimed iOS simulator fails with `xcuitest.installer.LocalXCTestInstaller$IOSDriverTimeoutException: iOS driver not ready in time`, even with `MAESTRO_DRIVER_STARTUP_TIMEOUT=300000`; `simctl openurl` may also time out (`NSPOSIXErrorDomain code=60`).
 
-Cause: a stale `xcodebuild test-without-building` process left bound to the UDID after a killed Maestro run (check `ps aux | grep xcodebuild` and match the `-xctestrun` temp path / `id=<udid>`), compounded by several same-type simulators booted by sibling worktrees.
+Cause: a stale `xcodebuild test-without-building` process left bound to the UDID after a killed Maestro run, compounded by several same-type simulators booted by sibling worktrees.
 
-Fix: kill only the `xcodebuild` process whose xctestrun path contains your UDID, then `xcrun simctl shutdown <udid> && xcrun simctl boot <udid>` (app and login state survive; `login.sh` is idempotent). Validate with a one-step `takeScreenshot` flow before dispatching the verifier again.
+Fix: stop the round, run `.kilo_workflow/e2e-stop-resource.sh ios`, then free its E2E slot. The simulator wrapper shuts down only a device the worktree claim booted; never kill `xcodebuild` or run `simctl shutdown` by hand. Redispatch fresh, take a slot, and validate through `apps/mobile/e2e/maestro.sh`.
 
-Variant — no stale xcodebuild at all (observed 2026-07-28, load avg 45+): the same `IOSDriverTimeoutException` after a killed Maestro run, but `ps aux | grep xcodebuild` is EMPTY — the wedge is the driver itself under load, not a leftover process. Fix: `xcrun simctl shutdown <udid> && xcrun simctl boot <udid>` alone, then validate with a one-step `takeScreenshot` flow and `MAESTRO_DRIVER_STARTUP_TIMEOUT=300000`. Prevention: never let a shell-tool timeout kill `maestro test` mid-wait — size the shell timeout ~3x the flow's worst case under load.
+Variant — no stale xcodebuild at all (observed 2026-07-28, load avg 45+): the same `IOSDriverTimeoutException` after a killed Maestro run, but no matching xcodebuild exists — the driver wedged under load. The same release-and-redispatch recovery applies. Size command timeouts above the flow's worst case so the harness does not kill Maestro mid-wait.
diff --git a/.kilo_workflow/learnings/mobile-session-ingest-log-empty-use-pipe-pane.md b/.kilo_workflow/learnings/mobile-session-ingest-log-empty-use-pipe-pane.md
deleted file mode 100644
index a7b824f032..0000000000
--- a/.kilo_workflow/learnings/mobile-session-ingest-log-empty-use-pipe-pane.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# mobile: session-ingest log file stays empty — use dev:capture or tmux pipe-pane for the socket tail
-
-Symptom: `dev/logs/cloudflare-session-ingest.log` is 0 bytes for the whole run, so `tail -f` on it
-shows nothing, while the service is clearly logging (connection and heartbeat lines exist).
-
-Cause: this worktree's dev runner writes service output to the tmux pane, not the log file (observed
-2026-07-28 on sessions-context-d669; `pnpm dev:capture cloudflare-session-ingest` had all output).
-
-Fix: for one-shot reads use `pnpm dev:capture cloudflare-session-ingest` (runbook-prescribed). For a
-continuous capture across a UI interaction (e.g. the context-switch socket-lease check), pipe the
-pane: resolve the window with `tmux list-windows -t kilo-dev-<slug>` (cloudflare-session-ingest was
-window 12), then `tmux pipe-pane -t kilo-dev-<slug>:12.0 -o "cat >> '<scratch>/ingest-tail.log'"`.
-`#{pane_pipe}` = 1 while active. Toggle it off with the same command at cleanup. Record byte offsets
-(`wc -c`) at interaction markers to bracket log segments; the wrangler lines carry no timestamps.
diff --git a/.kilo_workflow/learnings/mobile-simulator-claim-killed-mid-boot.md b/.kilo_workflow/learnings/mobile-simulator-claim-killed-mid-boot.md
index c0b685616c..1953f2d068 100644
--- a/.kilo_workflow/learnings/mobile-simulator-claim-killed-mid-boot.md
+++ b/.kilo_workflow/learnings/mobile-simulator-claim-killed-mid-boot.md
@@ -1,10 +1,10 @@
 # mobile: a simulator claim killed mid-boot reclaims as alreadyOwned but leaves the device Shutdown (build then fails code=405)
 
-Symptom: `pnpm dev:mobile:simulator claim` is interrupted (e.g. the invoking shell's own
+Symptom: `.kilo_workflow/e2e-start-resource.sh ios` is interrupted (e.g. the invoking shell's own
 command timeout kills it) after it wrote the claim lock but before the boot finished.
 (A fresh claim boots before it renames, so the `Kilo E2E - <worktree>` label may or may
 not have been applied yet at the moment of the kill.) A later
-`pnpm dev:mobile:simulator claim` returns instantly with `alreadyOwned: true` and does
+`.kilo_workflow/e2e-start-resource.sh ios` returns instantly with `alreadyOwned: true` and does
 **not** boot the device. `pnpm dev:mobile:ios build <udid>` then fails:
 
 ```
@@ -24,6 +24,6 @@ xcrun simctl bootstatus <udid> -b   # wait for readiness
 pnpm dev:mobile:ios build <udid>    # now installs
 ```
 
-Prevention: run `pnpm dev:mobile:simulator claim` with a generous timeout (>= 10 min) —
+Prevention: run `.kilo_workflow/e2e-start-resource.sh ios` with a generous timeout (>= 10 min) —
 booting an iPhone under parallel-workflow load exceeds 3 minutes on this machine, and the
 default 2–3 minute shell timeouts kill the claim at exactly the wrong moment.
diff --git a/.kilo_workflow/pick-reviewers.sh b/.kilo_workflow/pick-reviewers.sh
index 8d8eb995e6..811c6e77c6 100755
--- a/.kilo_workflow/pick-reviewers.sh
+++ b/.kilo_workflow/pick-reviewers.sh
@@ -6,33 +6,37 @@
 #
 #   pick-reviewers.sh <owner/repo> <requesting-handle> <file> [file...]
 #
-# Run from the repository the files live in (uses git log). Prints
-# "<count> <login>" lines, most frequent first — each login counted once per
-# PR it reviewed, bots and the requesting human dropped. No output at all
-# (exit 0) means no history — request nobody and say so in one line in the PR
-# description.
+# Run from the repository the files live in (uses git log); refuses when none
+# of the files exist there. Prints "<count> <login>" lines, most frequent
+# first — each login counted once per PR it reviewed, bots and the requesting
+# human dropped. No output at all (exit 0) means no history — request nobody
+# and say so in one line in the PR description.
 set -euo pipefail
 
 REPO=${1:?owner/repo} HANDLE=${2:?requesting GitHub handle}
 shift 2
 [ $# -gt 0 ] || { echo "usage: pick-reviewers.sh <owner/repo> <handle> <file>..." >&2; exit 1; }
 
+COMMITS=$(for f in "$@"; do git log -10 --format='%H' -- "$f"; done | sort -u)
+# No history at all is legitimate only for brand-new files. When none of the
+# files even exist in this repo, it is a typo or the wrong repo — refuse.
+if [ -z "$COMMITS" ]; then
+  git ls-files -- "$@" | grep -q . ||
+    { echo "pick-reviewers: none of the given files exist in this repo — run in the changed repo" >&2; exit 1; }
+fi
 PRS=$(
-  {
-    for f in "$@"; do
-      git log -10 --format='%H' -- "$f"
-    done | sort -u | while read -r sha; do
-      # Not every commit has a PR (unpushed or direct-pushed) — that is data,
-      # not an error. On failure gh prints the error BODY to stdout, so the
-      # output must be discarded with the failure, not passed through.
-      if out=$(gh api "repos/$REPO/commits/$sha/pulls" --jq '.[].number' 2>/dev/null); then
-        printf '%s\n' "$out"
-      fi
-    done
-    gh pr list --repo "$REPO" --author "$HANDLE" --state merged --limit 10 \
-      --json number --jq '.[].number'
-  } | sort -un
+  for sha in $COMMITS; do
+    # Not every commit has a PR (unpushed or direct-pushed) — successful empty
+    # output is data. Keep this loop out of a pipeline subshell so an API
+    # failure exits the command substitution instead of returning partial data.
+    out=$(gh api "repos/$REPO/commits/$sha/pulls" --jq '.[].number') ||
+      { echo "pick-reviewers: failed to find PRs for commit $sha" >&2; exit 1; }
+    printf '%s\n' "$out"
+  done
+  gh pr list --repo "$REPO" --author "$HANDLE" --state merged --limit 10 \
+    --json number --jq '.[].number'
 )
+PRS=$(printf '%s\n' "$PRS" | sort -un)
 
 [ -n "$PRS" ] || exit 0
 # One vote per login per PR — several review submissions on one PR are still
diff --git a/.kilo_workflow/pr-gate.sh b/.kilo_workflow/pr-gate.sh
index 3d90de7e44..7d40d63af5 100755
--- a/.kilo_workflow/pr-gate.sh
+++ b/.kilo_workflow/pr-gate.sh
@@ -28,6 +28,7 @@ REPO=${1:?owner/repo} PR=${2:?pr number}
 shift 2
 [[ "$REPO" =~ ^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$ ]] || { echo "repository must be owner/repo" >&2; exit 1; }
 ASSIGNEE="" LABEL="" BOT="kilo-code-bot" WAIT=0
+WAIVER="(bot) Kilobot posted no approving summary on this head after two retriggers"
 while [ $# -gt 0 ]; do
   case $1 in
     --assignee) ASSIGNEE=${2:?}; shift 2 ;;
@@ -44,8 +45,10 @@ while :; do
     --json headRefOid,mergeable,mergeStateStatus,statusCheckRollup,assignees,labels,comments)
   HEAD_OID=$(jq -r '.headRefOid' <<<"$DATA")
   HEAD_TIME=$(gh api "repos/$REPO/commits/$HEAD_OID" --jq '.commit.committer.date')
-  BOTCOMMENTS=$(jq -r --arg t "$HEAD_TIME" --arg bot "$BOT" \
-    '[.comments[] | select((.author.login == $bot or (.body | startswith("(bot) "))) and .createdAt > $t)
+  HEAD_EPOCH=$(jq -nr --arg t "$HEAD_TIME" '$t | fromdateiso8601')
+  BOTCOMMENTS=$(jq -r --argjson t "$HEAD_EPOCH" --arg bot "$BOT" --arg waiver "$WAIVER" \
+    '[.comments[] | select((.author.login == $bot or .body == $waiver)
+      and (.createdAt | fromdateiso8601) > $t)
       | "\(.author.login) @ \(.createdAt): \(.body | gsub("\\s+"; " ") | .[0:200])"] | .[]' <<<"$DATA")
   [ -n "$BOTCOMMENTS" ] && break
   [ "$(date +%s)" -ge "$DEADLINE" ] && break
@@ -61,7 +64,15 @@ BAD_CHECKS=$(jq -r '[.statusCheckRollup[]? | select((.conclusion // .state // "P
   | ($c | ascii_upcase) as $u
   | ($u == "SUCCESS" or $u == "NEUTRAL" or $u == "SKIPPED") | not)
   | "\(.name // .context): \(.conclusion // .state // "PENDING")"] | .[]' <<<"$DATA")
-[ -n "$BAD_CHECKS" ] && { echo "checks not green:"; sed 's/^/  /' <<<"$BAD_CHECKS"; } || echo "checks: all green"
+CHECK_COUNT=$(jq -r '(.statusCheckRollup // []) | length' <<<"$DATA")
+if [ "$CHECK_COUNT" -eq 0 ]; then
+  echo "checks: NONE REGISTERED"
+elif [ -n "$BAD_CHECKS" ]; then
+  echo "checks not green:"
+  sed 's/^/  /' <<<"$BAD_CHECKS"
+else
+  echo "checks: all green"
+fi
 
 # Any failure to ENUMERATE threads must fail the gate — a half-paginated
 # thread list reading as "0 unresolved" is exactly the false pass to avoid.
@@ -90,6 +101,7 @@ case $MERGEABLE in
   *) gate_fail "not mergeable ($MERGEABLE — resolve conflicts by merging origin/main)" ;;
 esac
 [ -z "$BAD_CHECKS" ] || gate_fail "CI checks not green on head"
+[ "$CHECK_COUNT" -gt 0 ] || gate_fail "no CI checks registered on head — wait for GitHub to enqueue them"
 [ "$THREADS_OK" -eq 1 ] || gate_fail "could not enumerate review threads — fix that before trusting any thread count"
 [ "$THREADS_OK" -eq 1 ] && [ "$UNRESOLVED" != "0" ] && gate_fail "$UNRESOLVED unresolved review thread(s)"
 if [ -n "$ASSIGNEE" ]; then
diff --git a/.kilo_workflow/pr-threads.sh b/.kilo_workflow/pr-threads.sh
index c702c2301c..22a8d8a1c3 100755
--- a/.kilo_workflow/pr-threads.sh
+++ b/.kilo_workflow/pr-threads.sh
@@ -63,21 +63,34 @@ read_body() {
 # valid REST reply target), and its existing comment bodies (so a retried
 # `close` never posts the same reply twice).
 thread_info() {
-  gh api graphql -f query='query($id:ID!){node(id:$id){
-    ... on PullRequestReviewThread{
-      pullRequest{number}
-      repository{nameWithOwner}
-      comments(first:100){nodes{databaseId body}}}}}' -f id="$1"
+  local id=$1 after="" page repo="" pr="" first="" bodies='[]'
+  while :; do
+    page=$(gh api graphql -f query='query($id:ID!,$after:String){node(id:$id){
+      ... on PullRequestReviewThread{
+        pullRequest{number}
+        repository{nameWithOwner}
+        comments(first:100,after:$after){
+          pageInfo{hasNextPage endCursor}
+          nodes{databaseId body}}}}}' -f id="$id" ${after:+-f after="$after"})
+    [ -n "$repo" ] || repo=$(jq -r '.data.node.repository.nameWithOwner' <<<"$page")
+    [ -n "$pr" ] || pr=$(jq -r '.data.node.pullRequest.number' <<<"$page")
+    [ -n "$first" ] || first=$(jq -r '.data.node.comments.nodes[0].databaseId' <<<"$page")
+    bodies=$(jq -cn --argjson a "$bodies" --argjson b "$(jq '[.data.node.comments.nodes[].body]' <<<"$page")" '$a + $b')
+    [ "$(jq -r '.data.node.comments.pageInfo.hasNextPage' <<<"$page")" = "true" ] || break
+    after=$(jq -r '.data.node.comments.pageInfo.endCursor' <<<"$page")
+  done
+  jq -cn --arg repo "$repo" --argjson pr "$pr" --argjson first "$first" --argjson bodies "$bodies" \
+    '{repo:$repo,pr:$pr,first:$first,bodies:$bodies}'
 }
 
 do_reply() {
   local thread=$1 body=$2 info repo pr comment
   info=$(thread_info "$thread")
-  repo=$(jq -r '.data.node.repository.nameWithOwner' <<<"$info")
+  repo=$(jq -r '.repo' <<<"$info")
   [ "$repo" = "$REPO" ] || { echo "pr-threads: thread $thread belongs to $repo, not $REPO" >&2; exit 1; }
-  pr=$(jq -r '.data.node.pullRequest.number' <<<"$info")
-  comment=$(jq -r '.data.node.comments.nodes[0].databaseId' <<<"$info")
-  if jq -e --arg b "$body" '.data.node.comments.nodes[] | select(.body == $b)' <<<"$info" >/dev/null; then
+  pr=$(jq -r '.pr' <<<"$info")
+  comment=$(jq -r '.first' <<<"$info")
+  if jq -e --arg b "$body" '.bodies[] | select(. == $b)' <<<"$info" >/dev/null; then
     echo "reply already posted; not repeating it"
     return 0
   fi
@@ -85,7 +98,10 @@ do_reply() {
 }
 
 do_resolve() {
-  local thread=$1 resolved
+  local thread=$1 info repo resolved
+  info=$(thread_info "$thread")
+  repo=$(jq -r '.repo' <<<"$info")
+  [ "$repo" = "$REPO" ] || { echo "pr-threads: thread $thread belongs to $repo, not $REPO" >&2; exit 1; }
   resolved=$(gh api graphql \
     -f query='mutation($t:ID!){resolveReviewThread(input:{threadId:$t}){thread{isResolved}}}' \
     -f t="$thread" --jq '.data.resolveReviewThread.thread.isResolved')
diff --git a/.kilo_workflow/slice-diff.sh b/.kilo_workflow/slice-diff.sh
index 53fce5887a..f088b07102 100755
--- a/.kilo_workflow/slice-diff.sh
+++ b/.kilo_workflow/slice-diff.sh
@@ -66,4 +66,8 @@ if [ "$MODE" = "reviewer" ] && [ "$NOWLINE" != "$EXPECT" ]; then
   echo "VIOLATION: the reviewer modified the owned paths (working-tree bytes changed) — the round is void"
   exit 1
 fi
+if [ "$MODE" = "implementer" ] && [ "$NOWLINE" = "$EXPECT" ]; then
+  echo "VIOLATION: the implementer reported completion without changing the owned paths — the round is void"
+  exit 1
+fi
 echo "OK"
diff --git a/AGENTS.md b/AGENTS.md
index 8018f88cf7..ade2e3b498 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -43,7 +43,7 @@ data-contract caveats, even when changed code is outside `packages/db`.
 | `pnpm format` | Format supported files |
 | `pnpm typecheck` | Run repository TypeScript checks |
 | `pnpm lint` | Run repository lint checks |
-| `pnpm test` | Run root test script; currently web and web-env tests, not every package suite |
+| `pnpm test` | Run web, web-env, and local development-tool tests; not every package suite |
 | `pnpm validate` | Run root typecheck, lint, and test scripts |
 
 Package-level scripts are in the relevant `package.json`. Read root and relevant
@@ -63,7 +63,7 @@ package manifests before running repository JavaScript or package scripts. Load
 | Service, Durable Object, or Worker code | `services/AGENTS.md`, nearest owning service's `AGENTS.md`, and relevant Durable Objects or Workers skills |
 | Domain language and ownership | `CONTEXT.md`, when its scope applies |
 | Business requirements | Relevant `.specs/*.md`, indexed by `specs` skill |
-| UI and product design | `DESIGN.md`, relevant app `AGENTS.md`, and `kilo-design` skill |
+| UI and product design | Relevant app `AGENTS.md`; for `apps/web`, the `kilo-design-cloud` skill synced from `Kilo-Org/kilo-design` |
 | Contribution and PR workflow | `CONTRIBUTING.md` and relevant Git or PR skill |
 
 ## Security Baseline
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index f66f5d7c2f..239680c020 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -102,7 +102,8 @@ pnpm dev:stop
 pnpm test
 ```
 
-This runs the web tests and web environment tests. They should pass against the local PostgreSQL database.
+This runs the web, web environment, and local development-tool tests. They
+should pass against the local PostgreSQL database.
 
 ## Repo Layout
 
@@ -143,7 +144,7 @@ The repo includes a seed runner for creating local fixtures via `pnpm dev:seed`.
 | `pnpm dev:restart` | Restart a running service |
 | `pnpm dev:env` | Sync `.dev.vars` files from `.env.local` |
 | `pnpm web:env set <VARIABLE>` | Add or rotate shared web env vars across dotenv defaults, Vercel, and 1Password |
-| `pnpm test` | Run web tests and web environment tests |
+| `pnpm test` | Run web, web environment, and local development-tool tests |
 | `pnpm test:e2e` | Run Playwright end-to-end tests |
 | `pnpm typecheck` | Run TypeScript type checking |
 | `pnpm lint` | Lint all source files |
diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md
index 08401ff1ec..93d6816df7 100644
--- a/DEVELOPMENT.md
+++ b/DEVELOPMENT.md
@@ -232,7 +232,8 @@ Run the root test script to confirm everything is working:
 pnpm test
 ```
 
-This runs the web tests and web environment tests. They should pass against the local PostgreSQL database.
+This runs the web, web environment, and local development-tool tests. They
+should pass against the local PostgreSQL database.
 
 ## Common Development Commands
 
@@ -241,7 +242,7 @@ This runs the web tests and web environment tests. They should pass against the
 | `KILO_PORT_OFFSET=auto pnpm dev:start` | Start all local services in a tmux dashboard with worktree-safe ports |
 | `pnpm dev:stop` | Stop the tmux session and all services |
 | `pnpm dev:env` | Sync `.dev.vars` files from `.env.local` (see [Worker `.dev.vars` setup](#worker-dev-vars-setup)) |
-| `pnpm test` | Run web tests and web environment tests |
+| `pnpm test` | Run web, web environment, and local development-tool tests |
 | `pnpm typecheck` | Run the TypeScript type checker |
 | `pnpm lint` | Lint all source files |
 | `pnpm format` | Format all supported files with oxfmt |
diff --git a/apps/mobile/e2e/AGENTS.md b/apps/mobile/e2e/AGENTS.md
index 9175b5c57c..6c7f3307bb 100644
--- a/apps/mobile/e2e/AGENTS.md
+++ b/apps/mobile/e2e/AGENTS.md
@@ -2,22 +2,29 @@
 
 Interactive verification against a local backend. Run commands from the repository root unless a step says otherwise. Long-lived services live in a worktree-specific tmux session owned by the repository dev runner; use it, never loose background processes.
 
-## Device Slot: Required First Step
+## E2E Bundle: Required First Step
 
-This machine is shared by parallel workflows. Before starting a stack, booting a simulator or emulator, or running a native build — on every run, whether or not you can see another workflow active — acquire a slot:
+This machine is shared by parallel workflows. One slot permits one round's
+complete bundle: one dev stack, up to one iOS simulator, up to one Android
+emulator, plus its remote CLIs and other resources. It is not one slot per
+resource or platform verifier.
+
+The planner owns a repro bundle; the orchestrator owns later verification
+bundles. Before dispatching verifiers, that owner runs:
 
 ```bash
-.kilo_workflow/e2e-slot.sh acquire   # run from your own tmux session — it resolves the name itself; blocks until a slot frees
-.kilo_workflow/e2e-slot.sh status    # current holders
-.kilo_workflow/e2e-slot.sh release   # the moment the device phase ends
-.kilo_workflow/e2e-slot.sh stacks    # any stack running with no slot
+.kilo_workflow/e2e-take-slot.sh      # run from your own tmux session; blocks until a slot frees
+.kilo_workflow/e2e-slot-status.sh    # live holders; stale slots and unaccounted resources
 ```
 
-A slot, this worktree's dev stack, and the simulators it claims are one resource: the slot is what entitles you to all three, and `release` takes all three back — it stops the stack and releases every simulator this worktree claimed, powering off the ones your claims booted. Release when your device phase is genuinely over, not partway through a round you still need services or a device for.
+The owner starts every bundle resource through `e2e-start-resource.sh`, passes
+the ready services and device identifiers in each verifier handoff, then stops
+every resource through `e2e-stop-resource.sh` before freeing the slot. Parallel
+iOS and Android verifiers share this bundle and never take another slot.
 
 - Default 3 slots, machine-global, owned by tmux session name; a dead session's slot is reclaimed automatically, so a crash cannot wedge the queue.
-- `acquire` blocking is correct behavior, not a hang and not a wedge. Wait for it. Never start device work unslotted because the queue was busy, because your phase looks small, or because a stack is already up.
-- Acquiring is idempotent per session; every device phase (repro gate, each E2E round) needs a slot.
+- A blocked take is correct behavior, not a hang and not a wedge. Wait for it.
+- Taking is idempotent per session; every E2E round needs one bundle slot.
 - Release as soon as the device phase ends. Planning, implementation, review, checks, and CI waits are uncapped — never hold a slot through them.
 
 ## Fresh Worktree Quickstart
@@ -29,7 +36,7 @@ node --version   # must be v24; activate the root .nvmrc first if needed
 pnpm dev:worktree:prepare
 ```
 
-Record pre-existing state so you later clean up only resources you created:
+Record pre-existing state so you later clean up only resources you own:
 
 ```bash
 pnpm dev:status --json
@@ -37,20 +44,23 @@ tmux ls
 xcrun simctl list devices booted
 ```
 
-If a complete stack is already running for this worktree, reuse it. Never start a competing stack or stop an unrelated `kilo-dev-*` session.
+Reuse an existing stack only when it belongs to the current live slot bundle.
+Otherwise it is unaccounted: stop it through `e2e-stop-resource.sh stack`, then
+take a slot and start fresh. Never stop an unrelated `kilo-dev-*` session.
 
-If this worktree has no stack, start the complete mobile flow — after acquiring a device slot (see above):
+If this worktree has no stack, the bundle owner starts the complete mobile flow
+after taking its slot:
 
 ```bash
 pnpm dev:env -y cloudflare-session-ingest
-pnpm dev:start --no-attach mobile cloud-agent-next kiloclaw event-service
+.kilo_workflow/e2e-start-resource.sh stack mobile cloud-agent-next kiloclaw event-service
 pnpm drizzle migrate
 pnpm dev:status --json
 ```
 
 Rules:
 
-- Do not export `KILO_PORT_OFFSET` or source `apps/mobile/.env`; stale shell values select the wrong bundle endpoints. Secondary worktrees get an isolated port offset automatically, and startup injects this worktree's LAN URLs before Metro starts. When the automatic offset lands on occupied ports (AirPlay on 5000/7000, another worktree's stack), `dev:start` probes for a free offset itself and persists it in the manifest; later `dev:restart`/`dev:env` reuse the persisted value, so no manual prefix is needed. A per-command `KILO_PORT_OFFSET=<n>` prefix still overrides everything when you must pin one — never `export` it.
+- Do not export `KILO_PORT_OFFSET` or source `apps/mobile/.env`; stale shell values select the wrong bundle endpoints. Secondary worktrees get an isolated port offset automatically, and startup injects this worktree's LAN URLs before Metro starts. When the automatic offset lands on occupied ports (AirPlay on 5000/7000, another worktree's stack), `dev:start` probes for a free offset itself and persists it before services launch; later `dev:restart`/`dev:env` reuse the persisted value, so no manual prefix is needed. A per-command `KILO_PORT_OFFSET=<n>` prefix still overrides everything when you must pin one — never `export` it.
 - The `dev:env` step creates the JWT Secrets Store binding. Without it, session-ingest looks healthy but rejects every session request.
 - Secrets Store state is local to each Worker directory. `dev:start` refreshes every source-backed secret for its service graph before launching Workers; a secret-creation failure is fatal, not something to retry past.
 - `event-service` is required for presence and notification behavior.
@@ -93,14 +103,16 @@ Pinned surface only: REST pull/repo/check-runs/statuses/`pulls/{n}/files` (pagin
 
 ## iOS Simulator
 
-Never share a simulator with another worktree. Claim one before any build, install, login, Maestro, or MCP action; the claim command prefers an unclaimed shutdown iPhone and boots it:
+The bundle owner claims and builds before dispatch. Never share a simulator
+with another worktree; the claim command prefers an unclaimed shutdown iPhone
+and boots it:
 
 ```bash
-pnpm dev:mobile:simulator claim [udid]   # idempotent per worktree
-pnpm dev:mobile:simulator release-all    # this worktree's claims; the slot release runs it for you
+.kilo_workflow/e2e-start-resource.sh ios [udid]  # idempotent per worktree
+.kilo_workflow/e2e-stop-resource.sh ios          # this worktree's claims
 ```
 
-The wrapper renames the claimed device to `Kilo E2E - <sanitized-worktree-basename>` and restores the original name on release. Never call `xcrun simctl rename` yourself. The claim also records whether it was the thing that booted the device, which is what lets release power off only the devices it started — so never boot or shut down an E2E simulator with `xcrun simctl` behind the wrapper's back. A claim is stale — and silently reclaimable — once its owning worktree is deleted. Releasing the slot releases the claims, so an explicit `release-all` is only for handing a device back mid-slot.
+The wrapper renames the claimed device to `Kilo E2E - <sanitized-worktree-basename>` and restores the original name on release. Never call `xcrun simctl rename` yourself. The claim also records whether it was the thing that booted the device, which is what lets release power off only the devices it started — so never boot or shut down an E2E simulator with `xcrun simctl` behind the wrapper's back. A claim is stale — and silently reclaimable — once its owning worktree is deleted.
 
 Install a validated cached native build. A compatible fingerprint skips rebuilding; a cache miss serializes through the host-wide native compiler semaphore. Never install an arbitrary DerivedData app or run a separate Expo native build:
 
@@ -125,11 +137,11 @@ xcrun simctl openurl <udid> \
 Backend and Metro must be running. These idempotent wrappers verify simulator ownership, required services, the generated API port, and Metro project provenance, then reconnect the dev client to this worktree's exact Metro URL before Maestro runs. Never bypass their preflight or call the login YAML flows directly:
 
 ```bash
-apps/mobile/e2e/login.sh <udid> [email]   # default: e2e-mobile-<worktree-basename>@example.com
+apps/mobile/e2e/login.sh <udid> [email]   # default: e2e-mobile-<worktree>-<ios|android>@example.com
 apps/mobile/e2e/logout.sh <udid>
 ```
 
-The default email is `e2e-mobile-<worktree-basename>@example.com`, derived deterministically from the worktree directory name. Hyphens are preserved by `normalizeEmail`, so each worktree signs into a distinct backend user. Pass an explicit email only when a test needs a specific account.
+The default email is `e2e-mobile-<worktree-basename>-<ios|android>@example.com`, derived from the worktree and device serial. Parallel platform shards therefore use separate backend users. Pass an explicit email only when a test needs a specific account.
 
 Login requests an email OTP, waits up to 30 seconds for the worktree-local outbox, verifies the code, accepts first-account consent, and asserts Home. If the request half fails it cold-relaunches through `flows/open-app.yaml` and retries once — that clears both a half-started dev client and an email field left dirty by an earlier run — and if the retry fails too it says which half broke: no outbox email means the app never reached `POST /api/auth/native/otp`, a new outbox email means the request worked and only the code screen was never reached. `flows/settle-app.yaml` handles late tracking and Expo developer-menu prompts without restarting the app; `flows/open-app.yaml` is the standalone cold-launch flow.
 
@@ -168,12 +180,12 @@ pnpm dev:seed app:api-token <email>              # mint a bearer token (used by
 
 ## Maestro
 
-One-time machine setup: `brew install maestro`. For MCP, use stdio command `maestro mcp`, then restart the agent session so its tools appear.
+One-time machine setup: `brew install maestro`. Workflow verification never uses Maestro Model Context Protocol (MCP) tools because they bypass the device lock; use the repository wrapper below.
 
-- Maestro is the primary automation driver on both iOS and Android. Fall back to `xcrun simctl` (iOS) or repository-wrapped ADB (Android) only when Maestro cannot inspect or operate a native state, or when low-level device control is required. Setup still uses `simctl`/ADB for boot, install, dev-client URL reconnection, screenshots, shutdown, and cleanup.
+- Maestro is the primary automation driver on both iOS and Android. Fall back to `xcrun simctl` (iOS) or repository-wrapped ADB (Android) only when Maestro cannot inspect or operate a native state, or when low-level device control is required. Setup still uses `simctl`/ADB for boot, install, dev-client URL reconnection, and screenshots; the repository wrappers own shutdown and cleanup.
 - With more than one simulator booted (parallel worktrees), always target by UDID and go through `e2e/maestro.sh <udid> ...` — it serializes per device (the driver is single-tenant) and without an explicit device Maestro picks an arbitrary booted simulator, so taps silently land on another worktree’s device. The Maestro MCP tools mis-target the same way; prefer the CLI plus `simctl` screenshots when several simulators are up.
 - Inspect the screen before selecting elements; re-inspect after UI changes.
-- Never guess a selector from a visible label or screenshot. Copy the exact `txt` or `a11y` value from `maestro_inspect_screen` (`a11y` maps to Maestro `text:`). Maestro text matching is full-string regex, not substring.
+- Never guess a selector from a visible label or screenshot. Copy the exact text or accessibility value from `e2e/maestro.sh <udid> hierarchy`. Maestro text matching is full-string regex, not substring.
 - Tab buttons expose React Navigation's full accessibility labels, not the visible uppercase text. Current iOS labels: `Home, tab, 1 of 4`, `KiloClaw, tab, 2 of 4`, `Agents, tab, 3 of 4`, `Profile, tab, 4 of 4`. `tapOn: 'Agents'` is wrong. Inspect again before relying on these examples; the count and labels can change.
 
 CLI fallback — always through `e2e/maestro.sh`, which serializes per device (Maestro's per-device driver is single-tenant; two concurrent sessions against one UDID interleave taps and fail flows in ways that read as product defects):
@@ -181,7 +193,7 @@ CLI fallback — always through `e2e/maestro.sh`, which serializes per device (M
 ```bash
 apps/mobile/e2e/maestro.sh <udid|emulator-5554> test -e KEY=VALUE <flow.yaml>
 xcrun simctl io <udid> screenshot <path>      # iOS
-adb exec-out screencap -p > <path>            # Android
+pnpm dev:mobile:android adb -s <serial> exec-out screencap -p > <path>  # Android
 ```
 
 Attach a screenshot of a changed flow to the PR when it helps review. For transitions, prefer a short screenshot loop over `simctl io recordVideo`, which can produce one-frame recordings.
@@ -193,10 +205,10 @@ Use this only when testing session discovery, mirroring, or mobile-to-CLI messag
 The orchestrator starts a local CLI as a remote session for this worktree:
 
 ```bash
-apps/mobile/e2e/remote-cli.sh start [email]
+apps/mobile/e2e/remote-cli.sh start <email>
 ```
 
-The helper resolves this worktree's stack ports, mints a token for the given user (default: the per-worktree login account, `e2e-mobile-<worktree-slug>@example.com`), installs the CLI into a disposable per-worktree directory, and launches it in a `kilo-e2e-cli-<worktree-slug>` tmux session already pointed at the local API, session-ingest, and event-service. Pass the account the app is signed in as when it differs from the default. Manage it with `remote-cli.sh status` and `remote-cli.sh stop`.
+The helper resolves this worktree's stack ports, mints a token for the given user, installs the CLI into a disposable per-worktree directory, and launches it in a `kilo-e2e-cli-<worktree-slug>` tmux session already pointed at the local API, session-ingest, and event-service. The email is required — pass the account the app is signed in as (`login.sh`'s default is `e2e-mobile-<worktree-slug>-<ios|android>@example.com`). Manage it with `remote-cli.sh status` and `remote-cli.sh stop`.
 
 Run any one-off CLI command against the same prepared stack with `exec` instead of the interactive TUI:
 
@@ -214,7 +226,7 @@ CLI_SESSION="kilo-e2e-cli-$(basename "$PWD")"
 tmux capture-pane -p -t "$CLI_SESSION" -S -100
 ```
 
-Drive the session with `tmux send-keys`; slash commands need one Enter for autocomplete and another to submit. Type a prompt to create a session; the mobile list updates after the CLI WebSocket connects and its first heartbeat (about 12 seconds). If no session is prepared for this worktree, stop and ask the orchestrator to run `remote-cli.sh start`.
+Drive the session with `tmux send-keys`; slash commands need one Enter for autocomplete and another to submit. Type a prompt to create a session; the mobile list updates after the CLI WebSocket connects and its first heartbeat (about 12 seconds). If no session is prepared for this worktree, stop and ask the orchestrator to run `remote-cli.sh start <email>`.
 
 ## Android Emulator
 
@@ -224,39 +236,38 @@ Do not conclude Android is unavailable from `command -v adb` or the inherited `P
 pnpm dev:mobile:android doctor
 ```
 
-Use the wrappers for all Android tooling, including the Expo/Gradle build, so the resolved SDK/JDK environment is applied. Ordered glue: acquire e2e slot → launch emulator → `claim` at first adb visibility → bounded boot wait → `build` → `login.sh`. Claim the moment the serial is visible, before waiting for boot — adb serials are host-global, and a concurrent worktree's polling loop can claim your fresh emulator during the boot wait (a lost race means: never drive that device, never kill it, boot another port). Never unbounded `adb wait-for-device`. Never put manual `adb reverse` or dev-client `am start` on the primary path — `login.sh` preflight does both.
+The bundle owner uses the wrappers for emulator lifecycle and the Expo/Gradle
+build before dispatch: take slot → `emulator-start` → claim its exact serial at
+first ADB visibility → bounded boot wait → `build`. The verifier starts with
+`login.sh`. Never use unbounded `adb wait-for-device`, manual `adb reverse`, or
+dev-client `am start`; `login.sh` preflight handles the last two.
 
 ### Launch and GPU policy
 
-Two launch attempts total, then a test-environment blocker with the tail of `$EMULATOR_LOG`. Attempt 1 uses `-gpu host` (Mac GPU; fastest; software rendering competes for the CPU under parallel-workflow load). Keep `-no-snapshot-save -no-boot-anim` on every launch. Attempt 2 switches GPU only on an observed process-death signal (`pgrep -f "qemu.*<avd-name>"` empty, or the log shows the emulator exiting/erroring — the pane mirrors it live but dies with the session) → `-gpu swiftshader_indirect`. If the process is still alive but the boot envelope expired → repeat `-gpu host`. Never a third launch.
+Two launch attempts total, then a test-environment blocker with the recorded log tail. Attempt 1 uses the Mac GPU. Attempt 2 switches to software rendering only when the recorded PID died; a live process that missed the boot envelope retries the Mac GPU. `emulator-start` atomically allocates the console port, creates the worktree session, and records its exact PID/session; never launch with raw `tmux`, `emulator`, or a hand-picked port.
 
 ```bash
-# After e2e-slot acquire (see Device Slot: Required First Step)
-ANDROID_SESSION="kilo-e2e-android-$(basename "$PWD")"
-EMULATOR_LOG="/tmp/${ANDROID_SESSION}.log"
-GPU_FLAG=host   # attempt 2: swiftshader_indirect only after process death; else host again
-# Explicit free even console port, so YOUR emulator's serial is known up front
-# (emulator-$PORT) and a parallel worktree's launch can never be confused with it.
-PORT=5554; while lsof -nP -iTCP:"$PORT" -sTCP:LISTEN >/dev/null 2>&1; do PORT=$((PORT + 2)); done
-tmux new-session -d -s "$ANDROID_SESSION" -c "$PWD" \
-  "pnpm dev:mobile:android emulator -avd <avd-name> -port $PORT -no-snapshot-save -no-boot-anim -gpu $GPU_FLAG 2>&1 | tee \"$EMULATOR_LOG\""
+EMULATOR=$(.kilo_workflow/e2e-start-resource.sh android <avd-name> --gpu host)
+SERIAL=$(jq -r .serial <<<"$EMULATOR")
+EMULATOR_PID=$(jq -r .pid <<<"$EMULATOR")
+EMULATOR_LOG=$(jq -r .log <<<"$EMULATOR")
 ```
 
-Emulators always launch inside `$ANDROID_SESSION` — the session name is the boot provenance `e2e-slot.sh release` uses to power off exactly the emulators this worktree started. Record `$PORT` in the round handoff so the next round reuses the same serial. Never drive or kill a device claimed by another worktree, and never delete a foreign claim file — if your serial is taken, pick the next free port instead.
+Record `SERIAL`, `EMULATOR_PID`, and `EMULATOR_LOG` in the round handoff. Never drive or kill a device claimed by another worktree, and never delete a foreign claim file.
 
 ### Bounded boot wait
 
 From the moment of launch, poll about every 15 s until the envelope expires. Cold boot on an idle host ≈ 1–3 minutes; under parallel-workflow load allow up to 8 minutes before declaring the attempt failed (relaunch-rule bounds, not SLAs). Each poll, check in order:
 
-1. **Liveness** — `pgrep -f "qemu.*<avd-name>"` still prints a PID. If empty, the attempt failed with the process-death signal.
-2. **Visibility** — `emulator-$PORT` appears with state `device` in `pnpm dev:mobile:android adb devices -l` (poll for YOUR serial, never "the first emulator"). Claim it immediately: `pnpm dev:mobile:android claim emulator-$PORT` — do not wait for readiness first; adb serials are host-global and a concurrent worktree's polling loop can otherwise claim your fresh emulator during the boot wait.
-3. **Readiness** — once visible, `pnpm dev:mobile:android adb -s <serial> shell getprop sys.boot_completed` prints `1`.
+1. **Liveness** — `kill -0 "$EMULATOR_PID"` succeeds. If not, the attempt died.
+2. **Visibility** — `$SERIAL` appears with state `device` in `pnpm dev:mobile:android adb devices -l`. Claim it immediately: `pnpm dev:mobile:android claim "$SERIAL"`.
+3. **Readiness** — once visible, `pnpm dev:mobile:android adb -s "$SERIAL" shell getprop sys.boot_completed` prints `1`.
 
 Device visibility is not readiness. Never gate on `adb devices` output alone, and never wait on any one stage without the liveness check.
 
-### Failed attempt → kill hard → relaunch once
+### Failed attempt → stop exactly yours → relaunch once
 
-On failure: `tmux kill-session -t "$ANDROID_SESSION" 2>/dev/null` (session may already be gone if the emulator exited), then confirm the emulator process is actually gone — `pgrep -f "qemu.*<avd-name>"` prints nothing. If it survives: with a known serial, `pnpm dev:mobile:android adb -s <serial> emu kill`; with no serial yet (process died or never became visible to adb), `pkill -f "qemu.*<avd-name>"`. Re-check `pgrep` either way — a surviving emulator holds the AVD lock and dooms any relaunch. Then relaunch once per the GPU policy with the same envelope. If the second attempt also fails to boot, stop and return a test-environment blocker with the tail of `$EMULATOR_LOG` (survives session death; never a third launch, never an early give-up).
+On failure run `.kilo_workflow/e2e-stop-resource.sh android`; it uses the recorded session and verifies the recorded PID before sending a signal, so it cannot kill a sibling's same-AVD emulator. Relaunch once per the GPU policy with the same envelope. If the second attempt also fails, stop and return a test-environment blocker with `tail -200 "$EMULATOR_LOG"`; never a third launch.
 
 ### Build and login
 
@@ -311,17 +322,28 @@ pnpm dev:mobile:android adb -s <serial> shell input keyevent KEYCODE_BACK
 
 ## Cleanup
 
-Clean up only resources you started. The remote CLI session and its disposable install belong to the orchestrator; never kill `kilo-e2e-cli-*` sessions or remove CLI scratch directories you did not create.
+Each verifier removes only its own temporary files:
+
+```bash
+rm -f "$LOGIN_LOG"
+```
+
+After all verifiers return, the bundle owner stops everything it started, then
+frees the slot:
 
 ```bash
-rm -f "$LOGIN_LOG"                           # if created
-rm -f "$EMULATOR_LOG"                        # if created
-.kilo_workflow/e2e-slot.sh release           # always, as soon as the device phase ends
+.kilo_workflow/e2e-stop-resource.sh android
+.kilo_workflow/e2e-stop-resource.sh ios
+.kilo_workflow/e2e-stop-resource.sh stack
+.kilo_workflow/e2e-free-slot.sh
+rm -f "$EMULATOR_LOG"
 ```
 
-The slot release is the teardown. It stops this worktree's dev stack, releases every simulator this worktree claimed (powering off the ones the claims booted, restoring their names, leaving a device that was already running before the claim alone), drops this worktree's Android claims, and kills this worktree's `kilo-e2e-android-*` emulator session. So there is no `pnpm dev:stop`, no `xcrun simctl shutdown`, no per-device `release`, and no emulator-session kill on this list: releasing the slot does all of it, and forgetting one is how devices used to stay running all day. Never call `xcrun simctl shutdown` on an E2E device yourself — the claim, not your memory of what you booted, is what knows whether the device is yours to power off.
+The wrappers release only this worktree's claims and power off only devices
+they started. Never call `xcrun simctl shutdown` or kill an emulator session
+yourself.
 
-Also stop recorders, log followers, and emulator processes you created. Never use `tmux kill-server`, kill an unrelated `kilo-dev-*` session, or use `pnpm dev:stop --force` while sibling worktrees are active.
+Also stop recorders and log followers you created. Never use `tmux kill-server`, kill an unrelated `kilo-dev-*` session, or use `pnpm dev:stop --force` while sibling worktrees are active.
 
 Verify cleanup, and confirm no generated E2E fixtures remain tracked or untracked:
 
diff --git a/apps/mobile/e2e/flows/login-request-code.yaml b/apps/mobile/e2e/flows/login-request-code.yaml
index 194ba138f7..4e9f4b2f5e 100644
--- a/apps/mobile/e2e/flows/login-request-code.yaml
+++ b/apps/mobile/e2e/flows/login-request-code.yaml
@@ -4,7 +4,7 @@
 # code" screen. The 6-digit code is emailed to the local outbox
 # (dev/logs/emails/); read it there and pass it to login-verify-code.yaml.
 #
-#   maestro --device <udid> test -e EMAIL=e2e-mobile@example.com \
+#   apps/mobile/e2e/maestro.sh <udid> test -e EMAIL=e2e-mobile@example.com \
 #     e2e/flows/login-request-code.yaml
 #
 # EMAIL is required (-e). Do NOT add it as a flow-level `env:` default — a
diff --git a/apps/mobile/e2e/flows/login-verify-code.yaml b/apps/mobile/e2e/flows/login-verify-code.yaml
index db62612a9f..1b26491855 100644
--- a/apps/mobile/e2e/flows/login-verify-code.yaml
+++ b/apps/mobile/e2e/flows/login-verify-code.yaml
@@ -3,7 +3,7 @@
 # Enters OTP on the "Enter the code" screen and lands on Home. Assumes
 # login-request-code.yaml already reached that screen.
 #
-#   maestro --device <udid> test -e OTP=123456 e2e/flows/login-verify-code.yaml
+#   apps/mobile/e2e/maestro.sh <udid> test -e OTP=123456 e2e/flows/login-verify-code.yaml
 #
 # Prefer the one-shot wrapper e2e/login.sh. See e2e/AGENTS.md.
 appId: com.kilocode.kiloapp
diff --git a/apps/mobile/e2e/flows/logout.yaml b/apps/mobile/e2e/flows/logout.yaml
index 49ca2d23c5..1291e4dc85 100644
--- a/apps/mobile/e2e/flows/logout.yaml
+++ b/apps/mobile/e2e/flows/logout.yaml
@@ -2,7 +2,7 @@
 #
 # Idempotent: if the app is already signed out, it just lands on the login page.
 #
-#   maestro --device <udid> test e2e/flows/logout.yaml
+#   apps/mobile/e2e/maestro.sh <udid> test e2e/flows/logout.yaml
 #
 # See e2e/AGENTS.md for the full workflow.
 appId: com.kilocode.kiloapp
diff --git a/apps/mobile/e2e/login.sh b/apps/mobile/e2e/login.sh
index 5c0dd0f536..dea66e2095 100755
--- a/apps/mobile/e2e/login.sh
+++ b/apps/mobile/e2e/login.sh
@@ -8,10 +8,9 @@
 # Usage:
 #   e2e/login.sh <device-udid> [email]
 #
-# When no email is given, defaults to a per-worktree-unique address
-# (e2e-mobile-<worktree-basename>@example.com) so concurrent worktrees never
-# share a backend user. It is stable within a worktree, so repeat logins reuse
-# the same seeded account.
+# When no email is given, defaults to a per-worktree, per-platform address
+# (e2e-mobile-<worktree-basename>-<ios|android>@example.com), so parallel
+# platform shards and concurrent worktrees never share a backend user.
 #
 # Env overrides:
 #   OUTBOX   outbox dir (default: <repo-root>/dev/logs/emails)
@@ -26,9 +25,15 @@ REPO_ROOT="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel)"
 OUTBOX="${OUTBOX:-$REPO_ROOT/dev/logs/emails}"
 
 WORKTREE_SLUG="$(basename "$REPO_ROOT" | tr -cs 'a-zA-Z0-9' '-' | sed 's/^-*//;s/-*$//' | tr 'A-Z' 'a-z')"
-EMAIL="${2:-e2e-mobile-${WORKTREE_SLUG}@example.com}"
+case "$DEVICE" in
+  emulator-*) PLATFORM=android ;;
+  *) PLATFORM=ios ;;
+esac
+EMAIL="${2:-e2e-mobile-${WORKTREE_SLUG}-${PLATFORM}@example.com}"
 
-"$SCRIPT_DIR/preflight.sh" "$DEVICE"
+if [ "${KILO_MAESTRO_LOCKED:-}" != "1" ]; then
+  exec "$SCRIPT_DIR/maestro.sh" "$DEVICE" --exec "$0" "$@"
+fi
 
 # Newest sign-in-code email for EMAIL, or empty.
 latest_email() {
@@ -47,28 +52,23 @@ latest_email() {
 
 # Two parallel logins with the same email invalidate each other's OTP: a
 # second code request voids the first code, so the first verify 401s. Hold a
-# per-worktree+email mutex from the outbox snapshot through code verification
-# (device prep above stays parallel). Same mkdir-lock pattern as maestro.sh;
-# a dead holder's lock is reclaimed, a live one is polled every 2s.
-LOCK="${TMPDIR:-/tmp}/kilo-otp-locks/${WORKTREE_SLUG}-${EMAIL}"
-mkdir -p "$(dirname "$LOCK")"
-while ! mkdir "$LOCK" 2>/dev/null; do
-  holder="$(cat "$LOCK/pid" 2>/dev/null || true)"
-  if [ -n "$holder" ] && ! kill -0 "$holder" 2>/dev/null; then
-    mv "$LOCK" "$LOCK.stale.$$" 2>/dev/null && rm -rf "$LOCK.stale.$$"
-    continue
-  fi
-  sleep 2
-done
-trap 'rm -rf "$LOCK"' EXIT
-echo $$ >"$LOCK/pid"
+# email mutex from the outbox snapshot through code verification. OTP
+# invalidation is keyed by normalized email, not worktree.
+EMAIL_KEY=$(printf '%s' "$EMAIL" | tr '[:upper:]' '[:lower:]' | shasum -a 256 | cut -d' ' -f1)
+LOCK="${TMPDIR:-/tmp}/kilo-otp-locks/$EMAIL_KEY"
+if [ "${KILO_OTP_LOCKED:-}" != "1" ]; then
+  exec "$REPO_ROOT/node_modules/.bin/tsx" "$REPO_ROOT/dev/local/process-lock.ts" \
+    --wait 1200 "$LOCK" -- env KILO_MAESTRO_LOCKED=1 KILO_OTP_LOCKED=1 "$0" "$@"
+fi
+
+"$SCRIPT_DIR/preflight.sh" "$DEVICE"
 
 # Snapshot inside the lock: an email another login produced while we waited
 # must count as "old", or we would read its already-consumed code.
 before="$(latest_email)"
 
 request_code() {
-  maestro --device "$DEVICE" test -e "EMAIL=$EMAIL" "$SCRIPT_DIR/flows/login-request-code.yaml"
+  "$SCRIPT_DIR/maestro.sh" "$DEVICE" test -e "EMAIL=$EMAIL" "$SCRIPT_DIR/flows/login-request-code.yaml"
 }
 
 # Say which half broke, so nobody reads Maestro's generic "could be a real
@@ -89,7 +89,7 @@ if ! request_code; then
   # One cold relaunch clears both known first-attempt failures: a half-started
   # dev client, and an email field left dirty by an earlier run.
   echo "==> retrying launch and sign-in request once after a cold relaunch"
-  maestro --device "$DEVICE" test "$SCRIPT_DIR/flows/open-app.yaml" || true
+  "$SCRIPT_DIR/maestro.sh" "$DEVICE" test "$SCRIPT_DIR/flows/open-app.yaml" || true
   request_code || { diagnose_request; exit 1; }
 fi
 
@@ -110,5 +110,5 @@ if [ -z "$code" ]; then
 fi
 
 echo "==> verifying sign-in code"
-maestro --device "$DEVICE" test -e "OTP=$code" "$SCRIPT_DIR/flows/login-verify-code.yaml"
+"$SCRIPT_DIR/maestro.sh" "$DEVICE" test -e "OTP=$code" "$SCRIPT_DIR/flows/login-verify-code.yaml"
 echo "==> signed in"
diff --git a/apps/mobile/e2e/logout.sh b/apps/mobile/e2e/logout.sh
index 5d81a971bd..74097974a7 100755
--- a/apps/mobile/e2e/logout.sh
+++ b/apps/mobile/e2e/logout.sh
@@ -11,5 +11,8 @@ set -euo pipefail
 DEVICE="${1:?usage: logout.sh <device-udid>}"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
+if [ "${KILO_MAESTRO_LOCKED:-}" != "1" ]; then
+  exec "$SCRIPT_DIR/maestro.sh" "$DEVICE" --exec "$0" "$@"
+fi
 "$SCRIPT_DIR/preflight.sh" "$DEVICE"
-maestro --device "$DEVICE" test "$SCRIPT_DIR/flows/logout.yaml"
+"$SCRIPT_DIR/maestro.sh" "$DEVICE" test "$SCRIPT_DIR/flows/logout.yaml"
diff --git a/apps/mobile/e2e/maestro.sh b/apps/mobile/e2e/maestro.sh
index 235bdea01a..1ef5cdde2e 100755
--- a/apps/mobile/e2e/maestro.sh
+++ b/apps/mobile/e2e/maestro.sh
@@ -1,41 +1,44 @@
 #!/usr/bin/env bash
-# Serializes Maestro invocations per device. Maestro's device driver
-# (XCUITest on iOS, uiautomator on Android) is single-tenant: two concurrent
-# `maestro test`/`maestro hierarchy` processes against the same UDID/serial
-# interleave taps and captures, and flows fail in ways that look like product
-# defects. This wrapper takes a per-device mutex, then execs maestro.
-#
-# Usage: maestro.sh <device> <maestro-args...>
-#   e.g. maestro.sh <udid> test -e EMAIL=x flows/login-request-code.yaml
-#
-# Lock: atomic mkdir under ${TMPDIR:-/tmp}/kilo-maestro-locks/<device>, holder
-# PID recorded inside, released by the EXIT trap when maestro ends. A held
-# lock with a live holder is polled every 2s; a dead holder's is reclaimed.
+# Serialize Maestro per device and turn its JUnit result into a trustworthy exit
+# code. `--exec` holds the same device lock around a multi-command helper.
 set -euo pipefail
 
 DEVICE="${1:?usage: maestro.sh <device> <maestro-args...>}"
 shift
-
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel)"
 LOCK="${TMPDIR:-/tmp}/kilo-maestro-locks/$DEVICE"
-mkdir -p "$(dirname "$LOCK")"
 
-while ! mkdir "$LOCK" 2>/dev/null; do
-  holder="$(cat "$LOCK/pid" 2>/dev/null || true)"
-  if [ -n "$holder" ] && ! kill -0 "$holder" 2>/dev/null; then
-    # Holder is dead: reclaim. mv is atomic, so two reclaimers cannot delete
-    # a lock a third process just acquired.
-    mv "$LOCK" "$LOCK.stale.$$" 2>/dev/null && rm -rf "$LOCK.stale.$$"
-    continue
-  fi
-  sleep 2
-done
-trap 'rm -rf "$LOCK"' EXIT
-echo $$ >"$LOCK/pid"
+if [ "${KILO_MAESTRO_LOCKED:-}" != "1" ]; then
+  exec "$REPO_ROOT/node_modules/.bin/tsx" "$REPO_ROOT/dev/local/process-lock.ts" \
+    --wait 1200 "$LOCK" -- env KILO_MAESTRO_LOCKED=1 "$0" "$DEVICE" "$@"
+fi
+
+if [ "${1:-}" = "--exec" ]; then
+  shift
+  [ $# -gt 0 ] || { echo "maestro.sh: --exec needs a command" >&2; exit 1; }
+  exec "$@"
+fi
 
-# Run maestro as a child (no exec): the EXIT trap then releases the lock the
-# moment maestro ends, instead of leaving a dead-PID lock for the next waiter
-# to reclaim — which PID reuse could make look live forever.
+if [ "${1:-}" != "test" ]; then
+  exec maestro --device "$DEVICE" "$@"
+fi
+
+REPORT_DIR=$(mktemp -d "${TMPDIR:-/tmp}/kilo-maestro-report.XXXXXX")
+trap 'rm -rf "$REPORT_DIR"' EXIT
+REPORT="$REPORT_DIR/junit.xml"
 set +e
-maestro --device "$DEVICE" "$@"
+maestro --device "$DEVICE" "$@" --format JUNIT --output "$REPORT"
 rc=$?
+set -e
+
+if [ "$rc" -eq 0 ]; then
+  if [ ! -s "$REPORT" ]; then
+    echo "maestro.sh: test exited 0 without a JUnit report" >&2
+    rc=1
+  elif grep -Eq '<(failure|error)([ >])|(failures|errors)="[1-9][0-9]*"' "$REPORT"; then
+    echo "maestro.sh: JUnit reports a failed assertion" >&2
+    rc=1
+  fi
+fi
 exit "$rc"
diff --git a/apps/mobile/e2e/remote-cli.sh b/apps/mobile/e2e/remote-cli.sh
index 1eea3f3883..0a60264aea 100755
--- a/apps/mobile/e2e/remote-cli.sh
+++ b/apps/mobile/e2e/remote-cli.sh
@@ -9,8 +9,8 @@
 #   - a passthrough for any one-off `kilo` command (remote, run, session, ...).
 #
 # Usage:
-#   apps/mobile/e2e/remote-cli.sh start [email] [--reinstall]   # interactive TUI in tmux
-#   apps/mobile/e2e/remote-cli.sh prepare [email] [--reinstall] # write env only, no launch
+#   apps/mobile/e2e/remote-cli.sh start <email> [--reinstall]   # interactive TUI in tmux
+#   apps/mobile/e2e/remote-cli.sh prepare <email> [--reinstall] # write env only, no launch
 #   apps/mobile/e2e/remote-cli.sh exec <kilo args...>           # run any kilo command
 #   apps/mobile/e2e/remote-cli.sh status
 #   apps/mobile/e2e/remote-cli.sh stop [--purge]
@@ -20,12 +20,10 @@
 #   apps/mobile/e2e/remote-cli.sh exec session list --pure
 #   apps/mobile/e2e/remote-cli.sh exec run "say hello"
 #
-# When no email is given, defaults to the per-worktree-unique login account
-# (e2e-mobile-<worktree-slug>@example.com), matching e2e/login.sh. The user must
-# already exist (sign in on the device first, or seed one). Pass an explicit
-# email to target a specific account (e.g. the one the app is signed in as).
-# `exec` reuses an already-prepared env and only prepares (mints a token) when
-# none exists yet.
+# The email is required and must be the account the app is signed in as —
+# e2e/login.sh's default is e2e-mobile-<worktree-slug>-<ios|android>@example.com.
+# The user must already exist (sign in on the device first, or seed one).
+# `exec` reuses an already-prepared env; run `start <email>` once first.
 #
 # Env overrides:
 #   KILO_CLI_VERSION   npm version/tag of @kilocode/cli to install (default: latest)
@@ -40,7 +38,6 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_ROOT="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel)"
 WORKTREE_SLUG="$(basename "$REPO_ROOT" | tr -cs 'a-zA-Z0-9' '-' | sed 's/^-*//;s/-*$//')"
-DEFAULT_EMAIL="e2e-mobile-$(printf '%s' "$WORKTREE_SLUG" | tr 'A-Z' 'a-z')@example.com"
 SESSION="kilo-e2e-cli-${WORKTREE_SLUG}"
 CLI_HOME="$REPO_ROOT/dev/.dev-logs/remote-cli/${WORKTREE_SLUG}"
 ENV_FILE="$CLI_HOME/.cli-env"
@@ -72,7 +69,8 @@ prepare_env() {
 
   if [ -z "$nextjs_port" ] || [ -z "$ingest_port" ]; then
     echo "Required services are not up for $REPO_ROOT." >&2
-    echo "Start them first, e.g.: pnpm dev:start --no-attach mobile cloud-agent-next event-service" >&2
+    echo "If you hold no E2E slot: take one, then .kilo_workflow/e2e-start-resource.sh stack mobile cloud-agent-next kiloclaw event-service" >&2
+    echo "If a bundle owner already runs this stack, use it — never start a second one." >&2
     exit 1
   fi
   if [ -z "$event_port" ]; then
@@ -150,7 +148,7 @@ EOF
   PREP_NEXTJS="$nextjs_port" PREP_INGEST="$ingest_port" PREP_EVENT="$event_port"
 }
 
-# Parse "[email] [--reinstall]" for start/prepare. Sets OPT_EMAIL, OPT_REINSTALL.
+# Parse "<email> [--reinstall]" for start/prepare. Sets OPT_EMAIL, OPT_REINSTALL.
 parse_prepare_args() {
   OPT_EMAIL="" OPT_REINSTALL=0
   local arg
@@ -161,7 +159,7 @@ parse_prepare_args() {
       *) if [ -z "$OPT_EMAIL" ]; then OPT_EMAIL="$arg"; else echo "Unexpected argument: $arg" >&2; exit 2; fi ;;
     esac
   done
-  [ -n "$OPT_EMAIL" ] || OPT_EMAIL="$DEFAULT_EMAIL"
+  [ -n "$OPT_EMAIL" ] || { echo "usage: remote-cli.sh start|prepare <email> [--reinstall] — pass the account the app is signed in as" >&2; exit 2; }
 }
 
 cmd_prepare() {
@@ -208,8 +206,8 @@ cmd_exec() {
     exit 2
   fi
   if [ ! -f "$ENV_FILE" ]; then
-    echo "==> no prepared env for this worktree; preparing with $DEFAULT_EMAIL" >&2
-    prepare_env "$DEFAULT_EMAIL" 0
+    echo "no prepared env for this worktree — run: remote-cli.sh start <email> (the account the app is signed in as)" >&2
+    exit 1
   fi
   # Run kilo with the prepared env in a subshell so it does not leak into the
   # caller. Command stdout/stderr and exit code pass straight through.
@@ -249,5 +247,5 @@ case "${1:-start}" in
   status) shift || true; cmd_status ;;
   stop) shift || true; cmd_stop "$@" ;;
   -h|--help) grep '^#' "$0" | sed 's/^# \{0,1\}//' | sed '1d' ;;
-  *) cmd_start "$@" ;;
+  *) echo "unknown command: ${1} (expected start|prepare|exec|status|stop)" >&2; exit 2 ;;
 esac
diff --git a/apps/web/AGENTS.md b/apps/web/AGENTS.md
index 9426ed4ff7..41ff7f6695 100644
--- a/apps/web/AGENTS.md
+++ b/apps/web/AGENTS.md
@@ -2,7 +2,9 @@
 
 ## UI Work
 
-When editing UI files in `apps/web` — React components, pages, layouts, or styles (`.tsx`/`.css`) — use the `/kilo-design` skill.
+When editing or reviewing UI files in `apps/web` — React components, pages, layouts, or styles (`.tsx`/`.css`) — load the `kilo-design-cloud` skill, synced from `Kilo-Org/kilo-design` into `.agents/skills/`. Never load it for non-UI work.
+
+For `apps/web`, that skill replaces the root `DESIGN.md`. Its `src/tokens.cloud.ts` references are upstream design artifacts tracked by VVV-130, not files expected in this repository; until adoption lands, use the current Cloud semantic tokens and components.
 
 ## Web Environment Variables
 
diff --git a/dev/local/cli.ts b/dev/local/cli.ts
index eac1d30e40..8881aed046 100644
--- a/dev/local/cli.ts
+++ b/dev/local/cli.ts
@@ -1,7 +1,11 @@
 import { execFileSync, execSync } from 'node:child_process';
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
 import {
+  applyPortOffset,
+  candidatePortOffsets,
+  clearDevLogs,
   resolveTargets,
   getService,
   getGroups,
@@ -10,10 +14,11 @@ import {
   resolveGroups,
   topologicalSort,
   portOffset,
-  findFreePortOffset,
+  writePersistedPortOffset,
   resolveSessionNextAuthUrl,
   services,
 } from './services';
+import { acquireProcessLock, withProcessLockAsync } from './process-lock';
 import { syncEnvVars } from './env-sync';
 import { getWranglerRegistryPath } from './wrangler-registry';
 import {
@@ -37,6 +42,7 @@ import {
   findServicePane,
   isPaneRunningCommand,
   captureServicePane,
+  pipeServicePane,
 } from './tmux';
 import { detectLanIp, prepareMobileEnvironment } from './mobile-env';
 import { probeDockerApi } from './docker-api-probe';
@@ -48,6 +54,8 @@ import {
   readEnvValue,
   readEnvMtime,
   waitForEnvValueChange,
+  buildFollowLogPipeCommand,
+  buildLogPipeCommand,
   probePort,
   restartServiceInTmux,
 } from './runner';
@@ -61,7 +69,11 @@ const sleep = (ms: number) => new Promise<void>(r => setTimeout(r, ms));
 // Scan the resolved services' full computed port set for occupants. The
 // shared kiloclaw-docker-tcp bridge on 23750 is reused (not a conflict) when
 // the listener really is the Docker API.
-async function findPortConflicts(serviceNames: string[]): Promise<{
+async function findPortConflicts(
+  serviceNames: string[],
+  portProbe: typeof probePort = probePort,
+  dockerProbe: typeof probeDockerApi = probeDockerApi
+): Promise<{
   conflicts: string[];
   reusedHostServices: Set<string>;
 }> {
@@ -69,16 +81,178 @@ async function findPortConflicts(serviceNames: string[]): Promise<{
   const reusedHostServices = new Set<string>();
   for (const name of serviceNames) {
     const service = getService(name);
-    if (service.type === 'infra' || service.port <= 0 || !(await probePort(service.port))) {
+    if (service.type === 'infra' || service.port <= 0) continue;
+    const ports = [
+      { label: name, port: service.port },
+      ...(service.type === 'worker'
+        ? [{ label: `${name}-inspector`, port: service.port + 10_000 }]
+        : []),
+    ];
+    for (const candidate of ports) {
+      if (!(await portProbe(candidate.port))) continue;
+      if (
+        name === 'kiloclaw-docker-tcp' &&
+        candidate.port === service.port &&
+        (await dockerProbe(candidate.port))
+      ) {
+        reusedHostServices.add(name);
+      } else {
+        conflicts.push(`${candidate.label}:${candidate.port}`);
+      }
+    }
+  }
+  return { conflicts, reusedHostServices };
+}
+
+function processIdentity(pid: number): string | undefined {
+  try {
+    return (
+      execFileSync('ps', ['-o', 'lstart=', '-p', String(pid)], {
+        encoding: 'utf8',
+      })
+        .replace(/\s+/g, ' ')
+        .trim() || undefined
+    );
+  } catch {
+    return undefined;
+  }
+}
+
+async function acquirePortOffsetLease(
+  serviceNames: string[],
+  explicit: boolean,
+  repoRoot: string,
+  sessionName: string,
+  leasesRoot = path.join(os.tmpdir(), 'kilo-port-offset-leases'),
+  scanPorts: typeof findPortConflicts = findPortConflicts
+): Promise<Set<string>> {
+  const startingOffset = portOffset;
+  const candidates = explicit
+    ? [startingOffset]
+    : [startingOffset, ...candidatePortOffsets(startingOffset)];
+  fs.mkdirSync(leasesRoot, { recursive: true });
+
+  for (const candidate of candidates) {
+    applyPortOffset(candidate);
+    const claimPath = path.join(leasesRoot, `${candidate}.json`);
+    let release: () => Promise<void>;
+    try {
+      release = await acquireProcessLock(
+        path.join(leasesRoot, `${candidate}.lock`),
+        `port offset ${candidate}`
+      );
+    } catch {
+      if (explicit)
+        throw new Error(`KILO_PORT_OFFSET ${candidate} is being started by another worktree`);
       continue;
     }
-    if (name === 'kiloclaw-docker-tcp' && (await probeDockerApi(service.port))) {
-      reusedHostServices.add(name);
-    } else {
-      conflicts.push(`${name}:${service.port}`);
+    try {
+      let claim: { identity?: string; pid?: number; session?: string } | undefined;
+      try {
+        claim = JSON.parse(fs.readFileSync(claimPath, 'utf8'));
+      } catch {
+        fs.rmSync(claimPath, { force: true });
+      }
+      const pendingPid = claim?.pid;
+      const pending =
+        typeof pendingPid === 'number' &&
+        Number.isInteger(pendingPid) &&
+        pendingPid > 0 &&
+        typeof claim?.identity === 'string' &&
+        processIdentity(pendingPid) === claim.identity;
+      if ((claim?.session && sessionExists(claim.session)) || pending) {
+        if (explicit)
+          throw new Error(`KILO_PORT_OFFSET ${candidate} is reserved by another worktree`);
+        continue;
+      }
+      fs.rmSync(claimPath, { force: true });
+
+      const scan = await scanPorts(serviceNames);
+      if (scan.conflicts.length > 0) {
+        if (explicit) {
+          throw new Error(
+            `Refusing to share occupied worktree service ports: ${scan.conflicts.join(', ')}. ` +
+              'Stop the owning worktree or set a distinct KILO_PORT_OFFSET.'
+          );
+        }
+        continue;
+      }
+      const temp = `${claimPath}.${process.pid}.tmp`;
+      const identity = processIdentity(process.pid);
+      if (!identity) throw new Error('Could not identify the port-offset starter process');
+      fs.writeFileSync(
+        temp,
+        JSON.stringify({
+          identity,
+          pid: process.pid,
+          repoRoot,
+          session: sessionName,
+        })
+      );
+      fs.renameSync(temp, claimPath);
+      return scan.reusedHostServices;
+    } finally {
+      await release();
+    }
+  }
+
+  applyPortOffset(startingOffset);
+  throw new Error('No free worktree port offset is available');
+}
+
+async function releasePortOffsetClaims(
+  repoRoot: string,
+  sessionName: string,
+  leasesRoot = path.join(os.tmpdir(), 'kilo-port-offset-leases'),
+  lockWaitMs = 5000,
+  removeClaim = (claimPath: string) => fs.rmSync(claimPath, { force: true })
+): Promise<void> {
+  let entries: string[];
+  try {
+    entries = fs.readdirSync(leasesRoot).filter(entry => /^\d+\.json$/.test(entry));
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const offset = entry.slice(0, -5);
+    let release: () => Promise<void>;
+    try {
+      release = await acquireProcessLock(
+        path.join(leasesRoot, `${offset}.lock`),
+        `port offset ${offset}`,
+        lockWaitMs
+      );
+    } catch {
+      console.warn(`Skipping busy port offset ${offset} claim; it will be reclaimed when stale`);
+      continue;
+    }
+    try {
+      const claimPath = path.join(leasesRoot, entry);
+      let claim: { repoRoot?: string; session?: string };
+      try {
+        claim = JSON.parse(fs.readFileSync(claimPath, 'utf8'));
+      } catch {
+        continue;
+      }
+      if (claim.repoRoot === repoRoot && claim.session === sessionName) removeClaim(claimPath);
+    } catch (error) {
+      console.warn(
+        `Could not remove port offset ${offset} claim; it will be reclaimed when stale: ${
+          error instanceof Error ? error.message : error
+        }`
+      );
+    } finally {
+      try {
+        await release();
+      } catch (error) {
+        console.warn(
+          `Could not release port offset ${offset} cleanup lock: ${
+            error instanceof Error ? error.message : error
+          }`
+        );
+      }
     }
   }
-  return { conflicts, reusedHostServices };
 }
 
 function determineEnabledGroups(serviceNames: string[]): string[] {
@@ -107,9 +281,10 @@ const CAPTURE_TIMEOUT_MS = 30_000;
 // Commands
 // ---------------------------------------------------------------------------
 
-async function cmdUp(args: string[], repoRoot: string): Promise<void> {
+async function cmdUp(args: string[], repoRoot: string): Promise<string | undefined> {
   const noAttach = args.includes('--no-attach');
-  const targets = args.filter(arg => arg !== '--no-attach');
+  const reuseRunning = args.includes('--reuse-running');
+  const targets = args.filter(arg => arg !== '--no-attach' && arg !== '--reuse-running');
 
   // --- Preflight checks ---
   if (!isTmuxAvailable()) {
@@ -150,37 +325,47 @@ async function cmdUp(args: string[], repoRoot: string): Promise<void> {
   // hash/persisted offset's ports are held by a foreign occupant (another
   // worktree's stack, macOS AirPlay on 5000/7000), probe +100 candidate
   // offsets and take the first whose full computed port set is free. Never
-  // silently share. The chosen offset is persisted in the manifest at the end
-  // of startup so later port-computing commands agree without an env prefix.
+  // silently share. The chosen offset is persisted before startup so later
+  // port-computing commands agree even if startup is interrupted.
   const offsetIsExplicit =
     process.env.KILO_PORT_OFFSET !== undefined && process.env.KILO_PORT_OFFSET !== 'auto';
   let reusedHostServices = new Set<string>();
   if (!sessionAlreadyRunning) {
-    let scan = await findPortConflicts(serviceNames);
-    if (scan.conflicts.length > 0 && !offsetIsExplicit) {
-      console.warn(
-        `⚠ Ports at offset ${portOffset} are occupied (${scan.conflicts.join(', ')}) — probing for a free offset…`
-      );
-      const freeOffset = await findFreePortOffset(
-        async () => (await findPortConflicts(serviceNames)).conflicts.length > 0
-      );
-      if (freeOffset !== undefined) {
-        console.log(`${DIM}Auto-selected port offset ${freeOffset}${RESET}`);
-        scan = await findPortConflicts(serviceNames);
-      }
-    }
-    if (scan.conflicts.length > 0) {
-      throw new Error(
-        `Refusing to share occupied worktree service ports: ${scan.conflicts.join(', ')}. ` +
-          'Stop the owning worktree or set a distinct KILO_PORT_OFFSET.'
-      );
-    }
-    reusedHostServices = scan.reusedHostServices;
+    const originalOffset = portOffset;
+    reusedHostServices = await acquirePortOffsetLease(
+      serviceNames,
+      offsetIsExplicit,
+      repoRoot,
+      sessionName
+    );
+    if (portOffset !== originalOffset)
+      console.log(`${DIM}Auto-selected port offset ${portOffset}${RESET}`);
+    // Persist before tmux or any service exists: a killed partial startup still
+    // leaves every later command on the ports the children inherited.
+    writePersistedPortOffset(repoRoot, portOffset);
   }
 
   // --- Export port offset for child processes (e.g. scripts/dev.sh) ---
   process.env.KILO_PORT_OFFSET = String(portOffset);
 
+  // Repeated bundle setup calls reuse a complete stack without refreshing
+  // secrets or restarting live panes.
+  if (sessionAlreadyRunning && reuseRunning) {
+    const manifest = readManifest(repoRoot);
+    const missing = await missingRunningServices(manifest, sessionName, serviceNames, {
+      repoRoot,
+      waitMs: 30_000,
+      pollMs: 500,
+    });
+    if (missing.length > 0)
+      throw new Error(
+        `Cannot reuse session ${sessionName}; requested services are missing or stayed down for 30s: ${missing.join(', ')}. ` +
+          'Do not rerun without --reuse-running while another verifier may use the stack. Retry the same command once; if it still fails, stop every shard, stop the stack, and start a fresh round.'
+      );
+    console.log(`Reusing running session ${sessionName} without restarting services.`);
+    return noAttach ? undefined : sessionName;
+  }
+
   const otherSessions = findOtherKiloDevSessions();
   if (otherSessions.length > 0) {
     console.warn(`⚠ Other kilo-dev sessions are running: ${otherSessions.join(', ')}`);
@@ -239,8 +424,7 @@ async function cmdUp(args: string[], repoRoot: string): Promise<void> {
         ? `Session ${sessionName} already running.`
         : `Session ${sessionName} already running — attaching.`
     );
-    if (!noAttach) attachSession(sessionName);
-    return;
+    return noAttach ? undefined : sessionName;
   }
 
   // --- Check for socat when kiloclaw-docker-tcp is requested ---
@@ -288,11 +472,7 @@ async function cmdUp(args: string[], repoRoot: string): Promise<void> {
   }
 
   // --- Prepare log directory ---
-  const logDir = path.join(repoRoot, 'dev', 'logs');
-  fs.mkdirSync(logDir, { recursive: true });
-  for (const entry of fs.readdirSync(logDir)) {
-    fs.rmSync(path.join(logDir, entry), { recursive: true, force: true });
-  }
+  clearDevLogs(repoRoot);
 
   // --- Create tmux session ---
   // Pass critical runtime env into the session so panes see this worktree's
@@ -581,7 +761,7 @@ async function cmdUp(args: string[], repoRoot: string): Promise<void> {
   console.log(
     `${GREEN}Started ${startedServices.length} services in session ${sessionName}${RESET}`
   );
-  if (!noAttach) attachSession(sessionName);
+  return noAttach ? undefined : sessionName;
 }
 
 type ServiceStatus = 'up' | 'down';
@@ -644,6 +824,59 @@ function readManifest(repoRoot: string): Manifest | undefined {
   }
 }
 
+async function missingRunningServices(
+  manifest: Manifest | undefined,
+  sessionName: string,
+  requested: string[],
+  checks: {
+    repoRoot?: string;
+    findPane?: typeof findServicePane;
+    isPaneRunning?: typeof isPaneRunningCommand;
+    probe?: typeof probePort;
+    waitMs?: number;
+    pollMs?: number;
+  } = {}
+): Promise<string[]> {
+  if (manifest?.session !== sessionName) return requested;
+  const entries = new Map(
+    manifest.services.flatMap(service =>
+      typeof service?.name === 'string' ? [[service.name, service] as const] : []
+    )
+  );
+  const findPane = checks.findPane ?? findServicePane;
+  const isPaneRunning = checks.isPaneRunning ?? isPaneRunningCommand;
+  const probe = checks.probe ?? probePort;
+  const repoRoot = checks.repoRoot ?? process.cwd();
+  const missing = requested.filter(name => getService(name).type !== 'infra' && !entries.has(name));
+  let pending = requested.filter(name => getService(name).type === 'infra' || entries.has(name));
+  const check = async (names: string[]): Promise<string[]> => {
+    const down = await Promise.all(
+      names.map(async name => {
+        const service = getService(name);
+        if (service.type === 'infra') return service.port <= 0 || !(await probe(service.port));
+        const entry = entries.get(name);
+        if (!entry) return true;
+        const port =
+          name === 'nextjs'
+            ? (readNextjsDevPort(repoRoot) ?? entry.port ?? service.port)
+            : (entry.port ?? service.port);
+        if (name === 'kiloclaw-docker-tcp') return !(await probeDockerApi(port));
+        const pane = findPane(sessionName, name);
+        if (!pane) return true;
+        return port === 0 ? !isPaneRunning(sessionName, pane) : !(await probe(port));
+      })
+    );
+    return names.filter((_, index) => down[index]);
+  };
+  const deadline = Date.now() + (checks.waitMs ?? 0);
+  while (pending.length > 0) {
+    pending = await check(pending);
+    if (pending.length === 0 || Date.now() >= deadline) break;
+    await sleep(checks.pollMs ?? 100);
+  }
+  return [...missing, ...pending];
+}
+
 function readNextjsDevPort(repoRoot: string): number | undefined {
   try {
     const raw = fs.readFileSync(path.join(repoRoot, '.dev-port'), 'utf-8').trim();
@@ -777,6 +1010,21 @@ function cmdCapture(serviceName: string, linesArg: string | undefined): void {
   process.stdout.write(captureServicePane(getSessionName(), serviceName, lines));
 }
 
+function cmdCaptureFollow(serviceName: string, outputPath?: string): void {
+  if (!services.has(serviceName)) throw new Error(`Unknown service: ${serviceName}`);
+  const logPath = path.join(findRepoRoot(), 'dev', 'logs', `${serviceName}.log`);
+  if (outputPath === undefined) {
+    pipeServicePane(getSessionName(), serviceName, buildLogPipeCommand(logPath));
+    console.log(`Stopped continuous capture for ${serviceName}`);
+    return;
+  }
+  const resolved = path.resolve(outputPath);
+  fs.mkdirSync(path.dirname(resolved), { recursive: true });
+  fs.closeSync(fs.openSync(resolved, 'a'));
+  pipeServicePane(getSessionName(), serviceName, buildFollowLogPipeCommand(logPath, resolved));
+  console.log(`Capturing ${serviceName} continuously to ${resolved}`);
+}
+
 async function cmdStop(repoRoot: string, force: boolean): Promise<void> {
   const sessionName = getSessionName();
 
@@ -784,6 +1032,7 @@ async function cmdStop(repoRoot: string, force: boolean): Promise<void> {
     killSession(sessionName);
     console.log(`Killed tmux session ${sessionName}`);
   }
+  await releasePortOffsetClaims(repoRoot, sessionName);
 
   // Docker Compose uses project name "dev" for every worktree, so containers
   // (postgres, redis, grafana) are shared singletons. Tearing them down here
@@ -832,14 +1081,18 @@ async function cmdEnv(args: string[], repoRoot: string): Promise<void> {
 function printUsage(): void {
   console.log(`
 Usage:
-  dev:start [--no-attach] [targets...]
+  dev:start [--no-attach] [--reuse-running] [targets...]
                           Start services (default: core)
+                          --reuse-running never restarts an existing complete stack
   dev:stop [--force]      Stop all services (skips shared Docker infra if
                           other kilo-dev sessions are running; --force overrides)
   dev:status [--json]     Show running services and their ports
   dev:restart <service>   Restart a running service
   dev:capture <service> [lines]
                           Capture a service pane wherever the dashboard moved it
+  dev:capture <service> --follow <file>
+  dev:capture <service> --stop-follow
+                          Start or stop continuous capture on the resolved pane
   dev:env [targets...]    Sync env vars (.dev.vars + .env.development.local)
   dev:env --check         Validate env vars (CI mode)
   dev:env -y              Sync without confirmation
@@ -859,10 +1112,23 @@ async function main() {
 
   switch (command) {
     case 'up':
-      await cmdUp(args.slice(1), repoRoot);
+      {
+        const sessionToAttach = await withProcessLockAsync(
+          path.join(repoRoot, 'dev', 'logs', 'start.lock'),
+          'dev:start',
+          () => cmdUp(args.slice(1), repoRoot),
+          1_200_000
+        );
+        if (sessionToAttach) attachSession(sessionToAttach);
+      }
       break;
     case 'stop':
-      await cmdStop(repoRoot, args.includes('--force') || args.includes('-f'));
+      await withProcessLockAsync(
+        path.join(repoRoot, 'dev', 'logs', 'start.lock'),
+        'dev:start/stop',
+        () => cmdStop(repoRoot, args.includes('--force') || args.includes('-f')),
+        1_200_000
+      );
       break;
     case 'status':
       await cmdStatus(repoRoot, args.includes('--json'));
@@ -878,8 +1144,19 @@ async function main() {
     }
     case 'capture': {
       const serviceName = args[1];
-      if (!serviceName) throw new Error('Usage: dev:capture <service> [lines]');
-      cmdCapture(serviceName, args[2]);
+      if (!serviceName)
+        throw new Error('Usage: dev:capture <service> [lines|--follow <file>|--stop-follow]');
+      if (args[2] === '--follow') {
+        if (!args[3] || args.length !== 4)
+          throw new Error('Usage: dev:capture <service> --follow <file>');
+        cmdCaptureFollow(serviceName, args[3]);
+      } else if (args[2] === '--stop-follow') {
+        if (args.length !== 3) throw new Error('Usage: dev:capture <service> --stop-follow');
+        cmdCaptureFollow(serviceName);
+      } else {
+        if (args.length > 3) throw new Error('Usage: dev:capture <service> [lines]');
+        cmdCapture(serviceName, args[2]);
+      }
       break;
     }
     case 'env':
@@ -894,7 +1171,18 @@ async function main() {
   }
 }
 
-main().catch((err: unknown) => {
-  console.error(err instanceof Error ? err.message : err);
-  process.exit(1);
-});
+const isMain =
+  process.argv[1] && path.resolve(process.argv[1]) === path.resolve(import.meta.filename);
+if (isMain) {
+  main().catch((err: unknown) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  });
+}
+
+export {
+  acquirePortOffsetLease,
+  findPortConflicts,
+  missingRunningServices,
+  releasePortOffsetClaims,
+};
diff --git a/dev/local/maestro-wrapper.test.ts b/dev/local/maestro-wrapper.test.ts
new file mode 100644
index 0000000000..7a000e6638
--- /dev/null
+++ b/dev/local/maestro-wrapper.test.ts
@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+test('maestro wrapper fails a zero-exit test whose JUnit report failed', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-maestro-wrapper-'));
+  const fake = path.join(root, 'maestro');
+  fs.writeFileSync(
+    fake,
+    `#!/bin/sh
+output=
+while [ "$#" -gt 0 ]; do
+  [ "$1" = "--output" ] && { output=$2; shift 2; continue; }
+  shift
+done
+printf '<testsuite failures="1"><testcase><failure/></testcase></testsuite>\\n' > "$output"
+`
+  );
+  fs.chmodSync(fake, 0o755);
+  try {
+    const result = spawnSync(
+      path.join(process.cwd(), 'apps/mobile/e2e/maestro.sh'),
+      ['test-device', 'test', 'flow.yaml'],
+      {
+        cwd: process.cwd(),
+        env: { ...process.env, PATH: `${root}:${process.env.PATH}`, TMPDIR: root },
+        encoding: 'utf8',
+      }
+    );
+    assert.equal(result.status, 1, result.stderr);
+    assert.match(result.stderr, /JUnit reports a failed assertion/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
diff --git a/dev/local/mobile-android.test.ts b/dev/local/mobile-android.test.ts
index 41b1249d66..8309e377cc 100644
--- a/dev/local/mobile-android.test.ts
+++ b/dev/local/mobile-android.test.ts
@@ -5,12 +5,109 @@ import path from 'node:path';
 import test from 'node:test';
 
 import {
+  androidEmulatorSession,
   claimAndroidDevice,
+  commandMatchesRecordedEmulator,
+  findAvailableEmulatorPort,
+  isValidEmulatorRecord,
+  parseEmulatorStartArgs,
+  processOwnsListeningPort,
   readGradleWrapperVersion,
   releaseAndroidDevice,
+  releaseWorktreeAndroidDevices,
   resolveAndroidEnvironment,
+  signalProcessIfPresent,
 } from './mobile-android';
 
+test('allocates the first free even emulator console port', () => {
+  const occupied = new Set([5554, 5556]);
+  assert.equal(
+    findAvailableEmulatorPort(port => occupied.has(port)),
+    5558
+  );
+});
+
+test('recognizes the qemu process image that replaces the emulator launcher', () => {
+  const emulator = '/opt/android/emulator/emulator';
+  const command =
+    '/opt/android/emulator/qemu/darwin-aarch64/qemu-system-aarch64-headless -avd Pixel_9 -port 5554';
+  assert.equal(commandMatchesRecordedEmulator(command, emulator, 'Pixel_9', 5554), true);
+  assert.equal(commandMatchesRecordedEmulator(command, emulator, 'Pixel_8', 5554), false);
+  assert.equal(commandMatchesRecordedEmulator(command, emulator, 'Pixel_9', 5556), false);
+  assert.equal(commandMatchesRecordedEmulator(command, emulator, 'Pixel', 5554), false);
+  assert.equal(
+    commandMatchesRecordedEmulator(
+      command.replace('-port 5554', '-port 55546'),
+      emulator,
+      'Pixel_9',
+      5554
+    ),
+    false
+  );
+});
+
+test('records an emulator only when its process owns the console port', () => {
+  assert.equal(
+    processOwnsListeningPort(5554, 123, () => [123]),
+    true
+  );
+  assert.equal(
+    processOwnsListeningPort(5554, 123, () => [456]),
+    false
+  );
+});
+
+test('sanitizes Android emulator tmux targets derived from worktree names', () => {
+  assert.equal(androidEmulatorSession('/tmp/cloud-4.2'), 'kilo-e2e-android-cloud-4_2');
+  assert.equal(androidEmulatorSession('/tmp/foo:bar[dev]'), 'kilo-e2e-android-foo_bar_dev_');
+});
+
+test('accepts only the exact wrapper-owned emulator record', () => {
+  const worktreeRoot = '/tmp/cloud-4.2';
+  const session = androidEmulatorSession(worktreeRoot);
+  const record = {
+    avd: 'Pixel_9',
+    gpu: 'host',
+    log: '/tmp/emulator.log',
+    pid: 123,
+    pidFile: path.join(os.tmpdir(), `${session}.pid`),
+    port: 5554,
+    serial: 'emulator-5554',
+    session,
+    worktreeRoot,
+  };
+  assert.equal(isValidEmulatorRecord(record, worktreeRoot), true);
+  assert.equal(isValidEmulatorRecord({ ...record, port: 5556 }, worktreeRoot), false);
+  assert.equal(
+    isValidEmulatorRecord({ ...record, worktreeRoot: '/tmp/foreign' }, worktreeRoot),
+    false
+  );
+});
+
+test('rejects emulator-start when the flag appears where the AVD name belongs', () => {
+  assert.throws(() => parseEmulatorStartArgs(['--gpu', 'host', 'Pixel_9']), /Usage:/);
+  assert.deepEqual(parseEmulatorStartArgs(['Pixel_9', '--gpu', 'host']), {
+    avd: 'Pixel_9',
+    gpu: 'host',
+  });
+});
+
+test('treats a process that disappears before its signal as stopped', () => {
+  const gone = Object.assign(new Error('gone'), { code: 'ESRCH' });
+  assert.doesNotThrow(() =>
+    signalProcessIfPresent(123, 'SIGTERM', () => {
+      throw gone;
+    })
+  );
+  assert.throws(
+    () =>
+      signalProcessIfPresent(123, 'SIGTERM', () => {
+        throw Object.assign(new Error('denied'), { code: 'EPERM' });
+      }),
+    /denied/
+  );
+});
+
 test('skips a partial Android SDK root when a later root has all required tools', () => {
   const env = resolveAndroidEnvironment({
     home: '/Users/test',
@@ -210,6 +307,31 @@ test('creates an explicit ready Android claim', () => {
   }
 });
 
+test('releases every Android claim owned by one worktree and preserves foreign claims', () => {
+  const worktreeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-worktree-own-'));
+  const foreignWorktree = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-worktree-foreign-'));
+  const ownSerials = [`test-own-a-${process.pid}`, `test-own-b-${process.pid}`];
+  const foreignSerial = `test-foreign-${process.pid}`;
+  try {
+    for (const serial of ownSerials) claimAndroidDevice(serial, worktreeRoot, `boot-${serial}`);
+    claimAndroidDevice(foreignSerial, foreignWorktree, `boot-${foreignSerial}`);
+
+    assert.deepEqual(releaseWorktreeAndroidDevices(worktreeRoot).sort(), ownSerials.sort());
+    const claimRoot = path.join(os.tmpdir(), 'kilo-mobile-android-claims');
+    for (const serial of ownSerials)
+      assert.equal(fs.existsSync(path.join(claimRoot, `${serial}.json`)), false);
+    assert.equal(fs.existsSync(path.join(claimRoot, `${foreignSerial}.json`)), true);
+  } finally {
+    const claimRoot = path.join(os.tmpdir(), 'kilo-mobile-android-claims');
+    for (const serial of [...ownSerials, foreignSerial]) {
+      fs.rmSync(path.join(claimRoot, `${serial}.json`), { force: true });
+      fs.rmSync(path.join(claimRoot, `${serial}.json.lock`), { recursive: true, force: true });
+    }
+    fs.rmSync(worktreeRoot, { recursive: true, force: true });
+    fs.rmSync(foreignWorktree, { recursive: true, force: true });
+  }
+});
+
 test('upgrades a same-worktree legacy Android claim to ready', () => {
   const serial = `test-upgrade-${process.pid}-${Date.now()}`;
   const worktreeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-worktree-'));
diff --git a/dev/local/mobile-android.ts b/dev/local/mobile-android.ts
index d7a9de814f..b7e80c184e 100644
--- a/dev/local/mobile-android.ts
+++ b/dev/local/mobile-android.ts
@@ -13,7 +13,7 @@ import {
   runAndroidBuild,
 } from './mobile-android-build';
 import { withNativeBuildSemaphore } from './mobile-native-build';
-import { withProcessLock } from './process-lock';
+import { withProcessLock, withProcessLockAsync } from './process-lock';
 
 type AndroidEnvironment = {
   adb: string;
@@ -49,6 +49,18 @@ type ClaimOptions = {
   };
 };
 
+type EmulatorRecord = {
+  avd: string;
+  gpu: string;
+  log: string;
+  pid: number;
+  pidFile: string;
+  port: number;
+  serial: string;
+  session: string;
+  worktreeRoot: string;
+};
+
 function firstExisting(
   candidates: string[],
   exists: (candidate: string) => boolean
@@ -142,6 +154,274 @@ function run(command: string, args: string[], env: AndroidEnvironment, cwd?: str
   });
 }
 
+function tmuxSessionExists(session: string): boolean {
+  return spawnSync('tmux', ['has-session', '-t', session]).status === 0;
+}
+
+function androidEmulatorSlug(worktreeRoot: string): string {
+  return path.basename(worktreeRoot).replace(/[^A-Za-z0-9_-]/g, '_');
+}
+
+function androidEmulatorSession(worktreeRoot: string): string {
+  return `kilo-e2e-android-${androidEmulatorSlug(worktreeRoot)}`;
+}
+
+function emulatorRecordPath(worktreeRoot: string): string {
+  return path.join(
+    os.tmpdir(),
+    'kilo-mobile-android-emulators',
+    `${androidEmulatorSlug(worktreeRoot)}.json`
+  );
+}
+
+function portIsListening(port: number): boolean {
+  return (
+    spawnSync('lsof', ['-nP', `-iTCP:${port}`, '-sTCP:LISTEN'], { stdio: 'ignore' }).status === 0
+  );
+}
+
+function listeningProcessIds(port: number): number[] {
+  const result = spawnSync('lsof', ['-nP', '-t', `-iTCP:${port}`, '-sTCP:LISTEN'], {
+    encoding: 'utf8',
+  });
+  if (result.status !== 0) return [];
+  return result.stdout
+    .trim()
+    .split(/\s+/)
+    .map(Number)
+    .filter(pid => Number.isInteger(pid) && pid > 0);
+}
+
+function processOwnsListeningPort(
+  port: number,
+  pid: number,
+  listeners: (port: number) => number[] = listeningProcessIds
+): boolean {
+  return listeners(port).includes(pid);
+}
+
+function findAvailableEmulatorPort(isListening = portIsListening): number | undefined {
+  for (let port = 5554; port <= 5680; port += 2) {
+    if (!isListening(port)) return port;
+  }
+  return undefined;
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+function processIsAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function signalProcessIfPresent(
+  pid: number,
+  signal: NodeJS.Signals,
+  sendSignal: typeof process.kill = process.kill
+): void {
+  try {
+    sendSignal(pid, signal);
+  } catch (error) {
+    if (!(error instanceof Error && 'code' in error && error.code === 'ESRCH')) throw error;
+  }
+}
+
+function commandMatchesRecordedEmulator(
+  command: string,
+  emulator: string,
+  avd: string,
+  port: number
+): boolean {
+  const qemuRoot = `${path.dirname(emulator)}${path.sep}qemu${path.sep}`;
+  const exactArgument = (flag: string, value: string): boolean => {
+    const escape = (input: string) => input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`(?:^|\\s)${escape(flag)}\\s+${escape(value)}(?=\\s|$)`).test(command);
+  };
+  return (
+    (command.includes(emulator) || command.includes(qemuRoot)) &&
+    exactArgument('-avd', avd) &&
+    exactArgument('-port', String(port))
+  );
+}
+
+function recordedEmulatorStillOwnsPid(record: EmulatorRecord, env: AndroidEnvironment): boolean {
+  if (!processIsAlive(record.pid)) return false;
+  const command =
+    spawnSync('ps', ['-p', String(record.pid), '-o', 'command='], {
+      encoding: 'utf8',
+    }).stdout?.trim() ?? '';
+  return commandMatchesRecordedEmulator(command, env.emulator, record.avd, record.port);
+}
+
+const delay = (ms: number) => new Promise<void>(resolve => setTimeout(resolve, ms));
+
+function isValidEmulatorRecord(record: unknown, worktreeRoot: string): record is EmulatorRecord {
+  if (typeof record !== 'object' || record === null) return false;
+  const value = record as Partial<EmulatorRecord>;
+  const expectedSession = androidEmulatorSession(worktreeRoot);
+  return (
+    value.worktreeRoot === worktreeRoot &&
+    value.session === expectedSession &&
+    value.pidFile === path.join(os.tmpdir(), `${expectedSession}.pid`) &&
+    value.serial === `emulator-${value.port}` &&
+    Number.isInteger(value.pid) &&
+    Number.isInteger(value.port) &&
+    (value.port ?? 0) >= 5554 &&
+    (value.port ?? 0) <= 5680 &&
+    (value.port ?? 0) % 2 === 0
+  );
+}
+
+async function stopAndroidEmulator(env: AndroidEnvironment, worktreeRoot: string): Promise<void> {
+  const recordPath = emulatorRecordPath(worktreeRoot);
+  const expectedSession = androidEmulatorSession(worktreeRoot);
+  let raw: string;
+  try {
+    raw = fs.readFileSync(recordPath, 'utf8');
+  } catch (error) {
+    if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT')) throw error;
+    if (tmuxSessionExists(expectedSession))
+      spawnSync('tmux', ['kill-session', '-t', expectedSession], { stdio: 'ignore' });
+    return;
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid emulator record at ${recordPath}; refusing teardown`);
+  }
+  if (!isValidEmulatorRecord(parsed, worktreeRoot))
+    throw new Error(`Invalid emulator record at ${recordPath}; refusing teardown`);
+  const record = parsed;
+
+  if (tmuxSessionExists(record.session))
+    spawnSync('tmux', ['kill-session', '-t', record.session], { stdio: 'ignore' });
+  for (let i = 0; i < 50 && processIsAlive(record.pid); i++) await delay(100);
+  if (recordedEmulatorStillOwnsPid(record, env)) {
+    signalProcessIfPresent(record.pid, 'SIGTERM');
+    for (let i = 0; i < 50 && processIsAlive(record.pid); i++) await delay(100);
+  }
+  if (recordedEmulatorStillOwnsPid(record, env)) {
+    signalProcessIfPresent(record.pid, 'SIGKILL');
+    for (let i = 0; i < 20 && processIsAlive(record.pid); i++) await delay(100);
+  }
+  if (recordedEmulatorStillOwnsPid(record, env))
+    throw new Error(`Emulator PID ${record.pid} did not stop; keeping ${recordPath}`);
+  fs.rmSync(record.pidFile, { force: true });
+  fs.rmSync(recordPath, { force: true });
+}
+
+async function startAndroidEmulator(
+  env: AndroidEnvironment,
+  worktreeRoot: string,
+  avd: string,
+  gpu: string
+): Promise<EmulatorRecord> {
+  const session = androidEmulatorSession(worktreeRoot);
+
+  return withProcessLockAsync(
+    path.join(os.tmpdir(), 'kilo-mobile-android-emulators', 'launch.lock'),
+    'Android emulator launch',
+    async () => {
+      const recordPath = emulatorRecordPath(worktreeRoot);
+      if (tmuxSessionExists(session) || fs.existsSync(recordPath))
+        throw new Error(
+          `${session} already exists; run pnpm dev:mobile:android emulator-stop before launching another`
+        );
+      const port = findAvailableEmulatorPort();
+      if (port === undefined) throw new Error('No free Android emulator console port (5554-5680)');
+      const serial = `emulator-${port}`;
+      const log = path.join(os.tmpdir(), `${session}.log`);
+      const pidFile = path.join(os.tmpdir(), `${session}.pid`);
+      fs.mkdirSync(path.dirname(recordPath), { recursive: true });
+      fs.rmSync(log, { force: true });
+      fs.rmSync(pidFile, { force: true });
+      const emulatorArgs = [
+        '-avd',
+        avd,
+        '-port',
+        String(port),
+        '-no-snapshot-save',
+        '-no-boot-anim',
+        '-gpu',
+        gpu,
+      ];
+      const command = `echo $$ > ${shellQuote(pidFile)}; exec ${[env.emulator, ...emulatorArgs]
+        .map(shellQuote)
+        .join(' ')} >> ${shellQuote(log)} 2>&1`;
+
+      let pid = 0;
+      let sessionStarted = false;
+      try {
+        execFileSync('tmux', ['new-session', '-d', '-s', session, '-c', worktreeRoot, command]);
+        sessionStarted = true;
+        for (let i = 0; i < 50 && !fs.existsSync(pidFile); i++) await delay(100);
+        pid = Number(fs.readFileSync(pidFile, 'utf8').trim());
+        if (!Number.isInteger(pid) || pid <= 0)
+          throw new Error(`${session} did not record its PID`);
+        for (let i = 0; i < 300 && !portIsListening(port); i++) {
+          if (!processIsAlive(pid)) throw new Error(`${session} exited during launch; see ${log}`);
+          await delay(100);
+        }
+        if (!portIsListening(port))
+          throw new Error(`${session} did not bind console port ${port} within 30s; see ${log}`);
+        if (!processIsAlive(pid) || !processOwnsListeningPort(port, pid))
+          throw new Error(
+            `${session} does not own console port ${port}; refusing to record a foreign emulator`
+          );
+        const record = {
+          avd,
+          gpu,
+          log,
+          pid,
+          pidFile,
+          port,
+          serial,
+          session,
+          worktreeRoot,
+        } satisfies EmulatorRecord;
+        const tempRecord = `${recordPath}.${process.pid}.tmp`;
+        fs.writeFileSync(tempRecord, JSON.stringify(record, null, 2));
+        fs.renameSync(tempRecord, recordPath);
+        return record;
+      } catch (error) {
+        if (sessionStarted && tmuxSessionExists(session))
+          spawnSync('tmux', ['kill-session', '-t', session], { stdio: 'ignore' });
+        if (pid > 0) {
+          const partialRecord = {
+            avd,
+            gpu,
+            log,
+            pid,
+            pidFile,
+            port,
+            serial,
+            session,
+            worktreeRoot,
+          };
+          if (recordedEmulatorStillOwnsPid(partialRecord, env)) {
+            signalProcessIfPresent(pid, 'SIGTERM');
+            for (let i = 0; i < 50 && processIsAlive(pid); i++) await delay(100);
+          }
+          if (recordedEmulatorStillOwnsPid(partialRecord, env))
+            signalProcessIfPresent(pid, 'SIGKILL');
+        }
+        fs.rmSync(pidFile, { force: true });
+        fs.rmSync(`${recordPath}.${process.pid}.tmp`, { force: true });
+        fs.rmSync(recordPath, { force: true });
+        throw error;
+      }
+    },
+    60_000
+  );
+}
+
 function getAndroidSerials(env: AndroidEnvironment): string[] {
   const output = execFileSync(env.adb, ['devices'], {
     encoding: 'utf8',
@@ -155,6 +435,25 @@ function getAndroidSerials(env: AndroidEnvironment): string[] {
     .map(([serial]) => serial);
 }
 
+function parseEmulatorStartArgs(args: string[]): { avd: string; gpu: string } {
+  const avd = args[0];
+  const gpuIndex = args.indexOf('--gpu');
+  const gpu = gpuIndex === -1 ? 'host' : args[gpuIndex + 1];
+  const expectedArgs = gpuIndex === -1 ? 1 : 3;
+  if (
+    !avd ||
+    avd.startsWith('-') ||
+    !gpu ||
+    !['host', 'swiftshader_indirect'].includes(gpu) ||
+    args.length !== expectedArgs
+  ) {
+    throw new Error(
+      'Usage: pnpm dev:mobile:android emulator-start <avd-name> [--gpu host|swiftshader_indirect]'
+    );
+  }
+  return { avd, gpu };
+}
+
 // Identity of the running emulator instance, stable for its whole life and
 // regenerated by the guest kernel on every boot.
 function readBootId(env: AndroidEnvironment, serial: string): string {
@@ -251,6 +550,34 @@ function releaseAndroidDevice(serial: string, worktreeRoot: string): void {
   });
 }
 
+function releaseWorktreeAndroidDevices(worktreeRoot: string): string[] {
+  const claimRoot = path.join(os.tmpdir(), 'kilo-mobile-android-claims');
+  let entries: string[];
+  try {
+    entries = fs.readdirSync(claimRoot);
+  } catch (error) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return [];
+    throw error;
+  }
+  const released: string[] = [];
+  const failures: Error[] = [];
+  for (const entry of entries) {
+    if (!entry.endsWith('.json')) continue;
+    const serial = entry.slice(0, -'.json'.length);
+    try {
+      const claim = JSON.parse(fs.readFileSync(path.join(claimRoot, entry), 'utf8')) as DeviceClaim;
+      if (claim.worktreeRoot !== worktreeRoot) continue;
+      releaseAndroidDevice(serial, worktreeRoot);
+      released.push(serial);
+    } catch (error) {
+      failures.push(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  if (failures.length > 0)
+    throw new AggregateError(failures, failures.map(failure => failure.message).join('; '));
+  return released;
+}
+
 async function main(): Promise<void> {
   const [command, ...args] = process.argv.slice(2);
   const env = environment();
@@ -319,6 +646,17 @@ async function main(): Promise<void> {
     console.log(`Installed ${serial}`);
     return;
   }
+  if (command === 'emulator-start') {
+    const { avd, gpu } = parseEmulatorStartArgs(args);
+    console.log(JSON.stringify(await startAndroidEmulator(env, worktreeRoot, avd, gpu), null, 2));
+    return;
+  }
+  if (command === 'emulator-stop') {
+    if (args.length !== 0) throw new Error('Usage: pnpm dev:mobile:android emulator-stop');
+    await stopAndroidEmulator(env, worktreeRoot);
+    console.log(`Stopped wrapper-owned emulator for ${path.basename(worktreeRoot)}`);
+    return;
+  }
   if (command === 'claim') {
     const serials = getAndroidSerials(env);
     const serial = args[0] ?? serials[0];
@@ -334,6 +672,16 @@ async function main(): Promise<void> {
     console.log(`Released ${serial}`);
     return;
   }
+  if (command === 'release-all') {
+    if (args.length !== 0) throw new Error('Usage: pnpm dev:mobile:android release-all');
+    const released = releaseWorktreeAndroidDevices(worktreeRoot);
+    console.log(
+      released.length === 0
+        ? `No Android device claimed by ${worktreeRoot}`
+        : `Released ${released.join(' ')}`
+    );
+    return;
+  }
   if (command === 'adb') return run(env.adb, args, env);
   if (command === 'emulator') return run(env.emulator, args, env);
   if (command === 'sdkmanager') {
@@ -341,7 +689,7 @@ async function main(): Promise<void> {
     return run(env.sdkmanager, args, env);
   }
   throw new Error(
-    'Usage: pnpm dev:mobile:android [doctor|fingerprint|build|prune|claim|release|adb|emulator|sdkmanager] [args...]'
+    'Usage: pnpm dev:mobile:android [doctor|fingerprint|build|prune|claim|release|release-all|emulator-start|emulator-stop|adb|emulator|sdkmanager] [args...]'
   );
 }
 
@@ -450,9 +798,17 @@ function androidProcessEnv(env: AndroidEnvironment): NodeJS.ProcessEnv {
 }
 
 export {
+  androidEmulatorSession,
   claimAndroidDevice,
+  commandMatchesRecordedEmulator,
+  findAvailableEmulatorPort,
+  isValidEmulatorRecord,
+  parseEmulatorStartArgs,
+  processOwnsListeningPort,
   readGradleWrapperVersion,
   releaseAndroidDevice,
+  releaseWorktreeAndroidDevices,
   resolveAndroidEnvironment,
+  signalProcessIfPresent,
 };
 export type { AndroidEnvironment };
diff --git a/dev/local/mobile-simulator.ts b/dev/local/mobile-simulator.ts
index 6a998849ca..52a2b26ad3 100644
--- a/dev/local/mobile-simulator.ts
+++ b/dev/local/mobile-simulator.ts
@@ -34,7 +34,7 @@ export type ShutdownFn = (deviceId: string) => void;
 // and silently reclaimable — when its worktree no longer exists on
 // disk. Concurrency is handled by atomic `wx` creation plus a short
 // per-device mutation lock; device-phase parallelism is capped by the
-// machine-global slot semaphore (.kilo_workflow/e2e-slot.sh), so no
+// machine-global slot semaphore (.kilo_workflow/e2e-take-slot.sh), so no
 // heavier ownership protocol is needed here.
 type ClaimRecord = {
   deviceId?: string;
@@ -447,8 +447,9 @@ function releaseSimulator(args: {
 
 // Release every simulator this worktree still holds, powering off the ones
 // its claims booted. Callers that only know the worktree — teardown paths like
-// `.kilo_workflow/e2e-slot.sh release`, which frees a slot without ever seeing
-// a UDID — need this so a forgotten `release <udid>` cannot leak a device.
+// `.kilo_workflow/e2e-stop-resource.sh ios`, which stops a resource without
+// ever seeing a UDID — need this so a forgotten `release <udid>` cannot leak a
+// device.
 // Returns the released device ids. Foreign claims are ignored, never touched.
 function releaseWorktreeSimulators(args: {
   lockRoot: string;
diff --git a/dev/local/mobile-workflow.test.ts b/dev/local/mobile-workflow.test.ts
index 371e43ee15..b27ec5f5b2 100644
--- a/dev/local/mobile-workflow.test.ts
+++ b/dev/local/mobile-workflow.test.ts
@@ -81,6 +81,12 @@ test('login polls the local outbox without one-second latency', () => {
   assert.match(login, /sleep 0\.25/);
 });
 
+test('parallel platform logins default to separate accounts', () => {
+  const login = fs.readFileSync('apps/mobile/e2e/login.sh', 'utf8');
+  assert.match(login, /emulator-\*\) PLATFORM=android/);
+  assert.match(login, /e2e-mobile-\$\{WORKTREE_SLUG\}-\$\{PLATFORM\}@example\.com/);
+});
+
 test('shared launch prompt grace periods total at most five seconds', () => {
   const settle = fs.readFileSync('apps/mobile/e2e/flows/settle-app.yaml', 'utf8');
   const openApp = fs.readFileSync('apps/mobile/e2e/flows/open-app.yaml', 'utf8');
@@ -94,12 +100,13 @@ test('shared launch prompt grace periods total at most five seconds', () => {
 
 test('settle flow handles the exact iOS external-app prompt within existing waits', () => {
   const flow = fs.readFileSync('apps/mobile/e2e/flows/settle-app.yaml', 'utf8');
-  const promptGuardIndex = flow.indexOf(`visible: 'Open this page in "Kilo"\\?'`);
-  const openActionIndex = flow.indexOf("tapOn: 'Open'", promptGuardIndex);
   const finalReadyWaitIndex = flow.lastIndexOf('- extendedWaitUntil:');
   const waitBlocks = [...flow.matchAll(/- extendedWaitUntil:\n[\s\S]*?(?=\n- |$)/g)].map(
     match => match[0]
   );
+  const secondWaitEnd = flow.indexOf(waitBlocks[1]) + waitBlocks[1].length;
+  const promptGuardIndex = flow.indexOf('- runFlow:', secondWaitEnd);
+  const openActionIndex = flow.indexOf("tapOn: 'Open'", promptGuardIndex);
   const timeouts = [...flow.matchAll(/timeout: (\d+)/g)].map(match => Number(match[1]));
 
   assert.match(
@@ -114,6 +121,11 @@ test('settle flow handles the exact iOS external-app prompt within existing wait
   );
   assert.match(waitBlocks[1], /timeout: 3000\n\s+optional: true/);
   assert.ok(promptGuardIndex > flow.indexOf(waitBlocks[1]), 'settle-app should guard Open');
+  assert.match(
+    flow.slice(promptGuardIndex, openActionIndex),
+    /Open this page in "Kilo"\\\?/,
+    'settle-app should guard Open with the exact prompt'
+  );
   assert.ok(openActionIndex > promptGuardIndex, 'settle-app should tap the exact Open action');
 
   const promptChain = [
diff --git a/dev/local/port-offset-lease.test.ts b/dev/local/port-offset-lease.test.ts
new file mode 100644
index 0000000000..097bb331f6
--- /dev/null
+++ b/dev/local/port-offset-lease.test.ts
@@ -0,0 +1,191 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import {
+  acquirePortOffsetLease,
+  findPortConflicts,
+  missingRunningServices,
+  releasePortOffsetClaims,
+} from './cli';
+import { acquireProcessLock } from './process-lock';
+import { applyPortOffset, portOffset } from './services';
+
+test('reuses a running stack only when every requested service is live', async () => {
+  const manifest = {
+    session: 'kilo-dev-test',
+    portOffset: 100,
+    wranglerRegistryPath: '/tmp/wrangler',
+    services: [
+      { name: 'mobile', port: 8181, group: 'mobile', type: 'process' },
+      { name: 'nextjs', port: 3100, group: 'app', type: 'nextjs' },
+    ],
+  };
+  const live = {
+    repoRoot: '/missing',
+    findPane: () => ({ windowIndex: 1, paneIndex: 0 }),
+    isPaneRunning: () => true,
+    probe: async () => true,
+  };
+  assert.deepEqual(
+    await missingRunningServices(manifest, 'kilo-dev-test', ['postgres', 'mobile', 'nextjs'], live),
+    []
+  );
+  assert.deepEqual(
+    await missingRunningServices(manifest, 'kilo-dev-test', ['mobile', 'event-service'], live),
+    ['event-service']
+  );
+  assert.deepEqual(await missingRunningServices(manifest, 'another-session', ['mobile'], live), [
+    'mobile',
+  ]);
+  assert.deepEqual(
+    await missingRunningServices(manifest, 'kilo-dev-test', ['mobile', 'nextjs'], {
+      ...live,
+      probe: async port => port !== 8181,
+    }),
+    ['mobile']
+  );
+});
+
+test('reuse waits through the normal service boot window', async () => {
+  const manifest = {
+    session: 'kilo-dev-test',
+    portOffset: 100,
+    wranglerRegistryPath: '/tmp/wrangler',
+    services: [{ name: 'mobile', port: 8181, group: 'mobile', type: 'process' }],
+  };
+  let probes = 0;
+  assert.deepEqual(
+    await missingRunningServices(manifest, 'kilo-dev-test', ['mobile'], {
+      findPane: () => ({ windowIndex: 1, paneIndex: 0 }),
+      isPaneRunning: () => true,
+      probe: async () => ++probes >= 3,
+      waitMs: 100,
+      pollMs: 1,
+    }),
+    []
+  );
+  assert.equal(probes, 3);
+});
+
+test('port conflict scan includes worker inspector ports', async () => {
+  let probes = 0;
+  const result = await findPortConflicts(
+    ['event-service'],
+    async () => ++probes === 2,
+    async () => false
+  );
+  assert.equal(probes, 2);
+  assert.match(result.conflicts[0], /^event-service-inspector:/);
+});
+
+test('automatic port selection skips conflicts and restores the offset on exhaustion', async () => {
+  const leases = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-port-lease-'));
+  const initialOffset = portOffset;
+  let scans = 0;
+  try {
+    await acquirePortOffsetLease(
+      [],
+      false,
+      '/worktree/one',
+      'missing-session-one',
+      leases,
+      async () => ({
+        conflicts: ++scans === 1 ? ['occupied:1'] : [],
+        reusedHostServices: new Set<string>(),
+      })
+    );
+    assert.equal(scans, 2);
+    await releasePortOffsetClaims('/worktree/one', 'missing-session-one', leases);
+    applyPortOffset(initialOffset);
+
+    await assert.rejects(
+      acquirePortOffsetLease(
+        [],
+        false,
+        '/worktree/two',
+        'missing-session-two',
+        leases,
+        async () => ({
+          conflicts: ['occupied:1'],
+          reusedHostServices: new Set<string>(),
+        })
+      ),
+      /No free worktree port offset/
+    );
+    assert.equal(portOffset, initialOffset);
+  } finally {
+    applyPortOffset(initialOffset);
+    fs.rmSync(leases, { recursive: true, force: true });
+  }
+});
+
+test('keeps a port offset reserved until its stack stops', async () => {
+  const leases = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-port-lease-'));
+  try {
+    await acquirePortOffsetLease([], true, '/worktree/one', 'missing-session-one', leases);
+    await assert.rejects(
+      acquirePortOffsetLease([], true, '/worktree/two', 'missing-session-two', leases),
+      /reserved by another worktree/
+    );
+    await releasePortOffsetClaims('/worktree/one', 'missing-session-one', leases);
+    await acquirePortOffsetLease([], true, '/worktree/two', 'missing-session-two', leases);
+    await releasePortOffsetClaims('/worktree/two', 'missing-session-two', leases);
+  } finally {
+    fs.rmSync(leases, { recursive: true, force: true });
+  }
+});
+
+test('reclaims a startup claim when its pid identity no longer matches', async () => {
+  const leases = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-port-lease-'));
+  try {
+    await acquirePortOffsetLease([], true, '/worktree/one', 'missing-session-one', leases);
+    const claimPath = path.join(
+      leases,
+      fs.readdirSync(leases).find(entry => entry.endsWith('.json'))!
+    );
+    const claim = JSON.parse(fs.readFileSync(claimPath, 'utf8'));
+    fs.writeFileSync(claimPath, JSON.stringify({ ...claim, identity: 'recycled-pid' }));
+
+    await acquirePortOffsetLease([], true, '/worktree/two', 'missing-session-two', leases);
+    await releasePortOffsetClaims('/worktree/two', 'missing-session-two', leases);
+  } finally {
+    fs.rmSync(leases, { recursive: true, force: true });
+  }
+});
+
+test('does not abort claim cleanup when an offset lock is busy', async () => {
+  const leases = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-port-lease-'));
+  try {
+    await acquirePortOffsetLease([], true, '/worktree/one', 'missing-session-one', leases);
+    const claim = fs.readdirSync(leases).find(entry => entry.endsWith('.json'))!;
+    const unlock = await acquireProcessLock(
+      path.join(leases, claim.replace(/\.json$/, '.lock')),
+      'test port offset'
+    );
+    try {
+      await releasePortOffsetClaims('/worktree/one', 'missing-session-one', leases, 0);
+      assert.equal(fs.existsSync(path.join(leases, claim)), true);
+    } finally {
+      await unlock();
+    }
+    await releasePortOffsetClaims('/worktree/one', 'missing-session-one', leases);
+    assert.equal(fs.existsSync(path.join(leases, claim)), false);
+  } finally {
+    fs.rmSync(leases, { recursive: true, force: true });
+  }
+});
+
+test('does not abort claim cleanup when removing a claim fails', async () => {
+  const leases = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-port-lease-'));
+  try {
+    await acquirePortOffsetLease([], true, '/worktree/one', 'missing-session-one', leases);
+    await releasePortOffsetClaims('/worktree/one', 'missing-session-one', leases, 0, () => {
+      throw new Error('read-only filesystem');
+    });
+  } finally {
+    fs.rmSync(leases, { recursive: true, force: true });
+  }
+});
diff --git a/dev/local/process-lock.test.ts b/dev/local/process-lock.test.ts
new file mode 100644
index 0000000000..78ea2bbc98
--- /dev/null
+++ b/dev/local/process-lock.test.ts
@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { withProcessLockAsync } from './process-lock';
+
+test('serializes async work on the same lock', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-process-lock-'));
+  const events: string[] = [];
+  try {
+    const first = withProcessLockAsync(path.join(root, 'lock'), 'test lock', async () => {
+      events.push('first:start');
+      await new Promise(resolve => setTimeout(resolve, 50));
+      events.push('first:end');
+    });
+    await new Promise(resolve => setTimeout(resolve, 10));
+    const second = withProcessLockAsync(
+      path.join(root, 'lock'),
+      'test lock',
+      async () => {
+        events.push('second');
+      },
+      1000
+    );
+    await Promise.all([first, second]);
+    assert.deepEqual(events, ['first:start', 'first:end', 'second']);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
diff --git a/dev/local/process-lock.ts b/dev/local/process-lock.ts
index 99cfacab46..62d89fafce 100644
--- a/dev/local/process-lock.ts
+++ b/dev/local/process-lock.ts
@@ -1,6 +1,11 @@
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
 import lockfile from 'proper-lockfile';
 
 export function withProcessLock<T>(lockPath: string, label: string, mutate: () => T): T {
+  fs.mkdirSync(path.dirname(lockPath), { recursive: true });
   let release: (() => void) | undefined;
   try {
     release = lockfile.lockSync(lockPath, {
@@ -19,3 +24,91 @@ export function withProcessLock<T>(lockPath: string, label: string, mutate: () =
     release();
   }
 }
+
+export async function acquireProcessLock(
+  lockPath: string,
+  label: string,
+  waitMs = 0
+): Promise<() => Promise<void>> {
+  fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+  try {
+    return await lockfile.lock(lockPath, {
+      lockfilePath: lockPath,
+      realpath: false,
+      stale: 30_000,
+      update: 10_000,
+      retries:
+        waitMs > 0
+          ? {
+              retries: Math.ceil(waitMs / 1000),
+              factor: 1,
+              minTimeout: 1000,
+              maxTimeout: 1000,
+              randomize: false,
+            }
+          : 0,
+    });
+  } catch (error) {
+    throw new Error(`${label} is locked by another live process`, { cause: error });
+  }
+}
+
+export async function withProcessLockAsync<T>(
+  lockPath: string,
+  label: string,
+  mutate: () => Promise<T>,
+  waitMs = 0
+): Promise<T> {
+  const release = await acquireProcessLock(lockPath, label, waitMs);
+  try {
+    return await mutate();
+  } finally {
+    await release();
+  }
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  let waitMs = 0;
+  if (args[0] === '--wait') {
+    const seconds = Number(args[1]);
+    if (!Number.isFinite(seconds) || seconds < 0)
+      throw new Error('process-lock: --wait must be a non-negative number of seconds');
+    waitMs = seconds * 1000;
+    args.splice(0, 2);
+  }
+  const lockPath = args.shift();
+  if (!lockPath || args.shift() !== '--' || args.length === 0) {
+    throw new Error('Usage: process-lock.ts [--wait <seconds>] <lock-path> -- <command> [args...]');
+  }
+
+  const [command, ...commandArgs] = args;
+  process.exitCode = await withProcessLockAsync(
+    lockPath,
+    path.basename(lockPath),
+    () =>
+      new Promise<number>((resolve, reject) => {
+        const child = spawn(command, commandArgs, { stdio: 'inherit' });
+        const signals = ['SIGINT', 'SIGTERM', 'SIGHUP'] as const;
+        const handlers = new Map(
+          signals.map(signal => [signal, () => child.kill(signal)] as const)
+        );
+        for (const [signal, handler] of handlers) process.once(signal, handler);
+        child.once('error', reject);
+        child.once('exit', code => {
+          for (const [signal, handler] of handlers) process.off(signal, handler);
+          resolve(code ?? 1);
+        });
+      }),
+    waitMs
+  );
+}
+
+const isMain =
+  process.argv[1] && path.resolve(process.argv[1]) === path.resolve(import.meta.filename);
+if (isMain) {
+  main().catch(error => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  });
+}
diff --git a/dev/local/runner.ts b/dev/local/runner.ts
index 24c9406e4b..6c011126de 100644
--- a/dev/local/runner.ts
+++ b/dev/local/runner.ts
@@ -134,9 +134,17 @@ function buildInfraLogCommand(serviceName: string): string {
   return `docker compose ${profileArg}-f dev/docker-compose.yml logs -f ${shellQuote(serviceName)}`;
 }
 
-function buildLogPipeCommand(logPath: string): string {
+export function buildLogPipeCommand(logPath: string): string {
   const filterPath = path.join(findRepoRoot(), 'dev', 'local', 'log-filter.ts');
-  return `tsx ${shellQuote(filterPath)} >> ${shellQuote(logPath)}`;
+  // Absolute tsx path: tmux pipe-pane commands inherit the tmux *server's*
+  // PATH, not the caller's, and a server started outside a direnv shell has
+  // no node_modules/.bin on it.
+  const tsxPath = path.join(findRepoRoot(), 'node_modules', '.bin', 'tsx');
+  return `${shellQuote(tsxPath)} ${shellQuote(filterPath)} >> ${shellQuote(logPath)}`;
+}
+
+export function buildFollowLogPipeCommand(logPath: string, followPath: string): string {
+  return `tee -a ${shellQuote(followPath)} | ${buildLogPipeCommand(logPath)}`;
 }
 
 function shellQuote(value: string): string {
diff --git a/dev/local/services.test.ts b/dev/local/services.test.ts
index 4313c40f18..8481f9e355 100644
--- a/dev/local/services.test.ts
+++ b/dev/local/services.test.ts
@@ -5,10 +5,9 @@ import path from 'node:path';
 import test from 'node:test';
 
 import {
-  applyPortOffset,
   candidatePortOffsets,
+  clearDevLogs,
   computePortOffset,
-  findFreePortOffset,
   getAlwaysOnGroupIds,
   getService,
   portOffset,
@@ -16,6 +15,7 @@ import {
   resolveGroups,
   resolveSessionNextAuthUrl,
   resolveTargets,
+  writePersistedPortOffset,
 } from './services';
 
 test('uses an automatic port offset for secondary worktrees by default', () => {
@@ -81,38 +81,40 @@ test('reads the persisted offset back from the running-stack manifest', () => {
   }
 });
 
-test('candidate offsets step by 100 and wrap within the valid range', () => {
-  const candidates = candidatePortOffsets(4900);
-  assert.equal(candidates[0], 5000);
-  assert.equal(candidates[1], 100);
-  assert.equal(candidates.length, 49);
-  assert.ok(!candidates.includes(4900));
-  assert.ok(!candidates.includes(0));
+test('persists the selected offset before a stack manifest exists', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-port-offset-'));
+  try {
+    writePersistedPortOffset(dir, 900);
+    assert.equal(readPersistedPortOffset(dir), 900);
+    assert.equal(fs.readFileSync(path.join(dir, 'dev/logs/port-offset'), 'utf8'), '900\n');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
 });
 
-test('applies the first free candidate offset when ports collide', async () => {
-  const original = portOffset;
-  const candidates = candidatePortOffsets(original);
-  const occupiedOffsets = new Set([original, candidates[0], candidates[1]]);
+test('log cleanup preserves startup coordination state', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-log-cleanup-'));
+  const logs = path.join(dir, 'dev/logs');
   try {
-    const chosen = await findFreePortOffset(async () => occupiedOffsets.has(portOffset));
-    assert.equal(chosen, candidates[2]);
-    assert.equal(portOffset, candidates[2]);
-    const worker = getService('auto-routing');
-    assert.equal(worker.port, 8810 + candidates[2]);
-    assert.ok(worker.command.includes(String(worker.port)));
+    fs.mkdirSync(path.join(logs, 'start.lock'), { recursive: true });
+    fs.writeFileSync(path.join(logs, 'port-offset'), '900\n');
+    fs.writeFileSync(path.join(logs, 'service.log'), 'old\n');
+    clearDevLogs(dir);
+    assert.equal(fs.readFileSync(path.join(logs, 'port-offset'), 'utf8'), '900\n');
+    assert.ok(fs.existsSync(path.join(logs, 'start.lock')));
+    assert.ok(!fs.existsSync(path.join(logs, 'service.log')));
   } finally {
-    applyPortOffset(original);
+    fs.rmSync(dir, { recursive: true, force: true });
   }
 });
 
-test('restores the original offset when every candidate is occupied', async () => {
-  const original = portOffset;
-  const originalPort = getService('auto-routing').port;
-  const chosen = await findFreePortOffset(async () => true);
-  assert.equal(chosen, undefined);
-  assert.equal(portOffset, original);
-  assert.equal(getService('auto-routing').port, originalPort);
+test('candidate offsets step by 100 and wrap within the valid range', () => {
+  const candidates = candidatePortOffsets(4900);
+  assert.equal(candidates[0], 5000);
+  assert.equal(candidates[1], 100);
+  assert.equal(candidates.length, 49);
+  assert.ok(!candidates.includes(4900));
+  assert.ok(!candidates.includes(0));
 });
 
 test('points NEXTAUTH_URL at the offset port when the web app runs without a tunnel', () => {
diff --git a/dev/local/services.ts b/dev/local/services.ts
index b9165aed8f..61ed8bde15 100644
--- a/dev/local/services.ts
+++ b/dev/local/services.ts
@@ -305,6 +305,14 @@ export function computePortOffset(args: {
 // on the ports of the stack that was actually started, even when dev:start
 // auto-probed away from the hash default.
 export function readPersistedPortOffset(repoRoot: string): number | undefined {
+  try {
+    const value = Number(
+      fs.readFileSync(path.join(repoRoot, 'dev', 'logs', 'port-offset'), 'utf-8').trim()
+    );
+    if (Number.isInteger(value) && value >= 0) return value;
+  } catch {
+    // A stack started before the dedicated file may still have a manifest.
+  }
   try {
     const raw = JSON.parse(
       fs.readFileSync(path.join(repoRoot, 'dev', 'logs', 'manifest.json'), 'utf-8')
@@ -316,6 +324,24 @@ export function readPersistedPortOffset(repoRoot: string): number | undefined {
   }
 }
 
+export function writePersistedPortOffset(repoRoot: string, value: number): void {
+  const logs = path.join(repoRoot, 'dev', 'logs');
+  fs.mkdirSync(logs, { recursive: true });
+  const target = path.join(logs, 'port-offset');
+  const temp = `${target}.${process.pid}.tmp`;
+  fs.writeFileSync(temp, `${value}\n`);
+  fs.renameSync(temp, target);
+}
+
+export function clearDevLogs(repoRoot: string): void {
+  const logs = path.join(repoRoot, 'dev', 'logs');
+  fs.mkdirSync(logs, { recursive: true });
+  for (const entry of fs.readdirSync(logs)) {
+    if (entry === 'port-offset' || entry === 'start.lock') continue;
+    fs.rmSync(path.join(logs, entry), { recursive: true, force: true });
+  }
+}
+
 function getPortOffset(): number {
   const root = execSync('git rev-parse --show-toplevel', { encoding: 'utf-8' }).trim();
   return computePortOffset({
@@ -688,21 +714,6 @@ export function candidatePortOffsets(start: number): number[] {
   return candidates;
 }
 
-// Probe candidate offsets until one whose full computed port set is free is
-// found, applying it via applyPortOffset and returning it. Restores the
-// starting offset and returns undefined when every candidate is occupied.
-export async function findFreePortOffset(
-  hasConflicts: () => Promise<boolean>
-): Promise<number | undefined> {
-  const start = portOffset;
-  for (const candidate of candidatePortOffsets(start)) {
-    applyPortOffset(candidate);
-    if (!(await hasConflicts())) return candidate;
-  }
-  applyPortOffset(start);
-  return undefined;
-}
-
 export function resolveTransitiveDeps(targets: string[]): string[] {
   const result = new Set<string>();
   const stack = [...targets];
diff --git a/dev/local/tmux.test.ts b/dev/local/tmux.test.ts
index 3cfd5ff99c..e683b86a1e 100644
--- a/dev/local/tmux.test.ts
+++ b/dev/local/tmux.test.ts
@@ -10,9 +10,15 @@ import {
   buildInteractiveShellCommand,
   captureServicePane,
   listWindows,
+  pipeServicePane,
   setPaneServiceIdentity,
 } from './tmux';
-import { buildStartCommand, restartServiceInTmux } from './runner';
+import {
+  buildFollowLogPipeCommand,
+  buildLogPipeCommand,
+  buildStartCommand,
+  restartServiceInTmux,
+} from './runner';
 
 test('buildInteractiveShellCommand wraps quoted startup commands in parseable shell syntax', () => {
   const startupCommand =
@@ -45,24 +51,23 @@ test(
   () => {
     const sessionName = `kilo-tmux-test-${process.pid}-${Date.now()}`;
     const serviceName = 'mobile';
+    const output = path.join(os.tmpdir(), `${sessionName}.log`);
+    const followOutput = path.join(os.tmpdir(), `${sessionName}-follow.log`);
     const tmux = (...args: string[]) => execFileSync('tmux', args, { stdio: 'ignore' });
 
     try {
       tmux('new-session', '-d', '-s', sessionName, '-n', 'dashboard', 'sleep 120');
-      tmux(
-        'new-window',
-        '-d',
-        '-t',
-        sessionName,
-        '-n',
-        serviceName,
-        '/bin/sh',
-        '-c',
-        'printf "worktree-mobile-pane\\n"; sleep 120'
-      );
+      tmux('new-window', '-d', '-t', sessionName, '-n', serviceName, '/bin/sh');
       const serviceWindow = listWindows(sessionName).find(window => window.name === serviceName);
       assert.ok(serviceWindow);
       setPaneServiceIdentity(sessionName, serviceWindow.index, 0, serviceName);
+      tmux(
+        'send-keys',
+        '-t',
+        `${sessionName}:${serviceWindow.index}.0`,
+        'printf "worktree-mobile-pane\\n"',
+        'Enter'
+      );
       tmux(
         'join-pane',
         '-h',
@@ -72,7 +77,36 @@ test(
         `${sessionName}:0.0`
       );
       assert.match(captureServicePane(sessionName, serviceName, 20), /worktree-mobile-pane/);
+      pipeServicePane(sessionName, serviceName, buildFollowLogPipeCommand(output, followOutput));
+      tmux('send-keys', '-t', `${sessionName}:0.1`, 'printf "followed-pane\\n"', 'Enter');
+      for (
+        let i = 0;
+        i < 60 &&
+        (!fs.existsSync(followOutput) ||
+          !fs.readFileSync(followOutput, 'utf8').includes('followed-pane') ||
+          !fs.existsSync(output) ||
+          !fs.readFileSync(output, 'utf8').includes('followed-pane'));
+        i++
+      ) {
+        execFileSync('sleep', ['0.05']);
+      }
+      assert.match(fs.readFileSync(output, 'utf8'), /followed-pane/);
+      assert.match(fs.readFileSync(followOutput, 'utf8'), /followed-pane/);
+      pipeServicePane(sessionName, serviceName, buildLogPipeCommand(output));
+      tmux('send-keys', '-t', `${sessionName}:0.1`, 'printf "replacement-pane\\n"', 'Enter');
+      for (
+        let i = 0;
+        i < 60 &&
+        (!fs.existsSync(output) || !fs.readFileSync(output, 'utf8').includes('replacement-pane'));
+        i++
+      ) {
+        execFileSync('sleep', ['0.05']);
+      }
+      assert.match(fs.readFileSync(output, 'utf8'), /replacement-pane/);
+      assert.doesNotMatch(fs.readFileSync(followOutput, 'utf8'), /replacement-pane/);
     } finally {
+      fs.rmSync(output, { force: true });
+      fs.rmSync(followOutput, { force: true });
       try {
         tmux('kill-session', '-t', sessionName);
       } catch {
diff --git a/dev/local/tmux.ts b/dev/local/tmux.ts
index e776e96309..ced878bbce 100644
--- a/dev/local/tmux.ts
+++ b/dev/local/tmux.ts
@@ -455,6 +455,16 @@ function captureServicePane(sessionName: string, serviceName: string, historyLin
   );
 }
 
+function pipeServicePane(sessionName: string, serviceName: string, command: string): void {
+  const pane = findServicePane(sessionName, serviceName);
+  if (!pane) throw new Error(`Service ${serviceName} is not running in ${sessionName}`);
+  execFileSync(
+    'tmux',
+    ['pipe-pane', '-t', `${sessionName}:${pane.windowIndex}.${pane.paneIndex}`, command],
+    { stdio: 'ignore' }
+  );
+}
+
 function isPaneRunningCommand(sessionName: string, pane: PaneInfo): boolean {
   try {
     const command = execSync(
@@ -590,6 +600,7 @@ export {
   countPanes,
   findServicePane,
   captureServicePane,
+  pipeServicePane,
   isPaneRunningCommand,
   paneHasRunningChild,
   selectPane,
diff --git a/dev/local/workflow-scripts.test.ts b/dev/local/workflow-scripts.test.ts
new file mode 100644
index 0000000000..7763421dbb
--- /dev/null
+++ b/dev/local/workflow-scripts.test.ts
@@ -0,0 +1,648 @@
+import assert from 'node:assert/strict';
+import { execFileSync, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+const repoRoot = process.cwd();
+
+function executable(file: string, contents: string): void {
+  fs.writeFileSync(file, contents);
+  fs.chmodSync(file, 0o755);
+}
+
+function gitRepo(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-workflow-script-'));
+  execFileSync('git', ['init', '-b', 'main', root]);
+  execFileSync('git', ['-C', root, 'config', 'user.email', 'test@example.com']);
+  execFileSync('git', ['-C', root, 'config', 'user.name', 'Test']);
+  fs.writeFileSync(path.join(root, '.gitignore'), '.env.local\n');
+  fs.writeFileSync(path.join(root, 'file.txt'), 'base\n');
+  execFileSync('git', ['-C', root, 'add', '.']);
+  execFileSync('git', ['-C', root, 'commit', '-m', 'base']);
+  return root;
+}
+
+test('baseline detects changes to an explicitly included ignored file', () => {
+  const root = gitRepo();
+  const baseline = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-baseline-test-'));
+  fs.rmdirSync(baseline);
+  const script = path.join(repoRoot, '.kilo_workflow/baseline.sh');
+  try {
+    fs.writeFileSync(path.join(root, '.env.local'), 'before\n');
+    execFileSync(script, ['snapshot', root, baseline, '--include', '.env.local']);
+    fs.writeFileSync(path.join(root, '.env.local'), 'after\n');
+    const result = spawnSync(script, ['check', root, baseline, '--include', '.env.local'], {
+      encoding: 'utf8',
+    });
+    assert.equal(result.status, 1);
+    assert.match(result.stdout, /DIVERGED included files/);
+    assert.ok(fs.existsSync(baseline), 'a mismatch should retain its evidence');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+    fs.rmSync(baseline, { recursive: true, force: true });
+  }
+});
+
+test('a successful baseline check consumes the snapshot for the next round', () => {
+  const root = gitRepo();
+  const baseline = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-baseline-test-'));
+  fs.rmdirSync(baseline);
+  const script = path.join(repoRoot, '.kilo_workflow/baseline.sh');
+  try {
+    execFileSync(script, ['snapshot', root, baseline]);
+    assert.match(execFileSync(script, ['check', root, baseline], { encoding: 'utf8' }), /OK/);
+    assert.ok(!fs.existsSync(baseline));
+    assert.doesNotThrow(() => execFileSync(script, ['snapshot', root, baseline]));
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+    fs.rmSync(baseline, { recursive: true, force: true });
+  }
+});
+
+test('slice check rejects an implementer that changed nothing', () => {
+  const root = gitRepo();
+  const output = path.join(os.tmpdir(), `kilo-slice-${process.pid}-${Date.now()}.diff`);
+  const script = path.join(repoRoot, '.kilo_workflow/slice-diff.sh');
+  try {
+    const snapshot = execFileSync(script, [root, output, '--', 'file.txt'], {
+      encoding: 'utf8',
+    }).trim();
+    const result = spawnSync(
+      script,
+      ['--check', 'implementer', snapshot, root, output, '--', 'file.txt'],
+      { encoding: 'utf8' }
+    );
+    assert.equal(result.status, 1);
+    assert.match(result.stdout, /without changing the owned paths/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+    fs.rmSync(output, { force: true });
+  }
+});
+
+test('role dispatches allocate distinct artifacts and verifier scratch', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-dispatch-test-'));
+  const bin = path.join(root, 'bin');
+  const scratch = path.join(root, 'scratch');
+  const home = path.join(root, 'home');
+  fs.mkdirSync(bin);
+  fs.mkdirSync(scratch);
+  fs.mkdirSync(home);
+  const tmux = path.join(bin, 'tmux');
+  const tmuxLog = path.join(root, 'tmux.log');
+  const handoff = path.join(root, 'handoff.md');
+  fs.writeFileSync(handoff, 'Review this.\n');
+  fs.writeFileSync(
+    tmux,
+    '#!/bin/sh\n' +
+      'if [ "$1" = display-message ]; then echo caller; fi\n' +
+      'if [ "$1" = new-window ]; then printf "%s\\n" "$*" >> "$TMUX_LOG"; echo @42; fi\n' +
+      'exit 0\n'
+  );
+  fs.chmodSync(tmux, 0o755);
+  const script = path.join(repoRoot, '.kilo_workflow/dispatch-role.sh');
+  const env = {
+    ...process.env,
+    HOME: home,
+    PATH: `${bin}:${process.env.PATH}`,
+    TMUX_LOG: tmuxLog,
+    TMUX_PANE: '%1',
+  };
+  const dispatch = (role = 'implementer', extraArgs: string[] = []) =>
+    execFileSync(
+      script,
+      [role, 'test-abcd', 'r1', repoRoot, scratch, 'Exercise the role.', ...extraArgs],
+      {
+        cwd: root,
+        encoding: 'utf8',
+        env,
+      }
+    ).trim();
+  try {
+    const first = dispatch();
+    fs.writeFileSync(path.join(home, '.cache/kilo-launch-gate/last'), '0\n');
+    const second = dispatch();
+    assert.notEqual(first, second);
+    assert.ok(fs.existsSync(`${first}.meta`));
+    assert.ok(fs.existsSync(`${second}.meta`));
+    assert.match(fs.readFileSync(`${first}.meta`, 'utf8'), /^tmux=@42$/m);
+    fs.writeFileSync(path.join(home, '.cache/kilo-launch-gate/last'), '0\n');
+    const verifier = dispatch('e2e-verifier');
+    const verifierScratch = fs
+      .readFileSync(`${verifier}.meta`, 'utf8')
+      .match(/^scratch=(.*)$/m)?.[1];
+    assert.ok(verifierScratch?.startsWith(`${scratch}/e2e-r1-`));
+    assert.ok(fs.existsSync(verifierScratch));
+    fs.writeFileSync(path.join(home, '.cache/kilo-launch-gate/last'), '0\n');
+    dispatch('implementer', ['--file', 'handoff.md']);
+    const tmuxCommands = fs.readFileSync(tmuxLog, 'utf8');
+    assert.ok(tmuxCommands.includes(`--file ${path.join(fs.realpathSync(root), 'handoff.md')}`));
+    assert.match(tmuxCommands, /--auto/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('interactive launches return a stable tmux window id', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-interactive-test-'));
+  const bin = path.join(root, 'bin');
+  const home = path.join(root, 'home');
+  const log = path.join(root, 'interactive.log');
+  fs.mkdirSync(bin);
+  fs.mkdirSync(home);
+  fs.writeFileSync(
+    path.join(bin, 'tmux'),
+    '#!/bin/sh\n' +
+      'if [ "$1" = display-message ]; then echo caller; fi\n' +
+      'if [ "$1" = new-window ]; then echo @77; fi\n' +
+      'exit 0\n'
+  );
+  fs.writeFileSync(path.join(bin, 'sleep'), '#!/bin/sh\nexit 0\n');
+  for (const command of ['tmux', 'sleep']) fs.chmodSync(path.join(bin, command), 0o755);
+  try {
+    const output = execFileSync(
+      path.join(repoRoot, '.kilo_workflow/launch-interactive.sh'),
+      ['test-abcd-planner', repoRoot, '--log', log, 'kilo', '--interactive'],
+      {
+        encoding: 'utf8',
+        env: {
+          ...process.env,
+          HOME: home,
+          PATH: `${bin}:${process.env.PATH}`,
+          TMUX_PANE: '%1',
+        },
+      }
+    ).trim();
+    assert.equal(output, '@77');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('await-role accepts only a completed role-specific verdict', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-await-role-test-'));
+  const bin = path.join(root, 'bin');
+  fs.mkdirSync(bin);
+  fs.writeFileSync(path.join(bin, 'tmux'), '#!/bin/sh\nexit 1\n');
+  fs.writeFileSync(path.join(bin, 'sleep'), '#!/bin/sh\nexit 0\n');
+  for (const command of ['tmux', 'sleep']) fs.chmodSync(path.join(bin, command), 0o755);
+  const script = path.join(repoRoot, '.kilo_workflow/await-role.sh');
+  const run = (
+    name: string,
+    options: {
+      exit?: boolean;
+      log: string;
+      meta?: string;
+    }
+  ) => {
+    const log = path.join(root, `${name}.log`);
+    fs.writeFileSync(log, options.log);
+    if (options.exit !== false) fs.writeFileSync(`${log}.exit`, '0\n');
+    if (options.meta !== undefined) fs.writeFileSync(`${log}.meta`, options.meta);
+    return spawnSync(script, [log, '--timeout', '0', '--stall', '999'], {
+      encoding: 'utf8',
+      env: { ...process.env, PATH: `${bin}:${process.env.PATH}` },
+    });
+  };
+  try {
+    const done = run('done', {
+      log: 'No findings.\nEXITCODE=0\n',
+      meta: 'role=impl-reviewer\nmode=verify\ntmux=@1\n',
+    });
+    assert.equal(done.status, 0);
+    assert.equal(done.stdout.trim(), 'DONE No findings.');
+
+    const invalid = [
+      run('implementer-wrong-sentinel', {
+        log: 'No findings.\nEXITCODE=0\n',
+        meta: 'role=implementer\nmode=verify\ntmux=@2\n',
+      }),
+      run('repro-wrong-sentinel', {
+        log: 'VERIFICATION PASSED.\nEXITCODE=0\n',
+        meta: 'role=e2e-verifier\nmode=repro\ntmux=@3\n',
+      }),
+      run('zero-findings', {
+        log: 'FINDINGS: 0\nEXITCODE=0\n',
+        meta: 'role=impl-reviewer\nmode=verify\ntmux=@4\n',
+      }),
+      run('corrupt-meta', {
+        log: 'No findings.\nEXITCODE=0\n',
+        meta: 'role=unknown\nmode=verify\ntmux=@5\n',
+      }),
+      run('missing-meta', {
+        log: 'No findings.\nEXITCODE=0\n',
+      }),
+      run('dead-target', {
+        exit: false,
+        log: 'still working\n',
+        meta: 'role=impl-reviewer\nmode=verify\ntmux=@6\n',
+      }),
+    ];
+    for (const result of invalid) {
+      assert.equal(result.status, 2, result.stderr);
+      assert.match(result.stdout, /^VOID /);
+    }
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('reviewer ranking aborts when commit history lookup fails', () => {
+  const root = gitRepo();
+  const bin = path.join(root, 'bin');
+  fs.mkdirSync(bin);
+  const gh = path.join(bin, 'gh');
+  fs.writeFileSync(
+    gh,
+    '#!/bin/sh\n[ "$1" = api ] && exit 1\n[ "$1" = pr ] && [ "$2" = list ] && exit 0\nexit 0\n'
+  );
+  fs.chmodSync(gh, 0o755);
+  try {
+    const result = spawnSync(
+      path.join(repoRoot, '.kilo_workflow/pick-reviewers.sh'),
+      ['Kilo-Org/cloud', 'requester', 'file.txt'],
+      {
+        cwd: root,
+        encoding: 'utf8',
+        env: { ...process.env, PATH: `${bin}:${process.env.PATH}` },
+      }
+    );
+    assert.equal(result.status, 1);
+    assert.match(result.stderr, /failed to find PRs for commit/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('reviewer ranking refuses files that do not exist in the repo', () => {
+  const root = gitRepo();
+  try {
+    const result = spawnSync(
+      path.join(repoRoot, '.kilo_workflow/pick-reviewers.sh'),
+      ['Kilo-Org/cloud', 'requester', 'no-such-file.txt'],
+      { cwd: root, encoding: 'utf8' }
+    );
+    assert.equal(result.status, 1);
+    assert.match(result.stderr, /run in the changed repo/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('launch gate explains how to repair an unprepared worktree', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-launch-gate-test-'));
+  const workflow = path.join(root, '.kilo_workflow');
+  fs.mkdirSync(workflow);
+  const script = path.join(workflow, 'launch-gate.sh');
+  fs.copyFileSync(path.join(repoRoot, '.kilo_workflow/launch-gate.sh'), script);
+  fs.chmodSync(script, 0o755);
+  try {
+    const result = spawnSync(script, [], {
+      encoding: 'utf8',
+      env: { ...process.env, HOME: path.join(root, 'home') },
+    });
+    assert.equal(result.status, 1);
+    assert.match(result.stderr, /prepare the cloud worktree/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('E2E lifecycle scripts take, start, stop, and free one slot', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-e2e-lifecycle-test-'));
+  const bin = path.join(root, 'bin');
+  const home = path.join(root, 'home');
+  const commandLog = path.join(root, 'commands.log');
+  fs.mkdirSync(bin);
+  fs.mkdirSync(home);
+  fs.writeFileSync(
+    path.join(bin, 'tmux'),
+    '#!/bin/sh\n' +
+      'if [ "$1" = display-message ]; then echo test-owner; exit 0; fi\n' +
+      'if [ "$1" = has-session ]; then [ "$3" = "=test-owner" ]; exit; fi\n' +
+      'if [ "$1" = list-sessions ]; then echo test-owner; exit 0; fi\n' +
+      'exit 1\n'
+  );
+  fs.writeFileSync(path.join(bin, 'git'), `#!/bin/sh\nprintf '%s\\n' '${repoRoot}'\n`);
+  fs.writeFileSync(path.join(bin, 'pnpm'), '#!/bin/sh\nprintf "%s\\n" "$*" >> "$COMMAND_LOG"\n');
+  for (const command of ['tmux', 'git', 'pnpm']) fs.chmodSync(path.join(bin, command), 0o755);
+  const env = {
+    ...process.env,
+    COMMAND_LOG: commandLog,
+    HOME: home,
+    PATH: `${bin}:${process.env.PATH}`,
+    TMPDIR: path.join(root, 'tmp'),
+    TMUX_PANE: '%1',
+  };
+  try {
+    const run = (script: string, args: string[] = []) =>
+      spawnSync(path.join(repoRoot, '.kilo_workflow', script), args, {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        env,
+      });
+    assert.equal(run('e2e-take-slot.sh').status, 0);
+    assert.equal(run('e2e-start-resource.sh', ['stack', 'mobile', 'web']).status, 0);
+    assert.equal(run('e2e-stop-resource.sh', ['stack']).status, 0);
+    assert.match(run('e2e-slot-status.sh').stdout, /slot-1: test-owner/);
+    // The old API was `e2e-slot.sh acquire <session>` — a forwarded session
+    // name must fail loudly, never acquire under the wrong owner.
+    const badTake = run('e2e-take-slot.sh', ['my-session']);
+    assert.equal(badTake.status, 1);
+    assert.match(badTake.stderr, /takes no session name/);
+    assert.equal(run('e2e-free-slot.sh').status, 0);
+    assert.match(run('e2e-slot-status.sh').stdout, /0\/3 held/);
+    assert.equal(
+      fs.readFileSync(commandLog, 'utf8'),
+      'dev:start --no-attach --reuse-running mobile web\ndev:stop\n'
+    );
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('E2E status reclaims dead slot owners and reports unaccounted stacks', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-e2e-status-test-'));
+  const bin = path.join(root, 'bin');
+  const home = path.join(root, 'home');
+  const slot = path.join(home, '.cache/kilo-e2e-slots/slot-1');
+  fs.mkdirSync(bin);
+  fs.mkdirSync(slot, { recursive: true });
+  fs.writeFileSync(path.join(slot, 'owner'), 'dead-owner');
+  fs.writeFileSync(path.join(slot, 'worktree'), path.join(root, 'dead-abcd'));
+  fs.writeFileSync(path.join(slot, 'since'), '2026-01-01T00:00:00Z\n');
+  fs.writeFileSync(
+    path.join(bin, 'tmux'),
+    '#!/bin/sh\n' +
+      'if [ "$1" = has-session ]; then exit 1; fi\n' +
+      'if [ "$1" = list-sessions ]; then printf "live-owner\\nkilo-dev-orphan-abcd\\n"; exit 0; fi\n' +
+      'exit 1\n'
+  );
+  fs.chmodSync(path.join(bin, 'tmux'), 0o755);
+  try {
+    const result = spawnSync(path.join(repoRoot, '.kilo_workflow/e2e-slot-status.sh'), [], {
+      encoding: 'utf8',
+      env: { ...process.env, HOME: home, PATH: `${bin}:${process.env.PATH}`, TMPDIR: root },
+    });
+    assert.equal(result.status, 0, result.stderr);
+    assert.ok(!fs.existsSync(slot));
+    assert.match(result.stderr, /reclaimed slot-1 from dead session dead-owner/);
+    assert.match(result.stdout, /UNACCOUNTED stack: kilo-dev-orphan-abcd/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('reap removes a stale ownerless slot left by an interrupted acquire', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-e2e-orphan-test-'));
+  const bin = path.join(root, 'bin');
+  const home = path.join(root, 'home');
+  const slot = path.join(home, '.cache/kilo-e2e-slots/slot-1');
+  fs.mkdirSync(bin);
+  fs.mkdirSync(slot, { recursive: true });
+  const old = new Date(Date.now() - 61_000);
+  fs.utimesSync(slot, old, old);
+  fs.writeFileSync(
+    path.join(bin, 'tmux'),
+    '#!/bin/sh\nif [ "$1" = list-sessions ]; then exit 0; fi\nexit 1\n'
+  );
+  fs.chmodSync(path.join(bin, 'tmux'), 0o755);
+  try {
+    const result = spawnSync(path.join(repoRoot, '.kilo_workflow/e2e-slot-status.sh'), [], {
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        HOME: home,
+        PATH: `${bin}:${process.env.PATH}`,
+        TMPDIR: root,
+      },
+    });
+    assert.equal(result.status, 0, result.stderr);
+    assert.ok(!fs.existsSync(slot));
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('PR gate rejects a bot comment older than the current head', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-pr-gate-test-'));
+  const workflow = path.join(root, '.kilo_workflow');
+  const bin = path.join(root, 'bin');
+  fs.mkdirSync(workflow);
+  fs.mkdirSync(bin);
+  for (const script of ['pr-gate.sh', 'pr-threads.sh']) {
+    fs.copyFileSync(path.join(repoRoot, '.kilo_workflow', script), path.join(workflow, script));
+    fs.chmodSync(path.join(workflow, script), 0o755);
+  }
+  executable(
+    path.join(bin, 'gh'),
+    `#!/bin/sh
+if [ "$1 $2" = "pr view" ]; then
+  printf '%s\n' '{"headRefOid":"abc","mergeable":"MERGEABLE","mergeStateStatus":"CLEAN","statusCheckRollup":[{"name":"test","conclusion":"SUCCESS"}],"assignees":[{"login":"igor"}],"labels":[],"comments":[{"author":{"login":"kilo-code-bot"},"createdAt":"2026-01-01T00:00:00Z","body":"approved"}]}'
+elif [ "$1" = api ] && [ "$2" = "repos/Kilo-Org/cloud/commits/abc" ]; then
+  printf '%s\n' '2026-01-02T00:00:00Z'
+elif [ "$1 $2" = "api graphql" ]; then
+  printf '%s\n' '{"pageInfo":{"hasNextPage":false,"endCursor":null},"nodes":[]}'
+else
+  exit 1
+fi
+`
+  );
+  try {
+    const result = spawnSync(path.join(workflow, 'pr-gate.sh'), ['Kilo-Org/cloud', '1'], {
+      encoding: 'utf8',
+      env: { ...process.env, PATH: `${bin}:${process.env.PATH}` },
+    });
+    assert.equal(result.status, 1, result.stderr);
+    assert.match(result.stdout, /bot comments after head commit: NONE/);
+    assert.match(result.stdout, /no kilo-code-bot summary/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('PR thread listing fails when a later page cannot be read', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-pr-threads-test-'));
+  const bin = path.join(root, 'bin');
+  const calls = path.join(root, 'calls');
+  fs.mkdirSync(bin);
+  executable(
+    path.join(bin, 'gh'),
+    `#!/bin/sh
+n=$(cat "$CALLS" 2>/dev/null || echo 0)
+n=$((n + 1))
+printf '%s\n' "$n" > "$CALLS"
+[ "$n" -eq 1 ] || exit 19
+printf '%s\n' '{"pageInfo":{"hasNextPage":true,"endCursor":"next"},"nodes":[]}'
+`
+  );
+  try {
+    const result = spawnSync(
+      path.join(repoRoot, '.kilo_workflow/pr-threads.sh'),
+      ['unresolved', 'Kilo-Org/cloud', '1'],
+      {
+        encoding: 'utf8',
+        env: { ...process.env, CALLS: calls, PATH: `${bin}:${process.env.PATH}` },
+      }
+    );
+    assert.equal(result.status, 19);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('PR thread close is repository-bound and idempotent', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-pr-close-test-'));
+  const bin = path.join(root, 'bin');
+  const log = path.join(root, 'gh.log');
+  const gh = path.join(bin, 'gh');
+  fs.mkdirSync(bin);
+  executable(
+    gh,
+    `#!/bin/sh
+printf '%s\n' "$*" >> "$GH_LOG"
+case "$*" in
+  *resolveReviewThread*) printf '%s\n' true ;;
+  *node\\(id:*) printf '%s\n' '{"data":{"node":{"pullRequest":{"number":1},"repository":{"nameWithOwner":"Kilo-Org/other"},"comments":{"pageInfo":{"hasNextPage":false,"endCursor":null},"nodes":[{"databaseId":7,"body":"(bot) fixed"}]}}}}' ;;
+  *) exit 1 ;;
+esac
+`
+  );
+  const run = () =>
+    spawnSync(
+      path.join(repoRoot, '.kilo_workflow/pr-threads.sh'),
+      ['close', 'Kilo-Org/cloud', 'thread', 'fixed'],
+      {
+        encoding: 'utf8',
+        env: { ...process.env, GH_LOG: log, PATH: `${bin}:${process.env.PATH}` },
+      }
+    );
+  try {
+    const foreign = run();
+    assert.equal(foreign.status, 1);
+    assert.match(foreign.stderr, /belongs to Kilo-Org\/other/);
+    assert.doesNotMatch(fs.readFileSync(log, 'utf8'), /resolveReviewThread|\/replies/);
+
+    fs.writeFileSync(
+      gh,
+      fs.readFileSync(gh, 'utf8').replace('"Kilo-Org/other"', '"Kilo-Org/cloud"')
+    );
+    fs.writeFileSync(log, '');
+    const retry = run();
+    assert.equal(retry.status, 0, retry.stderr);
+    assert.match(retry.stdout, /reply already posted/);
+    assert.match(retry.stdout, /resolved thread/);
+    assert.doesNotMatch(fs.readFileSync(log, 'utf8'), /\/replies/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('interactive monitor distinguishes completed, blocked, and dead sessions', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-await-interactive-test-'));
+  const bin = path.join(root, 'bin');
+  fs.mkdirSync(bin);
+  executable(path.join(bin, 'tmux'), '#!/bin/sh\nexit 1\n');
+  executable(path.join(bin, 'sleep'), '#!/bin/sh\nexit 0\n');
+  const run = (scratch: string) =>
+    spawnSync(path.join(repoRoot, '.kilo_workflow/await-interactive.sh'), ['@1', scratch], {
+      encoding: 'utf8',
+      env: { ...process.env, PATH: `${bin}:${process.env.PATH}` },
+    });
+  try {
+    assert.deepEqual(
+      [run(path.join(root, 'gone')).status, run(path.join(root, 'gone')).stdout.trim()],
+      [0, 'COMPLETED']
+    );
+    const blocked = path.join(root, 'blocked');
+    fs.mkdirSync(blocked);
+    fs.writeFileSync(path.join(blocked, 'final-report.md'), 'blocked\n');
+    const blockedResult = run(blocked);
+    assert.equal(blockedResult.status, 5);
+    assert.equal(blockedResult.stdout.trim(), `BLOCKED ${blocked}/final-report.md`);
+    const dead = path.join(root, 'dead');
+    fs.mkdirSync(dead);
+    const deadResult = run(dead);
+    assert.equal(deadResult.status, 2);
+    assert.equal(deadResult.stdout.trim(), 'DEAD');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('section setup removes its worktree and branch when preparation fails', () => {
+  const root = gitRepo();
+  const remote = path.join(os.tmpdir(), `kilo-init-remote-${process.pid}-${Date.now()}.git`);
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-init-home-'));
+  const bin = path.join(home, 'bin');
+  const workflow = path.join(root, '.kilo_workflow');
+  fs.mkdirSync(bin);
+  fs.mkdirSync(workflow);
+  fs.copyFileSync(
+    path.join(repoRoot, '.kilo_workflow/init-section.sh'),
+    path.join(workflow, 'init-section.sh')
+  );
+  fs.chmodSync(path.join(workflow, 'init-section.sh'), 0o755);
+  executable(path.join(bin, 'pnpm'), '#!/bin/sh\nexit 9\n');
+  try {
+    execFileSync('git', ['clone', '--bare', root, remote]);
+    execFileSync('git', ['-C', root, 'remote', 'add', 'origin', remote]);
+    const result = spawnSync(path.join(workflow, 'init-section.sh'), ['cleanup'], {
+      cwd: root,
+      encoding: 'utf8',
+      env: { ...process.env, HOME: home, PATH: `${bin}:${process.env.PATH}` },
+    });
+    assert.equal(result.status, 9);
+    assert.equal(
+      execFileSync('git', ['-C', root, 'branch', '--format=%(refname:short)'], {
+        encoding: 'utf8',
+      }).trim(),
+      'main'
+    );
+    assert.equal(
+      execFileSync('git', ['-C', root, 'worktree', 'list', '--porcelain'], {
+        encoding: 'utf8',
+      }).match(/^worktree /gm)?.length,
+      1
+    );
+    assert.deepEqual(fs.readdirSync(path.join(home, 'Projects/.worktrees')), []);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+    fs.rmSync(remote, { recursive: true, force: true });
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('steer requires a new submitted echo for an identical message', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-steer-test-'));
+  const bin = path.join(root, 'bin');
+  const state = path.join(root, 'state');
+  fs.mkdirSync(bin);
+  fs.writeFileSync(state, '1\n');
+  executable(
+    path.join(bin, 'tmux'),
+    `#!/bin/sh
+case "$1" in
+  display-message) echo node ;;
+  capture-pane)
+    echo '› repeat me'
+    [ "$(cat "$STATE")" -eq 2 ] && echo '› repeat me'
+    ;;
+  send-keys) echo 2 > "$STATE" ;;
+esac
+`
+  );
+  executable(path.join(bin, 'sleep'), '#!/bin/sh\nexit 0\n');
+  try {
+    const result = spawnSync(path.join(repoRoot, '.kilo_workflow/steer.sh'), ['@1', 'repeat me'], {
+      encoding: 'utf8',
+      env: { ...process.env, PATH: `${bin}:${process.env.PATH}`, STATE: state },
+    });
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(result.stdout.trim(), 'running');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
diff --git a/package.json b/package.json
index c9cb55a967..042aed004a 100644
--- a/package.json
+++ b/package.json
@@ -10,7 +10,7 @@
     "preinstall": "npx only-allow pnpm",
     "typecheck": "scripts/typecheck-all.sh",
     "build": "pnpm --filter web build",
-    "test": "pnpm --filter web test && pnpm run test:web-env",
+    "test": "pnpm --filter web test && pnpm run test:web-env && pnpm run test:dev-local",
     "test:web-env": "tsx --tsconfig scripts/web-env/tsconfig.json --test scripts/web-env/shared.test.ts",
     "test:setup-smoke": "pnpm --filter web run test:setup-smoke",
     "lint": "scripts/lint-all.sh",
@@ -23,7 +23,7 @@
     "test:e2e": "pnpm --filter web run test:e2e",
     "dependency-cycle-check": "pnpm --filter web run dependency-cycle-check",
     "dev:worktree:prepare": "bash scripts/worktree-prepare.sh",
-    "test:db": "docker compose -f dev/docker-compose.yml up -d --wait postgres && pnpm drizzle migrate",
+    "test:db": "docker compose -f dev/docker-compose.yml up -d --wait postgres && POSTGRES_URL=${POSTGRES_URL:-postgresql://postgres:postgres@localhost:5432/postgres} pnpm drizzle migrate",
     "dev:db:reset": "pnpm --filter web db:empty-database",
     "dev:start": "tsx dev/local/cli.ts up",
     "dev:stop": "tsx dev/local/cli.ts stop",
@@ -35,7 +35,8 @@
     "dev:mobile:simulator": "tsx dev/local/mobile-simulator.ts",
     "dev:mobile:android": "tsx dev/local/mobile-android.ts",
     "dev:mobile:ios": "tsx dev/local/mobile-ios-build.ts",
-    "test:mobile-workflow": "tsx --test dev/local/mobile-simulator.test.ts dev/local/mobile-native-build.test.ts dev/local/mobile-ios-build.test.ts dev/local/mobile-android-build.test.ts dev/local/mobile-android.test.ts dev/local/mobile-workflow.test.ts",
+    "test:dev-local": "tsx --test dev/local/*.test.ts dev/local/env-sync/*.test.ts dev/local/scripts/*.test.ts",
+    "test:mobile-workflow": "tsx --test dev/local/mobile-simulator.test.ts dev/local/mobile-native-build.test.ts dev/local/mobile-ios-build.test.ts dev/local/mobile-android-build.test.ts dev/local/mobile-android.test.ts dev/local/mobile-workflow.test.ts dev/local/maestro-wrapper.test.ts",
     "dev:setup-env": "tsx dev/local/setup-env.ts",
     "dev:seed": "tsx dev/seed/index.ts",
     "dev:discord-gateway-cron": "tsx dev/discord-gateway-cron.ts",
diff --git a/skills-lock.json b/skills-lock.json
index 2c72014f69..73366d7eed 100644
--- a/skills-lock.json
+++ b/skills-lock.json
@@ -6,6 +6,12 @@
       "sourceType": "github",
       "computedHash": "72efa2277fea08f43b393c74abaacc9fa575e20bc63bdc9d46829b8a39352852"
     },
+    "kilo-design-cloud": {
+      "source": "Kilo-Org/kilo-design",
+      "sourceType": "github",
+      "skillPath": "skills/kilo-design-cloud/SKILL.md",
+      "computedHash": "8d4efadfae142c0db44367c48e12cf9e46d0d322692335a2f159c2f0ca169f33"
+    },
     "workers-best-practices": {
       "source": "cloudflare/skills",
       "sourceType": "github",

From 13e8eb1d90a274f77cfc2161eb941e0efc42fc93 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Wed, 29 Jul 2026 23:58:21 +0200
Subject: [PATCH 07/34] docs(workflow): smooth the rough edges the Q&A rounds
 exposed

Five kilo-auto/efficient rounds over 18 workflow hypotheticals found two
repeat misses: agents hand-repairing a non-init-section worktree (5/5
divergent) and over-filing learnings to learnings/system/ (2/5). Fail loud
with the remedy in init-section's preflight, document that a hand-created
worktree cannot be repaired, and state that system/ is the rare exception.
---
 .kilo_workflow/WORKFLOW.md     | 4 ++--
 .kilo_workflow/init-section.sh | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.kilo_workflow/WORKFLOW.md b/.kilo_workflow/WORKFLOW.md
index 2fee42b74d..d7dd601d50 100644
--- a/.kilo_workflow/WORKFLOW.md
+++ b/.kilo_workflow/WORKFLOW.md
@@ -13,7 +13,7 @@ These apply to every role. Later sections do not repeat them.
 - Every long-lived process — planner, orchestrator, dispatched role agents, local services — runs in tmux, with a unique descriptive window or session name; the launch scripts guarantee this. The one exception is the starter, which lives wherever the user invoked it (often a plain harness session outside tmux) — its launches still land in tmux via `launch-interactive.sh`.
 - Section names are lowercase slugs (`[a-z0-9-]` only — they become branch, tmux, and path names). `init-section.sh` appends the four-hex run id, for example `billing-a7f3`, so parallel runs cannot collide.
 - All workflow tmux lives on the default tmux server — never a custom socket; slot reaping and monitoring key on the sessions one server can see.
-- Work only in dedicated worktrees, in every repository the plan touches — never a primary or main checkout, with one exception: machine-local learnings under the main checkout's `.kilo_workflow/learnings/system/`. [`init-section.sh`](init-section.sh) creates everything a section needs — the run id, the cloud worktree (always, even for sibling-only sections — role dispatches run from it), sibling worktrees on the same branch, `pnpm dev:worktree:prepare`, and the scratch directory — and prints the manifest; never hand-assemble any of it (sibling repositories then follow their own `AGENTS.md` setup; `~/Projects/kilocode` uses bun, not pnpm). A worktree is the one local artifact that outlives the run; remove it (`git worktree remove <path>`) once its PR closes.
+- Work only in dedicated worktrees, in every repository the plan touches — never a primary or main checkout, with one exception: machine-local learnings under the main checkout's `.kilo_workflow/learnings/system/`. [`init-section.sh`](init-section.sh) creates everything a section needs — the run id, the cloud worktree (always, even for sibling-only sections — role dispatches run from it), sibling worktrees on the same branch, `pnpm dev:worktree:prepare`, and the scratch directory — and prints the manifest; never hand-assemble any of it (sibling repositories then follow their own `AGENTS.md` setup; `~/Projects/kilocode` uses bun, not pnpm). A worktree made any other way — by `git worktree add`, by hand — has no run id, manifest, or scratch and cannot be repaired in place: remove it and run `init-section.sh`. A worktree is the one local artifact that outlives the run; remove it (`git worktree remove <path>`) once its PR closes.
 - The scratch directory (from `init-section.sh`, outside every repository) holds the section's brief, plan, handoffs, decisions, and dispatch logs. Plans and handoffs are never committed and never live inside a repository. A planner adding a repository mid-plan runs `init-section.sh add-repo <section> <repo>` and adds the printed worktree path to the handoff.
 - The PR, ready for human eyes, is the deliverable. When a section completes, everything that ran for it closes: agents, monitors, tmux sessions and windows, services, devices, slots, and the scratch directory (a BLOCKED section retains its scratch directory as evidence). Anything a human needs afterward lives in the PR.
 - Every reviewer and verifier invocation is a fresh session, so earlier conclusions cannot anchor later passes.
@@ -347,7 +347,7 @@ Never collapse retryable and non-retryable failures into one generic error state
 Environment blockers and their fixes — broken local stacks, credential traps, simulator quirks, tool wedges — recorded so future runs do not rediscover them. Product bugs never go in learnings.
 
 - Format: **symptom / cause / fix**, a few lines each, in a file whose name makes it findable from the symptom (for example `mobile-metro-file-map-stale-after-node-modules-relayout.md`).
-- System-specific learnings (true only of this machine: installed tools, local ports, OS quirks) go to `learnings/system/`, which is gitignored (only its `.gitkeep` is committed). Write them to the **main checkout's** copy — `~/Projects/cloud/.kilo_workflow/learnings/system/` — so they survive worktree deletion and reach parallel runs immediately; `pnpm dev:worktree:prepare` copies them into fresh worktrees.
+- System-specific learnings (true only of this machine: installed tools, local ports, OS quirks) go to `learnings/system/`, which is gitignored (only its `.gitkeep` is committed). Write them to the **main checkout's** copy — `~/Projects/cloud/.kilo_workflow/learnings/system/` — so they survive worktree deletion and reach parallel runs immediately; `pnpm dev:worktree:prepare` copies them into fresh worktrees. `learnings/system/` is the rare exception: when in doubt, commit in the section worktree.
 - Everything else goes to the section worktree's `.kilo_workflow/learnings/` and is committed — the orchestrator includes new learnings in the run's PR (they reach other runs once merged; that lag is accepted). Committed promptly, not at the end: an uncommitted learning blocks E2E dispatch (see E2E Loop) and is one stray cleanup away from vanishing. The planner cannot commit (the orchestrator owns Git), so a planner-authored learning is named in the orchestrator handoff as work for the first commit.
 - `.kilo_workflow/` is exempt from section disjointness — any section may write learnings or fix this document; overlaps resolve as ordinary merge conflicts.
 - Role agents whose rules forbid dirtying the tree (the E2E verifier's byte-identical baseline restore) write their learnings to `$SCRATCH/learnings/` instead and list them in their report; the orchestrator moves them into `.kilo_workflow/learnings/` and commits them.
diff --git a/.kilo_workflow/init-section.sh b/.kilo_workflow/init-section.sh
index 6e64a16ac9..31f236a2c5 100755
--- a/.kilo_workflow/init-section.sh
+++ b/.kilo_workflow/init-section.sh
@@ -40,9 +40,9 @@ canonical_repo() {
 
 preflight_worktree() {
   local repo=$1 path=$2
-  [ ! -e "$path" ] || { echo "init-section: target already exists: $path" >&2; exit 1; }
+  [ ! -e "$path" ] || { echo "init-section: target already exists: $path — remove it (git worktree remove --force $path; git branch -D $SECTION) or it was not created by init-section and cannot be repaired by hand" >&2; exit 1; }
   ! git -C "$repo" show-ref --verify --quiet "refs/heads/$SECTION" ||
-    { echo "init-section: branch already exists in $repo: $SECTION" >&2; exit 1; }
+    { echo "init-section: branch already exists in $repo: $SECTION — delete it (git branch -D $SECTION) if it is stale" >&2; exit 1; }
 }
 
 add_worktree() {

From a2e292d23d59bb32a32b4e34b00f50667ea1bf86 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 00:00:40 +0200
Subject: [PATCH 08/34] fix(workflow): resolve worktree from script location,
 not caller CWD

Kilobot: invoked by absolute path from a sibling repo, acquire recorded the
sibling's root in the slot and broke status UNACCOUNTED matching. Also
correct the slot-status header: arguments are a usage error, only the
no-arg report is exit 0.
---
 .kilo_workflow/.e2e-slot-state.sh | 6 +++++-
 .kilo_workflow/e2e-slot-status.sh | 5 +++--
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/.kilo_workflow/.e2e-slot-state.sh b/.kilo_workflow/.e2e-slot-state.sh
index 227c06c6ed..d4db3c8bc3 100755
--- a/.kilo_workflow/.e2e-slot-state.sh
+++ b/.kilo_workflow/.e2e-slot-state.sh
@@ -81,7 +81,11 @@ case "${1:?internal usage: $0 acquire|release|status|_held}" in
       for number in $(seq 1 "$TOTAL"); do
         slot="$DIR/slot-$number"
         if mkdir "$slot" 2>/dev/null; then
-          worktree=$(git rev-parse --show-toplevel 2>/dev/null || pwd -P)
+          # Resolve via this script's own location, never the caller's CWD:
+          # invoked by absolute path from a sibling repository (WORKFLOW.md),
+          # a bare rev-parse would record the sibling's root and break the
+          # status report's UNACCOUNTED matching.
+          worktree=$(git -C "$(dirname "$0")" rev-parse --show-toplevel 2>/dev/null || pwd -P)
           if printf '%s' "$worktree" > "$slot/worktree" &&
              date -u +%Y-%m-%dT%H:%M:%SZ > "$slot/since" &&
              printf '%s' "$owner" > "$slot/owner"; then
diff --git a/.kilo_workflow/e2e-slot-status.sh b/.kilo_workflow/e2e-slot-status.sh
index 88f80832b2..a2b7683c05 100755
--- a/.kilo_workflow/e2e-slot-status.sh
+++ b/.kilo_workflow/e2e-slot-status.sh
@@ -1,7 +1,8 @@
 #!/usr/bin/env bash
 # Reap dead slot owners, list live holders, then report known resources whose
-# worktree has no slot. Reporting is read-only and always exits 0 — UNACCOUNTED
-# lines in the output are the finding; the owning workflow cleans up.
+# worktree has no slot. Reporting is read-only and exits 0 — UNACCOUNTED lines
+# in the output are the finding; the owning workflow cleans up. Passing any
+# argument is a usage error (exit 1).
 set -euo pipefail
 HERE=$(dirname "$0")
 "$HERE/.e2e-slot-state.sh" status "$@"

From f7669034f3deed8f51cdcd058c45ae05af8a817a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 00:01:56 +0200
Subject: [PATCH 09/34] style: fix markdown table padding in the vendored
 kilo-design-cloud skill

---
 .agents/skills/kilo-design-cloud/SKILL.md                     | 2 +-
 .agents/skills/kilo-design-cloud/overlay.md                   | 4 ++--
 .../skills/kilo-design-cloud/reference/product-judgment.md    | 2 +-
 .../skills/kilo-design-cloud/reference/token-architecture.md  | 4 ++--
 .agents/skills/kilo-design-cloud/reference/voice.md           | 2 +-
 .specs/mcp-gateway-auth.md                                    | 2 +-
 6 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/.agents/skills/kilo-design-cloud/SKILL.md b/.agents/skills/kilo-design-cloud/SKILL.md
index 9e3c0f8efa..c8da4e9296 100644
--- a/.agents/skills/kilo-design-cloud/SKILL.md
+++ b/.agents/skills/kilo-design-cloud/SKILL.md
@@ -29,7 +29,7 @@ Completion criterion: the answer or change names the loaded overlay/recipe, foll
 ## Recipe Router
 
 | Prompt or file signal | Load |
-| --- | --- |
+|---|---|
 | primary action, CTA, button hierarchy, blue button drift | `patterns/cloud-web/primary-actions.md` |
 | tabs, segmented navigation, Radix tabs, active tab state | `patterns/cloud-web/tabs.md` |
 | tokens, globals.css, semantic mapping | `reference/token-architecture.md`; record that Cloud token adoption is `VVV-130` |
diff --git a/.agents/skills/kilo-design-cloud/overlay.md b/.agents/skills/kilo-design-cloud/overlay.md
index cb13d8e529..2bb70ba83a 100644
--- a/.agents/skills/kilo-design-cloud/overlay.md
+++ b/.agents/skills/kilo-design-cloud/overlay.md
@@ -11,7 +11,7 @@ Cloud is the pilot product for Kilo's agent-consumable design system. It is a de
 ## Code Sources To Read First
 
 | Concern | Cloud path |
-| --- | --- |
+|---|---|
 | Base theme and Tailwind tokens | `apps/web/src/app/globals.css` |
 | Font variables | `apps/web/src/app/layout.tsx` |
 | shadcn config | `apps/web/components.json` |
@@ -23,7 +23,7 @@ Cloud is the pilot product for Kilo's agent-consumable design system. It is a de
 Use semantic roles, not raw values:
 
 | Role | Cloud token |
-| --- | --- |
+|---|---|
 | Page background | `--background` / `bg-background` |
 | Default text | `--foreground` / `text-foreground` |
 | Raised surface | `--card`, `--popover` |
diff --git a/.agents/skills/kilo-design-cloud/reference/product-judgment.md b/.agents/skills/kilo-design-cloud/reference/product-judgment.md
index 2eaa1b84ac..c3ae581ba1 100644
--- a/.agents/skills/kilo-design-cloud/reference/product-judgment.md
+++ b/.agents/skills/kilo-design-cloud/reference/product-judgment.md
@@ -5,7 +5,7 @@ This reference is for agent behavior inside Cloud UI work. It is not product cod
 ## Modes
 
 | Mode | Do | Done when |
-| --- | --- | --- |
+|---|---|---|
 | Shape | Clarify a flow, hierarchy, states, and tradeoffs. Do not edit. | The recommendation is concrete enough to implement. |
 | Implement | Make the smallest coherent Cloud code change. | Changed code matches the overlay or recipe, or calls out a gap. |
 | Review | Inspect code/screens and report findings. Do not edit. | Findings cite paths, severity, rule, fix, and relevant interaction or responsive gaps. |
diff --git a/.agents/skills/kilo-design-cloud/reference/token-architecture.md b/.agents/skills/kilo-design-cloud/reference/token-architecture.md
index 572fada6b4..ad852f6254 100644
--- a/.agents/skills/kilo-design-cloud/reference/token-architecture.md
+++ b/.agents/skills/kilo-design-cloud/reference/token-architecture.md
@@ -23,7 +23,7 @@ The playground sits outside this product-consumption path. It previews and edits
 ## Product Artifact Names
 
 | Product surface | Generated artifact |
-| --- | --- |
+|---|---|
 | Cloud | `src/tokens.cloud.ts` |
 | Landing | `src/tokens.landing.css` |
 | VS Code, JetBrains, CLI/ANSI | `src/tokens.extension-host-map.md` |
@@ -31,7 +31,7 @@ The playground sits outside this product-consumption path. It previews and edits
 ## Naming Discipline
 
 | Prefer | Avoid |
-| --- | --- |
+|---|---|
 | primary action | yellow button |
 | muted foreground | gray text |
 | raised surface | dark card |
diff --git a/.agents/skills/kilo-design-cloud/reference/voice.md b/.agents/skills/kilo-design-cloud/reference/voice.md
index 80b3bacfd9..ef08d61919 100644
--- a/.agents/skills/kilo-design-cloud/reference/voice.md
+++ b/.agents/skills/kilo-design-cloud/reference/voice.md
@@ -24,7 +24,7 @@ Kilo Cloud voice is clear, technical, calm, and direct.
 ## Examples
 
 | Weak | Better |
-| --- | --- |
+|---|---|
 | Submit | Create workspace |
 | OK | Save changes |
 | Yes | Delete project |
diff --git a/.specs/mcp-gateway-auth.md b/.specs/mcp-gateway-auth.md
index 0e398a7b1a..4261d11c50 100644
--- a/.specs/mcp-gateway-auth.md
+++ b/.specs/mcp-gateway-auth.md
@@ -118,7 +118,7 @@ when they appear in all capitals.
 | `GET /.well-known/oauth-authorization-server/mcp-connect/...` | Worker discovery alias | Path-aware compatibility alias for clients that start discovery from one scoped connect URL; redirects to app canonical metadata. |
 | `POST /api/mcp-gateway/oauth/register` | App | Dynamic client registration. |
 | `POST /api/mcp-gateway/oauth/register/resource/{scope}/{owner_id}/{config_id}/{route_key}` | App | Resource-specific registration after route eligibility discovery. |
-| `GET|PUT|DELETE /api/mcp-gateway/oauth/register/{client_id}` | App | Registration management authorized by registration token. |
+| `GET | PUT | DELETE /api/mcp-gateway/oauth/register/{client_id}` | App | Registration management authorized by registration token. |
 | `GET /api/mcp-gateway/oauth/authorize` | App | Generic authorization-code flow; requires `resource`. |
 | `GET /api/mcp-gateway/oauth/authorize/{scope}/{owner_id}/{config_id}/{route_key}` | App | Route-specific authorization-code flow. |
 | `POST /api/mcp-gateway/oauth/token` | App | Authorization-code and refresh-token exchange. |

From 55b8827d69af79f032717f7b7b85b6d7167f93bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 00:15:26 +0200
Subject: [PATCH 10/34] fix(workflow): make slot reap and the lock test
 portable to Linux
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

GNU stat -f means --file-system and exits 0, defeating the BSD-first mtime
fallback in reap; probe GNU syntax first. The lock-active test used pid 2 as
its dead pid, which is kthreadd on Linux — use a pid above both platforms'
max.
---
 .kilo_workflow/.e2e-slot-state.sh  | 4 +++-
 dev/local/mobile-ios-build.test.ts | 4 +++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/.kilo_workflow/.e2e-slot-state.sh b/.kilo_workflow/.e2e-slot-state.sh
index d4db3c8bc3..ea918f8776 100755
--- a/.kilo_workflow/.e2e-slot-state.sh
+++ b/.kilo_workflow/.e2e-slot-state.sh
@@ -35,7 +35,9 @@ reap() {
 
     # mkdir wins the slot before acquire publishes its owner. Only clear an
     # ownerless directory once it is old enough to be an interrupted acquire.
-    modified=$(stat -f %m "$slot" 2>/dev/null || stat -c %Y "$slot" 2>/dev/null || echo "$now")
+    # GNU first: on GNU stat, `-f` means --file-system and exits 0 with mount
+    # info, so a BSD-first probe never falls through. BSD stat rejects `-c`.
+    modified=$(stat -c %Y "$slot" 2>/dev/null || stat -f %m "$slot" 2>/dev/null || echo "$now")
     age=$((now - modified))
     [ "$age" -gt 60 ] && rm -rf "$slot"
   done
diff --git a/dev/local/mobile-ios-build.test.ts b/dev/local/mobile-ios-build.test.ts
index 61901dccc6..ce13e31e72 100644
--- a/dev/local/mobile-ios-build.test.ts
+++ b/dev/local/mobile-ios-build.test.ts
@@ -1804,7 +1804,9 @@ test('validateSimulatorClaim enforces worktree ownership and rejects corrupt rec
 
 test('defaultIsLockActive requires both pidAlive and processIdentity match', () => {
   const aliveRecord: LockRecord = { key: 'k', pid: 1, identity: 'a', startedAt: '' };
-  const deadRecord: LockRecord = { key: 'k', pid: 2, identity: 'b', startedAt: '' };
+  // PID 9999999 exceeds the max PID on macOS (99998) and Linux (2^22), so the
+  // default probe reports it dead on both — a low "dead" pid is alive on Linux.
+  const deadRecord: LockRecord = { key: 'k', pid: 9999999, identity: 'b', startedAt: '' };
 
   // Both probes agree: active
   let active = defaultIsLockActive({

From 7083eb497f453d70ab0be3cc29487ef747576cad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 01:07:25 +0200
Subject: [PATCH 11/34] fix(workflow): act on the Kilobot full-diff review
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- probe GNU stat first in await-role, await-interactive, and baseline (the
  same GNU -f/--file-system trap the slot reap fix closed; baseline was
  writing mount garbage into fingerprints)
- run e2e start/stop-resource from the script's own repo, not the caller's
  CWD — a sibling-worktree invocation could start/stop the wrong stack
- remote-cli status exits 0 on its happy path and refuses extra arguments
- login.sh probes sha256sum before shasum, like baseline and slice-diff
- launch-gate clamps a corrupt or future-dated launch timestamp
- restore the DESIGN.md pointer in the root AGENTS.md design row
- cover the new contracts: start without a slot, sibling-CWD wrappers,
  status/free argument refusal
---
 .kilo_workflow/await-interactive.sh  |  2 +-
 .kilo_workflow/await-role.sh         |  2 +-
 .kilo_workflow/baseline.sh           |  6 +++---
 .kilo_workflow/e2e-start-resource.sh |  4 ++++
 .kilo_workflow/e2e-stop-resource.sh  |  5 +++++
 .kilo_workflow/launch-gate.sh        |  2 ++
 AGENTS.md                            |  2 +-
 apps/mobile/e2e/login.sh             |  6 +++++-
 apps/mobile/e2e/remote-cli.sh        |  4 ++--
 dev/local/workflow-scripts.test.ts   | 23 +++++++++++++++++------
 10 files changed, 41 insertions(+), 15 deletions(-)

diff --git a/.kilo_workflow/await-interactive.sh b/.kilo_workflow/await-interactive.sh
index 5130f3fd0c..1e277d6f53 100755
--- a/.kilo_workflow/await-interactive.sh
+++ b/.kilo_workflow/await-interactive.sh
@@ -33,7 +33,7 @@ while [ $# -gt 0 ]; do
   esac
 done
 
-mtime() { stat -f %m "$1" 2>/dev/null || stat -c %Y "$1" 2>/dev/null || echo 0; }
+mtime() { stat -c %Y "$1" 2>/dev/null || stat -f %m "$1" 2>/dev/null || echo 0; }
 
 START=$(date +%s)
 while :; do
diff --git a/.kilo_workflow/await-role.sh b/.kilo_workflow/await-role.sh
index 409a6250b8..088e52b602 100755
--- a/.kilo_workflow/await-role.sh
+++ b/.kilo_workflow/await-role.sh
@@ -67,7 +67,7 @@ case "$ROLE/$MODE" in
     ;;
 esac
 
-mtime() { stat -f %m "$1" 2>/dev/null || stat -c %Y "$1" 2>/dev/null || echo 0; }
+mtime() { stat -c %Y "$1" 2>/dev/null || stat -f %m "$1" 2>/dev/null || echo 0; }
 target_dead() {
   [ -n "$TMUX_TARGET" ] || return 1
   ! tmux list-panes -t "$TMUX_TARGET" >/dev/null 2>&1
diff --git a/.kilo_workflow/baseline.sh b/.kilo_workflow/baseline.sh
index e28b2e75c6..2a4b43d7be 100755
--- a/.kilo_workflow/baseline.sh
+++ b/.kilo_workflow/baseline.sh
@@ -54,10 +54,10 @@ capture() {
     if [ -L "$WT/$p" ]; then
       printf 'link\t%s\t%s\n' "$(readlink "$WT/$p")" "$p"
     elif command -v sha256sum >/dev/null; then
-      printf 'file\t%s\t%s\t%s\n' "$(stat -f %p "$WT/$p" 2>/dev/null || stat -c %a "$WT/$p")" \
+      printf 'file\t%s\t%s\t%s\n' "$(stat -c %a "$WT/$p" 2>/dev/null || stat -f %p "$WT/$p")" \
         "$(sha256sum "$WT/$p" | cut -d' ' -f1)" "$p"
     else
-      printf 'file\t%s\t%s\t%s\n' "$(stat -f %p "$WT/$p" 2>/dev/null || stat -c %a "$WT/$p")" \
+      printf 'file\t%s\t%s\t%s\n' "$(stat -c %a "$WT/$p" 2>/dev/null || stat -f %p "$WT/$p")" \
         "$(shasum -a 256 "$WT/$p" | cut -d' ' -f1)" "$p"
     fi
   done | sort > "$out/untracked.tsv"
@@ -75,7 +75,7 @@ capture() {
         hash=$(shasum -a 256 "$WT/$p" | cut -d' ' -f1)
       fi
       printf 'file\t%s\t%s\t%s\n' \
-        "$(stat -f %p "$WT/$p" 2>/dev/null || stat -c %a "$WT/$p")" "$hash" "$p"
+        "$(stat -c %a "$WT/$p" 2>/dev/null || stat -f %p "$WT/$p")" "$hash" "$p"
     elif [ -e "$WT/$p" ]; then
       echo "baseline: --include supports files, symlinks, or absent paths, not $p" >&2
       return 1
diff --git a/.kilo_workflow/e2e-start-resource.sh b/.kilo_workflow/e2e-start-resource.sh
index 06b8d39957..8e77657e3b 100755
--- a/.kilo_workflow/e2e-start-resource.sh
+++ b/.kilo_workflow/e2e-start-resource.sh
@@ -9,6 +9,10 @@ HERE=$(dirname "$0")
 
 resource=${1:?usage: $0 stack [targets...] | ios [udid] | android <avd> [--gpu ...] | command <cmd> [args...]}
 shift
+# Run repo wrappers from this script's own repository, never the caller's
+# CWD — invoked by absolute path from a sibling worktree, pnpm would
+# otherwise start the wrong stack while the slot record names this one.
+cd "$(git -C "$(dirname "$0")" rev-parse --show-toplevel)"
 case "$resource" in
   stack) exec pnpm dev:start --no-attach --reuse-running "$@" ;;
   ios) exec pnpm dev:mobile:simulator claim "$@" ;;
diff --git a/.kilo_workflow/e2e-stop-resource.sh b/.kilo_workflow/e2e-stop-resource.sh
index ff3127b8b3..c5cd1546c7 100755
--- a/.kilo_workflow/e2e-stop-resource.sh
+++ b/.kilo_workflow/e2e-stop-resource.sh
@@ -2,6 +2,11 @@
 # Stop one resource before the caller frees its E2E slot.
 set -euo pipefail
 
+# Run from this script's own repository, never the caller's CWD — invoked by
+# absolute path from a sibling worktree, pnpm would otherwise stop the wrong
+# stack while the slot record names this one.
+cd "$(git -C "$(dirname "$0")" rev-parse --show-toplevel)"
+
 resource=${1:?usage: $0 stack | ios | android | command <cmd> [args...]}
 shift
 case "$resource" in
diff --git a/.kilo_workflow/launch-gate.sh b/.kilo_workflow/launch-gate.sh
index 5646b6e9f9..f578bfcf65 100755
--- a/.kilo_workflow/launch-gate.sh
+++ b/.kilo_workflow/launch-gate.sh
@@ -13,7 +13,9 @@ if [ "${1:-}" = "--locked" ]; then
   mkdir -p "$GATE"
   now=$(date +%s)
   last=$(cat "$GATE/last" 2>/dev/null || echo 0)
+  case "$last" in ''|*[!0-9]*) last=0 ;; esac
   remaining=$(( 3 - (now - last) ))
+  [ "$remaining" -le 3 ] || remaining=3
   [ "$remaining" -le 0 ] || sleep "$remaining"
   date +%s > "$GATE/last"
   exit 0
diff --git a/AGENTS.md b/AGENTS.md
index ade2e3b498..5284079067 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -63,7 +63,7 @@ package manifests before running repository JavaScript or package scripts. Load
 | Service, Durable Object, or Worker code | `services/AGENTS.md`, nearest owning service's `AGENTS.md`, and relevant Durable Objects or Workers skills |
 | Domain language and ownership | `CONTEXT.md`, when its scope applies |
 | Business requirements | Relevant `.specs/*.md`, indexed by `specs` skill |
-| UI and product design | Relevant app `AGENTS.md`; for `apps/web`, the `kilo-design-cloud` skill synced from `Kilo-Org/kilo-design` |
+| UI and product design | `DESIGN.md`, relevant app `AGENTS.md`; for `apps/web`, the `kilo-design-cloud` skill synced from `Kilo-Org/kilo-design` |
 | Contribution and PR workflow | `CONTRIBUTING.md` and relevant Git or PR skill |
 
 ## Security Baseline
diff --git a/apps/mobile/e2e/login.sh b/apps/mobile/e2e/login.sh
index dea66e2095..23350086cf 100755
--- a/apps/mobile/e2e/login.sh
+++ b/apps/mobile/e2e/login.sh
@@ -54,7 +54,11 @@ latest_email() {
 # second code request voids the first code, so the first verify 401s. Hold a
 # email mutex from the outbox snapshot through code verification. OTP
 # invalidation is keyed by normalized email, not worktree.
-EMAIL_KEY=$(printf '%s' "$EMAIL" | tr '[:upper:]' '[:lower:]' | shasum -a 256 | cut -d' ' -f1)
+if command -v sha256sum >/dev/null; then
+  EMAIL_KEY=$(printf '%s' "$EMAIL" | tr '[:upper:]' '[:lower:]' | sha256sum | cut -d' ' -f1)
+else
+  EMAIL_KEY=$(printf '%s' "$EMAIL" | tr '[:upper:]' '[:lower:]' | shasum -a 256 | cut -d' ' -f1)
+fi
 LOCK="${TMPDIR:-/tmp}/kilo-otp-locks/$EMAIL_KEY"
 if [ "${KILO_OTP_LOCKED:-}" != "1" ]; then
   exec "$REPO_ROOT/node_modules/.bin/tsx" "$REPO_ROOT/dev/local/process-lock.ts" \
diff --git a/apps/mobile/e2e/remote-cli.sh b/apps/mobile/e2e/remote-cli.sh
index 0a60264aea..179e9b48e0 100755
--- a/apps/mobile/e2e/remote-cli.sh
+++ b/apps/mobile/e2e/remote-cli.sh
@@ -220,7 +220,7 @@ cmd_status() {
     tmux capture-pane -p -t "$SESSION" -S -40 | sed -e 's/[[:space:]]*$//' | grep -v '^$' | tail -20
   else
     echo "No remote CLI session '$SESSION' is running."
-    [ -f "$ENV_FILE" ] && echo "(env is prepared; run 'remote-cli.sh exec <args>' or 'start')"
+    [ -f "$ENV_FILE" ] && echo "(env is prepared; run 'remote-cli.sh exec <args>' or 'start')" || true
   fi
 }
 
@@ -244,7 +244,7 @@ case "${1:-start}" in
   start) shift || true; cmd_start "$@" ;;
   prepare) shift || true; cmd_prepare "$@" ;;
   exec) shift || true; cmd_exec "$@" ;;
-  status) shift || true; cmd_status ;;
+  status) shift || true; [ "$#" -eq 0 ] || { echo "status takes no arguments" >&2; exit 2; }; cmd_status ;;
   stop) shift || true; cmd_stop "$@" ;;
   -h|--help) grep '^#' "$0" | sed 's/^# \{0,1\}//' | sed '1d' ;;
   *) echo "unknown command: ${1} (expected start|prepare|exec|status|stop)" >&2; exit 2 ;;
diff --git a/dev/local/workflow-scripts.test.ts b/dev/local/workflow-scripts.test.ts
index 7763421dbb..ff536833e0 100644
--- a/dev/local/workflow-scripts.test.ts
+++ b/dev/local/workflow-scripts.test.ts
@@ -326,7 +326,7 @@ test('E2E lifecycle scripts take, start, stop, and free one slot', () => {
       'exit 1\n'
   );
   fs.writeFileSync(path.join(bin, 'git'), `#!/bin/sh\nprintf '%s\\n' '${repoRoot}'\n`);
-  fs.writeFileSync(path.join(bin, 'pnpm'), '#!/bin/sh\nprintf "%s\\n" "$*" >> "$COMMAND_LOG"\n');
+  fs.writeFileSync(path.join(bin, 'pnpm'), '#!/bin/sh\nprintf "%s: %s\\n" "$PWD" "$*" >> "$COMMAND_LOG"\n');
   for (const command of ['tmux', 'git', 'pnpm']) fs.chmodSync(path.join(bin, command), 0o755);
   const env = {
     ...process.env,
@@ -337,26 +337,37 @@ test('E2E lifecycle scripts take, start, stop, and free one slot', () => {
     TMUX_PANE: '%1',
   };
   try {
-    const run = (script: string, args: string[] = []) =>
+    const run = (script: string, args: string[] = [], cwd: string = repoRoot) =>
       spawnSync(path.join(repoRoot, '.kilo_workflow', script), args, {
-        cwd: repoRoot,
+        cwd,
         encoding: 'utf8',
         env,
       });
+    // Starting a resource before taking a slot refuses with the remedy.
+    const early = run('e2e-start-resource.sh', ['stack', 'mobile']);
+    assert.equal(early.status, 1);
+    assert.match(early.stderr, /take a slot first/);
     assert.equal(run('e2e-take-slot.sh').status, 0);
-    assert.equal(run('e2e-start-resource.sh', ['stack', 'mobile', 'web']).status, 0);
-    assert.equal(run('e2e-stop-resource.sh', ['stack']).status, 0);
+    // Invoked from a foreign CWD, repo wrappers still run in the script's repo.
+    assert.equal(run('e2e-start-resource.sh', ['stack', 'mobile', 'web'], os.tmpdir()).status, 0);
+    assert.equal(run('e2e-stop-resource.sh', ['stack'], os.tmpdir()).status, 0);
     assert.match(run('e2e-slot-status.sh').stdout, /slot-1: test-owner/);
     // The old API was `e2e-slot.sh acquire <session>` — a forwarded session
     // name must fail loudly, never acquire under the wrong owner.
     const badTake = run('e2e-take-slot.sh', ['my-session']);
     assert.equal(badTake.status, 1);
     assert.match(badTake.stderr, /takes no session name/);
+    const badStatus = run('e2e-slot-status.sh', ['bogus']);
+    assert.equal(badStatus.status, 1);
+    assert.match(badStatus.stderr, /takes no arguments/);
+    const badFree = run('e2e-free-slot.sh', ['bogus']);
+    assert.equal(badFree.status, 1);
+    assert.match(badFree.stderr, /takes no arguments/);
     assert.equal(run('e2e-free-slot.sh').status, 0);
     assert.match(run('e2e-slot-status.sh').stdout, /0\/3 held/);
     assert.equal(
       fs.readFileSync(commandLog, 'utf8'),
-      'dev:start --no-attach --reuse-running mobile web\ndev:stop\n'
+      `${repoRoot}: dev:start --no-attach --reuse-running mobile web\n${repoRoot}: dev:stop\n`
     );
   } finally {
     fs.rmSync(root, { recursive: true, force: true });

From 53466448314294fb7496d9d29360843d23ea3b15 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 01:11:15 +0200
Subject: [PATCH 12/34] style: oxfmt the lifecycle test

---
 dev/local/workflow-scripts.test.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/dev/local/workflow-scripts.test.ts b/dev/local/workflow-scripts.test.ts
index ff536833e0..6b5ac395c2 100644
--- a/dev/local/workflow-scripts.test.ts
+++ b/dev/local/workflow-scripts.test.ts
@@ -326,7 +326,10 @@ test('E2E lifecycle scripts take, start, stop, and free one slot', () => {
       'exit 1\n'
   );
   fs.writeFileSync(path.join(bin, 'git'), `#!/bin/sh\nprintf '%s\\n' '${repoRoot}'\n`);
-  fs.writeFileSync(path.join(bin, 'pnpm'), '#!/bin/sh\nprintf "%s: %s\\n" "$PWD" "$*" >> "$COMMAND_LOG"\n');
+  fs.writeFileSync(
+    path.join(bin, 'pnpm'),
+    '#!/bin/sh\nprintf "%s: %s\\n" "$PWD" "$*" >> "$COMMAND_LOG"\n'
+  );
   for (const command of ['tmux', 'git', 'pnpm']) fs.chmodSync(path.join(bin, command), 0o755);
   const env = {
     ...process.env,

From 9eb007dd929e3f6b443ca9f5a37b3ca0af6c3599 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 01:28:37 +0200
Subject: [PATCH 13/34] fix(workflow): let pr-gate see Kilobot's edited summary

Kilobot edits its standing summary comment instead of posting anew, so the
gate's createdAt filter never saw approvals after the first review. Fetch
issue comments via REST with since=<head-date>, which filters by updated_at,
and accept the [bot]-suffixed REST login.
---
 .kilo_workflow/pr-gate.sh          | 20 ++++++-----
 dev/local/workflow-scripts.test.ts | 53 +++++++++++++++++++++++++++---
 2 files changed, 60 insertions(+), 13 deletions(-)

diff --git a/.kilo_workflow/pr-gate.sh b/.kilo_workflow/pr-gate.sh
index 7d40d63af5..ab748a0267 100755
--- a/.kilo_workflow/pr-gate.sh
+++ b/.kilo_workflow/pr-gate.sh
@@ -18,8 +18,9 @@
 #
 # Prints the facts, then `GATE FAIL: ...` lines for every mechanical item
 # that does not hold (exit 1), or `GATE OK (mechanical items)` (exit 0).
-# Bot comments are printed only when they postdate the head commit — read the
-# newest one's verdict yourself; wording drifts, never string-match it. A
+# Bot comments are printed only when their activity postdates the head commit
+# (Kilobot edits its standing summary, so updated_at, not created_at) — read
+# the newest one's verdict yourself; wording drifts, never string-match it. A
 # `(bot) Kilobot posted no approving summary...` waiver comment posted after
 # the head satisfies the bot-summary item per the Kilobot loop's waiver rule.
 set -euo pipefail
@@ -42,14 +43,17 @@ done
 DEADLINE=$(( $(date +%s) + WAIT ))
 while :; do
   DATA=$(gh pr view "$PR" --repo "$REPO" \
-    --json headRefOid,mergeable,mergeStateStatus,statusCheckRollup,assignees,labels,comments)
+    --json headRefOid,mergeable,mergeStateStatus,statusCheckRollup,assignees,labels)
   HEAD_OID=$(jq -r '.headRefOid' <<<"$DATA")
   HEAD_TIME=$(gh api "repos/$REPO/commits/$HEAD_OID" --jq '.commit.committer.date')
-  HEAD_EPOCH=$(jq -nr --arg t "$HEAD_TIME" '$t | fromdateiso8601')
-  BOTCOMMENTS=$(jq -r --argjson t "$HEAD_EPOCH" --arg bot "$BOT" --arg waiver "$WAIVER" \
-    '[.comments[] | select((.author.login == $bot or .body == $waiver)
-      and (.createdAt | fromdateiso8601) > $t)
-      | "\(.author.login) @ \(.createdAt): \(.body | gsub("\\s+"; " ") | .[0:200])"] | .[]' <<<"$DATA")
+  # Kilobot EDITS its standing summary comment instead of posting anew, so a
+  # createdAt filter never sees later approvals. The REST `since` parameter
+  # filters by updated_at — exactly "bot activity postdating the head".
+  # REST logins carry the [bot] suffix gh pr view normalizes away.
+  COMMENTS=$(gh api "repos/$REPO/issues/$PR/comments?since=$HEAD_TIME&per_page=100")
+  BOTCOMMENTS=$(jq -r --arg bot "$BOT" --arg waiver "$WAIVER" \
+    '[.[] | select((.user.login == $bot or .user.login == ($bot + "[bot]") or .body == $waiver))
+      | "\(.user.login) @ \(.updated_at): \(.body | gsub("\\s+"; " ") | .[0:200])"] | .[]' <<<"$COMMENTS")
   [ -n "$BOTCOMMENTS" ] && break
   [ "$(date +%s)" -ge "$DEADLINE" ] && break
   sleep 120
diff --git a/dev/local/workflow-scripts.test.ts b/dev/local/workflow-scripts.test.ts
index 6b5ac395c2..cd5acfe83c 100644
--- a/dev/local/workflow-scripts.test.ts
+++ b/dev/local/workflow-scripts.test.ts
@@ -454,11 +454,14 @@ test('PR gate rejects a bot comment older than the current head', () => {
     path.join(bin, 'gh'),
     `#!/bin/sh
 if [ "$1 $2" = "pr view" ]; then
-  printf '%s\n' '{"headRefOid":"abc","mergeable":"MERGEABLE","mergeStateStatus":"CLEAN","statusCheckRollup":[{"name":"test","conclusion":"SUCCESS"}],"assignees":[{"login":"igor"}],"labels":[],"comments":[{"author":{"login":"kilo-code-bot"},"createdAt":"2026-01-01T00:00:00Z","body":"approved"}]}'
-elif [ "$1" = api ] && [ "$2" = "repos/Kilo-Org/cloud/commits/abc" ]; then
-  printf '%s\n' '2026-01-02T00:00:00Z'
-elif [ "$1 $2" = "api graphql" ]; then
-  printf '%s\n' '{"pageInfo":{"hasNextPage":false,"endCursor":null},"nodes":[]}'
+  printf '%s\n' '{"headRefOid":"abc","mergeable":"MERGEABLE","mergeStateStatus":"CLEAN","statusCheckRollup":[{"name":"test","conclusion":"SUCCESS"}],"assignees":[{"login":"igor"}],"labels":[]}'
+elif [ "$1" = api ]; then
+  case "$2" in
+    repos/Kilo-Org/cloud/commits/abc) printf '%s\n' '2026-01-02T00:00:00Z' ;;
+    repos/Kilo-Org/cloud/issues/1/comments?*) printf '%s\n' '[]' ;;
+    graphql) printf '%s\n' '{"pageInfo":{"hasNextPage":false,"endCursor":null},"nodes":[]}' ;;
+    *) exit 1 ;;
+  esac
 else
   exit 1
 fi
@@ -477,6 +480,46 @@ fi
   }
 });
 
+test('PR gate sees a bot summary edited after the current head', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-pr-gate-edit-test-'));
+  const workflow = path.join(root, '.kilo_workflow');
+  const bin = path.join(root, 'bin');
+  fs.mkdirSync(workflow);
+  fs.mkdirSync(bin);
+  for (const script of ['pr-gate.sh', 'pr-threads.sh']) {
+    fs.copyFileSync(path.join(repoRoot, '.kilo_workflow', script), path.join(workflow, script));
+    fs.chmodSync(path.join(workflow, script), 0o755);
+  }
+  executable(
+    path.join(bin, 'gh'),
+    `#!/bin/sh
+if [ "$1 $2" = "pr view" ]; then
+  printf '%s\n' '{"headRefOid":"abc","mergeable":"MERGEABLE","mergeStateStatus":"CLEAN","statusCheckRollup":[{"name":"test","conclusion":"SUCCESS"}],"assignees":[{"login":"igor"}],"labels":[]}'
+elif [ "$1" = api ]; then
+  case "$2" in
+    repos/Kilo-Org/cloud/commits/abc) printf '%s\n' '2026-01-02T00:00:00Z' ;;
+    repos/Kilo-Org/cloud/issues/1/comments?*) printf '%s\n' '[{"user":{"login":"kilo-code-bot[bot]"},"created_at":"2026-01-01T00:00:00Z","updated_at":"2026-01-02T00:10:00Z","body":"Recommendation: Merge"}]' ;;
+    graphql) printf '%s\n' '{"pageInfo":{"hasNextPage":false,"endCursor":null},"nodes":[]}' ;;
+    *) exit 1 ;;
+  esac
+else
+  exit 1
+fi
+`
+  );
+  try {
+    const result = spawnSync(path.join(workflow, 'pr-gate.sh'), ['Kilo-Org/cloud', '1'], {
+      encoding: 'utf8',
+      env: { ...process.env, PATH: `${bin}:${process.env.PATH}` },
+    });
+    assert.equal(result.status, 0, result.stderr + result.stdout);
+    assert.match(result.stdout, /GATE OK/);
+    assert.match(result.stdout, /kilo-code-bot\[bot\] @ 2026-01-02T00:10:00Z/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('PR thread listing fails when a later page cannot be read', () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-pr-threads-test-'));
   const bin = path.join(root, 'bin');

From 243d868cd4c5af001e5c068e0fb7e9af500372f2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 02:31:01 +0200
Subject: [PATCH 14/34] chore(e2e): add appium 3 + webdriverio for mobile e2e

Appium drivers (xcuitest, uiautomator2) install into a machine-global
APPIUM_HOME (~/.cache/kilo-appium) on first use instead of living in the
dependency tree, so only appium and the webdriverio client are deps.
---
 package.json        |    4 +-
 pnpm-lock.yaml      | 1765 ++++++++++++++++++++++++++++++++++++++++++-
 pnpm-workspace.yaml |    7 +
 3 files changed, 1745 insertions(+), 31 deletions(-)

diff --git a/package.json b/package.json
index 042aed004a..fff7e37959 100644
--- a/package.json
+++ b/package.json
@@ -49,6 +49,7 @@
     "@types/node": "catalog:",
     "@types/proper-lockfile": "4.1.4",
     "@typescript/native-preview": "catalog:",
+    "appium": "catalog:",
     "husky": "9.1.7",
     "ink": "6.8.0",
     "oxfmt": "0.40.0",
@@ -58,6 +59,7 @@
     "proper-lockfile": "4.1.2",
     "react": "19.2.6",
     "tsx": "catalog:",
-    "typescript": "catalog:"
+    "typescript": "catalog:",
+    "webdriverio": "catalog:"
   }
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 936a35222a..4f7967f3b3 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -45,6 +45,9 @@ catalogs:
     '@workos-inc/node':
       specifier: 8.13.0
       version: 8.13.0
+    appium:
+      specifier: 3.6.0
+      version: 3.6.0
     aws4fetch:
       specifier: 1.0.20
       version: 1.0.20
@@ -75,6 +78,9 @@ catalogs:
     vitest:
       specifier: 4.1.6
       version: 4.1.6
+    webdriverio:
+      specifier: 9.30.0
+      version: 9.30.0
     workers-tagged-logger:
       specifier: 1.0.0
       version: 1.0.0
@@ -151,6 +157,9 @@ importers:
       '@typescript/native-preview':
         specifier: 'catalog:'
         version: 7.0.0-dev.20260514.1
+      appium:
+        specifier: 'catalog:'
+        version: 3.6.0(@types/node@24.12.4)(bufferutil@4.1.0)(utf-8-validate@6.0.6)
       husky:
         specifier: 9.1.7
         version: 9.1.7
@@ -181,6 +190,9 @@ importers:
       typescript:
         specifier: 'catalog:'
         version: 5.9.3
+      webdriverio:
+        specifier: 'catalog:'
+        version: 9.30.0(bufferutil@4.1.0)(utf-8-validate@6.0.6)
 
   apps/extension:
     dependencies:
@@ -3240,6 +3252,37 @@ packages:
       zod:
         optional: true
 
+  '@appium/base-driver@10.7.2':
+    resolution: {integrity: sha512-uYY84XZ0LFbXgNCePkVQXRshfSIbnajYSg1QBWYW3zvZodQyoXOInP5sylH8d/B0KM8b2Unn+VP9yoejX6v9CQ==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: '>=10'}
+
+  '@appium/base-plugin@3.3.3':
+    resolution: {integrity: sha512-U9IkSWMNYnoOInLa8sIEGtdG/kcfK4Av1UxIAcLIIpooXg4EPkUzta268PMVIeW/LKXzrATfIOLs5MuPgIdUpQ==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: '>=10'}
+
+  '@appium/docutils@2.5.2':
+    resolution: {integrity: sha512-kseUbImhXFWka1dZ5FPthHKZtqCKzHPwuFheYimQeqMsXKQV9Nd3TJ5HMRUqonaIw6bfAW81TvzP6gx132cMlg==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: '>=10'}
+    hasBin: true
+
+  '@appium/logger@2.0.10':
+    resolution: {integrity: sha512-RFR+9erki0Wqv3pElkbocoE1v2UsYUEvBybqEOTNl3dniA377vqKR9MiQl6W32XlruuIYZH8kkkdQJ3/0TEbyQ==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: '>=10'}
+
+  '@appium/schema@1.3.0':
+    resolution: {integrity: sha512-A/1zs8jUr9q/0Ft3dXSvWQN7JMo/bIcFv5o34fWMRtxZwtHsbl44t5PP5nirZOLZfD8G4oFvm0NSyvjs+sqAzg==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: '>=10'}
+
+  '@appium/support@7.2.6':
+    resolution: {integrity: sha512-WkfHSocC6bZGLHloVfOpTT2/300FPkrOu2PifOiFvfOCPTILIQsiqFIr/TUqeB72oJDarTdfX3doTmsAufXxoQ==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: '>=10'}
+
+  '@appium/types@1.6.0':
+    resolution: {integrity: sha512-7xHJ0AsW/B/uR3m62jKMhX3KvrtV6HcFzOLyCulkjrgwfLNlscVJKdmKul4U3Cj0rEDhCaUCcyagBdiSKDiAfw==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: '>=10'}
+    peerDependencies:
+      '@appium/logger': ^2.0.0
+
   '@apple/app-store-server-library@3.1.0':
     resolution: {integrity: sha512-d26SICRz8BwCV2qPR0BSXBMxmw0NEvJLwsdREcBmCrus8NmyHw2XgOOP0fiFjcctPn/JXtmSDuGVnaHe+dqO+A==}
 
@@ -4443,10 +4486,17 @@ packages:
       react: ^16.8.0 || ^17 || ^18 || ^19
       react-dom: ^16.8.0 || ^17 || ^18 || ^19
 
+  '@colors/colors@1.6.0':
+    resolution: {integrity: sha512-Ir+AOibqzrIsL6ajt3Rz3LskB7OiMVHqltZmspbW/TJuTVuyOMirVqAkjfY6JISiLHgyNqicAC8AyHHGzNd/dA==}
+    engines: {node: '>=0.1.90'}
+
   '@cspotcode/source-map-support@0.8.1':
     resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==}
     engines: {node: '>=12'}
 
+  '@dabh/diagnostics@2.0.8':
+    resolution: {integrity: sha512-R4MSXTVnuMzGD7bzHdW2ZhhdPC/igELENcq5IjEverBvq5hn1SXCWcsi6eSsdWP0/Ur+SItRRjAktmdoX/8R/Q==}
+
   '@date-fns/tz@1.5.0':
     resolution: {integrity: sha512-lwYN/vDPeNRULcepoE/LO2Pgx+7/RV+S9ARfbc9lr2DtGkOD7pAiruHvbR1RX3Qyf6ja47EWJDMsNK5vK08DJg==}
 
@@ -4525,9 +4575,6 @@ packages:
   '@emnapi/runtime@1.11.2':
     resolution: {integrity: sha512-kyOl3X0DuTiT1h2ft8r2fYO8JYtU9a9Xis/zBSiGArNaagCOWx90N1k2wxp18czFDH+OgcWGb5ZP/XMt3dcyPA==}
 
-  '@emnapi/runtime@1.9.0':
-    resolution: {integrity: sha512-QN75eB0IH2ywSpRpNddCRfQIhmJYBCJ1x5Lb3IscKAL8bMnVAKnRg8dCoXbHzVLLH7P38N2Z3mtulB7W0J0FKw==}
-
   '@emnapi/runtime@1.9.2':
     resolution: {integrity: sha512-3U4+MIWHImeyu1wnmVygh5WlgfYDtyf0k8AbLhMFxOipihf6nrWC4syIm/SwEeec0mNSafiiNnMJwbza/Is6Lw==}
 
@@ -5098,70 +5145,145 @@ packages:
     cpu: [arm64]
     os: [darwin]
 
+  '@img/sharp-darwin-arm64@0.35.3':
+    resolution: {integrity: sha512-RMnFX7YQsMoh7lWfcM4NEHHymBX/rLuKNPVM84XE9ONPcaSCDgE7CHIHpSgPcO2xcRthgBy1HfNO319mwhIAkg==}
+    engines: {node: '>=20.9.0'}
+    cpu: [arm64]
+    os: [darwin]
+
   '@img/sharp-darwin-x64@0.34.5':
     resolution: {integrity: sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
     cpu: [x64]
     os: [darwin]
 
+  '@img/sharp-darwin-x64@0.35.3':
+    resolution: {integrity: sha512-Xo+5uFBtLN0BKqieTxiFzFPQAUlBbbH5iBKyRX/z1JrbnYsHTfKJnUfL8+p2TPXr1pXqao4eeL4Rl144uDpK9w==}
+    engines: {node: '>=20.9.0'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-freebsd-wasm32@0.35.3':
+    resolution: {integrity: sha512-lUxcqWIj2wMQ9BrwNjngcr1gWUr5xgaGThBRqPPalIC2n67Cqj1uPh8NnA/ZhAg8hUbKl+kVHKwgUIwe6ZYPrg==}
+    engines: {node: '>=20.9.0'}
+    os: [freebsd]
+
   '@img/sharp-libvips-darwin-arm64@1.2.4':
     resolution: {integrity: sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g==}
     cpu: [arm64]
     os: [darwin]
 
+  '@img/sharp-libvips-darwin-arm64@1.3.2':
+    resolution: {integrity: sha512-9J6ypZFpQBj4YnePGoq/S38w6nz+vqg5WZLrLGY4YuSemdMq47GMLBPO42MzwdGwpg/agZ7xzZcFHa48xlywfg==}
+    cpu: [arm64]
+    os: [darwin]
+
   '@img/sharp-libvips-darwin-x64@1.2.4':
     resolution: {integrity: sha512-1IOd5xfVhlGwX+zXv2N93k0yMONvUlANylbJw1eTah8K/Jtpi15KC+WSiaX/nBmbm2HxRM1gZ0nSdjSsrZbGKg==}
     cpu: [x64]
     os: [darwin]
 
+  '@img/sharp-libvips-darwin-x64@1.3.2':
+    resolution: {integrity: sha512-m2pW1n6cns9VaubNwsZ+c3CRYjxNQWgJ5gPlnL1nbBcpkBvFm6SCFN5o0psFHI8w9n11NKhFkeEDns98tiqbEw==}
+    cpu: [x64]
+    os: [darwin]
+
   '@img/sharp-libvips-linux-arm64@1.2.4':
     resolution: {integrity: sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw==}
     cpu: [arm64]
     os: [linux]
     libc: [glibc]
 
+  '@img/sharp-libvips-linux-arm64@1.3.2':
+    resolution: {integrity: sha512-dqVSFynCox4C/J8kT16V7SIFAns0IjgLwkvYT7p8LQVmJ5OS5b6tI9IGflxTeuBS//zXeFIUbwt5dwxyZ17cnA==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
   '@img/sharp-libvips-linux-arm@1.2.4':
     resolution: {integrity: sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A==}
     cpu: [arm]
     os: [linux]
     libc: [glibc]
 
+  '@img/sharp-libvips-linux-arm@1.3.2':
+    resolution: {integrity: sha512-1eMLzy92I4J6rmi4mAT8yC3HxOtniyGELlzGbNMLLeqe052ahFQ0h6LFq+lh5DsDIdYViIDst08abvSbcEdLXQ==}
+    cpu: [arm]
+    os: [linux]
+    libc: [glibc]
+
   '@img/sharp-libvips-linux-ppc64@1.2.4':
     resolution: {integrity: sha512-FMuvGijLDYG6lW+b/UvyilUWu5Ayu+3r2d1S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA==}
     cpu: [ppc64]
     os: [linux]
     libc: [glibc]
 
+  '@img/sharp-libvips-linux-ppc64@1.3.2':
+    resolution: {integrity: sha512-3z0NHDxD6n5I9gc05U1eW1AyRm+Gznzq3naMrthPNqE6oYykcogW0l/jfpJdjYnuNl8R7yI9pNbE1XiUeyq0Aw==}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
   '@img/sharp-libvips-linux-riscv64@1.2.4':
     resolution: {integrity: sha512-oVDbcR4zUC0ce82teubSm+x6ETixtKZBh/qbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZFF1UwPS2scyGA==}
     cpu: [riscv64]
     os: [linux]
     libc: [glibc]
 
+  '@img/sharp-libvips-linux-riscv64@1.3.2':
+    resolution: {integrity: sha512-bsb4rI+NldGOsXuej2r8OdSS8+zXDVaCWxyWrcv6kneTOlgAHtZABRzBBCwdsPiD90J4myNJuHpg6kA20ImW/w==}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
   '@img/sharp-libvips-linux-s390x@1.2.4':
     resolution: {integrity: sha512-qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ==}
     cpu: [s390x]
     os: [linux]
     libc: [glibc]
 
+  '@img/sharp-libvips-linux-s390x@1.3.2':
+    resolution: {integrity: sha512-/ABshyj8gCpyIrNXnHn4LorDJ0HHm1VhXPBlxZ8zAtfVPAaSafXPGn+sUSIRiwaSBy0mmFjSjiXI5mkcwdChKQ==}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
   '@img/sharp-libvips-linux-x64@1.2.4':
     resolution: {integrity: sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw==}
     cpu: [x64]
     os: [linux]
     libc: [glibc]
 
+  '@img/sharp-libvips-linux-x64@1.3.2':
+    resolution: {integrity: sha512-ITPEtgffGJ0S6G9dRyw/366tJQqFRcHWPHhC+Stpg3Z8AEMrDrTr2lhdz4f/Y/HMbRh//7Z5mBzEpVdi62Oc3w==}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
   '@img/sharp-libvips-linuxmusl-arm64@1.2.4':
     resolution: {integrity: sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw==}
     cpu: [arm64]
     os: [linux]
     libc: [musl]
 
+  '@img/sharp-libvips-linuxmusl-arm64@1.3.2':
+    resolution: {integrity: sha512-zE9EdiUzUmg5mDT5a1rk5fYJ6GWPloTwWBYDS14naqHsL+EaMpDj1AWnpLgh3u0YCORv2Tt50wrcrpYqkP97Kw==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
   '@img/sharp-libvips-linuxmusl-x64@1.2.4':
     resolution: {integrity: sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg==}
     cpu: [x64]
     os: [linux]
     libc: [musl]
 
+  '@img/sharp-libvips-linuxmusl-x64@1.3.2':
+    resolution: {integrity: sha512-m0lrLiUt+lBYnCFr8qV/65yMR4E/c7/wf78I5eKTdkEakFAlZ9QlzEM3QIhhAwVeUhLAHLcCq7a7Vszq/oFNZQ==}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
   '@img/sharp-linux-arm64@0.34.5':
     resolution: {integrity: sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
@@ -5169,6 +5291,13 @@ packages:
     os: [linux]
     libc: [glibc]
 
+  '@img/sharp-linux-arm64@0.35.3':
+    resolution: {integrity: sha512-QgKDspHPnrU+GQ55XPhGwyhC8acLVOOSyAvo1oVfFmrIXLkDNmGWzAfDZ4xK8oSA1qBQrALcHX0G5UZni/SuFQ==}
+    engines: {node: '>=20.9.0'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
   '@img/sharp-linux-arm@0.34.5':
     resolution: {integrity: sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
@@ -5176,6 +5305,13 @@ packages:
     os: [linux]
     libc: [glibc]
 
+  '@img/sharp-linux-arm@0.35.3':
+    resolution: {integrity: sha512-affVWCTLooy8TSxbDx2qkzuDeaWLNVBA+P//FNBirHsXpP2fuBhk5AuboYUnrDnzoXes8GFjpTx0SBFOCRg+FA==}
+    engines: {node: '>=20.9.0'}
+    cpu: [arm]
+    os: [linux]
+    libc: [glibc]
+
   '@img/sharp-linux-ppc64@0.34.5':
     resolution: {integrity: sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
@@ -5183,6 +5319,13 @@ packages:
     os: [linux]
     libc: [glibc]
 
+  '@img/sharp-linux-ppc64@0.35.3':
+    resolution: {integrity: sha512-sMd8rDxmpLOwv/7N44klFjOD5DUO7FLdjiXDI0hoxYaf7Ar262dQIEkosE98bps+5HPLtp/EvNqeqQtOycP/IA==}
+    engines: {node: '>=20.9.0'}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
   '@img/sharp-linux-riscv64@0.34.5':
     resolution: {integrity: sha512-51gJuLPTKa7piYPaVs8GmByo7/U7/7TZOq+cnXJIHZKavIRHAP77e3N2HEl3dgiqdD/w0yUfiJnII77PuDDFdw==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
@@ -5190,6 +5333,13 @@ packages:
     os: [linux]
     libc: [glibc]
 
+  '@img/sharp-linux-riscv64@0.35.3':
+    resolution: {integrity: sha512-0Eob78yjlYPfL5vMNWAW55l3R9Y6BQS/gOfe0ZcP9mEz9ohhKSt4im1hayiknXgf8AWrFqMvJcKIdmLmEe7yeQ==}
+    engines: {node: '>=20.9.0'}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
   '@img/sharp-linux-s390x@0.34.5':
     resolution: {integrity: sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
@@ -5197,6 +5347,13 @@ packages:
     os: [linux]
     libc: [glibc]
 
+  '@img/sharp-linux-s390x@0.35.3':
+    resolution: {integrity: sha512-KgAxQ0DxpNOq1rG2t5cgTgShJFGSuU7XO45cqC+1NVOuZnP6tlgZRuSYOfNupGkHID0o3cJOsw4DVeJpMovcGw==}
+    engines: {node: '>=20.9.0'}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
   '@img/sharp-linux-x64@0.34.5':
     resolution: {integrity: sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
@@ -5204,6 +5361,13 @@ packages:
     os: [linux]
     libc: [glibc]
 
+  '@img/sharp-linux-x64@0.35.3':
+    resolution: {integrity: sha512-8pqvxubL2PGdhlPy6GLqzDYMUjyRmKAwKHYKixpdJYBUK7PJ0C029XdsnpFIdgRZG68fZiGdHVWcKPvtiPB4cA==}
+    engines: {node: '>=20.9.0'}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
   '@img/sharp-linuxmusl-arm64@0.34.5':
     resolution: {integrity: sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
@@ -5211,6 +5375,13 @@ packages:
     os: [linux]
     libc: [musl]
 
+  '@img/sharp-linuxmusl-arm64@0.35.3':
+    resolution: {integrity: sha512-Vz0iQjzzcSX3HCbfwFfCSG/9SCIqyO0mH2sXyiHaAYfBk0cRsCWXRyQYX0ovCK/PAQBbTzQ0dsPQHh5MAFL59w==}
+    engines: {node: '>=20.9.0'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
   '@img/sharp-linuxmusl-x64@0.34.5':
     resolution: {integrity: sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
@@ -5218,29 +5389,63 @@ packages:
     os: [linux]
     libc: [musl]
 
+  '@img/sharp-linuxmusl-x64@0.35.3':
+    resolution: {integrity: sha512-6O1NPKcDVj9QEdg7Hx549EX8U0rp6yXQERqru6yRN7fGBn32UvIRJUlWnk+8xDCiG76hXVBbX82NZ/ZKr0euIg==}
+    engines: {node: '>=20.9.0'}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
   '@img/sharp-wasm32@0.34.5':
     resolution: {integrity: sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
     cpu: [wasm32]
 
+  '@img/sharp-wasm32@0.35.3':
+    resolution: {integrity: sha512-cZ0XkcYGpHZkqW6iCkqTcmUC0CD9DhD5d/qeZlZkfRBn6GnHniZXLUo5+9xw8Iv76YE6LQFN9YNBlKREcCG76w==}
+    engines: {node: '>=20.9.0'}
+
+  '@img/sharp-webcontainers-wasm32@0.35.3':
+    resolution: {integrity: sha512-2rnq7bX3NzeR2T4YWgz8qiG4h3TSdMe+vN1iQXpJleSJ3SM5zQ8Fy2SyyXAWlbxpEZ2Y+Z4u1BePgJEYbSy80Q==}
+    engines: {node: '>=20.9.0'}
+    cpu: [wasm32]
+
   '@img/sharp-win32-arm64@0.34.5':
     resolution: {integrity: sha512-WQ3AgWCWYSb2yt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
     cpu: [arm64]
     os: [win32]
 
+  '@img/sharp-win32-arm64@0.35.3':
+    resolution: {integrity: sha512-4bPwFdMbeC4JQ8L8LOyWp6nsHcboP5fxkp6iPOXz2Vg49R42TuMs2whkJ5OAP4/Ul035qOzy0AecOF9VOscn4w==}
+    engines: {node: '>=20.9.0'}
+    cpu: [arm64]
+    os: [win32]
+
   '@img/sharp-win32-ia32@0.34.5':
     resolution: {integrity: sha512-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmijx1qaJsIiU+Hosw6xM5KijAWRJCSgNg==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
     cpu: [ia32]
     os: [win32]
 
+  '@img/sharp-win32-ia32@0.35.3':
+    resolution: {integrity: sha512-r53mXsBN6lFUDiST764SvgwUdHAqM4rPAiDzAmf4fLoB6X/rkfyTrLCg6+g17wJJiCmB3JYgHuUldCWUIRFSXw==}
+    engines: {node: ^20.9.0}
+    cpu: [ia32]
+    os: [win32]
+
   '@img/sharp-win32-x64@0.34.5':
     resolution: {integrity: sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
     cpu: [x64]
     os: [win32]
 
+  '@img/sharp-win32-x64@0.35.3':
+    resolution: {integrity: sha512-D4y1vNeZrIIJCN+uHaWVtH86B+aCrdMYYjicy9pXHvbGZeGYLLSd3wdVuC37FxVXlU1ARsk84eKWfWMXGYEqvA==}
+    engines: {node: '>=20.9.0'}
+    cpu: [x64]
+    os: [win32]
+
   '@isaacs/fs-minipass@4.0.1':
     resolution: {integrity: sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==}
     engines: {node: '>=18.0.0'}
@@ -7110,6 +7315,9 @@ packages:
     peerDependencies:
       '@opentelemetry/api': ^1.8
 
+  '@promptbook/utils@0.69.5':
+    resolution: {integrity: sha512-xm5Ti/Hp3o4xHrsK9Yy3MS6KbDxYbq485hDsFvxqaNA7equHLPdo8H8faTitTeb14QCDfLW4iwCxdVYu5sn6YQ==}
+
   '@protobufjs/aspromise@1.1.2':
     resolution: {integrity: sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==}
 
@@ -7137,6 +7345,11 @@ packages:
   '@protobufjs/utf8@1.1.1':
     resolution: {integrity: sha512-oOAWABowe8EAbMyWKM0tYDKi8Yaox52D+HWZhAIJqQXbqe0xI/GV7FhLWqlEKreMkfDjshR5FKgi3mnle0h6Eg==}
 
+  '@puppeteer/browsers@2.13.2':
+    resolution: {integrity: sha512-5EUZSUIc37H6aIXyWO0Z4y8NlF8NnjgmqeQgOGiswAU7pY0HOo16ho4+alIWmSfdZnjqBRawMsP3I5YqLSn6kw==}
+    engines: {node: '>=18'}
+    hasBin: true
+
   '@qdrant/js-client-rest@1.17.0':
     resolution: {integrity: sha512-aZFQeirWVqWAa1a8vJ957LMzcXkFHGbsoRhzc8AkGfg6V0jtK8PlG8/eyyc2xhYsR961FDDx1Tx6nyE0K7lS+A==}
     engines: {node: '>=18.17.0', pnpm: '>=8'}
@@ -8521,6 +8734,12 @@ packages:
   '@sideway/pinpoint@2.0.0':
     resolution: {integrity: sha512-RNiOoTPkptFtSVzQevY/yWtZwf/RxyVnPy/OcA9HBM3MlGDnBEYL5B41H0MTn0Uec8Hi+2qUtTfG2WWZBmMejQ==}
 
+  '@sidvind/better-ajv-errors@5.0.0':
+    resolution: {integrity: sha512-FeI/V2KGtOaDX+r0akidCGYy79lVR4YnAqk1GFgZFuHADErCAEmtZL4+IdCAcDXHqfZsII3fs9DrfC1pIR+19w==}
+    engines: {node: ^20.19 || ^22.12 || >= 24.0}
+    peerDependencies:
+      ajv: ^7.0.0 || ^8.0.0
+
   '@silvia-odwyer/photon-node@0.3.4':
     resolution: {integrity: sha512-bnly4BKB3KDTFxrUIcgCLbaeVVS8lrAkri1pEzskpmxu9MdfGQTy8b8EgcD83ywD3RPMsIulY8xJH5Awa+t9fA==}
 
@@ -8809,6 +9028,9 @@ packages:
     resolution: {integrity: sha512-O/IEdcCUKkubz60tFbGA7ceITTAJsty+lBjNoorP4Z6XRqaFb/OjQjZODophEcuq68nKm6/0r+6/lLQ+XVpk8g==}
     engines: {node: '>=18.0.0'}
 
+  '@so-ric/colorspace@1.1.6':
+    resolution: {integrity: sha512-/KiKkpHNOBgkFJwu9sh48LkHSMYGyuTcSFK/qMBdnOAlrRJzRSXAOFB5qwzaVQuDl8wAvHVMkaASQDReTahxuw==}
+
   '@speed-highlight/core@1.2.14':
     resolution: {integrity: sha512-G4ewlBNhUtlLvrJTb88d2mdy2KRijzs4UhnlrOSRT4bmjh/IqNElZa3zkrZ+TC47TwtlDWzVLFADljF1Ijp5hA==}
 
@@ -9501,6 +9723,9 @@ packages:
   '@tokenizer/token@0.3.0':
     resolution: {integrity: sha512-OvjF+z51L3ov0OyAU0duzsYuvO01PH7x4t6DJx+guahgTnBHkhJdG7soQeTSFLWN3efnHyibZ4Z8l2EuWwJN3A==}
 
+  '@tootallnate/quickjs-emscripten@0.23.0':
+    resolution: {integrity: sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==}
+
   '@trpc/client@11.17.0':
     resolution: {integrity: sha512-KpJBFrbKTDeVCFv/3ckL1XBBH5Yssn8hethI/rUy7GIpTj+VzjtPjykDqJpzobuVOz+d26cXCSu1t4I6MYI5Zg==}
     hasBin: true
@@ -9751,6 +9976,9 @@ packages:
   '@types/semver@7.7.1':
     resolution: {integrity: sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA==}
 
+  '@types/sinonjs__fake-timers@8.1.5':
+    resolution: {integrity: sha512-mQkU2jY8jJEF7YHjHvsQO8+3ughTL1mcnn96igfhONmR+fUPSKIkefQYpSe8bsly2Ep7oQbn/6VG5/9/0qcArQ==}
+
   '@types/stack-utils@2.0.3':
     resolution: {integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==}
 
@@ -9760,6 +9988,9 @@ packages:
   '@types/tedious@4.0.14':
     resolution: {integrity: sha512-KHPsfX/FoVbUGbyYvk1q9MMQHLPeRZhRJZdO45Q4YjvFkv4hMNghCWTvy7rdKessBsmtz4euWCWAB6/tVpI1Iw==}
 
+  '@types/triple-beam@1.3.5':
+    resolution: {integrity: sha512-6WaYesThRMCl19iryMYP7/x2OVgCtbIVflDGFpWnb9irXI3UjYE4AzmYuiUKY1AJstGijoY+MgUszMgRxIYTYw==}
+
   '@types/trusted-types@2.0.7':
     resolution: {integrity: sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==}
 
@@ -9781,6 +10012,9 @@ packages:
   '@types/webextension-polyfill@0.12.5':
     resolution: {integrity: sha512-uKSAv6LgcVdINmxXMKBuVIcg/2m5JZugoZO8x20g7j2bXJkPIl/lVGQcDlbV+aXAiTyXT2RA5U5mI4IGCDMQeg==}
 
+  '@types/which@2.0.2':
+    resolution: {integrity: sha512-113D3mDkZDjo+EeUEHCFy0qniNc1ZpecGiAU7WSo7YDoSzolZIQKpYFHrPpjkB2nuyahcKfrmLXeQlh7gqJYdw==}
+
   '@types/ws@8.18.1':
     resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==}
 
@@ -9790,6 +10024,9 @@ packages:
   '@types/yargs@17.0.35':
     resolution: {integrity: sha512-qUHkeCyQFxMXg79wQfTtfndEC+N9ZZg76HJftDJp+qH2tV7Gj4OJi7l+PiWwJ+pWtW8GwSmqsDj/oymhrTWXjg==}
 
+  '@types/yauzl@2.10.3':
+    resolution: {integrity: sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==}
+
   '@typescript-eslint/project-service@8.57.0':
     resolution: {integrity: sha512-pR+dK0BlxCLxtWfaKQWtYr7MhKmzqZxuii+ZjuFlZlIGRZm22HnXFqa2eY+90MUz8/i80YJmzFGDUsi8dMOV5w==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
@@ -10132,10 +10369,33 @@ packages:
   '@vue/shared@3.5.30':
     resolution: {integrity: sha512-YXgQ7JjaO18NeK2K9VTbDHaFy62WrObMa6XERNfNOkAhD1F1oDSf3ZJ7K6GqabZ0BvSDHajp8qfS5Sa2I9n8uQ==}
 
+  '@wdio/config@9.30.0':
+    resolution: {integrity: sha512-pH/Y1F4QVIsx33xyli8+9HCr4HRuOeUk8j/lqNBuuUzbvduYRCLmNkZqxRsLnRth8wrlPdzA8Hq+PPLwJWrceA==}
+    engines: {node: '>=18.20.0'}
+
   '@wdio/logger@9.18.0':
     resolution: {integrity: sha512-HdzDrRs+ywAqbXGKqe1i/bLtCv47plz4TvsHFH3j729OooT5VH38ctFn5aLXgECmiAKDkmH/A6kOq2Zh5DIxww==}
     engines: {node: '>=18.20.0'}
 
+  '@wdio/logger@9.29.1':
+    resolution: {integrity: sha512-0ZAEIo6PNyMIJPlOGkIgyOJUjcd0pC8/QHlVAAe1c91/IcjZ1X+k0yidXHaboJdN7dq1XPUacmhRdtua0U5EZg==}
+    engines: {node: '>=18.20.0'}
+
+  '@wdio/protocols@9.30.0':
+    resolution: {integrity: sha512-VDKCTw3GVdqUw1+fXAY4FUOSt+a3/r7T2O34d5HAaZLfI6QHacsU7/N0Sv3w/QgWU6yj3WkXElXq1oSWF1XcBw==}
+
+  '@wdio/repl@9.16.2':
+    resolution: {integrity: sha512-FLTF0VL6+o5BSTCO7yLSXocm3kUnu31zYwzdsz4n9s5YWt83sCtzGZlZpt7TaTzb3jVUfxuHNQDTb8UMkCu0lQ==}
+    engines: {node: '>=18.20.0'}
+
+  '@wdio/types@9.29.1':
+    resolution: {integrity: sha512-jp8jgMv6TS35G96YzHZxw3PVN0Dz6xQ6tnMAicndAJ8Jt9AIXb0ywIse4TjaFywakO3dLoEhlyA3ZtR26vmt+w==}
+    engines: {node: '>=18.20.0'}
+
+  '@wdio/utils@9.30.0':
+    resolution: {integrity: sha512-MhTx8jKOtspogeMUmASFsmL6vRetwCpvfcAFHauYZ62UzPjFwHThIXorzoG90mrcS9Yl+c8Sj9BfX+bdxwXfsg==}
+    engines: {node: '>=18.20.0'}
+
   '@webassemblyjs/ast@1.14.1':
     resolution: {integrity: sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ==}
 
@@ -10429,6 +10689,11 @@ packages:
     resolution: {integrity: sha512-7yeyCEurROLQJFv5Xj4lEGTy0borxepjFv1g22oAdqFu//SrAlDl1O1Nxx15SH1RoliUml6p8dwJW9jvZughhg==}
     engines: {node: '>=8'}
 
+  appium@3.6.0:
+    resolution: {integrity: sha512-qmsIj1VReEgW4tLZHX/1MXLCcV970gnTTgdQ1/aaWSisRJ6OeHbb582qJJmiyGl11wunx04il9YvTsy71J6dbw==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: '>=10'}
+    hasBin: true
+
   archiver-utils@5.0.2:
     resolution: {integrity: sha512-wuLJMmIBQYCsGZgYLTy5FIB2pF6Lfb6cXMSF8Qywwk3t20zWnAi7zLcQFdKQmIB8wyZpY5ER38x08GbwtR2cLA==}
     engines: {node: '>= 14'}
@@ -10437,6 +10702,10 @@ packages:
     resolution: {integrity: sha512-ZcbTaIqJOfCc03QwD468Unz/5Ir8ATtvAHsK+FdXbDIbGfihqh9mrvdcYunQzqn4HrvWWaFyaxJhGZagaJJpPQ==}
     engines: {node: '>= 14'}
 
+  archiver@8.0.0:
+    resolution: {integrity: sha512-fV1orZfsnPn9BaSByR/qE67rJCLJEy2Ox5bq7nJh+jquWaNh6Sfec75kJ2T6PtdGUbPQlrVoSVCEOa5SdiTQ1g==}
+    engines: {node: '>=18'}
+
   archy@1.0.0:
     resolution: {integrity: sha512-Xg+9RwCg/0p32teKdGMPTPnVXKD0w3DfHnFTficozsAgsvq2XenPJq/MYpzzQ/v8zrOyJn6Ds39VA4JIDwFfqw==}
 
@@ -10449,6 +10718,9 @@ packages:
   argparse@2.0.1:
     resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
 
+  argparse@3.0.0:
+    resolution: {integrity: sha512-BOp5NMrHqKxmq/OLr+clzzrRxgOKSLkcjmkWuChp7Irqwn4s74WjOBPIgWfA/HMcBnVkZ5XEuf9uUqzlpfCQ6A==}
+
   aria-hidden@1.2.6:
     resolution: {integrity: sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==}
     engines: {node: '>=10'}
@@ -10488,6 +10760,10 @@ packages:
     resolution: {integrity: sha512-WHw67kLXYbZuHTmcdbIrVArCq5wxo6NEuj3hiYAWr8mwJeC+C2mMCIBIWCiDoCye/OF/xelc+teJ1ERoWmnEIA==}
     engines: {node: '>=18'}
 
+  ast-types@0.13.4:
+    resolution: {integrity: sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==}
+    engines: {node: '>=4'}
+
   ast-types@0.16.1:
     resolution: {integrity: sha512-6t10qk83GOG8p0vKmaCr8eiilZwO171AvbROMtvvNiwrTly62t+7XkA8RdIIVbpMhCASAsxgAzdRSwh6nw/5Dg==}
     engines: {node: '>=4'}
@@ -10499,12 +10775,19 @@ packages:
     resolution: {integrity: sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==}
     hasBin: true
 
+  async-lock@1.4.1:
+    resolution: {integrity: sha512-Az2ZTpuytrtqENulXwO3GGv1Bztugx6TT37NIo7imr/Qo0gsYiGtSdBa2B6fsXhTpVZDNfu1Qn3pk531e3q+nQ==}
+
   async-mutex@0.5.0:
     resolution: {integrity: sha512-1A94B18jkJ3DYq284ohPxoXbfTA5HsQ7/Mf4DEhcyLx3Bz27Rh59iScbB6EPiP+B+joue6YCxcMXSbFC1tZKwA==}
 
   async@3.2.6:
     resolution: {integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==}
 
+  asyncbox@6.3.5:
+    resolution: {integrity: sha512-did9yFgGiHq9CzFirtQtVZKJfKo68IQzhqWmUd3R0WdO1V5LkJUy2NPQZOJZHKvNWma+ETwoJEA8ALt9h8pN1w==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: '>=10'}
+
   asynckit@0.4.0:
     resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
 
@@ -10705,6 +10988,14 @@ packages:
     engines: {node: '>=6.0.0'}
     hasBin: true
 
+  basic-auth@2.0.1:
+    resolution: {integrity: sha512-NF+epuEdnUYVlGuhaxbbq+dvJttwLnGY+YixlXlME5KpQ5W3CnXA5cVTneY3SPbPDRkcjMbifrwmFYcClgOZeg==}
+    engines: {node: '>= 0.8'}
+
+  basic-ftp@5.3.1:
+    resolution: {integrity: sha512-bopVNp6ugyA150DDuZfPFdt1KZ5a94ZDiwX4hMgZDzF+GttD80lEy8kj98kbyhLXnPvhtIo93mdnLIjpCAeeOw==}
+    engines: {node: '>=10.0.0'}
+
   before-after-hook@4.0.0:
     resolution: {integrity: sha512-q6tR3RPqIB1pMiTRMFcZwuG5T8vwp+vUvEG0vuI6B+Rikh5BfPp2fQ82c925FOs+b0lcFQ8CFrL+KbilfZFhOQ==}
 
@@ -10741,6 +11032,10 @@ packages:
     resolution: {integrity: sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA==}
     engines: {node: '>=18'}
 
+  body-parser@2.3.0:
+    resolution: {integrity: sha512-2cGmJupaNgg+QUwVLAucDuWuoMZ6EX9iHDRswZ5lsNYEmwPaRknMPCLZz07yTzVq/83p4o/wzbDZbBrTvGGTIw==}
+    engines: {node: '>=18'}
+
   boolbase@1.0.0:
     resolution: {integrity: sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==}
 
@@ -10757,6 +11052,9 @@ packages:
   bplist-creator@0.1.0:
     resolution: {integrity: sha512-sXaHZicyEEmY86WyueLTQesbeoH/mquvarJaQNbjuOQO+7gbFcDEWqKmcWA4cOTLzFlfgvkiVxolk1k5bBIpmg==}
 
+  bplist-creator@0.1.1:
+    resolution: {integrity: sha512-Ese7052fdWrxp/vqSJkydgx/1MdBnNOCV2XVfbmdGWD2H6EYza+Q4pyYSuVSnCUD22hfI/BFI4jHaC3NLXLlJQ==}
+
   bplist-parser@0.3.1:
     resolution: {integrity: sha512-PyJxiNtA5T2PlLIeBot4lbp7rj4OadzjnMZD/G5zuBNt8ei/yCU7+wW0h2bag9vr8c+/WuRWmSxbqAl9hL1rBA==}
     engines: {node: '>= 5.10.0'}
@@ -11123,6 +11421,10 @@ packages:
     resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==}
     engines: {node: '>=12'}
 
+  cliui@9.0.1:
+    resolution: {integrity: sha512-k7ndgKhwoQveBL+/1tqGJYNz097I7WOvwbmmU2AR5+magtbjPWQTS1C5vzGkBC8Ym8UWRzfKUzUUqFLypY4Q+w==}
+    engines: {node: '>=20'}
+
   clone@1.0.4:
     resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==}
     engines: {node: '>=0.8'}
@@ -11173,19 +11475,35 @@ packages:
     resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
     engines: {node: '>=7.0.0'}
 
+  color-convert@3.1.3:
+    resolution: {integrity: sha512-fasDH2ont2GqF5HpyO4w0+BcewlhHEZOFn9c1ckZdHpJ56Qb7MHhH/IcJZbBGgvdtwdwNbLvxiBEdg336iA9Sg==}
+    engines: {node: '>=14.6'}
+
   color-name@1.1.3:
     resolution: {integrity: sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==}
 
   color-name@1.1.4:
     resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
 
+  color-name@2.1.1:
+    resolution: {integrity: sha512-p2FdgwVx1a9yWBHP2wI0VgShkDpgN4kZISkxdNipGBJWpa5G6b04OINlVWCyJj0JmfvcPrgqt95E9k8yvaOJFg==}
+    engines: {node: '>=12.20'}
+
   color-string@1.9.1:
     resolution: {integrity: sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==}
 
+  color-string@2.1.4:
+    resolution: {integrity: sha512-Bb6Cq8oq0IjDOe8wJmi4JeNn763Xs9cfrBcaylK1tPypWzyoy2G3l90v9k64kjphl/ZJjPIShFztenRomi8WTg==}
+    engines: {node: '>=18'}
+
   color@4.2.3:
     resolution: {integrity: sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==}
     engines: {node: '>=12.5.0'}
 
+  color@5.0.3:
+    resolution: {integrity: sha512-ezmVcLR3xAVp8kYOm4GS45ZLLgIE6SPAFoduLr6hTDajwb3KZ2F46gulK3XpcwRFb5KKGCSezCBAY4Dw4HsyXA==}
+    engines: {node: '>=18'}
+
   colorette@2.0.20:
     resolution: {integrity: sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==}
 
@@ -11251,6 +11569,10 @@ packages:
     resolution: {integrity: sha512-6FqVXeETqWPoGcfzrXb37E50NP0LXT8kAMu5ooZayhWWdgEY4lBEEcbQNXtkuKQsGduxiIcI4gOTsxTmuq/bSg==}
     engines: {node: '>= 14'}
 
+  compress-commons@7.0.1:
+    resolution: {integrity: sha512-g0S8KAD8qf4+V//pr3BfB1aBnARLXNz2Gx+jmHU0LEriUuoQUOPOulVquHKTJ8+EAIIO7fhseNDr9wK5Q9FKBQ==}
+    engines: {node: '>=18'}
+
   compressible@2.0.18:
     resolution: {integrity: sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==}
     engines: {node: '>= 0.6'}
@@ -11305,6 +11627,10 @@ packages:
     resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==}
     engines: {node: '>= 0.6'}
 
+  content-type@2.0.0:
+    resolution: {integrity: sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ==}
+    engines: {node: '>=18'}
+
   convert-source-map@1.9.0:
     resolution: {integrity: sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==}
 
@@ -11377,6 +11703,10 @@ packages:
     resolution: {integrity: sha512-piICUB6ei4IlTv1+653yq5+KoqfBYmj9bw6LqXoOneTMDXk5nM1qt12mFW1caG3LlJXEKW1Bp0WggEmIfQB34g==}
     engines: {node: '>= 14'}
 
+  crc32-stream@7.0.1:
+    resolution: {integrity: sha512-IBWsY8xznyQrcHn8h4bC8/4ErNke5elzgG8GcqF4RFPw6aHkWWRc7Tgw6upjaTX/CT/yQgqYENkxYsTYN+hW2g==}
+    engines: {node: '>=18'}
+
   create-ecdh@4.0.4:
     resolution: {integrity: sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A==}
 
@@ -11436,10 +11766,16 @@ packages:
   css-select@5.2.2:
     resolution: {integrity: sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==}
 
+  css-shorthand-properties@1.1.2:
+    resolution: {integrity: sha512-C2AugXIpRGQTxaCW0N7n5jD/p5irUmCrwl03TrnMFBHDbdq44CFWR2zO7rK9xPN4Eo3pUxC4vQzQgbIpzrD1PQ==}
+
   css-tree@1.1.3:
     resolution: {integrity: sha512-tRpdppF7TRazZrjJ6v3stzv93qxRcSsFmW6cX0Zm2NVKpxE1WV1HblnghVv9TreireHkqI/VDEsfolRF1p6y7Q==}
     engines: {node: '>=8.0.0'}
 
+  css-value@0.0.1:
+    resolution: {integrity: sha512-FUV3xaJ63buRLgHrLQVlVgQnQdR4yqdLGaDu7g8CQcWjInDfM9plBTPI9FRfpahju1UBSaMckeb2/46ApS/V1Q==}
+
   css-what@6.2.2:
     resolution: {integrity: sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==}
     engines: {node: '>= 6'}
@@ -11517,6 +11853,10 @@ packages:
     resolution: {integrity: sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==}
     engines: {node: '>= 12'}
 
+  data-uri-to-buffer@6.0.2:
+    resolution: {integrity: sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw==}
+    engines: {node: '>= 14'}
+
   date-fns@4.1.0:
     resolution: {integrity: sha512-Ukq0owbQXxa/U3EGtsdVBkR1w7KOQ5gIBqdH2hkvknzZPYvBxb/aa6E8L7tmjFtkwZBu3UXBbjIgPo/Ez4xaNg==}
 
@@ -11534,6 +11874,14 @@ packages:
       supports-color:
         optional: true
 
+  debug@3.1.0:
+    resolution: {integrity: sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
   debug@3.2.7:
     resolution: {integrity: sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==}
     peerDependencies:
@@ -11604,6 +11952,10 @@ packages:
   deep-is@0.1.4:
     resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
 
+  deepmerge-ts@7.1.5:
+    resolution: {integrity: sha512-HOJkrhaYsweh+W+e74Yn7YStZOilkoPb6fycpwNLKzSPtruFs48nYis0zy5yJz1+ktUhHxoRDJ27RQAWLIJVJw==}
+    engines: {node: '>=16.0.0'}
+
   deepmerge@4.3.1:
     resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==}
     engines: {node: '>=0.10.0'}
@@ -11642,6 +11994,10 @@ packages:
   defu@6.1.7:
     resolution: {integrity: sha512-7z22QmUWiQ/2d0KkdYmANbRUVABpZ9SNYyH5vx6PZ+nE5bcC0l7uFvEfHlyld/HcGBFTL536ClDt3DEcSlEJAQ==}
 
+  degenerator@5.0.1:
+    resolution: {integrity: sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==}
+    engines: {node: '>= 14'}
+
   delayed-stream@1.0.0:
     resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==}
     engines: {node: '>=0.4.0'}
@@ -11685,6 +12041,9 @@ packages:
   detect-node-es@1.1.0:
     resolution: {integrity: sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==}
 
+  detect-node@2.1.0:
+    resolution: {integrity: sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==}
+
   detective-amd@6.0.1:
     resolution: {integrity: sha512-TtyZ3OhwUoEEIhTFoc1C9IyJIud3y+xYkSRjmvCt65+ycQuc3VcBrPRTMWoO/AnuCyOB8T5gky+xf7Igxtjd3g==}
     engines: {node: '>=18'}
@@ -11962,6 +12321,15 @@ packages:
   ecdsa-sig-formatter@1.0.11:
     resolution: {integrity: sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==}
 
+  edge-paths@3.0.5:
+    resolution: {integrity: sha512-sB7vSrDnFa4ezWQk9nZ/n0FdpdUuC6R1EOrlU3DL+bovcNFK28rqu2emmAUjujYEJTWIgQGqgVVWUZXMnc8iWg==}
+    engines: {node: '>=14.0.0'}
+
+  edgedriver@6.3.0:
+    resolution: {integrity: sha512-ggEQL+oEyIcM4nP2QC3AtCQ04o4kDNefRM3hja0odvlPSnsaxiruMxEZ93v3gDCKWYW6BXUr51PPradb+3nffw==}
+    engines: {node: '>=20.0.0'}
+    hasBin: true
+
   ee-first@1.1.1:
     resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==}
 
@@ -11994,6 +12362,9 @@ packages:
     resolution: {integrity: sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==}
     engines: {node: '>= 4'}
 
+  enabled@2.0.0:
+    resolution: {integrity: sha512-AKrN98kuwOzMIdAizXGI86UFBoo26CL21UM763y1h/GMSJ4/OHU9k2YlsmBpyScFo/wbLzWQJBMCW4+IO3/+OQ==}
+
   encodeurl@1.0.2:
     resolution: {integrity: sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==}
     engines: {node: '>= 0.8'}
@@ -12688,6 +13059,11 @@ packages:
   extend@3.0.2:
     resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==}
 
+  extract-zip@2.0.1:
+    resolution: {integrity: sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==}
+    engines: {node: '>= 10.17.0'}
+    hasBin: true
+
   fast-check@4.8.0:
     resolution: {integrity: sha512-GOJ158CUMnN6cSahsv4+ExARvIDuzzinFjkp0E9WtiBa5zcVeLozVkWaE4IzFcc+Y48Wp1EDlUZsXRyAztQcSg==}
     engines: {node: '>=12.17.0'}
@@ -12695,6 +13071,9 @@ packages:
   fast-content-type-parse@3.0.0:
     resolution: {integrity: sha512-ZvLdcY8P+N8mGQJahJV5G4U88CSvT1rP8ApL6uETe88MBXrBHAkZlSEySdUlyztF7ccb+Znos3TFqaepHxdhBg==}
 
+  fast-deep-equal@2.0.1:
+    resolution: {integrity: sha512-bCK/2Z4zLidyB4ReuIsvALH6w31YfAQDmXMqMx6FyfHqvBxtjC0eRumeSu4Bs3XtXwpyIywtSTrVT99BxY1f9w==}
+
   fast-deep-equal@3.1.3:
     resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
 
@@ -12743,6 +13122,10 @@ packages:
     resolution: {integrity: sha512-C0AaNuC+mscy6vrAQKAc/rMq+zAPHodfHGZu4sGVehvAQt/JLG1O5zEcYcXSY5zSqr4YVgxsB+pHXTq0i7eDlg==}
     hasBin: true
 
+  fastest-levenshtein@1.0.16:
+    resolution: {integrity: sha512-eRnCtTTtGZFpQCwhJiUOuxPQWRXVKYDn0b2PeHfXL6/Zi53SLAzAHfVhVWK2AryC/WH05kGfxhFIPvTF0SXQzg==}
+    engines: {node: '>= 4.9.1'}
+
   fastq@1.20.1:
     resolution: {integrity: sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==}
 
@@ -12760,6 +13143,9 @@ packages:
   fd-package-json@2.0.0:
     resolution: {integrity: sha512-jKmm9YtsNXN789RS/0mSzOC1NUq9mkVd65vbSSVsKdjGvYXBuE4oWe2QOEoFeRmJg+lPuZxpmrfFclNhoRMneQ==}
 
+  fd-slicer@1.1.0:
+    resolution: {integrity: sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==}
+
   fdir@6.5.0:
     resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
     engines: {node: '>=12.0.0'}
@@ -12769,6 +13155,9 @@ packages:
       picomatch:
         optional: true
 
+  fecha@4.2.3:
+    resolution: {integrity: sha512-OP2IUU6HeYKJi3i0z4A19kHMQoLVs4Hc+DPqqxI2h/DPZHTm/vjsfC6P0b4jCMy14XizLBqvndQ+UilD7707Jw==}
+
   fetch-blob@3.2.0:
     resolution: {integrity: sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==}
     engines: {node: ^12.20 || >= 14.13}
@@ -12880,6 +13269,9 @@ packages:
   flow-enums-runtime@0.0.6:
     resolution: {integrity: sha512-3PYnM29RFXwvAN6Pc/scUfkI7RwhQ/xqyLUyPNlXUp9S40zI8nup9tUSrTLSVnWGBN38FNiGWbwZOB6uR4OGdw==}
 
+  fn.name@1.1.0:
+    resolution: {integrity: sha512-GRnmB5gPyJpAhTQdSZTSp9uaPSvl09KoYcMQtsB9rQoOmzs9dH6ffeccH+Z+cv6P68Hu5bC6JjRh4Ah/mHSNRw==}
+
   follow-redirects@1.16.0:
     resolution: {integrity: sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==}
     engines: {node: '>=4.0'}
@@ -12996,6 +13388,10 @@ packages:
     engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
     os: [darwin]
 
+  ftp-response-parser@1.0.1:
+    resolution: {integrity: sha512-++Ahlo2hs/IC7UVQzjcSAfeUpCwTTzs4uvG5XfGnsinIFkWUYF4xWwPd5qZuK8MJrmUIxFMuHcfqaosCDjvIWw==}
+    engines: {node: '>=0.8.0'}
+
   function-bind@1.1.2:
     resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}
 
@@ -13026,6 +13422,11 @@ packages:
     engines: {node: '>=20.0.0'}
     hasBin: true
 
+  geckodriver@6.1.1:
+    resolution: {integrity: sha512-/AcCyc9o9o6hUbudaSJM2iOtXbxSLqQPOb4GrPvEN40cjraUeaX/j5kH3mSgwiroyMn7qzx2wM61AQ2XY8j3sA==}
+    engines: {node: '>=20.0.0'}
+    hasBin: true
+
   generator-function@2.0.1:
     resolution: {integrity: sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==}
     engines: {node: '>= 0.4'}
@@ -13068,10 +13469,18 @@ packages:
   get-port-please@3.2.0:
     resolution: {integrity: sha512-I9QVvBw5U/hw3RmWpYKRumUeaDgxTPd401x364rLmWBJcOQ753eov1eTgzDqRG9bqFIfDc7gfzcQEWrUri3o1A==}
 
+  get-port@7.2.0:
+    resolution: {integrity: sha512-afP4W205ONCuMoPBqcR6PSXnzX35KTcJygfJfcp+QY+uwm3p20p1YczWXhlICIzGMCxYBQcySEcOgsJcrkyobg==}
+    engines: {node: '>=16'}
+
   get-proto@1.0.1:
     resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==}
     engines: {node: '>= 0.4'}
 
+  get-stream@5.2.0:
+    resolution: {integrity: sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==}
+    engines: {node: '>=8'}
+
   get-stream@6.0.1:
     resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==}
     engines: {node: '>=10'}
@@ -13082,6 +13491,10 @@ packages:
   get-tsconfig@4.14.0:
     resolution: {integrity: sha512-yTb+8DXzDREzgvYmh6s9vHsSVCHeC0G3PI5bEXNBHtmshPnO+S5O7qgLEOn0I5QvMy6kpZN8K1NKGyilLb93wA==}
 
+  get-uri@6.0.5:
+    resolution: {integrity: sha512-b1O07XYq8eRuVzBNgJLstU6FYc1tS6wnMtF1I1D9lE8LxZSOGZ7LhxN54yPP6mGw5f2CkXY2BQUL9Fx41qvcIg==}
+    engines: {node: '>= 14'}
+
   getenv@2.0.0:
     resolution: {integrity: sha512-VilgtJj/ALgGY77fiLam5iD336eSWi96Q15JSAG1zi8NRBysm3LXKdGnHb4m5cuyxvOLQQKWpBZAT6ni4FI2iQ==}
     engines: {node: '>=6'}
@@ -13158,6 +13571,9 @@ packages:
     resolution: {integrity: sha512-7dYm06A945mXuIk/5HUlSjeyIYChW8vCEiU2dkOKKqJJzwAWxTkCc91Eqbz7TgODh2rtFFKWI/fekowWHOkmjQ==}
     engines: {node: ^12.20.0 || >=14.13.1}
 
+  grapheme-splitter@1.0.4:
+    resolution: {integrity: sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==}
+
   graphql-tag@2.12.7:
     resolution: {integrity: sha512-xnE/NFzy+0eIesvAsREJZ284zTl/wYuBAvpsFSDhRGRdRHdnE90M21Q3xAWyYInb0J756c6x0pIQ62+vtvOs1Q==}
     engines: {node: '>=10'}
@@ -13175,6 +13591,9 @@ packages:
     resolution: {integrity: sha512-ax7ZYomf6jqPTQ4+XCpUGyXKHk5WweS+e05MBO4/y3WJ5RkmPXNKvX+bx1behVILVwr6JSQvZAku021CHPXG3Q==}
     engines: {node: '>=10'}
 
+  handle-thing@2.0.1:
+    resolution: {integrity: sha512-9Qn4yBxelxoh2Ow62nP+Ka/kMnOXRi8BXnRaUwezLNhqelnN49xKz4F/dPP8OYLxLxq6JDtZb2i9XznUQbNPTg==}
+
   handlebars@4.7.9:
     resolution: {integrity: sha512-4E71E0rpOaQuJR2A3xDZ+GM1HyWYv1clR58tC8emQNeQe3RH7MAzSbat+V0wG78LQBo6m6bzSG/L4pBuCsgnUQ==}
     engines: {node: '>=0.4.7'}
@@ -13312,6 +13731,13 @@ packages:
     resolution: {integrity: sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==}
     engines: {node: ^16.14.0 || >=18.0.0}
 
+  hosted-git-info@9.0.3:
+    resolution: {integrity: sha512-Hc+ghLoSt6QaYZUv0WBiIvmMDZuZZ7oaDvdH8MbfOO4lOsxdXLEvuC6ePoGs9H1X9oCLyq6+NVN0MKqD+ydxyg==}
+    engines: {node: ^20.17.0 || >=22.9.0}
+
+  hpack.js@2.1.6:
+    resolution: {integrity: sha512-zJxVehUdMGIKsRaNt7apO2Gqp0BdqW5yaiGHXXmbpvxgBYVZnAql+BJb4RO5ad2MgpbZKn5G6nMnegrH1FcNYQ==}
+
   html-entities@2.6.0:
     resolution: {integrity: sha512-kig+rMn/QOVRvr7c86gQ8lWXq+Hkv6CbAH1hLu+RG338StTpE8Z0b44SDVaqVu7HGKf27frdmUYEs9hTUX/cLQ==}
 
@@ -13341,6 +13767,9 @@ packages:
       webpack:
         optional: true
 
+  htmlfy@0.8.1:
+    resolution: {integrity: sha512-xWROBw9+MEGwxpotll0h672KCaLrKKiCYzsyN8ZgL9cQbVumFnyvsk2JqiB9ELAV1GLj1GG/jxZUjV9OZZi/yQ==}
+
   htmlparser2@10.1.0:
     resolution: {integrity: sha512-VTZkM9GWRAtEpveh7MSF6SjjrpNVNNVJfFup7xTY3UpFtm67foy9HDVXneLtFVt4pMz5kZtgNcvCniNFb1hlEQ==}
 
@@ -13350,6 +13779,9 @@ packages:
   htmlparser2@6.1.0:
     resolution: {integrity: sha512-gyyPk6rgonLFEDGoeRgQNaEUvdJ4ktTmmUh/h2t7s+M8oPpIPxgNACWa+6ESR57kXstwqPiCut0V8NRpcwgU7A==}
 
+  http-deceiver@1.2.7:
+    resolution: {integrity: sha512-LmpOGxTfbpgtGVxJrj5k7asXHCgNZp5nLfp+hWc8QQRqtb7fUy6kRY3BO1h9ddF6yIPYUARgxGOwB42DnxIaNw==}
+
   http-errors@2.0.1:
     resolution: {integrity: sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==}
     engines: {node: '>= 0.8'}
@@ -13358,6 +13790,9 @@ packages:
     resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==}
     engines: {node: '>= 14'}
 
+  http-status-codes@2.3.0:
+    resolution: {integrity: sha512-RJ8XvFvpPM/Dmc5SV+dC4y5PCeOhT3x1Hq0NU3rjGeg5a/CqlhZ7uudknPwZFz4aeAXDcbAyaeP7GAo9lvngtA==}
+
   http_ece@1.2.0:
     resolution: {integrity: sha512-JrF8SSLVmcvc5NducxgyOrKXe3EsyHMgBFgSaIUGmArKe+rwr0uphRkRXvwiom3I+fpIfoItveHrfudL8/rxuA==}
     engines: {node: '>=16'}
@@ -13684,6 +14119,10 @@ packages:
     resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==}
     engines: {node: '>=8'}
 
+  is-stream@4.0.1:
+    resolution: {integrity: sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==}
+    engines: {node: '>=18'}
+
   is-typed-array@1.1.15:
     resolution: {integrity: sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==}
     engines: {node: '>= 0.4'}
@@ -13721,6 +14160,9 @@ packages:
     resolution: {integrity: sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw==}
     engines: {node: '>=16'}
 
+  isarray@0.0.1:
+    resolution: {integrity: sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==}
+
   isarray@1.0.0:
     resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==}
 
@@ -13737,6 +14179,10 @@ packages:
     resolution: {integrity: sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w==}
     engines: {node: '>=18'}
 
+  isexe@4.0.0:
+    resolution: {integrity: sha512-FFUtZMpoZ8RqHS3XeXEmHWLA4thH+ZxCv2lOiPIn1Xc7CxrqhWzNSDzD+/chS/zbYezmiwWLdQC09JdQKmthOw==}
+    engines: {node: '>=20'}
+
   isobject@3.0.1:
     resolution: {integrity: sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==}
     engines: {node: '>=0.10.0'}
@@ -14160,6 +14606,10 @@ packages:
     engines: {node: '>=6'}
     hasBin: true
 
+  jsftp@2.1.3:
+    resolution: {integrity: sha512-r79EVB8jaNAZbq8hvanL8e8JGu2ZNr2bXdHC4ZdQhRImpSPpnWwm5DYVzQ5QxJmtGtKhNNuvqGgbNaFl604fEQ==}
+    engines: {node: '>=6'}
+
   json-bigint@1.0.0:
     resolution: {integrity: sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==}
 
@@ -14232,6 +14682,10 @@ packages:
   keyv@4.5.4:
     resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
 
+  klaw@4.1.0:
+    resolution: {integrity: sha512-1zGZ9MF9H22UnkpVeuaGKOjfA2t6WrfdrJmGjy16ykcjnKQDmHVX+KI477rpbGevz/5FD4MC3xf1oxylBgcaQw==}
+    engines: {node: '>=14.14.0'}
+
   kleur@3.0.3:
     resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==}
     engines: {node: '>=6'}
@@ -14256,6 +14710,9 @@ packages:
   kubernetes-types@1.30.0:
     resolution: {integrity: sha512-Dew1okvhM/SQcIa2rcgujNndZwU8VnSapDgdxlYoB84ZlpAD43U6KLAFqYo17ykSFGHNPrg0qry0bP+GJd9v7Q==}
 
+  kuler@2.0.0:
+    resolution: {integrity: sha512-Xq9nH7KlWZmXAtodXDDRE7vs6DU1gTU8zYDHDiWLSip45Egwq3plLHzPn27NgvzL2r1LMPC1vdqh98sQxtqj4A==}
+
   ky@1.14.3:
     resolution: {integrity: sha512-9zy9lkjac+TR1c2tG+mkNSVlyOpInnWdSMiue4F+kq8TwJSgv6o8jhLRg8Ho6SnZ9wOYUq/yozts9qQCfk7bIw==}
     engines: {node: '>=18'}
@@ -14364,6 +14821,10 @@ packages:
     resolution: {integrity: sha512-xi6IyHML+c9+Q3W0S4fCQJOym42pyurFiJUHEcEyHS0CeKzia4yZDEsLlqOFykxOdHpNy0NmvVO31vcSqAxJCg==}
     engines: {node: '>= 12.0.0'}
 
+  lilconfig@3.1.3:
+    resolution: {integrity: sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==}
+    engines: {node: '>=14'}
+
   lines-and-columns@1.2.4:
     resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
 
@@ -14403,6 +14864,9 @@ packages:
     resolution: {integrity: sha512-++gUqRDEvcnN6Zhqrr+y/CkVEHhlrR96vZn3nZZPYzMcBUyBtTKzB9NadClFIsIVSsu+3i9tfk/erqy9kAmt7Q==}
     engines: {node: '>=14'}
 
+  locate-app@2.5.0:
+    resolution: {integrity: sha512-xIqbzPMBYArJRmPGUZD9CzV9wOqmVtQnaAn3wrj3s6WYW0bQvPI7x+sPYUGmDTYMHefVK//zc6HEYZ1qnxIK+Q==}
+
   locate-path@5.0.0:
     resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==}
     engines: {node: '>=8'}
@@ -14415,9 +14879,15 @@ packages:
     resolution: {integrity: sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
 
+  lockfile@1.0.4:
+    resolution: {integrity: sha512-cvbTwETRfsFh4nHsL1eGWapU1XFi5Ot9E85sWAwia7Y7EgB7vfqcZhTKZ+l7hCGxSPoushMv5GKhT5PdLv03WA==}
+
   lodash-es@4.18.1:
     resolution: {integrity: sha512-J8xewKD/Gk22OZbhpOVSwcs60zhd95ESDwezOFuA3/099925PdHJ7OFHNTGtajL3AlZkykD32HykiMo+BIBI8A==}
 
+  lodash.clonedeep@4.5.0:
+    resolution: {integrity: sha512-H5ZhCF25riFd9uB5UCkVKo61m3S/xZk1x4wA6yp/L3RFP6Z/eHH1ymQcGLo7J3GMPfm0V/7m1tryHuGVxpqEBQ==}
+
   lodash.debounce@4.0.8:
     resolution: {integrity: sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==}
 
@@ -14457,6 +14927,9 @@ packages:
   lodash.throttle@4.1.1:
     resolution: {integrity: sha512-wIkUCfVKpVsWo3JSZlc+8MB5it+2AN5W8J7YVMST30UrvcQNZ1Okbj+rbVniijTWE6FGYy4XJq/rHkas8qJMLQ==}
 
+  lodash.zip@4.2.0:
+    resolution: {integrity: sha512-C7IOaBBK/0gMORRBd8OETNx3kmOkgIWIPvyDpZSCTwUrpYmgZwJkjZeOD8ww4xbOUOs4/attY+pciKvadNfFbg==}
+
   lodash@4.18.1:
     resolution: {integrity: sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==}
 
@@ -14472,6 +14945,10 @@ packages:
     resolution: {integrity: sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w==}
     engines: {node: '>=18'}
 
+  logform@2.7.0:
+    resolution: {integrity: sha512-TFYA4jnP7PVbmlBIfhlSe+WKxs9dklXMTEGcBCIvLhE/Tn3H6Gk1norupVW7m5Cnd4bLcr08AytbyV/xj7f/kQ==}
+    engines: {node: '>= 12.0.0'}
+
   loglevel-plugin-prefix@0.8.4:
     resolution: {integrity: sha512-WpG9CcFAOjz/FtNht+QJeGpvVl/cdR6P0z6OcXSkr8wFJOsV2GRj2j10JLfjuA4aYkcKCNIEqRGCyTife9R8/g==}
 
@@ -14505,6 +14982,10 @@ packages:
     resolution: {integrity: sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==}
     engines: {node: 20 || >=22}
 
+  lru-cache@11.5.2:
+    resolution: {integrity: sha512-4pfM1Ff0x50o0tQwb5ucw/RzNyD0/YJME6IVcStalZuMWxdt3sR3huStTtxz4PUmvZfRguvDejasvQ2kifR11g==}
+    engines: {node: 20 || >=22}
+
   lru-cache@5.1.1:
     resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
 
@@ -14512,6 +14993,10 @@ packages:
     resolution: {integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==}
     engines: {node: '>=10'}
 
+  lru-cache@7.18.3:
+    resolution: {integrity: sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==}
+    engines: {node: '>=12'}
+
   lucide-react-native@1.25.0:
     resolution: {integrity: sha512-OI/X62YcYqoBghVaxNRmZ9v3pGZ9e7kY7CH4eeGgkW4qPyX8JMO77Nj/QdmS632nlx1DR2fuWmqnneIt1RmsOg==}
     peerDependencies:
@@ -14689,6 +15174,14 @@ packages:
     resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
     engines: {node: '>= 8'}
 
+  method-override@3.0.0:
+    resolution: {integrity: sha512-IJ2NNN/mSl9w3kzWB92rcdHpz+HjkxhDJWNDBqSlas+zQdP8wBiJzITPg08M/k2uVvMow7Sk41atndNtt/PHSA==}
+    engines: {node: '>= 0.10'}
+
+  methods@1.1.2:
+    resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==}
+    engines: {node: '>= 0.6'}
+
   metro-babel-transformer@0.84.4:
     resolution: {integrity: sha512-rvCfz8snl9h20VcvpOHxZuHP1SlAkv4HXbzw7nyyVwu6Eqo5PRerbakQ9XmUCOsRy70spJ37O+G1TK8oMzo48g==}
     engines: {node: ^20.19.4 || ^22.13.0 || ^24.3.0 || >= 25.0.0}
@@ -14951,6 +15444,9 @@ packages:
     resolution: {integrity: sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==}
     engines: {node: '>= 18'}
 
+  mitt@3.0.1:
+    resolution: {integrity: sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==}
+
   mkdirp@1.0.4:
     resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==}
     engines: {node: '>=10'}
@@ -14979,6 +15475,10 @@ packages:
   monaco-editor@0.55.1:
     resolution: {integrity: sha512-jz4x+TJNFHwHtwuV9vA9rMujcZRb0CEilTEwG2rRSpe/A7Jdkuj8xPKttCgOh+v/lkHy7HsZ64oj+q3xoAFl9A==}
 
+  morgan@1.11.0:
+    resolution: {integrity: sha512-zSkVu3t18r39pw4ixfBKvfZi3y2UOqr7d4WYwcj3m8nXpEQK4rPO6GLzs/CExoRgmX3y9EjmmcXqv6jq0SK46g==}
+    engines: {node: '>= 0.8.0'}
+
   motion-dom@12.36.0:
     resolution: {integrity: sha512-Ep1pq8P88rGJ75om8lTCA13zqd7ywPGwCqwuWwin6BKc0hMLkVfcS6qKlRqEo2+t0DwoUcgGJfXwaiFn4AOcQA==}
 
@@ -15072,6 +15572,10 @@ packages:
   neo-async@2.6.2:
     resolution: {integrity: sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==}
 
+  netmask@2.1.1:
+    resolution: {integrity: sha512-eonl3sLUha+S1GzTPxychyhnUzKyeQkZ7jLjKrBagJgPla13F+uQ71HgpFefyHgqrjEbCPkDArxYsjY8/+gLKA==}
+    engines: {node: '>= 0.4.0'}
+
   next-auth@4.24.14:
     resolution: {integrity: sha512-YRz6xFDXKUwiXSMMChbrBEWyFktZ1qZXEgeSHQQ3nsy08B4c/xLk6REeutRsIFwkjY/1+ShHnu07DN3JeJguig==}
     peerDependencies:
@@ -15200,6 +15704,10 @@ packages:
     resolution: {integrity: sha512-3VW/8JpPqPvnJvseXowjZcirPisssnBuDikk6JIZ8jQzF7KJQX52iPFX4RYYxLycYH7IbMRSPUOga/esVjy5Yg==}
     engines: {node: '>=18'}
 
+  normalize-package-data@8.0.0:
+    resolution: {integrity: sha512-RWk+PI433eESQ7ounYxIp67CYuVsS1uYSonX3kA6ps/3LWfjVQa/ptEg6Y3T6uAMq1mWpX9PQ+qx+QaHpsc7gQ==}
+    engines: {node: ^20.17.0 || >=22.9.0}
+
   normalize-path@3.0.0:
     resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
     engines: {node: '>=0.10.0'}
@@ -15262,6 +15770,9 @@ packages:
   objectorarray@1.0.5:
     resolution: {integrity: sha512-eJJDYkhJFFbBBAxeh8xW+weHlkI28n2ZdQV/J/DNfWfSKlGEf2xcfAbZTv3riEXHAhL9SVOTs2pRmXiSTf78xg==}
 
+  obuf@1.1.2:
+    resolution: {integrity: sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg==}
+
   obug@2.1.1:
     resolution: {integrity: sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==}
 
@@ -15294,6 +15805,9 @@ packages:
   once@1.4.0:
     resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
 
+  one-time@1.0.0:
+    resolution: {integrity: sha512-5DXOiRKwuSEcQ/l0kGCF6Q3jcADFv5tSmRaJck/OqkVFcOzutB134KRSfF0xDrL39MNnqxbHBbUUcjZIhTgb2g==}
+
   onetime@2.0.1:
     resolution: {integrity: sha512-oyyPpiMaKARvvcgip+JV+7zci5L8D1W9RZIz2l1o08AM3pfspitVWnPt3mzHcBPp12oYMTy0pqrFs/C+m3EwsQ==}
     engines: {node: '>=4'}
@@ -15474,6 +15988,14 @@ packages:
     resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==}
     engines: {node: '>=6'}
 
+  pac-proxy-agent@7.2.0:
+    resolution: {integrity: sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA==}
+    engines: {node: '>= 14'}
+
+  pac-resolver@7.0.1:
+    resolution: {integrity: sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg==}
+    engines: {node: '>= 14'}
+
   package-hash@4.0.0:
     resolution: {integrity: sha512-whdkPIooSu/bASggZ96BWVvZTRMOFxnyUG5PnTSGKoJE2gd5mbVNmR2Nj20QFzxYYgAXpoqC+AiXzl+UMRh7zQ==}
     engines: {node: '>=8'}
@@ -15514,6 +16036,10 @@ packages:
     resolution: {integrity: sha512-ybiGyvspI+fAoRQbIPRddCcSTV9/LsJbf0e/S85VLowVGzRmokfneg2kwVW/KU5rOXrPSbF1qAKPMgNTqqROQQ==}
     engines: {node: '>=18'}
 
+  parse-listing@1.1.3:
+    resolution: {integrity: sha512-a1p1i+9Qyc8pJNwdrSvW1g5TPxRH0sywVi6OzVvYHRo6xwF9bDWBxtH0KkxeOOvhUE8vAMtiSfsYQFOuK901eA==}
+    engines: {node: '>=0.6.21'}
+
   parse-ms@2.1.0:
     resolution: {integrity: sha512-kHt7kzLoS9VBZfUsiKjv43mr91ea+U05EyKkEtqp7vNbHxmaVuEqN7XxeEVnGrMtYOAxGrDElSi96K7EgO1zCA==}
     engines: {node: '>=6'}
@@ -15706,6 +16232,10 @@ packages:
     resolution: {integrity: sha512-uysumyrvkUX0rX/dEVqt8gC3sTBzd4zoWfLeS29nb53imdaXVvLINYXTI2GNqzaMuvacNx4uJQ8+b3zXR0pkgQ==}
     engines: {node: '>=10.4.0'}
 
+  plist@4.0.0:
+    resolution: {integrity: sha512-4dOqNo0Y2NpfSf9q4+zr4bh7pzNWeckIam34Z0KYJhg8qtNNfh59VbD+Yna5SjwcxawVvLKx5w5FtuCijpEF4Q==}
+    engines: {node: '>=18'}
+
   pluralize@8.0.0:
     resolution: {integrity: sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==}
     engines: {node: '>=4'}
@@ -15957,6 +16487,10 @@ packages:
     resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==}
     engines: {node: '>= 0.10'}
 
+  proxy-agent@6.5.0:
+    resolution: {integrity: sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==}
+    engines: {node: '>= 14'}
+
   proxy-from-env@1.1.0:
     resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==}
 
@@ -16303,6 +16837,9 @@ packages:
     resolution: {integrity: sha512-sfWGGfavi0xr8Pg0sVsyHMAOziVYKgPLNrS7ig+ivMNb3wbCBw3KxtflsGBAwD3gYQlE/AEZsTLgToRrSCjb0Q==}
     engines: {node: '>=0.10.0'}
 
+  readable-stream@1.1.14:
+    resolution: {integrity: sha512-+MeVjFf4L44XUkhM1eYbD8fyEsxcV81pqMSR5gblfcLCHfZvbrqy4/qYHE+/R5HoBUT11WV5O08Cr1n3YXkWVQ==}
+
   readable-stream@2.3.8:
     resolution: {integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==}
 
@@ -16317,6 +16854,10 @@ packages:
   readdir-glob@1.1.3:
     resolution: {integrity: sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA==}
 
+  readdir-glob@3.0.0:
+    resolution: {integrity: sha512-AhNB2KgKeVJr16nK9LLZbJNWnYoT23ZrumNKFDebHBdkC8KHSqWo871JAUhoWC/RtjEVdqNMFpM6qrwRbaUqpw==}
+    engines: {node: '>=18'}
+
   readdirp@3.6.0:
     resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==}
     engines: {node: '>=8.10.0'}
@@ -16524,6 +17065,9 @@ packages:
     engines: {node: '>= 0.4'}
     hasBin: true
 
+  resq@1.11.0:
+    resolution: {integrity: sha512-G10EBz+zAAy3zUd/CDoBbXRL6ia9kOo3xRHrMDsHljI0GDkhYlyjwoCx5+3eCC4swi1uCoZQhskuJkj7Gp57Bw==}
+
   restore-cursor@2.0.0:
     resolution: {integrity: sha512-6IzJLuGi4+R14vwagDHX+JrXmPVtPpn4mffDJ1UdR7/Edm87fl6yi8mMBIVvFtJaNTUvjughmW4hwLhRG7gC1Q==}
     engines: {node: '>=4'}
@@ -16563,6 +17107,9 @@ packages:
   rfdc@1.4.1:
     resolution: {integrity: sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==}
 
+  rgb2hex@0.2.5:
+    resolution: {integrity: sha512-22MOP1Rh7sAo1BZpDG6R5RFYzR2lYEgwq7HEmyW2qcsOqR2lQKmn+O//xV3YG/0rrhMC6KVX2hU+ZXuaw9a5bw==}
+
   rimraf@3.0.2:
     resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==}
     deprecated: Rimraf versions prior to v4 are no longer supported
@@ -16620,6 +17167,10 @@ packages:
     resolution: {integrity: sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==}
     engines: {node: '>=6'}
 
+  safaridriver@1.0.1:
+    resolution: {integrity: sha512-jkg4434cYgtrIF2AeY/X0Wmd2W73cK5qIEFE3hDrrQenJH/2SDJIXGvPAigfvQTcE9+H31zkiNHbUqcihEiMRA==}
+    engines: {node: '>=18.0.0'}
+
   safe-buffer@5.1.2:
     resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==}
 
@@ -16647,6 +17198,9 @@ packages:
   safer-buffer@2.1.2:
     resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
 
+  sanitize-filename@1.6.4:
+    resolution: {integrity: sha512-9ZyI08PsvdQl2r/bBIGubpVdR3RR9sY6RDiWFPreA21C/EFlQhmgo20UZlNjZMMZNubusLhAQozkA0Od5J21Eg==}
+
   sass-loader@16.0.7:
     resolution: {integrity: sha512-w6q+fRHourZ+e+xA1kcsF27iGM6jdB8teexYCfdUw0sYgcDNeZESnDNT9sUmmPm3ooziwUJXGwZJSTF3kOdBfA==}
     engines: {node: '>= 18.12.0'}
@@ -16698,6 +17252,9 @@ packages:
   seedrandom@3.0.5:
     resolution: {integrity: sha512-8OwmbklUNzwezjGInmZ+2clQmExQPvomqjL7LFqOYqtmuxRgQYqOD3mHaU+MvZn5FLUeVxVfQjwLZW/n/JFuqg==}
 
+  select-hose@2.0.0:
+    resolution: {integrity: sha512-mEugaLK+YfkijB4fx0e6kImuJdCIt2LxCRcbEYPqRGCs4F2ogyfZU5IAZRdjCP8JPq2AtdNoC/Dux63d9Kiryg==}
+
   selenium-webdriver@4.45.0:
     resolution: {integrity: sha512-Cb2nqvJiwXVOtRTCYHX9D1FJR5+Ls7aL3Nev0t6n4CpXsQ//YGiiUmSCbvTDDeLtbV85SZ46qmLab4SIYKXWRw==}
     engines: {node: '>= 20.0.0'}
@@ -16729,10 +17286,18 @@ packages:
     resolution: {integrity: sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==}
     engines: {node: '>= 18'}
 
+  serialize-error@12.0.0:
+    resolution: {integrity: sha512-ZYkZLAvKTKQXWuh5XpBw7CdbSzagarX39WyZ2H07CDLC5/KfsRGlIXV8d4+tfqX1M7916mRqR1QfNHSij+c9Pw==}
+    engines: {node: '>=18'}
+
   serialize-error@2.1.0:
     resolution: {integrity: sha512-ghgmKt5o4Tly5yEG/UJp8qTd0AN7Xalw4XBtDEKP655B699qMEtra1WlXeE6WIvdEG481JvRxULKsInq/iNysw==}
     engines: {node: '>=0.10.0'}
 
+  serve-favicon@2.5.1:
+    resolution: {integrity: sha512-JndLBslCLA/ebr7rS3d+/EKkzTsTi1jI2T9l+vHfAaGJ7A7NhtDpSZ0lx81HCNWnnE0yHncG+SSnVf9IMxOwXQ==}
+    engines: {node: '>= 0.8.0'}
+
   serve-static@1.16.3:
     resolution: {integrity: sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==}
     engines: {node: '>= 0.8.0'}
@@ -16777,6 +17342,15 @@ packages:
     resolution: {integrity: sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
 
+  sharp@0.35.3:
+    resolution: {integrity: sha512-ej0zVHuZGHCiABXcNxeYhpRnPNPAcvbG8RMdBAhDAxLKkCRVSpK3Iyu7qbqw3JMzoj0REeM6f3tJLtVwl0023Q==}
+    engines: {node: '>=20.9.0'}
+    peerDependencies:
+      '@types/node': '*'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
   shebang-command@2.0.0:
     resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
     engines: {node: '>=8'}
@@ -16865,10 +17439,22 @@ packages:
     resolution: {integrity: sha512-HVk9X1E0gz3mSpoi60h/saazLKXKaZThMLU3u/aNwoYn8/xQyX2MGxL0ui2eaokkD7tF+Zo+cKTHUbe1mmmGzA==}
     engines: {node: '>=8.0.0'}
 
+  smart-buffer@4.2.0:
+    resolution: {integrity: sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==}
+    engines: {node: '>= 6.0.0', npm: '>= 3.0.0'}
+
   smol-toml@1.6.1:
     resolution: {integrity: sha512-dWUG8F5sIIARXih1DTaQAX4SsiTXhInKf1buxdY9DIg4ZYPZK5nGM1VRIYmEbDbsHt7USo99xSLFu5Q1IqTmsg==}
     engines: {node: '>= 18'}
 
+  socks-proxy-agent@8.0.5:
+    resolution: {integrity: sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==}
+    engines: {node: '>= 14'}
+
+  socks@2.8.9:
+    resolution: {integrity: sha512-LJhUYUvItdQ0LkJTmPeaEObWXAqFyfmP85x0tch/ez9cahmhlBBLbIqDFnvBnUJGagb0JbIQrkBs1wJ+yRYpEw==}
+    engines: {node: '>= 10.0.0', npm: '>= 3.0.0'}
+
   sonic-boom@4.2.1:
     resolution: {integrity: sha512-w6AxtubXa2wTXAUsZMMWERrsIRAdrK0Sc+FUytWvYAhBJLyuI4llrMIC1DtlNSdI99EI86KZum2MMq3EAZlF9Q==}
 
@@ -16915,6 +17501,9 @@ packages:
   space-separated-tokens@2.0.2:
     resolution: {integrity: sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==}
 
+  spacetrim@0.11.59:
+    resolution: {integrity: sha512-lLYsktklSRKprreOm7NXReW8YiX2VBjbgmXYEziOoGf/qsJqAEACaDvoTtUOycwjpaSh+bT8eu0KrJn7UNxiCg==}
+
   spawn-sync@1.0.15:
     resolution: {integrity: sha512-9DWBgrgYZzNghseho0JOuh+5fg9u6QWhAWa51QC7+U5rCheZ/j1DrEZnyE0RBBRqZ9uEXGPgSSM0nky6burpVw==}
 
@@ -16925,6 +17514,25 @@ packages:
   spawnd@5.0.0:
     resolution: {integrity: sha512-28+AJr82moMVWolQvlAIv3JcYDkjkFTEmfDc503wxrF5l2rQ3dFz6DpbXp3kD4zmgGGldfM4xM4v1sFj/ZaIOA==}
 
+  spdx-correct@3.2.0:
+    resolution: {integrity: sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==}
+
+  spdx-exceptions@2.5.0:
+    resolution: {integrity: sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==}
+
+  spdx-expression-parse@3.0.1:
+    resolution: {integrity: sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==}
+
+  spdx-license-ids@3.0.23:
+    resolution: {integrity: sha512-CWLcCCH7VLu13TgOH+r8p1O/Znwhqv/dbb6lqWy67G+pT1kHmeD/+V36AVb/vq8QMIQwVShJ6Ssl5FPh0fuSdw==}
+
+  spdy-transport@3.0.0:
+    resolution: {integrity: sha512-hsLVFE5SjA6TCisWeJXFKniGGOpBgMLmerfO2aCyCU5s7nJ/rpAepqmFifv/GCbSbueEeAJJnmSQ2rKC/g8Fcw==}
+
+  spdy@4.0.2:
+    resolution: {integrity: sha512-r46gZQZQV+Kl9oItvl1JZZqJKGr+oEkB08A6BzkiR7593/7IbtuncXHd2YoYeTsG4157ZssMu9KYvUHLcjcDoA==}
+    engines: {node: '>=6.0.0'}
+
   split-on-first@1.1.0:
     resolution: {integrity: sha512-43ZssAJaMusuKWL8sKUBQXHWOpq8d6CfN/u1p4gUzfJkM05C8rxTmYrkIPTXapZpORA6LkkzcUulJ8FqA7Uudw==}
     engines: {node: '>=6'}
@@ -16967,6 +17575,9 @@ packages:
   sqlite-vec@0.1.9:
     resolution: {integrity: sha512-L7XJWRIBNvR9O5+vh1FQ+IGkh/3D2AzVksW5gdtk28m78Hy8skFD0pqReKH1Yp0/BUKRGcffgKvyO/EON5JXpA==}
 
+  stack-trace@0.0.10:
+    resolution: {integrity: sha512-KGzahc7puUKkzyMt+IqAep+TVNbKP+k2Lmwhub39m1AsTSkaDutx56aDCo+HLDzf/D26BIHTJWNiTG1KAJiQCg==}
+
   stack-utils@2.0.6:
     resolution: {integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==}
     engines: {node: '>=10'}
@@ -17026,6 +17637,9 @@ packages:
     resolution: {integrity: sha512-uyQK/mx5QjHun80FLJTfaWE7JtwfRMKBLkMne6udYOmvH0CawotVa7TfgYHzAnpphn4+TweIx1QKMnRIbipmUg==}
     engines: {node: '>= 0.10.0'}
 
+  stream-combiner@0.2.2:
+    resolution: {integrity: sha512-6yHMqgLYDzQDcAkL+tjJDC5nSNuNIx0vZtRZeiPh7Saef7VHX9H5Ijn9l2VIol2zaNYlYEX6KyuT/237A58qEQ==}
+
   stream-http@3.2.0:
     resolution: {integrity: sha512-Oq1bLqisTyK3TSCXpPbT4sdeYNdmyZJv1LxpEm2vu1ZhK89kSE5YXwZc3cWk0MagGaKriBh9mCFbVGtO+vY29A==}
 
@@ -17062,6 +17676,9 @@ packages:
     resolution: {integrity: sha512-6hJPQ8N0V0P3SNmP6h2J99RLuzrWz2gvT7VnK5tKvrNqJoyS9W4/Fb8mo31UiPvy00z7DQXkP2hnKBVav76thw==}
     engines: {node: '>=20'}
 
+  string_decoder@0.10.31:
+    resolution: {integrity: sha512-ev2QzSzWPYmy9GuqfIVildA4OdcGLeFZQrq5ys6RtiuF+RQQiZWr8TZNyAcuVXyQRYfEO+MsoB/1BuQVhOJuoQ==}
+
   string_decoder@1.1.1:
     resolution: {integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==}
 
@@ -17295,6 +17912,9 @@ packages:
     resolution: {integrity: sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==}
     engines: {node: '>=6'}
 
+  tar-fs@3.1.3:
+    resolution: {integrity: sha512-/hU4AXnIdZu+Gvl1pk0oI5f5HxWsCJRtY2aFaJdk9VvyL48DWU6iU5WAIPG+wIi1YvWA6eTJvIviP/tMAZZNwQ==}
+
   tar-stream@3.1.8:
     resolution: {integrity: sha512-U6QpVRyCGHva435KoNWy9PRoi2IFYCgtEhq9nmrPPpbRacPs9IH4aJ3gbrFC8dPcXvdSZ4XXfXT5Fshbp2MtlQ==}
 
@@ -17309,6 +17929,10 @@ packages:
     resolution: {integrity: sha512-56adEpPMouktRlBLXiaYFFzZ/3+JXa8P9n7WbR+ibIjtviN55mEaOkiysCnPnWm+7kkui1Dn8J9l+g6zV8731w==}
     engines: {node: '>=18'}
 
+  teen_process@4.1.9:
+    resolution: {integrity: sha512-MUOuIDBvjJGrm5AgrrWyGbpoKbpSJWvc7xf76Hac4ONDB2BbKzMNWjCAjFZ3sX+KuioReNVJdXTO4o4Bj/gRaQ==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0, npm: '>=10'}
+
   teex@1.0.1:
     resolution: {integrity: sha512-eYE6iEI62Ni1H8oIa7KlDU6uQBtqr4Eajni3wX7rpfXD8ysFx8z0+dri+KWEPWpBsxXfxu58x/0jvTVT1ekOSg==}
 
@@ -17348,6 +17972,9 @@ packages:
   text-decoder@1.2.7:
     resolution: {integrity: sha512-vlLytXkeP4xvEq2otHeJfSQIRyWxo/oZGEbXrtEEF9Hnmrdly59sUbzZ/QgyWuLYHctCHxFF4tRQZNQ9k60ExQ==}
 
+  text-hex@1.0.0:
+    resolution: {integrity: sha512-uuVGNWzgJ4yhRaNSiubPY7OjISw4sw4E5Uv0wbjp+OzcbmVU/rsT8ujgcXJhn9ypzsgr5vlzpPqP+MBBKcGvbg==}
+
   third-party-capital@1.0.20:
     resolution: {integrity: sha512-oB7yIimd8SuGptespDAZnNkzIz+NWaJCu2RMsbs4Wmp9zSDUM8Nhi3s2OOcqYuv3mN4hitXc8DVx+LyUmbUDiA==}
 
@@ -17473,9 +18100,16 @@ packages:
   trim-lines@3.0.1:
     resolution: {integrity: sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==}
 
+  triple-beam@1.4.1:
+    resolution: {integrity: sha512-aZbgViZrg1QNcG+LULa7nhZpJTZSLm/mXnHXnbAbjmN5aSa0y7V+wvv6+4WaBtpISJzThKy+PIPxc1Nq1EJ9mg==}
+    engines: {node: '>= 14.0.0'}
+
   trough@2.2.0:
     resolution: {integrity: sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==}
 
+  truncate-utf8-bytes@1.0.2:
+    resolution: {integrity: sha512-95Pu1QXQvruGEhv62XCMO3Mm90GscOCClvrIUwCM0PYOXK3kaF3l3sIHxx71ThJfcbM2O5Au6SO3AWCSEfW4mQ==}
+
   ts-algebra@2.0.0:
     resolution: {integrity: sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw==}
 
@@ -17577,6 +18211,10 @@ packages:
     resolution: {integrity: sha512-tLq3bSNx+xSpwvAJnzrK0Ep5CLNWjvFTOp71URMaAEWBfRb9nnJiBoUe0tF8bI4ZFO3omgBR6NvnbzVUT3Ly4g==}
     engines: {node: '>=14.16'}
 
+  type-fest@4.26.0:
+    resolution: {integrity: sha512-OduNjVJsFbifKb57UqZ2EMP1i4u64Xwow3NYXUtBbD4vIwJdQd4+xl8YDou1dlm4DVrtwT/7Ky8z8WyCULVfxw==}
+    engines: {node: '>=16'}
+
   type-fest@4.41.0:
     resolution: {integrity: sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==}
     engines: {node: '>=16'}
@@ -17585,10 +18223,18 @@ packages:
     resolution: {integrity: sha512-PlBfpQwiUvGViBNX84Yxwjsdhd1TUlXr6zjX7eoirtCPIr08NAmxwa+fcYBTeRQxHo9YC9wwF3m9i700sHma8g==}
     engines: {node: '>=20'}
 
+  type-fest@5.8.0:
+    resolution: {integrity: sha512-YGYEVz3Fm5iy/AybuA0oyNFq7H4CgQNfRp/qfe8nurE1kuCeNm3/vfm9X4Mtl+qLyaKJUh5xrFZwogr41SMjYA==}
+    engines: {node: '>=20'}
+
   type-is@2.0.1:
     resolution: {integrity: sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==}
     engines: {node: '>= 0.6'}
 
+  type-is@2.1.0:
+    resolution: {integrity: sha512-faYHw0anBbc/kWF3zFTEnxSFOAGUX9GFbOBthvDdLsIlEoWOFOtS0zgCiQYwIskL9iGXZL3kAXD8OoZ4GmMATA==}
+    engines: {node: '>= 18'}
+
   type@2.7.3:
     resolution: {integrity: sha512-8j+1QmAbPvLZow5Qpi6NCaN8FB60p/6x8/vfNqOk/hC+HuvFZhL4+WfekuhQLiqFZXOgQdrs3B+XxEmCc6b3FQ==}
 
@@ -17738,6 +18384,10 @@ packages:
     resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==}
     engines: {node: '>= 10.0.0'}
 
+  unorm@1.6.0:
+    resolution: {integrity: sha512-b2/KCUlYZUeA7JFUuRJZPUtr4gZvBh7tavtv4fvk4+KV9pfGiR6CQAQAWl49ZpR3ts2dk4FYkP7EIgDJoiOLDA==}
+    engines: {node: '>= 0.4.0'}
+
   unpipe@1.0.0:
     resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==}
     engines: {node: '>= 0.8'}
@@ -17785,6 +18435,9 @@ packages:
     resolution: {integrity: sha512-oCwdVC7mTuWiPyjLUz/COz5TLk6wgp0RCsN+wHZ2Ekneac9w8uuV0njcbbie2ME+Vs+d6duwmYuR3HgQXs1fOg==}
     engines: {node: '>= 0.4'}
 
+  urlpattern-polyfill@10.1.0:
+    resolution: {integrity: sha512-IGjKp/o0NL3Bso1PymYURCJxMPNAf/ILOpendP9f5B6e1rTJgdgiOvgfoT8VxCAdY+Wisb9uhGaJJf3yZ2V9nw==}
+
   use-callback-ref@1.3.3:
     resolution: {integrity: sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg==}
     engines: {node: '>=10'}
@@ -17815,10 +18468,17 @@ packages:
     peerDependencies:
       react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
 
+  userhome@1.0.1:
+    resolution: {integrity: sha512-5cnLm4gseXjAclKowC4IjByaGsjtAoV6PrOQOljplNB54ReUYJP8HdAFq2muHinSDAh09PPX/uXDPfdxRHvuSA==}
+    engines: {node: '>= 0.8.0'}
+
   utf-8-validate@6.0.6:
     resolution: {integrity: sha512-q3l3P9UtEEiAHcsgsqTgf9PPjctrDWoIXW3NpOHFdRDbLvu4DLIcxHangJ4RLrWkBcKjmcs/6NkerI8T/rE4LA==}
     engines: {node: '>=6.14.2'}
 
+  utf8-byte-length@1.0.5:
+    resolution: {integrity: sha512-Xn0w3MtiQ6zoz2vFyUVruaCL53O/DwUvkEeOvj+uulMm0BkUGYWmBYVyElqZaSLhY6ZD0ulfU3aBra2aVT4xfA==}
+
   util-deprecate@1.0.2:
     resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
 
@@ -17840,6 +18500,10 @@ packages:
     resolution: {integrity: sha512-vzi9uRZ926x4XV73S/4qQaTwPXM2JBj6/6lI/byHH1jOpCzb0zDbfytgA9LcN/hzb2l7WQSQnxITOVx5un/wGw==}
     hasBin: true
 
+  uuid@14.0.1:
+    resolution: {integrity: sha512-6ZxzVpzDXDa3bJWaHilVayA+BH/1zmxCJoVgvmqJnid/gPoKHxUrS/aC/T6LGQtNHT+XHG9fXPJB4d+IrU30Ew==}
+    hasBin: true
+
   uvu@0.5.6:
     resolution: {integrity: sha512-+g8ENReyr8YsOc6fv/NVJs2vFdHBnBNdfE49rshrTzDWOlUx4Gq7KOS2GD8eqhy2j+Ejq29+SbKH8yjkAqXqoA==}
     engines: {node: '>=8'}
@@ -17849,6 +18513,9 @@ packages:
     resolution: {integrity: sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==}
     engines: {node: '>=10.12.0'}
 
+  validate-npm-package-license@3.0.4:
+    resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==}
+
   validate-npm-package-name@5.0.1:
     resolution: {integrity: sha512-OljLrQ9SQdOUqTaQxqL5dEfZWrXExyyWsozYlAWFawPVNuD83igl7uJD2RTkNMbniIYgt8l81eCJGIdQF7avLQ==}
     engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
@@ -17979,6 +18646,11 @@ packages:
     engines: {node: '>=8'}
     hasBin: true
 
+  wait-port@1.1.0:
+    resolution: {integrity: sha512-3e04qkoN3LxTMLakdqeWth8nih8usyg+sf1Bgdf9wwUkp05iuK1eSY/QpLvscT/+F/gA89+LpUmmgBtesbqI2Q==}
+    engines: {node: '>=10'}
+    hasBin: true
+
   walk-up-path@4.0.0:
     resolution: {integrity: sha512-3hu+tD8YzSLGuFYtPRb48vdhKMi0KQV5sn+uWr8+7dMEq/2G/dtLrdDinkLjqq5TIbIBjYJ4Ax/n3YiaW7QM8A==}
     engines: {node: 20 || >=22}
@@ -18006,6 +18678,9 @@ packages:
     engines: {node: ^20.12||^22.13||>=24.0}
     hasBin: true
 
+  wbuf@1.7.3:
+    resolution: {integrity: sha512-O84QOnr0icsbFGLS0O3bI5FswxzRr8/gHwWkDlQFskhSPryQXvrTMxjxGP4+iWYoauLoBvfDpkrOauZ+0iZpDA==}
+
   wcwidth@1.0.1:
     resolution: {integrity: sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==}
 
@@ -18033,6 +18708,19 @@ packages:
   web-vitals@5.1.0:
     resolution: {integrity: sha512-ArI3kx5jI0atlTtmV0fWU3fjpLmq/nD3Zr1iFFlJLaqa5wLBkUSzINwBPySCX/8jRyjlmy1Volw1kz1g9XE4Jg==}
 
+  webdriver@9.30.0:
+    resolution: {integrity: sha512-DisY5E8p5zAZyl8pee08p4Vlc91c94Am9oswZaNCgZH5Ewm//FoCZ+tHNppENqooCYjfa/upATbFqGOLuXQkrw==}
+    engines: {node: '>=18.20.0'}
+
+  webdriverio@9.30.0:
+    resolution: {integrity: sha512-cmV/uSbCvnJ99QejGPVGlzb9MjiSYUts8VjdESnDKvA7JvRMIJK0l807Js7HDK/g6KG7j+D2apsFHGlT7W5UeA==}
+    engines: {node: '>=18.20.0'}
+    peerDependencies:
+      puppeteer-core: '>=22.x || <=24.x'
+    peerDependenciesMeta:
+      puppeteer-core:
+        optional: true
+
   webidl-conversions@3.0.1:
     resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
 
@@ -18127,6 +18815,11 @@ packages:
     engines: {node: ^16.13.0 || >=18.0.0}
     hasBin: true
 
+  which@6.0.1:
+    resolution: {integrity: sha512-oGLe46MIrCRqX7ytPUf66EAYvdeMIZYn3WaocqqKZAxrBpkqHfL/qvTyJ/bTk5+AqHCjXmrv3CEWgy368zhRUg==}
+    engines: {node: ^20.17.0 || >=22.9.0}
+    hasBin: true
+
   why-is-node-running@2.3.0:
     resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==}
     engines: {node: '>=8'}
@@ -18143,6 +18836,14 @@ packages:
   winreg@0.0.12:
     resolution: {integrity: sha512-typ/+JRmi7RqP1NanzFULK36vczznSNN8kWVA9vIqXyv8GhghUlwhGp1Xj3Nms1FsPcNnsQrJOR10N58/nQ9hQ==}
 
+  winston-transport@4.9.0:
+    resolution: {integrity: sha512-8drMJ4rkgaPo1Me4zD/3WLfI/zPdA9o2IipKODunnGDcuqbHwjsbB79ylv04LCGGzU0xQ6vTznOMpQGaLhhm6A==}
+    engines: {node: '>= 12.0.0'}
+
+  winston@3.19.0:
+    resolution: {integrity: sha512-LZNJgPzfKR+/J3cHkxcpHKpKKvGfDZVPS4hfJCc4cCG0CgYzvlD6yE/S3CIL/Yt91ak327YCpiF/0MyeZHEHKA==}
+    engines: {node: '>= 12.0.0'}
+
   word-wrap@1.2.5:
     resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==}
     engines: {node: '>=0.10.0'}
@@ -18320,6 +19021,10 @@ packages:
     resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==}
     engines: {node: '>=12'}
 
+  yargs-parser@22.0.0:
+    resolution: {integrity: sha512-rwu/ClNdSMpkSrUb+d6BRsSkLUq1fmfsY6TOpYzTwvwkg1/NRG85KBy3kq++A8LKQwX6lsu+aWad+2khvuXrqw==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=23}
+
   yargs@15.4.1:
     resolution: {integrity: sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==}
     engines: {node: '>=8'}
@@ -18328,6 +19033,13 @@ packages:
     resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==}
     engines: {node: '>=12'}
 
+  yargs@18.0.0:
+    resolution: {integrity: sha512-4UEqdc2RYGHZc7Doyqkrqiln3p9X2DZVxaGbwhn2pi7MrRagKaOcIKe8L3OxYcbhXLgLFUS3zAYuQjKBQgmuNg==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=23}
+
+  yauzl@2.10.0:
+    resolution: {integrity: sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==}
+
   yauzl@3.3.0:
     resolution: {integrity: sha512-PtGEvEP30p7sbIBJKUBjUnqgTVOyMURc4dLo9iNyAJnNIEz9pm88cCXF21w94Kg3k6RXkeZh5DHOGS0qEONvNQ==}
     engines: {node: '>=12'}
@@ -18336,6 +19048,10 @@ packages:
     resolution: {integrity: sha512-Md9ankxxN23wncAN8s7+Tn3Co52zLUPMtnrLAbVCnfG5d2tKBFfmygYSgXlqFgXObtzIgqkx7aNgDBpso9+4qA==}
     engines: {node: '>=12'}
 
+  yauzl@3.4.0:
+    resolution: {integrity: sha512-jIH9yLR9wqr0wOS0TpBvo/g/2UgZH5qePVbjgRliiF0BYvOZyaBknKsF+x9Iht0O6sqgnB93rCICdOZFecJuDw==}
+    engines: {node: '>=12'}
+
   yocto-queue@0.1.0:
     resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
     engines: {node: '>=10'}
@@ -18360,6 +19076,10 @@ packages:
     resolution: {integrity: sha512-zK7YHHz4ZXpW89AHXUPbQVGKI7uvkd3hzusTdotCg1UxyaVtg0zFJSTfW/Dq5f7OBBVnq6cZIaC8Ti4hb6dtCA==}
     engines: {node: '>= 14'}
 
+  zip-stream@7.0.5:
+    resolution: {integrity: sha512-dSvYKdvLsAHCDqPOhIwk/q5CvuWtTB3Dgpoe0uVEFjTzIOAmsQpprX25InCvrvJsirEbu1OHyy67n/kAj1Sw/w==}
+    engines: {node: '>=18'}
+
   zod-to-json-schema@3.25.1:
     resolution: {integrity: sha512-pM/SU9d3YAggzi6MtR4h7ruuQlqKtad8e9S0fmxcMi+ueAK5Korys/aWcV9LIIHTVbj01NdzxcnXSN+O74ZIVA==}
     peerDependencies:
@@ -18487,6 +19207,118 @@ snapshots:
     optionalDependencies:
       zod: 4.4.3
 
+  '@appium/base-driver@10.7.2(@appium/logger@2.0.10)(@types/node@24.12.4)':
+    dependencies:
+      '@appium/support': 7.2.6(@types/node@24.12.4)
+      '@appium/types': 1.6.0(@appium/logger@2.0.10)
+      async-lock: 1.4.1
+      asyncbox: 6.3.5
+      axios: 1.16.1
+      body-parser: 2.3.0
+      express: 5.2.1
+      fastest-levenshtein: 1.0.16
+      http-status-codes: 2.3.0
+      lru-cache: 11.5.2
+      method-override: 3.0.0
+      morgan: 1.11.0
+      path-to-regexp: 8.4.2
+      serve-favicon: 2.5.1
+      type-fest: 5.8.0
+    optionalDependencies:
+      spdy: 4.0.2
+    transitivePeerDependencies:
+      - '@appium/logger'
+      - '@types/node'
+      - bare-abort-controller
+      - bare-buffer
+      - debug
+      - react-native-b4a
+      - supports-color
+
+  '@appium/base-plugin@3.3.3(@appium/logger@2.0.10)(@types/node@24.12.4)':
+    dependencies:
+      '@appium/base-driver': 10.7.2(@appium/logger@2.0.10)(@types/node@24.12.4)
+      '@appium/support': 7.2.6(@types/node@24.12.4)
+      '@appium/types': 1.6.0(@appium/logger@2.0.10)
+    transitivePeerDependencies:
+      - '@appium/logger'
+      - '@types/node'
+      - bare-abort-controller
+      - bare-buffer
+      - debug
+      - react-native-b4a
+      - supports-color
+
+  '@appium/docutils@2.5.2(@types/node@24.12.4)':
+    dependencies:
+      '@appium/support': 7.2.6(@types/node@24.12.4)
+      consola: 3.4.2
+      diff: 8.0.3
+      lilconfig: 3.1.3
+      normalize-package-data: 8.0.0
+      teen_process: 4.1.9
+      type-fest: 5.8.0
+      yaml: 2.8.4
+      yargs: 18.0.0
+      yargs-parser: 22.0.0
+    transitivePeerDependencies:
+      - '@types/node'
+      - bare-abort-controller
+      - bare-buffer
+      - debug
+      - react-native-b4a
+      - supports-color
+
+  '@appium/logger@2.0.10':
+    dependencies:
+      lru-cache: 11.5.2
+
+  '@appium/schema@1.3.0':
+    dependencies:
+      json-schema: 0.4.0
+
+  '@appium/support@7.2.6(@types/node@24.12.4)':
+    dependencies:
+      '@appium/logger': 2.0.10
+      '@appium/types': 1.6.0(@appium/logger@2.0.10)
+      archiver: 8.0.0
+      asyncbox: 6.3.5
+      axios: 1.16.1
+      bluebird: 3.7.2
+      bplist-creator: 0.1.1
+      bplist-parser: 0.3.2
+      form-data: 4.0.6
+      glob: 13.0.6
+      jsftp: 2.1.3
+      klaw: 4.1.0
+      lockfile: 1.0.4
+      normalize-package-data: 8.0.0
+      plist: 4.0.0
+      pluralize: 8.0.0
+      sanitize-filename: 1.6.4
+      semver: 7.8.5
+      shell-quote: 1.8.4
+      teen_process: 4.1.9
+      type-fest: 5.8.0
+      uuid: 14.0.1
+      which: 6.0.1
+      yauzl: 3.4.0
+    optionalDependencies:
+      sharp: 0.35.3(@types/node@24.12.4)
+    transitivePeerDependencies:
+      - '@types/node'
+      - bare-abort-controller
+      - bare-buffer
+      - debug
+      - react-native-b4a
+      - supports-color
+
+  '@appium/types@1.6.0(@appium/logger@2.0.10)':
+    dependencies:
+      '@appium/logger': 2.0.10
+      '@appium/schema': 1.3.0
+      type-fest: 5.8.0
+
   '@apple/app-store-server-library@3.1.0':
     dependencies:
       '@types/jsonwebtoken': 9.0.10
@@ -20434,10 +21266,18 @@ snapshots:
       react-dom: 19.2.6(react@19.2.6)
       react-is: 17.0.2
 
+  '@colors/colors@1.6.0': {}
+
   '@cspotcode/source-map-support@0.8.1':
     dependencies:
       '@jridgewell/trace-mapping': 0.3.9
 
+  '@dabh/diagnostics@2.0.8':
+    dependencies:
+      '@so-ric/colorspace': 1.1.6
+      enabled: 2.0.0
+      kuler: 2.0.0
+
   '@date-fns/tz@1.5.0': {}
 
   '@dependents/detective-less@5.0.1':
@@ -20551,11 +21391,6 @@ snapshots:
       tslib: 2.8.1
     optional: true
 
-  '@emnapi/runtime@1.9.0':
-    dependencies:
-      tslib: 2.8.1
-    optional: true
-
   '@emnapi/runtime@1.9.2':
     dependencies:
       tslib: 2.8.1
@@ -20773,7 +21608,7 @@ snapshots:
       progress: 2.0.3
       prompts: 2.4.2
       resolve-from: 5.0.0
-      semver: 7.8.2
+      semver: 7.8.5
       send: 0.19.2
       slugify: 1.6.8
       stacktrace-parser: 0.1.11
@@ -20813,7 +21648,7 @@ snapshots:
       getenv: 2.0.0
       glob: 13.0.6
       resolve-from: 5.0.0
-      semver: 7.8.2
+      semver: 7.8.5
       slugify: 1.6.8
       xcode: 3.0.1
       xml2js: 0.6.0
@@ -20853,7 +21688,7 @@ snapshots:
       getenv: 2.0.0
       glob: 13.0.6
       resolve-workspace-root: 2.0.1
-      semver: 7.8.2
+      semver: 7.8.5
       slugify: 1.6.8
     transitivePeerDependencies:
       - supports-color
@@ -20925,7 +21760,7 @@ snapshots:
       ignore: 5.3.2
       minimatch: 10.2.5
       resolve-from: 5.0.0
-      semver: 7.8.2
+      semver: 7.8.5
     transitivePeerDependencies:
       - supports-color
 
@@ -20937,7 +21772,7 @@ snapshots:
       getenv: 2.0.0
       jimp-compact: 0.16.1
       parse-png: 2.1.0
-      semver: 7.8.2
+      semver: 7.8.5
     transitivePeerDependencies:
       - supports-color
       - typescript
@@ -21090,7 +21925,7 @@ snapshots:
       debug: 4.4.3
       expo-modules-autolinking: 57.0.9(typescript@6.0.3)
       resolve-from: 5.0.0
-      semver: 7.8.2
+      semver: 7.8.5
     transitivePeerDependencies:
       - supports-color
       - typescript
@@ -21288,95 +22123,199 @@ snapshots:
       '@img/sharp-libvips-darwin-arm64': 1.2.4
     optional: true
 
+  '@img/sharp-darwin-arm64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-arm64': 1.3.2
+    optional: true
+
   '@img/sharp-darwin-x64@0.34.5':
     optionalDependencies:
       '@img/sharp-libvips-darwin-x64': 1.2.4
     optional: true
 
+  '@img/sharp-darwin-x64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-x64': 1.3.2
+    optional: true
+
+  '@img/sharp-freebsd-wasm32@0.35.3':
+    dependencies:
+      '@img/sharp-wasm32': 0.35.3
+    optional: true
+
   '@img/sharp-libvips-darwin-arm64@1.2.4':
     optional: true
 
+  '@img/sharp-libvips-darwin-arm64@1.3.2':
+    optional: true
+
   '@img/sharp-libvips-darwin-x64@1.2.4':
     optional: true
 
+  '@img/sharp-libvips-darwin-x64@1.3.2':
+    optional: true
+
   '@img/sharp-libvips-linux-arm64@1.2.4':
     optional: true
 
+  '@img/sharp-libvips-linux-arm64@1.3.2':
+    optional: true
+
   '@img/sharp-libvips-linux-arm@1.2.4':
     optional: true
 
+  '@img/sharp-libvips-linux-arm@1.3.2':
+    optional: true
+
   '@img/sharp-libvips-linux-ppc64@1.2.4':
     optional: true
 
+  '@img/sharp-libvips-linux-ppc64@1.3.2':
+    optional: true
+
   '@img/sharp-libvips-linux-riscv64@1.2.4':
     optional: true
 
+  '@img/sharp-libvips-linux-riscv64@1.3.2':
+    optional: true
+
   '@img/sharp-libvips-linux-s390x@1.2.4':
     optional: true
 
+  '@img/sharp-libvips-linux-s390x@1.3.2':
+    optional: true
+
   '@img/sharp-libvips-linux-x64@1.2.4':
     optional: true
 
+  '@img/sharp-libvips-linux-x64@1.3.2':
+    optional: true
+
   '@img/sharp-libvips-linuxmusl-arm64@1.2.4':
     optional: true
 
+  '@img/sharp-libvips-linuxmusl-arm64@1.3.2':
+    optional: true
+
   '@img/sharp-libvips-linuxmusl-x64@1.2.4':
     optional: true
 
+  '@img/sharp-libvips-linuxmusl-x64@1.3.2':
+    optional: true
+
   '@img/sharp-linux-arm64@0.34.5':
     optionalDependencies:
       '@img/sharp-libvips-linux-arm64': 1.2.4
     optional: true
 
+  '@img/sharp-linux-arm64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm64': 1.3.2
+    optional: true
+
   '@img/sharp-linux-arm@0.34.5':
     optionalDependencies:
       '@img/sharp-libvips-linux-arm': 1.2.4
     optional: true
 
+  '@img/sharp-linux-arm@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm': 1.3.2
+    optional: true
+
   '@img/sharp-linux-ppc64@0.34.5':
     optionalDependencies:
       '@img/sharp-libvips-linux-ppc64': 1.2.4
     optional: true
 
+  '@img/sharp-linux-ppc64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-ppc64': 1.3.2
+    optional: true
+
   '@img/sharp-linux-riscv64@0.34.5':
     optionalDependencies:
       '@img/sharp-libvips-linux-riscv64': 1.2.4
     optional: true
 
+  '@img/sharp-linux-riscv64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-riscv64': 1.3.2
+    optional: true
+
   '@img/sharp-linux-s390x@0.34.5':
     optionalDependencies:
       '@img/sharp-libvips-linux-s390x': 1.2.4
     optional: true
 
+  '@img/sharp-linux-s390x@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-s390x': 1.3.2
+    optional: true
+
   '@img/sharp-linux-x64@0.34.5':
     optionalDependencies:
       '@img/sharp-libvips-linux-x64': 1.2.4
     optional: true
 
+  '@img/sharp-linux-x64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-x64': 1.3.2
+    optional: true
+
   '@img/sharp-linuxmusl-arm64@0.34.5':
     optionalDependencies:
       '@img/sharp-libvips-linuxmusl-arm64': 1.2.4
     optional: true
 
+  '@img/sharp-linuxmusl-arm64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-arm64': 1.3.2
+    optional: true
+
   '@img/sharp-linuxmusl-x64@0.34.5':
     optionalDependencies:
       '@img/sharp-libvips-linuxmusl-x64': 1.2.4
     optional: true
 
+  '@img/sharp-linuxmusl-x64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-x64': 1.3.2
+    optional: true
+
   '@img/sharp-wasm32@0.34.5':
     dependencies:
-      '@emnapi/runtime': 1.9.0
+      '@emnapi/runtime': 1.11.2
+    optional: true
+
+  '@img/sharp-wasm32@0.35.3':
+    dependencies:
+      '@emnapi/runtime': 1.11.2
+    optional: true
+
+  '@img/sharp-webcontainers-wasm32@0.35.3':
+    dependencies:
+      '@img/sharp-wasm32': 0.35.3
     optional: true
 
   '@img/sharp-win32-arm64@0.34.5':
     optional: true
 
+  '@img/sharp-win32-arm64@0.35.3':
+    optional: true
+
   '@img/sharp-win32-ia32@0.34.5':
     optional: true
 
+  '@img/sharp-win32-ia32@0.35.3':
+    optional: true
+
   '@img/sharp-win32-x64@0.34.5':
     optional: true
 
+  '@img/sharp-win32-x64@0.35.3':
+    optional: true
+
   '@isaacs/fs-minipass@4.0.1':
     dependencies:
       minipass: 7.1.3
@@ -22308,14 +23247,14 @@ snapshots:
   '@napi-rs/wasm-runtime@0.2.12':
     dependencies:
       '@emnapi/core': 1.10.0
-      '@emnapi/runtime': 1.10.0
+      '@emnapi/runtime': 1.11.2
       '@tybys/wasm-util': 0.10.1
     optional: true
 
   '@napi-rs/wasm-runtime@1.1.1':
     dependencies:
       '@emnapi/core': 1.10.0
-      '@emnapi/runtime': 1.10.0
+      '@emnapi/runtime': 1.11.2
       '@tybys/wasm-util': 0.10.1
     optional: true
 
@@ -23415,6 +24354,10 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  '@promptbook/utils@0.69.5':
+    dependencies:
+      spacetrim: 0.11.59
+
   '@protobufjs/aspromise@1.1.2': {}
 
   '@protobufjs/base64@1.1.2': {}
@@ -23435,6 +24378,21 @@ snapshots:
 
   '@protobufjs/utf8@1.1.1': {}
 
+  '@puppeteer/browsers@2.13.2':
+    dependencies:
+      debug: 4.4.3
+      extract-zip: 2.0.1
+      progress: 2.0.3
+      proxy-agent: 6.5.0
+      semver: 7.8.5
+      tar-fs: 3.1.3
+      yargs: 17.7.2
+    transitivePeerDependencies:
+      - bare-abort-controller
+      - bare-buffer
+      - react-native-b4a
+      - supports-color
+
   '@qdrant/js-client-rest@1.17.0(typescript@5.9.3)':
     dependencies:
       '@qdrant/openapi-typescript-fetch': 1.2.6
@@ -24256,7 +25214,7 @@ snapshots:
       metro: 0.84.4(bufferutil@4.1.0)(utf-8-validate@6.0.6)
       metro-config: 0.84.4(bufferutil@4.1.0)(utf-8-validate@6.0.6)
       metro-core: 0.84.4
-      semver: 7.8.2
+      semver: 7.8.5
     transitivePeerDependencies:
       - bufferutil
       - supports-color
@@ -24941,6 +25899,11 @@ snapshots:
 
   '@sideway/pinpoint@2.0.0': {}
 
+  '@sidvind/better-ajv-errors@5.0.0(ajv@8.20.0)':
+    dependencies:
+      ajv: 8.20.0
+      kleur: 4.1.5
+
   '@silvia-odwyer/photon-node@0.3.4': {}
 
   '@sinclair/typebox@0.27.10': {}
@@ -25391,6 +26354,11 @@ snapshots:
     dependencies:
       tslib: 2.8.1
 
+  '@so-ric/colorspace@1.1.6':
+    dependencies:
+      color: 5.0.3
+      text-hex: 1.0.0
+
   '@speed-highlight/core@1.2.14': {}
 
   '@stablelib/base64@1.0.1': {}
@@ -25733,7 +26701,7 @@ snapshots:
       react-docgen: 7.1.1
       react-dom: 19.2.6(react@19.2.6)
       resolve: 1.22.11
-      semver: 7.8.2
+      semver: 7.8.5
       storybook: 10.4.6(@types/react@19.2.14)(bufferutil@4.1.0)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)(utf-8-validate@6.0.6)
       tsconfig-paths: 4.2.0
       webpack: 5.105.4(esbuild@0.27.4)
@@ -26202,6 +27170,8 @@ snapshots:
 
   '@tokenizer/token@0.3.0': {}
 
+  '@tootallnate/quickjs-emscripten@0.23.0': {}
+
   '@trpc/client@11.17.0(@trpc/server@11.17.0(typescript@5.9.3))(typescript@5.9.3)':
     dependencies:
       '@trpc/server': 11.17.0(typescript@5.9.3)
@@ -26493,6 +27463,8 @@ snapshots:
 
   '@types/semver@7.7.1': {}
 
+  '@types/sinonjs__fake-timers@8.1.5': {}
+
   '@types/stack-utils@2.0.3': {}
 
   '@types/tar-stream@3.1.4':
@@ -26503,6 +27475,8 @@ snapshots:
     dependencies:
       '@types/node': 24.12.4
 
+  '@types/triple-beam@1.3.5': {}
+
   '@types/trusted-types@2.0.7':
     optional: true
 
@@ -26520,6 +27494,8 @@ snapshots:
 
   '@types/webextension-polyfill@0.12.5': {}
 
+  '@types/which@2.0.2': {}
+
   '@types/ws@8.18.1':
     dependencies:
       '@types/node': 24.12.4
@@ -26530,6 +27506,11 @@ snapshots:
     dependencies:
       '@types/yargs-parser': 21.0.3
 
+  '@types/yauzl@2.10.3':
+    dependencies:
+      '@types/node': 24.12.4
+    optional: true
+
   '@typescript-eslint/project-service@8.57.0(typescript@5.9.3)':
     dependencies:
       '@typescript-eslint/tsconfig-utils': 8.57.0(typescript@5.9.3)
@@ -26859,6 +27840,21 @@ snapshots:
 
   '@vue/shared@3.5.30': {}
 
+  '@wdio/config@9.30.0':
+    dependencies:
+      '@wdio/logger': 9.29.1
+      '@wdio/types': 9.29.1
+      '@wdio/utils': 9.30.0
+      deepmerge-ts: 7.1.5
+      glob: 13.0.6
+      import-meta-resolve: 4.2.0
+      jiti: 2.7.0
+    transitivePeerDependencies:
+      - bare-abort-controller
+      - bare-buffer
+      - react-native-b4a
+      - supports-color
+
   '@wdio/logger@9.18.0':
     dependencies:
       chalk: 5.6.2
@@ -26867,6 +27863,46 @@ snapshots:
       safe-regex2: 5.1.1
       strip-ansi: 7.2.0
 
+  '@wdio/logger@9.29.1':
+    dependencies:
+      chalk: 5.6.2
+      loglevel: 1.9.2
+      loglevel-plugin-prefix: 0.8.4
+      safe-regex2: 5.1.1
+      strip-ansi: 7.2.0
+
+  '@wdio/protocols@9.30.0': {}
+
+  '@wdio/repl@9.16.2':
+    dependencies:
+      '@types/node': 20.19.41
+
+  '@wdio/types@9.29.1':
+    dependencies:
+      '@types/node': 20.19.41
+
+  '@wdio/utils@9.30.0':
+    dependencies:
+      '@puppeteer/browsers': 2.13.2
+      '@wdio/logger': 9.29.1
+      '@wdio/types': 9.29.1
+      decamelize: 6.0.1
+      deepmerge-ts: 7.1.5
+      edgedriver: 6.3.0
+      geckodriver: 6.1.1
+      get-port: 7.2.0
+      import-meta-resolve: 4.2.0
+      locate-app: 2.5.0
+      mitt: 3.0.1
+      safaridriver: 1.0.1
+      split2: 4.2.0
+      wait-port: 1.1.0
+    transitivePeerDependencies:
+      - bare-abort-controller
+      - bare-buffer
+      - react-native-b4a
+      - supports-color
+
   '@webassemblyjs/ast@1.14.1':
     dependencies:
       '@webassemblyjs/helper-numbers': 1.13.2
@@ -27126,9 +28162,9 @@ snapshots:
     dependencies:
       ajv: 6.14.0
 
-  ajv-keywords@5.1.0(ajv@8.18.0):
+  ajv-keywords@5.1.0(ajv@8.20.0):
     dependencies:
-      ajv: 8.18.0
+      ajv: 8.20.0
       fast-deep-equal: 3.1.3
 
   ajv@6.14.0:
@@ -27203,6 +28239,40 @@ snapshots:
     dependencies:
       default-require-extensions: 3.0.1
 
+  appium@3.6.0(@types/node@24.12.4)(bufferutil@4.1.0)(utf-8-validate@6.0.6):
+    dependencies:
+      '@appium/base-driver': 10.7.2(@appium/logger@2.0.10)(@types/node@24.12.4)
+      '@appium/base-plugin': 3.3.3(@appium/logger@2.0.10)(@types/node@24.12.4)
+      '@appium/docutils': 2.5.2(@types/node@24.12.4)
+      '@appium/logger': 2.0.10
+      '@appium/schema': 1.3.0
+      '@appium/support': 7.2.6(@types/node@24.12.4)
+      '@appium/types': 1.6.0(@appium/logger@2.0.10)
+      '@sidvind/better-ajv-errors': 5.0.0(ajv@8.20.0)
+      ajv: 8.20.0
+      ajv-formats: 3.0.1
+      argparse: 3.0.0
+      asyncbox: 6.3.5
+      axios: 1.16.1
+      lilconfig: 3.1.3
+      lru-cache: 11.5.2
+      ora: 5.4.1
+      semver: 7.8.5
+      teen_process: 4.1.9
+      type-fest: 5.8.0
+      winston: 3.19.0
+      ws: 8.21.0(bufferutil@4.1.0)(utf-8-validate@6.0.6)
+      yaml: 2.8.4
+    transitivePeerDependencies:
+      - '@types/node'
+      - bare-abort-controller
+      - bare-buffer
+      - bufferutil
+      - debug
+      - react-native-b4a
+      - supports-color
+      - utf-8-validate
+
   archiver-utils@5.0.2:
     dependencies:
       glob: 13.0.6
@@ -27227,6 +28297,22 @@ snapshots:
       - bare-buffer
       - react-native-b4a
 
+  archiver@8.0.0:
+    dependencies:
+      async: 3.2.6
+      buffer-crc32: 1.0.0
+      is-stream: 4.0.1
+      lazystream: 1.0.1
+      normalize-path: 3.0.0
+      readable-stream: 4.7.0
+      readdir-glob: 3.0.0
+      tar-stream: 3.1.9
+      zip-stream: 7.0.5
+    transitivePeerDependencies:
+      - bare-abort-controller
+      - bare-buffer
+      - react-native-b4a
+
   archy@1.0.0: {}
 
   arg@5.0.2: {}
@@ -27237,6 +28323,8 @@ snapshots:
 
   argparse@2.0.1: {}
 
+  argparse@3.0.0: {}
+
   aria-hidden@1.2.6:
     dependencies:
       tslib: 2.8.1
@@ -27276,6 +28364,10 @@ snapshots:
 
   ast-module-types@6.0.1: {}
 
+  ast-types@0.13.4:
+    dependencies:
+      tslib: 2.8.1
+
   ast-types@0.16.1:
     dependencies:
       tslib: 2.8.1
@@ -27288,12 +28380,18 @@ snapshots:
 
   astring@1.9.0: {}
 
+  async-lock@1.4.1: {}
+
   async-mutex@0.5.0:
     dependencies:
       tslib: 2.8.1
 
   async@3.2.6: {}
 
+  asyncbox@6.3.5:
+    dependencies:
+      p-limit: 7.3.0
+
   asynckit@0.4.0: {}
 
   atomic-sleep@1.0.0: {}
@@ -27573,6 +28671,12 @@ snapshots:
 
   baseline-browser-mapping@2.10.8: {}
 
+  basic-auth@2.0.1:
+    dependencies:
+      safe-buffer: 5.1.2
+
+  basic-ftp@5.3.1: {}
+
   before-after-hook@4.0.0: {}
 
   big-integer@1.6.52: {}
@@ -27611,6 +28715,20 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  body-parser@2.3.0:
+    dependencies:
+      bytes: 3.1.2
+      content-type: 2.0.0
+      debug: 4.4.3
+      http-errors: 2.0.1
+      iconv-lite: 0.7.2
+      on-finished: 2.4.1
+      qs: 6.15.2
+      raw-body: 3.0.2
+      type-is: 2.1.0
+    transitivePeerDependencies:
+      - supports-color
+
   boolbase@1.0.0: {}
 
   bottleneck@2.19.5: {}
@@ -27632,6 +28750,10 @@ snapshots:
     dependencies:
       stream-buffers: 2.2.0
 
+  bplist-creator@0.1.1:
+    dependencies:
+      stream-buffers: 2.2.0
+
   bplist-parser@0.3.1:
     dependencies:
       big-integer: 1.6.52
@@ -27910,7 +29032,7 @@ snapshots:
 
   chromatic@16.10.0(@chromatic-com/playwright@0.12.8(@playwright/test@1.58.2)(@types/react@19.2.14)(bufferutil@4.1.0)(esbuild@0.27.4)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)(typescript@5.9.3)(utf-8-validate@6.0.6)):
     dependencies:
-      semver: 7.8.2
+      semver: 7.8.5
     optionalDependencies:
       '@chromatic-com/playwright': 0.12.8(@playwright/test@1.58.2)(@types/react@19.2.14)(bufferutil@4.1.0)(esbuild@0.27.4)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)(typescript@5.9.3)(utf-8-validate@6.0.6)
 
@@ -28027,6 +29149,12 @@ snapshots:
       strip-ansi: 6.0.1
       wrap-ansi: 7.0.0
 
+  cliui@9.0.1:
+    dependencies:
+      string-width: 7.2.0
+      strip-ansi: 7.2.0
+      wrap-ansi: 9.0.2
+
   clone@1.0.4: {}
 
   clsx@2.1.1: {}
@@ -28080,20 +29208,35 @@ snapshots:
     dependencies:
       color-name: 1.1.4
 
+  color-convert@3.1.3:
+    dependencies:
+      color-name: 2.1.1
+
   color-name@1.1.3: {}
 
   color-name@1.1.4: {}
 
+  color-name@2.1.1: {}
+
   color-string@1.9.1:
     dependencies:
       color-name: 1.1.4
       simple-swizzle: 0.2.4
 
+  color-string@2.1.4:
+    dependencies:
+      color-name: 2.1.1
+
   color@4.2.3:
     dependencies:
       color-convert: 2.0.1
       color-string: 1.9.1
 
+  color@5.0.3:
+    dependencies:
+      color-convert: 3.1.3
+      color-string: 2.1.4
+
   colorette@2.0.20: {}
 
   colorjs.io@0.6.0-alpha.1: {}
@@ -28146,6 +29289,14 @@ snapshots:
       normalize-path: 3.0.0
       readable-stream: 4.7.0
 
+  compress-commons@7.0.1:
+    dependencies:
+      crc-32: 1.2.2
+      crc32-stream: 7.0.1
+      is-stream: 4.0.1
+      normalize-path: 3.0.0
+      readable-stream: 4.7.0
+
   compressible@2.0.18:
     dependencies:
       mime-db: 1.54.0
@@ -28210,6 +29361,8 @@ snapshots:
 
   content-type@1.0.5: {}
 
+  content-type@2.0.0: {}
+
   convert-source-map@1.9.0: {}
 
   convert-source-map@2.0.0: {}
@@ -28272,6 +29425,11 @@ snapshots:
       crc-32: 1.2.2
       readable-stream: 4.7.0
 
+  crc32-stream@7.0.1:
+    dependencies:
+      crc-32: 1.2.2
+      readable-stream: 4.7.0
+
   create-ecdh@4.0.4:
     dependencies:
       bn.js: 4.12.3
@@ -28343,7 +29501,7 @@ snapshots:
       postcss-modules-scope: 3.2.1(postcss@8.5.13)
       postcss-modules-values: 4.0.0(postcss@8.5.13)
       postcss-value-parser: 4.2.0
-      semver: 7.8.2
+      semver: 7.8.5
     optionalDependencies:
       webpack: 5.105.4(@swc/core@1.15.18)
 
@@ -28356,7 +29514,7 @@ snapshots:
       postcss-modules-scope: 3.2.1(postcss@8.5.13)
       postcss-modules-values: 4.0.0(postcss@8.5.13)
       postcss-value-parser: 4.2.0
-      semver: 7.8.2
+      semver: 7.8.5
     optionalDependencies:
       webpack: 5.105.4(esbuild@0.27.4)
 
@@ -28389,11 +29547,15 @@ snapshots:
       domutils: 3.2.2
       nth-check: 2.1.1
 
+  css-shorthand-properties@1.1.2: {}
+
   css-tree@1.1.3:
     dependencies:
       mdn-data: 2.0.14
       source-map: 0.6.1
 
+  css-value@0.0.1: {}
+
   css-what@6.2.2: {}
 
   css.escape@1.5.1: {}
@@ -28456,6 +29618,8 @@ snapshots:
 
   data-uri-to-buffer@4.0.1: {}
 
+  data-uri-to-buffer@6.0.2: {}
+
   date-fns@4.1.0: {}
 
   dayjs@1.11.20: {}
@@ -28466,6 +29630,10 @@ snapshots:
     dependencies:
       ms: 2.0.0
 
+  debug@3.1.0:
+    dependencies:
+      ms: 2.0.0
+
   debug@3.2.7:
     dependencies:
       ms: 2.1.3
@@ -28504,6 +29672,8 @@ snapshots:
 
   deep-is@0.1.4: {}
 
+  deepmerge-ts@7.1.5: {}
+
   deepmerge@4.3.1: {}
 
   default-browser-id@5.0.1: {}
@@ -28539,6 +29709,12 @@ snapshots:
 
   defu@6.1.7: {}
 
+  degenerator@5.0.1:
+    dependencies:
+      ast-types: 0.13.4
+      escodegen: 2.1.0
+      esprima: 4.0.1
+
   delayed-stream@1.0.0: {}
 
   depd@2.0.0: {}
@@ -28590,6 +29766,9 @@ snapshots:
 
   detect-node-es@1.1.0: {}
 
+  detect-node@2.1.0:
+    optional: true
+
   detective-amd@6.0.1:
     dependencies:
       ast-module-types: 6.0.1
@@ -28822,6 +30001,24 @@ snapshots:
     dependencies:
       safe-buffer: 5.2.1
 
+  edge-paths@3.0.5:
+    dependencies:
+      '@types/which': 2.0.2
+      which: 2.0.2
+
+  edgedriver@6.3.0:
+    dependencies:
+      '@wdio/logger': 9.18.0
+      '@zip.js/zip.js': 2.8.26
+      decamelize: 6.0.1
+      edge-paths: 3.0.5
+      fast-xml-parser: 5.7.3
+      http-proxy-agent: 7.0.2
+      https-proxy-agent: 7.0.6
+      which: 6.0.1
+    transitivePeerDependencies:
+      - supports-color
+
   ee-first@1.1.1: {}
 
   effect@4.0.0-beta.57:
@@ -28861,6 +30058,8 @@ snapshots:
 
   emojis-list@3.0.0: {}
 
+  enabled@2.0.0: {}
+
   encodeurl@1.0.2: {}
 
   encodeurl@2.0.0: {}
@@ -29705,12 +30904,24 @@ snapshots:
 
   extend@3.0.2: {}
 
+  extract-zip@2.0.1:
+    dependencies:
+      debug: 4.4.3
+      get-stream: 5.2.0
+      yauzl: 2.10.0
+    optionalDependencies:
+      '@types/yauzl': 2.10.3
+    transitivePeerDependencies:
+      - supports-color
+
   fast-check@4.8.0:
     dependencies:
       pure-rand: 8.4.0
 
   fast-content-type-parse@3.0.0: {}
 
+  fast-deep-equal@2.0.1: {}
+
   fast-deep-equal@3.1.3: {}
 
   fast-fifo@1.3.2: {}
@@ -29758,6 +30969,8 @@ snapshots:
       path-expression-matcher: 1.5.0
       strnum: 2.2.3
 
+  fastest-levenshtein@1.0.16: {}
+
   fastq@1.20.1:
     dependencies:
       reusify: 1.1.0
@@ -29776,10 +30989,16 @@ snapshots:
     dependencies:
       walk-up-path: 4.0.0
 
+  fd-slicer@1.1.0:
+    dependencies:
+      pend: 1.2.0
+
   fdir@6.5.0(picomatch@4.0.4):
     optionalDependencies:
       picomatch: 4.0.4
 
+  fecha@4.2.3: {}
+
   fetch-blob@3.2.0:
     dependencies:
       node-domexception: 1.0.0
@@ -29921,6 +31140,8 @@ snapshots:
 
   flow-enums-runtime@0.0.6: {}
 
+  fn.name@1.1.0: {}
+
   follow-redirects@1.16.0: {}
 
   fontfaceobserver@2.3.0: {}
@@ -30050,6 +31271,10 @@ snapshots:
   fsevents@2.3.3:
     optional: true
 
+  ftp-response-parser@1.0.1:
+    dependencies:
+      readable-stream: 1.1.14
+
   function-bind@1.1.2: {}
 
   functional-red-black-tree@1.0.1: {}
@@ -30099,6 +31324,17 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  geckodriver@6.1.1:
+    dependencies:
+      '@wdio/logger': 9.18.0
+      '@zip.js/zip.js': 2.8.26
+      decamelize: 6.0.1
+      http-proxy-agent: 7.0.2
+      https-proxy-agent: 7.0.6
+      modern-tar: 0.7.6
+    transitivePeerDependencies:
+      - supports-color
+
   generator-function@2.0.1: {}
 
   gensync@1.0.0-beta.2: {}
@@ -30135,11 +31371,17 @@ snapshots:
 
   get-port-please@3.2.0: {}
 
+  get-port@7.2.0: {}
+
   get-proto@1.0.1:
     dependencies:
       dunder-proto: 1.0.1
       es-object-atoms: 1.1.1
 
+  get-stream@5.2.0:
+    dependencies:
+      pump: 3.0.4
+
   get-stream@6.0.1: {}
 
   get-tsconfig@4.13.7:
@@ -30150,6 +31392,14 @@ snapshots:
     dependencies:
       resolve-pkg-maps: 1.0.0
 
+  get-uri@6.0.5:
+    dependencies:
+      basic-ftp: 5.3.1
+      data-uri-to-buffer: 6.0.2
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
   getenv@2.0.0: {}
 
   giget@3.3.0: {}
@@ -30227,6 +31477,8 @@ snapshots:
       - encoding
       - supports-color
 
+  grapheme-splitter@1.0.4: {}
+
   graphql-tag@2.12.7(graphql@16.14.2):
     dependencies:
       graphql: 16.14.2
@@ -30240,6 +31492,9 @@ snapshots:
     dependencies:
       duplexer: 0.1.2
 
+  handle-thing@2.0.1:
+    optional: true
+
   handlebars@4.7.9:
     dependencies:
       minimist: 1.2.8
@@ -30399,6 +31654,18 @@ snapshots:
     dependencies:
       lru-cache: 10.4.3
 
+  hosted-git-info@9.0.3:
+    dependencies:
+      lru-cache: 11.2.7
+
+  hpack.js@2.1.6:
+    dependencies:
+      inherits: 2.0.4
+      obuf: 1.1.2
+      readable-stream: 2.3.8
+      wbuf: 1.7.3
+    optional: true
+
   html-entities@2.6.0: {}
 
   html-escaper@2.0.2: {}
@@ -30437,6 +31704,8 @@ snapshots:
     optionalDependencies:
       webpack: 5.105.4(esbuild@0.27.4)
 
+  htmlfy@0.8.1: {}
+
   htmlparser2@10.1.0:
     dependencies:
       domelementtype: 2.3.0
@@ -30460,6 +31729,9 @@ snapshots:
       domutils: 2.8.0
       entities: 2.2.0
 
+  http-deceiver@1.2.7:
+    optional: true
+
   http-errors@2.0.1:
     dependencies:
       depd: 2.0.0
@@ -30475,6 +31747,8 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  http-status-codes@2.3.0: {}
+
   http_ece@1.2.0: {}
 
   https-browserify@1.0.0: {}
@@ -30742,6 +32016,8 @@ snapshots:
 
   is-stream@2.0.1: {}
 
+  is-stream@4.0.1: {}
+
   is-typed-array@1.1.15:
     dependencies:
       which-typed-array: 1.1.20
@@ -30768,6 +32044,8 @@ snapshots:
     dependencies:
       is-inside-container: 1.0.0
 
+  isarray@0.0.1: {}
+
   isarray@1.0.0: {}
 
   isarray@2.0.5: {}
@@ -30778,6 +32056,8 @@ snapshots:
 
   isexe@3.1.5: {}
 
+  isexe@4.0.0: {}
+
   isobject@3.0.1: {}
 
   istanbul-lib-coverage@3.2.2: {}
@@ -31661,6 +32941,17 @@ snapshots:
 
   jsesc@3.1.0: {}
 
+  jsftp@2.1.3:
+    dependencies:
+      debug: 3.2.7
+      ftp-response-parser: 1.0.1
+      once: 1.4.0
+      parse-listing: 1.1.3
+      stream-combiner: 0.2.2
+      unorm: 1.6.0
+    transitivePeerDependencies:
+      - supports-color
+
   json-bigint@1.0.0:
     dependencies:
       bignumber.js: 9.3.1
@@ -31741,6 +33032,8 @@ snapshots:
     dependencies:
       json-buffer: 3.0.1
 
+  klaw@4.1.0: {}
+
   kleur@3.0.3: {}
 
   kleur@4.1.5: {}
@@ -31781,6 +33074,8 @@ snapshots:
 
   kubernetes-types@1.30.0: {}
 
+  kuler@2.0.0: {}
+
   ky@1.14.3: {}
 
   kysely@0.29.2: {}
@@ -31867,6 +33162,8 @@ snapshots:
       lightningcss-win32-arm64-msvc: 1.30.1
       lightningcss-win32-x64-msvc: 1.30.1
 
+  lilconfig@3.1.3: {}
+
   lines-and-columns@1.2.4: {}
 
   lines-and-columns@2.0.4: {}
@@ -31907,6 +33204,12 @@ snapshots:
       pkg-types: 2.3.1
       quansync: 0.2.11
 
+  locate-app@2.5.0:
+    dependencies:
+      '@promptbook/utils': 0.69.5
+      type-fest: 4.26.0
+      userhome: 1.0.1
+
   locate-path@5.0.0:
     dependencies:
       p-locate: 4.1.0
@@ -31919,8 +33222,14 @@ snapshots:
     dependencies:
       p-locate: 6.0.0
 
+  lockfile@1.0.4:
+    dependencies:
+      signal-exit: 3.0.7
+
   lodash-es@4.18.1: {}
 
+  lodash.clonedeep@4.5.0: {}
+
   lodash.debounce@4.0.8: {}
 
   lodash.flattendeep@4.4.0: {}
@@ -31947,6 +33256,8 @@ snapshots:
 
   lodash.throttle@4.1.1: {}
 
+  lodash.zip@4.2.0: {}
+
   lodash@4.18.1: {}
 
   log-symbols@2.2.0:
@@ -31966,6 +33277,15 @@ snapshots:
       strip-ansi: 7.2.0
       wrap-ansi: 9.0.2
 
+  logform@2.7.0:
+    dependencies:
+      '@colors/colors': 1.6.0
+      '@types/triple-beam': 1.3.5
+      fecha: 4.2.3
+      ms: 2.1.3
+      safe-stable-stringify: 2.5.0
+      triple-beam: 1.4.1
+
   loglevel-plugin-prefix@0.8.4: {}
 
   loglevel@1.9.2: {}
@@ -31994,6 +33314,8 @@ snapshots:
 
   lru-cache@11.2.7: {}
 
+  lru-cache@11.5.2: {}
+
   lru-cache@5.1.1:
     dependencies:
       yallist: 3.1.1
@@ -32002,6 +33324,8 @@ snapshots:
     dependencies:
       yallist: 4.0.0
 
+  lru-cache@7.18.3: {}
+
   lucide-react-native@1.25.0(react-native-svg@15.15.4(react-native@0.86.0(@types/react@19.2.14)(bufferutil@4.1.0)(react@19.2.3)(utf-8-validate@6.0.6))(react@19.2.3))(react-native@0.86.0(@types/react@19.2.14)(bufferutil@4.1.0)(react@19.2.3)(utf-8-validate@6.0.6))(react@19.2.3):
     dependencies:
       react: 19.2.3
@@ -32304,6 +33628,17 @@ snapshots:
 
   merge2@1.4.1: {}
 
+  method-override@3.0.0:
+    dependencies:
+      debug: 3.1.0
+      methods: 1.1.2
+      parseurl: 1.3.3
+      vary: 1.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  methods@1.1.2: {}
+
   metro-babel-transformer@0.84.4:
     dependencies:
       '@babel/core': 7.29.0
@@ -32854,6 +34189,8 @@ snapshots:
     dependencies:
       minipass: 7.1.3
 
+  mitt@3.0.1: {}
+
   mkdirp@1.0.4: {}
 
   mlly@1.8.2:
@@ -32883,6 +34220,16 @@ snapshots:
       dompurify: 3.4.3
       marked: 14.0.0
 
+  morgan@1.11.0:
+    dependencies:
+      basic-auth: 2.0.1
+      debug: 2.6.9
+      depd: 2.0.0
+      on-finished: 2.4.1
+      on-headers: 1.1.0
+    transitivePeerDependencies:
+      - supports-color
+
   motion-dom@12.36.0:
     dependencies:
       motion-utils: 12.36.0
@@ -32959,6 +34306,8 @@ snapshots:
 
   neo-async@2.6.2: {}
 
+  netmask@2.1.1: {}
+
   next-auth@4.24.14(next@16.2.6(@babel/core@7.29.0)(@opentelemetry/api@1.9.1)(@playwright/test@1.58.2)(babel-plugin-react-compiler@1.0.0)(react-dom@19.2.6(react@19.2.6))(react@19.2.6))(react-dom@19.2.6(react@19.2.6))(react@19.2.6):
     dependencies:
       '@babel/runtime': 7.29.2
@@ -33115,13 +34464,19 @@ snapshots:
     dependencies:
       '@babel/parser': 7.29.7
 
+  normalize-package-data@8.0.0:
+    dependencies:
+      hosted-git-info: 9.0.3
+      semver: 7.8.5
+      validate-npm-package-license: 3.0.4
+
   normalize-path@3.0.0: {}
 
   npm-package-arg@11.0.3:
     dependencies:
       hosted-git-info: 7.0.2
       proc-log: 4.2.0
-      semver: 7.8.2
+      semver: 7.8.5
       validate-npm-package-name: 5.0.1
 
   npm-run-path@4.0.1:
@@ -33202,6 +34557,9 @@ snapshots:
 
   objectorarray@1.0.5: {}
 
+  obuf@1.1.2:
+    optional: true
+
   obug@2.1.1: {}
 
   ofetch@1.5.1:
@@ -33230,6 +34588,10 @@ snapshots:
     dependencies:
       wrappy: 1.0.2
 
+  one-time@1.0.0:
+    dependencies:
+      fn.name: 1.1.0
+
   onetime@2.0.1:
     dependencies:
       mimic-fn: 1.2.0
@@ -33599,6 +34961,24 @@ snapshots:
 
   p-try@2.2.0: {}
 
+  pac-proxy-agent@7.2.0:
+    dependencies:
+      '@tootallnate/quickjs-emscripten': 0.23.0
+      agent-base: 7.1.4
+      debug: 4.4.3
+      get-uri: 6.0.5
+      http-proxy-agent: 7.0.2
+      https-proxy-agent: 7.0.6
+      pac-resolver: 7.0.1
+      socks-proxy-agent: 8.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  pac-resolver@7.0.1:
+    dependencies:
+      degenerator: 5.0.1
+      netmask: 2.1.1
+
   package-hash@4.0.0:
     dependencies:
       graceful-fs: 4.2.11
@@ -33665,6 +35045,8 @@ snapshots:
       index-to-position: 1.2.0
       type-fest: 4.41.0
 
+  parse-listing@1.1.3: {}
+
   parse-ms@2.1.0: {}
 
   parse-passwd@1.0.0: {}
@@ -33856,6 +35238,11 @@ snapshots:
       base64-js: 1.5.1
       xmlbuilder: 15.1.1
 
+  plist@4.0.0:
+    dependencies:
+      '@xmldom/xmldom': 0.8.13
+      xmlbuilder: 15.1.1
+
   pluralize@8.0.0: {}
 
   pngjs@3.4.0: {}
@@ -33875,7 +35262,7 @@ snapshots:
       cosmiconfig: 9.0.1(typescript@5.9.3)
       jiti: 2.7.0
       postcss: 8.5.13
-      semver: 7.8.2
+      semver: 7.8.5
     optionalDependencies:
       webpack: 5.105.4(esbuild@0.27.4)
     transitivePeerDependencies:
@@ -34093,6 +35480,19 @@ snapshots:
       forwarded: 0.2.0
       ipaddr.js: 1.9.1
 
+  proxy-agent@6.5.0:
+    dependencies:
+      agent-base: 7.1.4
+      debug: 4.4.3
+      http-proxy-agent: 7.0.2
+      https-proxy-agent: 7.0.6
+      lru-cache: 7.18.3
+      pac-proxy-agent: 7.2.0
+      proxy-from-env: 1.1.0
+      socks-proxy-agent: 8.0.5
+    transitivePeerDependencies:
+      - supports-color
+
   proxy-from-env@1.1.0: {}
 
   proxy-from-env@2.1.0: {}
@@ -34555,6 +35955,13 @@ snapshots:
 
   react@19.2.6: {}
 
+  readable-stream@1.1.14:
+    dependencies:
+      core-util-is: 1.0.3
+      inherits: 2.0.4
+      isarray: 0.0.1
+      string_decoder: 0.10.31
+
   readable-stream@2.3.8:
     dependencies:
       core-util-is: 1.0.3
@@ -34583,6 +35990,10 @@ snapshots:
     dependencies:
       minimatch: 5.1.9
 
+  readdir-glob@3.0.0:
+    dependencies:
+      minimatch: 10.2.5
+
   readdirp@3.6.0:
     dependencies:
       picomatch: 2.3.2
@@ -34843,6 +36254,10 @@ snapshots:
       path-parse: 1.0.7
       supports-preserve-symlinks-flag: 1.0.0
 
+  resq@1.11.0:
+    dependencies:
+      fast-deep-equal: 2.0.1
+
   restore-cursor@2.0.0:
     dependencies:
       onetime: 2.0.1
@@ -34875,6 +36290,8 @@ snapshots:
 
   rfdc@1.4.1: {}
 
+  rgb2hex@0.2.5: {}
+
   rimraf@3.0.2:
     dependencies:
       glob: 13.0.6
@@ -35009,6 +36426,8 @@ snapshots:
     dependencies:
       mri: 1.2.0
 
+  safaridriver@1.0.1: {}
+
   safe-buffer@5.1.2: {}
 
   safe-buffer@5.2.1: {}
@@ -35033,6 +36452,10 @@ snapshots:
 
   safer-buffer@2.1.2: {}
 
+  sanitize-filename@1.6.4:
+    dependencies:
+      truncate-utf8-bytes: 1.0.2
+
   sass-loader@16.0.7(webpack@5.105.4(esbuild@0.27.4)):
     dependencies:
       neo-async: 2.6.2
@@ -35057,9 +36480,9 @@ snapshots:
   schema-utils@4.3.3:
     dependencies:
       '@types/json-schema': 7.0.15
-      ajv: 8.18.0
+      ajv: 8.20.0
       ajv-formats: 2.1.1
-      ajv-keywords: 5.1.0(ajv@8.18.0)
+      ajv-keywords: 5.1.0(ajv@8.20.0)
 
   scslre@0.3.0:
     dependencies:
@@ -35071,6 +36494,9 @@ snapshots:
 
   seedrandom@3.0.5: {}
 
+  select-hose@2.0.0:
+    optional: true
+
   selenium-webdriver@4.45.0(bufferutil@4.1.0)(utf-8-validate@6.0.6):
     dependencies:
       '@bazel/runfiles': 6.5.0
@@ -35123,8 +36549,20 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  serialize-error@12.0.0:
+    dependencies:
+      type-fest: 4.41.0
+
   serialize-error@2.1.0: {}
 
+  serve-favicon@2.5.1:
+    dependencies:
+      etag: 1.8.1
+      fresh: 0.5.2
+      ms: 2.1.3
+      parseurl: 1.3.3
+      safe-buffer: 5.2.1
+
   serve-static@1.16.3:
     dependencies:
       encodeurl: 2.0.0
@@ -35179,7 +36617,7 @@ snapshots:
     dependencies:
       '@img/colour': 1.1.0
       detect-libc: 2.1.2
-      semver: 7.8.2
+      semver: 7.8.5
     optionalDependencies:
       '@img/sharp-darwin-arm64': 0.34.5
       '@img/sharp-darwin-x64': 0.34.5
@@ -35206,6 +36644,40 @@ snapshots:
       '@img/sharp-win32-ia32': 0.34.5
       '@img/sharp-win32-x64': 0.34.5
 
+  sharp@0.35.3(@types/node@24.12.4):
+    dependencies:
+      '@img/colour': 1.1.0
+      detect-libc: 2.1.2
+      semver: 7.8.5
+    optionalDependencies:
+      '@img/sharp-darwin-arm64': 0.35.3
+      '@img/sharp-darwin-x64': 0.35.3
+      '@img/sharp-freebsd-wasm32': 0.35.3
+      '@img/sharp-libvips-darwin-arm64': 1.3.2
+      '@img/sharp-libvips-darwin-x64': 1.3.2
+      '@img/sharp-libvips-linux-arm': 1.3.2
+      '@img/sharp-libvips-linux-arm64': 1.3.2
+      '@img/sharp-libvips-linux-ppc64': 1.3.2
+      '@img/sharp-libvips-linux-riscv64': 1.3.2
+      '@img/sharp-libvips-linux-s390x': 1.3.2
+      '@img/sharp-libvips-linux-x64': 1.3.2
+      '@img/sharp-libvips-linuxmusl-arm64': 1.3.2
+      '@img/sharp-libvips-linuxmusl-x64': 1.3.2
+      '@img/sharp-linux-arm': 0.35.3
+      '@img/sharp-linux-arm64': 0.35.3
+      '@img/sharp-linux-ppc64': 0.35.3
+      '@img/sharp-linux-riscv64': 0.35.3
+      '@img/sharp-linux-s390x': 0.35.3
+      '@img/sharp-linux-x64': 0.35.3
+      '@img/sharp-linuxmusl-arm64': 0.35.3
+      '@img/sharp-linuxmusl-x64': 0.35.3
+      '@img/sharp-webcontainers-wasm32': 0.35.3
+      '@img/sharp-win32-arm64': 0.35.3
+      '@img/sharp-win32-ia32': 0.35.3
+      '@img/sharp-win32-x64': 0.35.3
+      '@types/node': 24.12.4
+    optional: true
+
   shebang-command@2.0.0:
     dependencies:
       shebang-regex: 3.0.0
@@ -35302,8 +36774,23 @@ snapshots:
 
   slugify@1.6.8: {}
 
+  smart-buffer@4.2.0: {}
+
   smol-toml@1.6.1: {}
 
+  socks-proxy-agent@8.0.5:
+    dependencies:
+      agent-base: 7.1.4
+      debug: 4.4.3
+      socks: 2.8.9
+    transitivePeerDependencies:
+      - supports-color
+
+  socks@2.8.9:
+    dependencies:
+      ip-address: 10.2.0
+      smart-buffer: 4.2.0
+
   sonic-boom@4.2.1:
     dependencies:
       atomic-sleep: 1.0.0
@@ -35344,6 +36831,8 @@ snapshots:
 
   space-separated-tokens@2.0.2: {}
 
+  spacetrim@0.11.59: {}
+
   spawn-sync@1.0.15:
     dependencies:
       concat-stream: 1.6.2
@@ -35367,6 +36856,43 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  spdx-correct@3.2.0:
+    dependencies:
+      spdx-expression-parse: 3.0.1
+      spdx-license-ids: 3.0.23
+
+  spdx-exceptions@2.5.0: {}
+
+  spdx-expression-parse@3.0.1:
+    dependencies:
+      spdx-exceptions: 2.5.0
+      spdx-license-ids: 3.0.23
+
+  spdx-license-ids@3.0.23: {}
+
+  spdy-transport@3.0.0:
+    dependencies:
+      debug: 4.4.3
+      detect-node: 2.1.0
+      hpack.js: 2.1.6
+      obuf: 1.1.2
+      readable-stream: 3.6.2
+      wbuf: 1.7.3
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
+  spdy@4.0.2:
+    dependencies:
+      debug: 4.4.3
+      handle-thing: 2.0.1
+      http-deceiver: 1.2.7
+      select-hose: 2.0.0
+      spdy-transport: 3.0.0
+    transitivePeerDependencies:
+      - supports-color
+    optional: true
+
   split-on-first@1.1.0: {}
 
   split2@4.2.0: {}
@@ -35401,6 +36927,8 @@ snapshots:
       sqlite-vec-windows-x64: 0.1.9
     optional: true
 
+  stack-trace@0.0.10: {}
+
   stack-utils@2.0.6:
     dependencies:
       escape-string-regexp: 2.0.0
@@ -35468,6 +36996,11 @@ snapshots:
 
   stream-buffers@2.2.0: {}
 
+  stream-combiner@0.2.2:
+    dependencies:
+      duplexer: 0.1.2
+      through: 2.3.8
+
   stream-http@3.2.0:
     dependencies:
       builtin-status-codes: 3.0.0
@@ -35518,6 +37051,8 @@ snapshots:
       get-east-asian-width: 1.5.0
       strip-ansi: 7.2.0
 
+  string_decoder@0.10.31: {}
+
   string_decoder@1.1.1:
     dependencies:
       safe-buffer: 5.1.2
@@ -35712,6 +37247,18 @@ snapshots:
 
   tapable@2.3.3: {}
 
+  tar-fs@3.1.3:
+    dependencies:
+      pump: 3.0.4
+      tar-stream: 3.1.9
+    optionalDependencies:
+      bare-fs: 4.5.5
+      bare-path: 3.0.0
+    transitivePeerDependencies:
+      - bare-abort-controller
+      - bare-buffer
+      - react-native-b4a
+
   tar-stream@3.1.8:
     dependencies:
       b4a: 1.8.0
@@ -35750,6 +37297,10 @@ snapshots:
       minizlib: 3.1.0
       yallist: 5.0.0
 
+  teen_process@4.1.9:
+    dependencies:
+      shell-quote: 1.8.4
+
   teex@1.0.1:
     dependencies:
       streamx: 2.23.0
@@ -35811,6 +37362,8 @@ snapshots:
     transitivePeerDependencies:
       - react-native-b4a
 
+  text-hex@1.0.0: {}
+
   third-party-capital@1.0.20: {}
 
   thread-stream@3.2.0:
@@ -35906,8 +37459,14 @@ snapshots:
 
   trim-lines@3.0.1: {}
 
+  triple-beam@1.4.1: {}
+
   trough@2.2.0: {}
 
+  truncate-utf8-bytes@1.0.2:
+    dependencies:
+      utf8-byte-length: 1.0.5
+
   ts-algebra@2.0.0: {}
 
   ts-api-utils@2.5.0(typescript@5.9.3):
@@ -36014,18 +37573,30 @@ snapshots:
 
   type-fest@3.13.1: {}
 
+  type-fest@4.26.0: {}
+
   type-fest@4.41.0: {}
 
   type-fest@5.5.0:
     dependencies:
       tagged-tag: 1.0.0
 
+  type-fest@5.8.0:
+    dependencies:
+      tagged-tag: 1.0.0
+
   type-is@2.0.1:
     dependencies:
       content-type: 1.0.5
       media-typer: 1.1.0
       mime-types: 3.0.2
 
+  type-is@2.1.0:
+    dependencies:
+      content-type: 2.0.0
+      media-typer: 1.1.0
+      mime-types: 3.0.2
+
   type@2.7.3: {}
 
   typebox@1.1.39: {}
@@ -36161,6 +37732,8 @@ snapshots:
 
   universalify@2.0.1: {}
 
+  unorm@1.6.0: {}
+
   unpipe@1.0.0: {}
 
   unplugin-utils@0.3.1:
@@ -36228,7 +37801,7 @@ snapshots:
       is-npm: 6.1.0
       latest-version: 9.0.0
       pupa: 3.3.0
-      semver: 7.8.2
+      semver: 7.8.5
       xdg-basedir: 5.1.0
 
   uri-js@4.4.1:
@@ -36242,6 +37815,8 @@ snapshots:
       punycode: 1.4.1
       qs: 6.15.2
 
+  urlpattern-polyfill@10.1.0: {}
+
   use-callback-ref@1.3.3(@types/react@19.2.14)(react@19.2.3):
     dependencies:
       react: 19.2.3
@@ -36285,10 +37860,14 @@ snapshots:
     dependencies:
       react: 19.2.6
 
+  userhome@1.0.1: {}
+
   utf-8-validate@6.0.6:
     dependencies:
       node-gyp-build: 4.8.4
 
+  utf8-byte-length@1.0.5: {}
+
   util-deprecate@1.0.2: {}
 
   util@0.12.5:
@@ -36307,6 +37886,8 @@ snapshots:
 
   uuid@13.0.2: {}
 
+  uuid@14.0.1: {}
+
   uvu@0.5.6:
     dependencies:
       dequal: 2.0.3
@@ -36320,6 +37901,11 @@ snapshots:
       '@types/istanbul-lib-coverage': 2.0.6
       convert-source-map: 2.0.0
 
+  validate-npm-package-license@3.0.4:
+    dependencies:
+      spdx-correct: 3.2.0
+      spdx-expression-parse: 3.0.1
+
   validate-npm-package-name@5.0.1: {}
 
   vary@1.1.2: {}
@@ -36586,6 +38172,14 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  wait-port@1.1.0:
+    dependencies:
+      chalk: 4.1.2
+      commander: 9.5.0
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
   walk-up-path@4.0.0: {}
 
   walkdir@0.4.1: {}
@@ -36608,6 +38202,11 @@ snapshots:
 
   watskeburt@5.0.3: {}
 
+  wbuf@1.7.3:
+    dependencies:
+      minimalistic-assert: 1.0.1
+    optional: true
+
   wcwidth@1.0.1:
     dependencies:
       defaults: 1.0.4
@@ -36687,6 +38286,62 @@ snapshots:
 
   web-vitals@5.1.0: {}
 
+  webdriver@9.30.0(bufferutil@4.1.0)(utf-8-validate@6.0.6):
+    dependencies:
+      '@types/node': 20.19.41
+      '@types/ws': 8.18.1
+      '@wdio/config': 9.30.0
+      '@wdio/logger': 9.29.1
+      '@wdio/protocols': 9.30.0
+      '@wdio/types': 9.29.1
+      '@wdio/utils': 9.30.0
+      deepmerge-ts: 7.1.5
+      https-proxy-agent: 7.0.6
+      undici: 6.27.0
+      ws: 8.21.0(bufferutil@4.1.0)(utf-8-validate@6.0.6)
+    transitivePeerDependencies:
+      - bare-abort-controller
+      - bare-buffer
+      - bufferutil
+      - react-native-b4a
+      - supports-color
+      - utf-8-validate
+
+  webdriverio@9.30.0(bufferutil@4.1.0)(utf-8-validate@6.0.6):
+    dependencies:
+      '@types/node': 20.19.41
+      '@types/sinonjs__fake-timers': 8.1.5
+      '@wdio/config': 9.30.0
+      '@wdio/logger': 9.29.1
+      '@wdio/protocols': 9.30.0
+      '@wdio/repl': 9.16.2
+      '@wdio/types': 9.29.1
+      '@wdio/utils': 9.30.0
+      archiver: 7.0.1
+      aria-query: 5.3.2
+      cheerio: 1.2.0
+      css-shorthand-properties: 1.1.2
+      css-value: 0.0.1
+      grapheme-splitter: 1.0.4
+      htmlfy: 0.8.1
+      is-plain-obj: 4.1.0
+      jszip: 3.10.1
+      lodash.clonedeep: 4.5.0
+      lodash.zip: 4.2.0
+      query-selector-shadow-dom: 1.0.1
+      resq: 1.11.0
+      rgb2hex: 0.2.5
+      serialize-error: 12.0.0
+      urlpattern-polyfill: 10.1.0
+      webdriver: 9.30.0(bufferutil@4.1.0)(utf-8-validate@6.0.6)
+    transitivePeerDependencies:
+      - bare-abort-controller
+      - bare-buffer
+      - bufferutil
+      - react-native-b4a
+      - supports-color
+      - utf-8-validate
+
   webidl-conversions@3.0.1: {}
 
   webidl-conversions@7.0.0: {}
@@ -36889,6 +38544,10 @@ snapshots:
     dependencies:
       isexe: 3.1.5
 
+  which@6.0.1:
+    dependencies:
+      isexe: 4.0.0
+
   why-is-node-running@2.3.0:
     dependencies:
       siginfo: 2.0.0
@@ -36904,6 +38563,26 @@ snapshots:
 
   winreg@0.0.12: {}
 
+  winston-transport@4.9.0:
+    dependencies:
+      logform: 2.7.0
+      readable-stream: 3.6.2
+      triple-beam: 1.4.1
+
+  winston@3.19.0:
+    dependencies:
+      '@colors/colors': 1.6.0
+      '@dabh/diagnostics': 2.0.8
+      async: 3.2.6
+      is-stream: 2.0.1
+      logform: 2.7.0
+      one-time: 1.0.0
+      readable-stream: 3.6.2
+      safe-stable-stringify: 2.5.0
+      stack-trace: 0.0.10
+      triple-beam: 1.4.1
+      winston-transport: 4.9.0
+
   word-wrap@1.2.5: {}
 
   wordwrap@1.0.0: {}
@@ -37140,6 +38819,8 @@ snapshots:
 
   yargs-parser@21.1.1: {}
 
+  yargs-parser@22.0.0: {}
+
   yargs@15.4.1:
     dependencies:
       cliui: 6.0.0
@@ -37164,6 +38845,20 @@ snapshots:
       y18n: 5.0.8
       yargs-parser: 21.1.1
 
+  yargs@18.0.0:
+    dependencies:
+      cliui: 9.0.1
+      escalade: 3.2.0
+      get-caller-file: 2.0.5
+      string-width: 7.2.0
+      y18n: 5.0.8
+      yargs-parser: 22.0.0
+
+  yauzl@2.10.0:
+    dependencies:
+      buffer-crc32: 0.2.13
+      fd-slicer: 1.1.0
+
   yauzl@3.3.0:
     dependencies:
       buffer-crc32: 0.2.13
@@ -37173,6 +38868,10 @@ snapshots:
     dependencies:
       pend: 1.2.0
 
+  yauzl@3.4.0:
+    dependencies:
+      pend: 1.2.0
+
   yocto-queue@0.1.0: {}
 
   yocto-queue@1.2.2: {}
@@ -37203,6 +38902,12 @@ snapshots:
       compress-commons: 6.0.2
       readable-stream: 4.7.0
 
+  zip-stream@7.0.5:
+    dependencies:
+      compress-commons: 7.0.1
+      normalize-path: 3.0.0
+      readable-stream: 4.7.0
+
   zod-to-json-schema@3.25.1(zod@4.4.3):
     dependencies:
       zod: 4.4.3
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 6e64d7ba66..8123821bee 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -24,6 +24,7 @@ catalog:
   '@vitest/coverage-v8': 4.1.6
   '@vitest/ui': 4.1.6
   '@workos-inc/node': 8.13.0
+  appium: 3.6.0
   aws4fetch: 1.0.20
   drizzle-kit: 0.31.10
   drizzle-orm: 0.45.2
@@ -36,6 +37,7 @@ catalog:
   typescript: 5.9.3
   ulid: 3.0.2
   vitest: 4.1.6
+  webdriverio: 9.30.0
   workers-tagged-logger: 1.0.0
   wrangler: 4.112.0
   zod: 4.4.3
@@ -43,6 +45,8 @@ catalog:
 minimumReleaseAge: 6842
 minimumReleaseAgeExclude:
   - tsx
+  - appium
+  - webdriverio
   - expo-dev-client
   - expo-dev-launcher
   - expo-dev-menu
@@ -158,3 +162,6 @@ allowBuilds:
   tree-sitter-bash: false
   geckodriver: true
   '@scarf/scarf': false
+  appium: set this to true or false
+  appium-ios-tuntap: set this to true or false
+  edgedriver: set this to true or false

From 609f57e09a293e42c6703949f1e50d7ed7f88dd0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 02:31:15 +0200
Subject: [PATCH 15/34] feat(e2e): appium + webdriverio automation core
 alongside the old setup

- wdio/ client (per-device deterministic ports, XCUITest/UiAutomator2 caps),
  helpers (full-string-regex selectors, topmost-first index, polling waits),
  run-flow runner (exit code is the verdict), hierarchy dumper
- appium.sh: per-device lock via process-lock, per-device appium server
  lifecycle, driver bootstrap into APPIUM_HOME
- the six launch/login flows ported from YAML to JS, same helper names and
  wait budgets
- login.sh/logout.sh rewired to appium.sh; interfaces unchanged

Old wrapper and YAML flows remain until device parity is proven.
---
 apps/mobile/e2e/appium.sh                   | 119 ++++++++++++
 apps/mobile/e2e/flows/login-assert-home.js  |   6 +
 apps/mobile/e2e/flows/login-request-code.js |  35 ++++
 apps/mobile/e2e/flows/login-verify-code.js  |  33 ++++
 apps/mobile/e2e/flows/logout.js             |  40 +++++
 apps/mobile/e2e/flows/open-app.js           |  25 +++
 apps/mobile/e2e/flows/settle-app.js         |  91 ++++++++++
 apps/mobile/e2e/flows/states.js             |  53 ++++++
 apps/mobile/e2e/login.sh                    |  19 +-
 apps/mobile/e2e/logout.sh                   |   8 +-
 apps/mobile/e2e/wdio/client.js              |  51 ++++++
 apps/mobile/e2e/wdio/helpers.js             | 189 ++++++++++++++++++++
 apps/mobile/e2e/wdio/hierarchy.js           |  25 +++
 apps/mobile/e2e/wdio/ports.js               |  35 ++++
 apps/mobile/e2e/wdio/run-flow.js            |  46 +++++
 15 files changed, 762 insertions(+), 13 deletions(-)
 create mode 100755 apps/mobile/e2e/appium.sh
 create mode 100644 apps/mobile/e2e/flows/login-assert-home.js
 create mode 100644 apps/mobile/e2e/flows/login-request-code.js
 create mode 100644 apps/mobile/e2e/flows/login-verify-code.js
 create mode 100644 apps/mobile/e2e/flows/logout.js
 create mode 100644 apps/mobile/e2e/flows/open-app.js
 create mode 100644 apps/mobile/e2e/flows/settle-app.js
 create mode 100644 apps/mobile/e2e/flows/states.js
 create mode 100644 apps/mobile/e2e/wdio/client.js
 create mode 100644 apps/mobile/e2e/wdio/helpers.js
 create mode 100644 apps/mobile/e2e/wdio/hierarchy.js
 create mode 100644 apps/mobile/e2e/wdio/ports.js
 create mode 100644 apps/mobile/e2e/wdio/run-flow.js

diff --git a/apps/mobile/e2e/appium.sh b/apps/mobile/e2e/appium.sh
new file mode 100755
index 0000000000..d6e44d7a09
--- /dev/null
+++ b/apps/mobile/e2e/appium.sh
@@ -0,0 +1,119 @@
+#!/usr/bin/env bash
+# Serialize Appium per device, manage one Appium server per device, and give
+# flows a trustworthy exit code (a node process exits non-zero on any failed
+# assertion — no report files to inspect). `--exec` holds the same device
+# lock around a multi-command helper.
+#
+#   appium.sh <device> test [-e KEY=VALUE]... <flow.js>
+#   appium.sh <device> hierarchy
+#   appium.sh <device> server start|stop|status
+#   appium.sh <device> --exec <command...>
+#
+# One-time machine setup is automatic: drivers install into APPIUM_HOME
+# (default ~/.cache/kilo-appium) on first use.
+set -euo pipefail
+
+DEVICE="${1:?usage: appium.sh <device> <command> [args...]}"
+shift
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel)"
+export APPIUM_HOME="${KILO_APPIUM_HOME:-$HOME/.cache/kilo-appium}"
+APPIUM_BIN="$REPO_ROOT/node_modules/.bin/appium"
+LOCK="${TMPDIR:-/tmp}/kilo-appium-locks/$DEVICE"
+
+if [ "${KILO_APPIUM_LOCKED:-}" != "1" ]; then
+  exec "$REPO_ROOT/node_modules/.bin/tsx" "$REPO_ROOT/dev/local/process-lock.ts" \
+    --wait 1200 "$LOCK" -- env KILO_APPIUM_LOCKED=1 "$0" "$DEVICE" "$@"
+fi
+
+# shellcheck disable=SC1090
+source <(node "$SCRIPT_DIR/wdio/ports.js" "$DEVICE")
+STATE_DIR="${TMPDIR:-/tmp}/kilo-appium/$APPIUM_DEVICE_SLUG"
+mkdir -p "$STATE_DIR" "$APPIUM_HOME"
+
+ensure_drivers() {
+  local want installed
+  case "$DEVICE" in
+    emulator-*) want=uiautomator2 ;;
+    *) want=xcuitest ;;
+  esac
+  # appium logs to stderr; the list never reaches stdout.
+  installed="$("$APPIUM_BIN" driver list --installed 2>&1 || true)"
+  if ! grep -qw "$want" <<<"$installed"; then
+    # Machine-global install: serialize so parallel first runs cannot race it.
+    "$REPO_ROOT/node_modules/.bin/tsx" "$REPO_ROOT/dev/local/process-lock.ts" \
+      --wait 1800 "${TMPDIR:-/tmp}/kilo-appium-locks/driver-install" -- \
+      "$APPIUM_BIN" driver install "$want"
+  fi
+}
+
+server_status() {
+  curl -sf -o /dev/null --max-time 3 "http://127.0.0.1:$APPIUM_PORT/status"
+}
+
+ensure_server() {
+  if server_status; then return 0; fi
+  ensure_drivers
+  echo "appium.sh: starting appium server for $DEVICE on port $APPIUM_PORT" >&2
+  nohup "$APPIUM_BIN" --port "$APPIUM_PORT" --log-level warn \
+    >"$STATE_DIR/appium.log" 2>&1 &
+  echo $! >"$STATE_DIR/appium.pid"
+  for _ in $(seq 1 60); do
+    if server_status; then return 0; fi
+    if ! kill -0 "$(cat "$STATE_DIR/appium.pid")" 2>/dev/null; then
+      echo "appium.sh: appium server died at launch; last log lines:" >&2
+      tail -n 20 "$STATE_DIR/appium.log" >&2
+      return 1
+    fi
+    sleep 1
+  done
+  echo "appium.sh: appium server did not answer /status within 60s ($STATE_DIR/appium.log)" >&2
+  return 1
+}
+
+stop_server() {
+  if [ -f "$STATE_DIR/appium.pid" ] && kill -0 "$(cat "$STATE_DIR/appium.pid")" 2>/dev/null; then
+    kill "$(cat "$STATE_DIR/appium.pid")" || true
+  fi
+  rm -f "$STATE_DIR/appium.pid"
+}
+
+cmd="${1:-}"
+case "$cmd" in
+  --exec)
+    shift
+    [ $# -gt 0 ] || { echo "appium.sh: --exec needs a command" >&2; exit 1; }
+    exec "$@"
+    ;;
+  server)
+    case "${2:-}" in
+      start) ensure_drivers && ensure_server ;;
+      stop) stop_server ;;
+      status) server_status && echo "up ($DEVICE, port $APPIUM_PORT)" || { echo "down"; exit 1; } ;;
+      *) echo "usage: appium.sh <device> server start|stop|status" >&2; exit 1 ;;
+    esac
+    ;;
+  test)
+    shift
+    ENV_ARGS=()
+    FLOW=""
+    while [ $# -gt 0 ]; do
+      case "$1" in
+        -e) ENV_ARGS+=("$2"); shift 2 ;;
+        *) FLOW="$1"; shift ;;
+      esac
+    done
+    [ -n "$FLOW" ] || { echo "usage: appium.sh <device> test [-e K=V]... <flow.js>" >&2; exit 1; }
+    ensure_server
+    env DEVICE="$DEVICE" APPIUM_PORT="$APPIUM_PORT" "${ENV_ARGS[@]}" \
+      node "$SCRIPT_DIR/wdio/run-flow.js" "$FLOW"
+    ;;
+  hierarchy)
+    ensure_server
+    env DEVICE="$DEVICE" APPIUM_PORT="$APPIUM_PORT" node "$SCRIPT_DIR/wdio/hierarchy.js"
+    ;;
+  *)
+    echo "usage: appium.sh <device> test|hierarchy|server|--exec ..." >&2
+    exit 1
+    ;;
+esac
diff --git a/apps/mobile/e2e/flows/login-assert-home.js b/apps/mobile/e2e/flows/login-assert-home.js
new file mode 100644
index 0000000000..96aafadf76
--- /dev/null
+++ b/apps/mobile/e2e/flows/login-assert-home.js
@@ -0,0 +1,6 @@
+// Confirms the login helper's already-authenticated branch leaves the app on Home.
+module.exports = async function assertHome(ctx) {
+  const { h } = ctx;
+  await h.tapOn('HOME|Home, tab, 1 of 4');
+  await h.assertVisible(/Good (morning|afternoon|evening)/);
+};
diff --git a/apps/mobile/e2e/flows/login-request-code.js b/apps/mobile/e2e/flows/login-request-code.js
new file mode 100644
index 0000000000..ad552a1420
--- /dev/null
+++ b/apps/mobile/e2e/flows/login-request-code.js
@@ -0,0 +1,35 @@
+// Login step 1/2 — request an email sign-in code.
+//
+// Establishes a signed-out baseline, then submits EMAIL to reach the "Enter
+// the code" screen. The 6-digit code is emailed to the local outbox
+// (dev/logs/emails/); read it there and pass it to login-verify-code.js.
+//
+//   apps/mobile/e2e/appium.sh <udid> test -e EMAIL=e2e-mobile@example.com \
+//     e2e/flows/login-request-code.js
+//
+// EMAIL is required (-e). Prefer the one-shot wrapper e2e/login.sh, which
+// runs both steps and pulls the code for you. See e2e/AGENTS.md.
+const logout = require('./logout');
+
+module.exports = async function requestCode(ctx) {
+  const { h, env } = ctx;
+  const email = env.EMAIL;
+  if (!email) throw new Error('EMAIL is required (pass -e EMAIL=<address>)');
+
+  await logout(ctx);
+
+  // Tap the input via its placeholder — the "Email address" label shares the
+  // field's accessibility text and would match the (non-focusable) label.
+  await h.tapOn('you@example.com');
+  // The field is uncontrolled, so a login page left on screen by an earlier
+  // run still holds its address, and typing inserts at the caret the tap just
+  // dropped mid-string — two attempts interleave into a malformed address.
+  await h.eraseText(100);
+  await h.inputText(email);
+  // Fail here, immediately and legibly, instead of 15s later on a missing
+  // "Verify code": a mismatch means typing landed in a field that was not empty.
+  await h.assertVisible(email);
+  await h.tapOn('Send sign-in code');
+  // Sending is a network round-trip.
+  await h.waitVisible('Verify code', { timeout: 15000 });
+};
diff --git a/apps/mobile/e2e/flows/login-verify-code.js b/apps/mobile/e2e/flows/login-verify-code.js
new file mode 100644
index 0000000000..aca3a74717
--- /dev/null
+++ b/apps/mobile/e2e/flows/login-verify-code.js
@@ -0,0 +1,33 @@
+// Login step 2/2 — verify the emailed sign-in code.
+//
+// Enters OTP on the "Enter the code" screen and lands on Home. Assumes
+// login-request-code.js already reached that screen.
+//
+//   apps/mobile/e2e/appium.sh <udid> test -e OTP=123456 e2e/flows/login-verify-code.js
+//
+// Prefer the one-shot wrapper e2e/login.sh. See e2e/AGENTS.md.
+const S = require('./states');
+
+module.exports = async function verifyCode(ctx) {
+  const { h, env, when } = ctx;
+  const otp = env.OTP;
+  if (!otp) throw new Error('OTP is required (pass -e OTP=<code>)');
+
+  await h.assertVisible('Verify code');
+  await h.tapOn('Sign-in code');
+  await h.eraseText(6);
+  await h.inputText(otp);
+  // The number pad has no dismiss key; "Verify code" sits above it, so tap directly.
+  await h.tapOn('Verify code');
+
+  // A brand-new account's first sign-in shows a consent screen before Home.
+  await h.waitVisible(new RegExp([S.CONSENT.source, S.NOTIF_PROMPT.source, S.HOME.source].join('|')), {
+    timeout: 20000,
+  });
+  await when(ctx, S.CONSENT, () => h.tapOn(S.CONSENT));
+  await h.waitVisible(new RegExp([S.NOTIF_PROMPT.source, S.HOME.source].join('|')), {
+    timeout: 15000,
+  });
+  await when(ctx, S.NOTIF_PROMPT, () => h.tapOn('Allow'));
+  await h.waitVisible(S.HOME, { timeout: 15000 });
+};
diff --git a/apps/mobile/e2e/flows/logout.js b/apps/mobile/e2e/flows/logout.js
new file mode 100644
index 0000000000..a6adb0c1b3
--- /dev/null
+++ b/apps/mobile/e2e/flows/logout.js
@@ -0,0 +1,40 @@
+// Logout helper — ends on the login page ("Welcome to Kilo Code").
+//
+// Idempotent: if the app is already signed out, it just lands on the login
+// page. Run via `apps/mobile/e2e/logout.sh <device>`; see e2e/AGENTS.md.
+const settleApp = require('./settle-app');
+const S = require('./states');
+
+module.exports = async function logout(ctx) {
+  const { h, when, whenNot } = ctx;
+
+  // An open code-verification screen backs out to the email form.
+  await when(ctx, 'Verify code', () => h.tapOn('Back'));
+
+  // Signed out already? Land on the login page. Anything else that is not
+  // Home gets settled first (prompts, developer menu, consent gate).
+  await whenNot(ctx, S.LOGIN, async () => {
+    await whenNot(ctx, S.HOME, () => settleApp(ctx));
+  });
+
+  // Booted into the consent gate (signed in, not consented) -> accept it to
+  // reach Home, then sign out below.
+  await when(ctx, S.CONSENT, async () => {
+    await h.tapOn(S.CONSENT);
+    await h.waitVisible(/Home, tab, 1 of 4/, { timeout: 15000 });
+  });
+
+  // Signed in: Profile tab -> Sign Out -> confirm the native alert.
+  await whenNot(ctx, S.LOGIN, async () => {
+    await h.tapOn('Profile, tab, 4 of 4');
+    await h.scrollUntilVisible('Sign Out', { direction: 'DOWN' });
+    await h.tapOn('Sign Out');
+    await h.assertVisible('Sign out?');
+    // The alert's confirm ("Sign out") and the screen button ("Sign Out")
+    // collide under a case-insensitive match; index 0 is topmost by position,
+    // which is the alert button.
+    await h.tapOn('Sign out', { index: 0, ci: true });
+  });
+
+  await h.assertVisible('you@example.com');
+};
diff --git a/apps/mobile/e2e/flows/open-app.js b/apps/mobile/e2e/flows/open-app.js
new file mode 100644
index 0000000000..a7a6213af8
--- /dev/null
+++ b/apps/mobile/e2e/flows/open-app.js
@@ -0,0 +1,25 @@
+// Standalone cold-launch flow: clears any prompt left on screen, relaunches
+// the dev client, waits for it to render a known state, then delegates prompt
+// handling to settle-app.js.
+const { BUNDLE_ID } = require('../wdio/client');
+const settleApp = require('./settle-app');
+const S = require('./states');
+
+module.exports = async function openApp(ctx) {
+  const { h, when } = ctx;
+
+  // Prompts left over from a previous run block the relaunch; answer them.
+  await when(ctx, S.TRACKING_BUTTON, () => h.tapOn(S.TRACKING_BUTTON));
+  await when(ctx, S.DEVMENU_INTRO, () => h.tapOn('Continue'));
+  await when(ctx, S.DEVMENU_OPEN, () => h.tapOn('Close'));
+
+  // Relaunch through the driver. activateApp is a plain bring-to-front via
+  // the platform (WDA / activity manager) and does not bounce the dev client
+  // to SpringBoard the way the old CLI launch could.
+  await h.stopApp(BUNDLE_ID);
+  await h.launchApp(BUNDLE_ID);
+
+  // Cold launch and bundling are slow; wait for any known state before settling.
+  await h.waitVisible(S.ANY_STATE, { timeout: 30000 });
+  await settleApp(ctx);
+};
diff --git a/apps/mobile/e2e/flows/settle-app.js b/apps/mobile/e2e/flows/settle-app.js
new file mode 100644
index 0000000000..ebb399cde9
--- /dev/null
+++ b/apps/mobile/e2e/flows/settle-app.js
@@ -0,0 +1,91 @@
+// Settles an already-running app: handles the Safari external-app prompt and
+// the SpringBoard custom-scheme confirmation (`Open in "Kilo"?`, shown by
+// `simctl openurl` since universal links were configured), the tracking
+// prompt, the Expo developer-menu introduction and menu, and notification
+// permission — ending on Home, the login page, or the consent gate. Never
+// restarts the app; open-app.js is the cold-launch wrapper around this flow.
+const S = require('./states');
+
+module.exports = async function settleApp(ctx) {
+  const { h, when } = ctx;
+
+  // Something known must render before we settle.
+  await h.waitVisible(S.ANY_STATE, { timeout: 15000 });
+
+  // A deep-link reconnect may raise the external-app confirmation; one
+  // bounded optional look, then move on (the only optional wait here).
+  await h.waitVisible(
+    new RegExp(
+      [
+        S.OPEN_IN_KILO.source,
+        S.TRACKING_PROMPT.source,
+        S.TRACKING_BUTTON.source,
+        S.DEVMENU_INTRO.source,
+        S.DEVMENU_OPEN.source,
+        S.NOTIF_PROMPT.source,
+      ].join('|')
+    ),
+    { timeout: 3000, optional: true }
+  );
+  await when(ctx, S.OPEN_IN_KILO, () => h.tapOn('Open'));
+
+  // Each wait below excludes the state just handled: prompts are answered in
+  // order and never reappear, so every barrier either advances or passes.
+  await h.waitVisible(
+    new RegExp(
+      [
+        S.TRACKING_PROMPT.source,
+        S.TRACKING_BUTTON.source,
+        S.DEVMENU_INTRO.source,
+        S.DEVMENU_OPEN.source,
+        S.NOTIF_PROMPT.source,
+        S.HOME.source,
+        S.LOGIN.source,
+        S.CONSENT.source,
+      ].join('|')
+    ),
+    { timeout: 5000 }
+  );
+  await when(ctx, S.TRACKING_BUTTON, () => h.tapOn(S.TRACKING_BUTTON));
+
+  await h.waitVisible(
+    new RegExp(
+      [
+        S.DEVMENU_INTRO.source,
+        S.DEVMENU_OPEN.source,
+        S.NOTIF_PROMPT.source,
+        S.HOME.source,
+        S.LOGIN.source,
+        S.CONSENT.source,
+      ].join('|')
+    ),
+    { timeout: 5000 }
+  );
+  await when(ctx, S.DEVMENU_INTRO, () => h.tapOn('Continue'));
+
+  await h.waitVisible(
+    new RegExp(
+      [
+        S.DEVMENU_OPEN.source,
+        S.NOTIF_PROMPT.source,
+        S.HOME.source,
+        S.LOGIN.source,
+        S.CONSENT.source,
+      ].join('|')
+    ),
+    { timeout: 5000 }
+  );
+  await when(ctx, S.DEVMENU_OPEN, () => h.tapOn('Close'));
+
+  await h.waitVisible(
+    new RegExp([S.NOTIF_PROMPT.source, S.HOME.source, S.LOGIN.source, S.CONSENT.source].join('|')),
+    { timeout: 5000 }
+  );
+  // The only generic Allow tap in the launch flows: reached exclusively from
+  // the identified notification prompt above.
+  await when(ctx, S.NOTIF_PROMPT, () => h.tapOn('Allow'));
+
+  await h.waitVisible(new RegExp([S.HOME.source, S.LOGIN.source, S.CONSENT.source].join('|')), {
+    timeout: 15000,
+  });
+};
diff --git a/apps/mobile/e2e/flows/states.js b/apps/mobile/e2e/flows/states.js
new file mode 100644
index 0000000000..0717c5e2b6
--- /dev/null
+++ b/apps/mobile/e2e/flows/states.js
@@ -0,0 +1,53 @@
+// Shared on-screen state patterns for the launch/login flows. Text matching
+// is full-string regex against the element label/text (see helpers.js), so
+// alternations and literals live here once instead of drifting between flows.
+
+// SpringBoard / Safari external-app confirmation when a deep link reopens the
+// dev client (both wordings, straight or curly quotes).
+const OPEN_IN_KILO = /Open this page in "Kilo"\?|Open in ["“”]Kilo["“”]\?/;
+
+// iOS App Tracking Transparency.
+const TRACKING_PROMPT =
+  /Allow “Kilo” to track your activity across other companies’ apps and websites\?/;
+const TRACKING_BUTTON = /Ask App Not to Track/;
+
+// Expo dev client: developer-menu introduction, then the opened menu itself.
+const DEVMENU_INTRO = /This is the developer menu.*/;
+const DEVMENU_OPEN = /Fast Refresh|Element Inspector/;
+
+// iOS notification permission (system sheet rendered inside the app).
+const NOTIF_PROMPT = /“Kilo” Would Like to Send You Notifications/;
+
+// App states.
+const HOME = /HOME|Home, tab, 1 of 4/;
+const LOGIN = /Welcome to Kilo Code/;
+const CONSENT = /Accept and continue/;
+
+// Any state a launch can land on — used to know the app rendered something
+// known before settling. Keep in sync with the prompts above.
+const ANY_STATE = new RegExp(
+  [
+    OPEN_IN_KILO.source,
+    TRACKING_PROMPT.source,
+    TRACKING_BUTTON.source,
+    DEVMENU_INTRO.source,
+    DEVMENU_OPEN.source,
+    NOTIF_PROMPT.source,
+    HOME.source,
+    LOGIN.source,
+    CONSENT.source,
+  ].join('|')
+);
+
+module.exports = {
+  ANY_STATE,
+  CONSENT,
+  DEVMENU_INTRO,
+  DEVMENU_OPEN,
+  HOME,
+  LOGIN,
+  NOTIF_PROMPT,
+  OPEN_IN_KILO,
+  TRACKING_BUTTON,
+  TRACKING_PROMPT,
+};
diff --git a/apps/mobile/e2e/login.sh b/apps/mobile/e2e/login.sh
index 23350086cf..cb167084aa 100755
--- a/apps/mobile/e2e/login.sh
+++ b/apps/mobile/e2e/login.sh
@@ -15,7 +15,8 @@
 # Env overrides:
 #   OUTBOX   outbox dir (default: <repo-root>/dev/logs/emails)
 #
-# Requires: maestro, perl. Run the backend + Metro first (see e2e/AGENTS.md).
+# Requires: perl (plus the repo install, which provides Appium). Run the
+# backend + Metro first (see e2e/AGENTS.md).
 set -euo pipefail
 
 DEVICE="${1:?usage: login.sh <device-udid> [email]}"
@@ -31,8 +32,8 @@ case "$DEVICE" in
 esac
 EMAIL="${2:-e2e-mobile-${WORKTREE_SLUG}-${PLATFORM}@example.com}"
 
-if [ "${KILO_MAESTRO_LOCKED:-}" != "1" ]; then
-  exec "$SCRIPT_DIR/maestro.sh" "$DEVICE" --exec "$0" "$@"
+if [ "${KILO_APPIUM_LOCKED:-}" != "1" ]; then
+  exec "$SCRIPT_DIR/appium.sh" "$DEVICE" --exec "$0" "$@"
 fi
 
 # Newest sign-in-code email for EMAIL, or empty.
@@ -62,7 +63,7 @@ fi
 LOCK="${TMPDIR:-/tmp}/kilo-otp-locks/$EMAIL_KEY"
 if [ "${KILO_OTP_LOCKED:-}" != "1" ]; then
   exec "$REPO_ROOT/node_modules/.bin/tsx" "$REPO_ROOT/dev/local/process-lock.ts" \
-    --wait 1200 "$LOCK" -- env KILO_MAESTRO_LOCKED=1 KILO_OTP_LOCKED=1 "$0" "$@"
+    --wait 1200 "$LOCK" -- env KILO_APPIUM_LOCKED=1 KILO_OTP_LOCKED=1 "$0" "$@"
 fi
 
 "$SCRIPT_DIR/preflight.sh" "$DEVICE"
@@ -72,11 +73,11 @@ fi
 before="$(latest_email)"
 
 request_code() {
-  "$SCRIPT_DIR/maestro.sh" "$DEVICE" test -e "EMAIL=$EMAIL" "$SCRIPT_DIR/flows/login-request-code.yaml"
+  "$SCRIPT_DIR/appium.sh" "$DEVICE" test -e "EMAIL=$EMAIL" "$SCRIPT_DIR/flows/login-request-code.js"
 }
 
-# Say which half broke, so nobody reads Maestro's generic "could be a real
-# regression" advice as a product-bug lead.
+# Say which half broke, so nobody reads a generic automation failure as a
+# product-bug lead.
 diagnose_request() {
   local now
   now="$(latest_email)"
@@ -93,7 +94,7 @@ if ! request_code; then
   # One cold relaunch clears both known first-attempt failures: a half-started
   # dev client, and an email field left dirty by an earlier run.
   echo "==> retrying launch and sign-in request once after a cold relaunch"
-  "$SCRIPT_DIR/maestro.sh" "$DEVICE" test "$SCRIPT_DIR/flows/open-app.yaml" || true
+  "$SCRIPT_DIR/appium.sh" "$DEVICE" test "$SCRIPT_DIR/flows/open-app.js" || true
   request_code || { diagnose_request; exit 1; }
 fi
 
@@ -114,5 +115,5 @@ if [ -z "$code" ]; then
 fi
 
 echo "==> verifying sign-in code"
-"$SCRIPT_DIR/maestro.sh" "$DEVICE" test -e "OTP=$code" "$SCRIPT_DIR/flows/login-verify-code.yaml"
+"$SCRIPT_DIR/appium.sh" "$DEVICE" test -e "OTP=$code" "$SCRIPT_DIR/flows/login-verify-code.js"
 echo "==> signed in"
diff --git a/apps/mobile/e2e/logout.sh b/apps/mobile/e2e/logout.sh
index 74097974a7..c64186e714 100755
--- a/apps/mobile/e2e/logout.sh
+++ b/apps/mobile/e2e/logout.sh
@@ -5,14 +5,14 @@
 # Usage:
 #   e2e/logout.sh <device-udid>
 #
-# Requires: maestro. See e2e/AGENTS.md ("Sign In and Out").
+# See e2e/AGENTS.md ("Sign In and Out").
 set -euo pipefail
 
 DEVICE="${1:?usage: logout.sh <device-udid>}"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
-if [ "${KILO_MAESTRO_LOCKED:-}" != "1" ]; then
-  exec "$SCRIPT_DIR/maestro.sh" "$DEVICE" --exec "$0" "$@"
+if [ "${KILO_APPIUM_LOCKED:-}" != "1" ]; then
+  exec "$SCRIPT_DIR/appium.sh" "$DEVICE" --exec "$0" "$@"
 fi
 "$SCRIPT_DIR/preflight.sh" "$DEVICE"
-"$SCRIPT_DIR/maestro.sh" "$DEVICE" test "$SCRIPT_DIR/flows/logout.yaml"
+"$SCRIPT_DIR/appium.sh" "$DEVICE" test "$SCRIPT_DIR/flows/logout.js"
diff --git a/apps/mobile/e2e/wdio/client.js b/apps/mobile/e2e/wdio/client.js
new file mode 100644
index 0000000000..f20f506ac7
--- /dev/null
+++ b/apps/mobile/e2e/wdio/client.js
@@ -0,0 +1,51 @@
+// WebdriverIO session factory for the Kilo dev build. One session per flow
+// invocation; flows manage app lifecycle themselves (terminate/activate), so
+// sessions never auto-launch or reset app state.
+const { remote } = require('webdriverio');
+const { portsFor } = require('./ports');
+
+const BUNDLE_ID = 'com.kilocode.kiloapp';
+
+function platformFor(device) {
+  return String(device).startsWith('emulator-') ? 'android' : 'ios';
+}
+
+async function connect(device) {
+  const platform = platformFor(device);
+  const ports = portsFor(device);
+  const capabilities =
+    platform === 'ios'
+      ? {
+          platformName: 'iOS',
+          'appium:automationName': 'XCUITest',
+          'appium:udid': device,
+          'appium:bundleId': BUNDLE_ID,
+          'appium:noReset': true,
+          'appium:autoLaunch': false,
+          'appium:wdaLocalPort': ports.wda,
+          // RN apps rarely go fully idle; a low idle timeout keeps element
+          // queries snappy instead of stalling behind WDA quiescence waits.
+          'appium:waitForIdleTimeout': 2,
+          'appium:newCommandTimeout': 600,
+        }
+      : {
+          platformName: 'Android',
+          'appium:automationName': 'UiAutomator2',
+          'appium:udid': device,
+          'appium:appPackage': BUNDLE_ID,
+          'appium:noReset': true,
+          'appium:autoLaunch': false,
+          'appium:systemPort': ports.system,
+          'appium:newCommandTimeout': 600,
+        };
+
+  return remote({
+    hostname: '127.0.0.1',
+    port: ports.server,
+    logLevel: 'warn',
+    connectionRetryTimeout: 15000,
+    capabilities,
+  });
+}
+
+module.exports = { BUNDLE_ID, connect, platformFor };
diff --git a/apps/mobile/e2e/wdio/helpers.js b/apps/mobile/e2e/wdio/helpers.js
new file mode 100644
index 0000000000..2e896bbb23
--- /dev/null
+++ b/apps/mobile/e2e/wdio/helpers.js
@@ -0,0 +1,189 @@
+// Flow primitives mirroring the old YAML flow vocabulary: tapOn,
+// assertVisible, extendedWaitUntil, inputText, eraseText, scrollUntilVisible,
+// stopApp/launchApp. Text matching is a full-string regex against the
+// element's visible text / accessibility label (iOS label/name/value,
+// Android text/content-desc), exactly like the flows relied on before.
+// Multiple matches are ordered topmost-first, then leftmost-first; pass
+// { index } to pick a later one.
+
+function regexSource(pattern) {
+  return pattern instanceof RegExp ? pattern.source : String(pattern);
+}
+
+function regexFlags(pattern, ci) {
+  if (ci) return 'i';
+  return pattern instanceof RegExp ? pattern.flags : '';
+}
+
+// iOS NSPredicate string literal: escape backslashes first, then quotes.
+function predicateEscape(s) {
+  return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+// Android UiSelector Java string literal: same escaping rules.
+function javaEscape(s) {
+  return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function make(driver, platform) {
+  async function findAll(pattern, { ci = false } = {}) {
+    const source = regexSource(pattern);
+    const flags = regexFlags(pattern, ci);
+    const anchored = flags.includes('i') ? `(?i)(?:${source})` : `(?:${source})`;
+    let elements;
+    if (platform === 'ios') {
+      const re = predicateEscape(anchored);
+      elements = await driver.findElements(
+        '-ios predicate string',
+        `label MATCHES "${re}" OR name MATCHES "${re}" OR value MATCHES "${re}"`
+      );
+    } else {
+      // UiSelector matches whole strings already; the (?:..) wrap keeps
+      // alternation precedence identical to the iOS side.
+      const re = javaEscape(anchored);
+      const byText = await driver.findElements(
+        'android uiautomator',
+        `new UiSelector().textMatches("${re}")`
+      );
+      const byDesc = await driver.findElements(
+        'android uiautomator',
+        `new UiSelector().descriptionMatches("${re}")`
+      );
+      const seen = new Set();
+      elements = [];
+      for (const el of [...byText, ...byDesc]) {
+        if (!seen.has(el.elementId)) {
+          seen.add(el.elementId);
+          elements.push(el);
+        }
+      }
+    }
+    if (elements.length <= 1) return elements;
+    const withRect = await Promise.all(
+      elements.map(async el => ({ el, rect: await driver.getElementRect(el.elementId) }))
+    );
+    withRect.sort((a, b) => a.rect.y - b.rect.y || a.rect.x - b.rect.x);
+    return withRect.map(({ el }) => el);
+  }
+
+  function describe(pattern) {
+    return pattern instanceof RegExp ? `/${pattern.source}/` : `'${pattern}'`;
+  }
+
+  async function visible(pattern, opts) {
+    try {
+      return (await findAll(pattern, opts)).length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  async function waitVisible(pattern, { timeout = 15000, optional = false, interval = 250 } = {}) {
+    const deadline = Date.now() + timeout;
+    for (;;) {
+      const els = await findAll(pattern).catch(() => []);
+      if (els.length > 0) return els[0];
+      if (Date.now() >= deadline) break;
+      await sleep(interval);
+    }
+    if (optional) return null;
+    throw new Error(`timed out after ${timeout}ms waiting for visible: ${describe(pattern)}`);
+  }
+
+  async function tapOn(pattern, { index = 0, ci = false } = {}) {
+    const els = await findAll(pattern, { ci });
+    if (els.length === 0) throw new Error(`no element matching ${describe(pattern)}`);
+    if (index >= els.length) {
+      throw new Error(`index ${index} out of range (${els.length} matches) for ${describe(pattern)}`);
+    }
+    await driver.elementClick(els[index].elementId);
+  }
+
+  async function assertVisible(pattern, opts) {
+    if (!(await visible(pattern, opts))) {
+      throw new Error(`expected visible: ${describe(pattern)}`);
+    }
+  }
+
+  async function inputText(text) {
+    await driver.keys(String(text));
+  }
+
+  // Types backspaces into the focused field. iOS wants the raw backspace
+  // character; Android wants the WebDriver BACKSPACE key.
+  async function eraseText(count = 100) {
+    const key = platform === 'ios' ? '\u0008' : '\uE003';
+    await driver.keys(new Array(count).fill(key));
+  }
+
+  // One flick of the content; sign=1 scrolls DOWN (content moves up).
+  async function swipeUp(sign = 1) {
+    const { width, height } = await driver.getWindowSize();
+    const x = Math.round(width / 2);
+    const from = Math.round(height * (sign > 0 ? 0.7 : 0.3));
+    const to = Math.round(height * (sign > 0 ? 0.3 : 0.7));
+    await driver.performActions([
+      {
+        type: 'pointer',
+        id: 'finger',
+        parameters: { pointerType: 'touch' },
+        actions: [
+          { type: 'pointerMove', duration: 0, x, y: from },
+          { type: 'pointerDown', button: 0 },
+          { type: 'pointerMove', duration: 400, x, y: to },
+          { type: 'pointerUp', button: 0 },
+        ],
+      },
+    ]);
+    await driver.releaseActions();
+  }
+
+  async function scrollUntilVisible(pattern, { direction = 'DOWN', maxScrolls = 10 } = {}) {
+    for (let i = 0; i < maxScrolls; i++) {
+      const els = await findAll(pattern).catch(() => []);
+      if (els.length > 0) return els[0];
+      await swipeUp(direction === 'UP' ? -1 : 1);
+    }
+    throw new Error(`scrolled ${maxScrolls} times without finding ${describe(pattern)}`);
+  }
+
+  async function stopApp(bundleId) {
+    await driver.terminateApp(bundleId);
+  }
+
+  async function launchApp(bundleId) {
+    await driver.activateApp(bundleId);
+  }
+
+  return {
+    assertVisible,
+    eraseText,
+    findAll,
+    inputText,
+    launchApp,
+    scrollUntilVisible,
+    stopApp,
+    swipeUp,
+    tapOn,
+    visible,
+    waitVisible,
+  };
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// Conditional step, mirroring `runFlow: when: visible:`.
+async function when(ctx, pattern, fn, opts) {
+  if (await ctx.h.visible(pattern, opts)) return fn(ctx);
+  return undefined;
+}
+
+// Conditional step, mirroring `runFlow: when: notVisible:`.
+async function whenNot(ctx, pattern, fn, opts) {
+  if (!(await ctx.h.visible(pattern, opts))) return fn(ctx);
+  return undefined;
+}
+
+module.exports = { make, sleep, when, whenNot };
diff --git a/apps/mobile/e2e/wdio/hierarchy.js b/apps/mobile/e2e/wdio/hierarchy.js
new file mode 100644
index 0000000000..645b315039
--- /dev/null
+++ b/apps/mobile/e2e/wdio/hierarchy.js
@@ -0,0 +1,25 @@
+// Dumps the current accessibility hierarchy (XML page source) for a device.
+// Inspect before selecting; re-inspect after UI changes. Output is large by
+// nature — redirect to a file and grep it, never print it wholesale into a
+// session transcript.
+const { connect } = require('./client');
+
+async function main() {
+  const device = process.env.DEVICE;
+  if (!device) {
+    console.error('usage: DEVICE=<udid> node hierarchy.js');
+    process.exit(1);
+  }
+  const driver = await connect(device);
+  try {
+    process.stdout.write(await driver.getPageSource());
+    process.stdout.write('\n');
+  } finally {
+    await driver.deleteSession().catch(() => {});
+  }
+}
+
+main().catch(err => {
+  console.error(`hierarchy failed: ${err && err.message ? err.message : err}`);
+  process.exit(1);
+});
diff --git a/apps/mobile/e2e/wdio/ports.js b/apps/mobile/e2e/wdio/ports.js
new file mode 100644
index 0000000000..f67b9531f5
--- /dev/null
+++ b/apps/mobile/e2e/wdio/ports.js
@@ -0,0 +1,35 @@
+// Deterministic per-device Appium port assignment. Used by appium.sh (via
+// `node ports.js <device>`) and client.js, so both always agree.
+//
+// One device gets a block of consecutive ports:
+//   base+0  appium server
+//   base+1  iOS WebDriverAgent (wdaLocalPort)
+//   base+2  Android UiAutomator2 systemPort
+// Base ranges 4730-9726 in steps of 10, hashed from the device id, so
+// parallel worktrees/devices never share a server port.
+const crypto = require('node:crypto');
+
+function portsFor(device) {
+  const hash = crypto.createHash('sha256').update(String(device)).digest();
+  const slot = hash.readUInt16BE(0) % 500;
+  const base = 4730 + slot * 10;
+  return { server: base, wda: base + 1, system: base + 2 };
+}
+
+function slugFor(device) {
+  return String(device).replace(/[^a-zA-Z0-9-]/g, '-');
+}
+
+if (require.main === module) {
+  const device = process.argv[2];
+  if (!device) {
+    console.error('usage: ports.js <device>');
+    process.exit(1);
+  }
+  const p = portsFor(device);
+  console.log(
+    `APPIUM_PORT=${p.server}\nAPPIUM_WDA_PORT=${p.wda}\nAPPIUM_SYSTEM_PORT=${p.system}\nAPPIUM_DEVICE_SLUG=${slugFor(device)}`
+  );
+}
+
+module.exports = { portsFor, slugFor };
diff --git a/apps/mobile/e2e/wdio/run-flow.js b/apps/mobile/e2e/wdio/run-flow.js
new file mode 100644
index 0000000000..0c2f2fc27a
--- /dev/null
+++ b/apps/mobile/e2e/wdio/run-flow.js
@@ -0,0 +1,46 @@
+// Runs one flow module against a device. Exit code is the verdict: 0 when the
+// flow completes, 1 on any assertion, selector, or driver error — no report
+// files to second-guess.
+//
+//   DEVICE=<udid> node run-flow.js <flow-file.js>
+//
+// Flow modules export an async function receiving
+//   { driver, h, env, device, platform, when, whenNot }
+// where `h` holds the selector helpers (see helpers.js) and `env` carries
+// flow parameters such as EMAIL and OTP.
+const path = require('node:path');
+const { connect, platformFor } = require('./client');
+const helpers = require('./helpers');
+
+async function main() {
+  const flowPath = process.argv[2];
+  const device = process.env.DEVICE;
+  if (!flowPath || !device) {
+    console.error('usage: DEVICE=<udid> node run-flow.js <flow-file.js>');
+    process.exit(1);
+  }
+  const flow = require(path.resolve(flowPath));
+  const platform = platformFor(device);
+  const driver = await connect(device);
+  try {
+    const h = helpers.make(driver, platform);
+    await flow({
+      device,
+      driver,
+      env: process.env,
+      h,
+      platform,
+      when: helpers.when,
+      whenNot: helpers.whenNot,
+    });
+    console.log(`FLOW OK ${path.basename(flowPath)} (${platform} ${device})`);
+  } finally {
+    await driver.deleteSession().catch(() => {});
+  }
+}
+
+main().catch(err => {
+  const message = err && err.message ? err.message.split('\n')[0] : String(err);
+  console.error(`FLOW FAILED ${process.argv[2] || ''}: ${message}`);
+  process.exit(1);
+});

From 16f608ad30612e9863b482c351c5dcbcae4ddfad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 02:38:03 +0200
Subject: [PATCH 16/34] chore(e2e): allow-list appium build scripts; drop
 obsolete maestro wrapper test

appium's postinstall no-ops when installed as a project dependency;
appium-ios-tuntap and edgedriver are unused by the e2e setup. The JUnit
exit-code hack test is obsolete: a node flow's exit code is the verdict.
---
 dev/local/maestro-wrapper.test.ts | 38 -------------------------------
 pnpm-workspace.yaml               |  7 +++---
 2 files changed, 4 insertions(+), 41 deletions(-)
 delete mode 100644 dev/local/maestro-wrapper.test.ts

diff --git a/dev/local/maestro-wrapper.test.ts b/dev/local/maestro-wrapper.test.ts
deleted file mode 100644
index 7a000e6638..0000000000
--- a/dev/local/maestro-wrapper.test.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-
-test('maestro wrapper fails a zero-exit test whose JUnit report failed', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-maestro-wrapper-'));
-  const fake = path.join(root, 'maestro');
-  fs.writeFileSync(
-    fake,
-    `#!/bin/sh
-output=
-while [ "$#" -gt 0 ]; do
-  [ "$1" = "--output" ] && { output=$2; shift 2; continue; }
-  shift
-done
-printf '<testsuite failures="1"><testcase><failure/></testcase></testsuite>\\n' > "$output"
-`
-  );
-  fs.chmodSync(fake, 0o755);
-  try {
-    const result = spawnSync(
-      path.join(process.cwd(), 'apps/mobile/e2e/maestro.sh'),
-      ['test-device', 'test', 'flow.yaml'],
-      {
-        cwd: process.cwd(),
-        env: { ...process.env, PATH: `${root}:${process.env.PATH}`, TMPDIR: root },
-        encoding: 'utf8',
-      }
-    );
-    assert.equal(result.status, 1, result.stderr);
-    assert.match(result.stderr, /JUnit reports a failed assertion/);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 8123821bee..64c1b28116 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -162,6 +162,7 @@ allowBuilds:
   tree-sitter-bash: false
   geckodriver: true
   '@scarf/scarf': false
-  appium: set this to true or false
-  appium-ios-tuntap: set this to true or false
-  edgedriver: set this to true or false
+  # appium's postinstall no-ops for project installs; tuntap and edgedriver are unused
+  appium: false
+  appium-ios-tuntap: false
+  edgedriver: false

From 5f4c64d722c71e190c09461c340e89441ac4f622 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 02:46:54 +0200
Subject: [PATCH 17/34] chore(learnings): drop maestro learnings, de-maestro
 the rest

Removed all maestro-rooted learnings outright (likely stale under the
new driver). Tool-independent product/platform knowledge (a11y bounds,
picker races, drag-cancel timing, mVCP blanks, deep links, simulator
limits) was kept and reworded to the appium wrapper.
---
 ...mserver-restart-systemui-anr-under-load.md |  4 +--
 ...roid-picker-tap-races-and-toast-capture.md |  8 ++---
 .../learnings/maestro-remote-exit-flow.md     | 31 -------------------
 .../maestro-takescreenshot-output-dir.md      |  9 ------
 .../maestro-tap-swallowed-by-ios-keyboard.md  | 19 ------------
 ...android-a11y-bounds-clamped-to-viewport.md |  7 +++--
 .../mobile-android-maestro-flow-pitfalls.md   | 24 --------------
 ...-e2e-android-a11y-phantom-expanded-band.md | 22 -------------
 ...-e2e-drag-cancel-race-instrument-timing.md | 16 +++++-----
 ...2e-ios-mvcp-suppress-toggle-blanks-list.md |  5 +--
 ...stro-concurrent-commands-driver-timeout.md | 24 --------------
 ...2e-top-clip-positioning-flashlist-clamp.md |  6 ++--
 ...bile-file-navigator-sheet-clipped-ios26.md |  4 +--
 ...mobile-ios-maestro-session-row-and-back.md | 18 -----------
 .../mobile-ios-simulator-e2e-limitations.md   |  2 +-
 ...bile-ios-text-size-slider-maestro-swipe.md | 14 ---------
 .../mobile-ios26-maestro-under-load.md        |  9 ------
 ...le-maestro-childof-fails-flat-a11y-tree.md | 25 ---------------
 ...stro-ios-driver-timeout-kill-stale-only.md | 14 ---------
 ...tro-ios-driver-timeout-stale-xcodebuild.md |  9 ------
 ...ro-swipe-eaten-by-sticky-header-overlay.md | 16 ----------
 .../mobile-pr-review-deep-link-route.md       |  2 +-
 22 files changed, 29 insertions(+), 259 deletions(-)
 delete mode 100644 .kilo_workflow/learnings/maestro-remote-exit-flow.md
 delete mode 100644 .kilo_workflow/learnings/maestro-takescreenshot-output-dir.md
 delete mode 100644 .kilo_workflow/learnings/maestro-tap-swallowed-by-ios-keyboard.md
 delete mode 100644 .kilo_workflow/learnings/mobile-android-maestro-flow-pitfalls.md
 delete mode 100644 .kilo_workflow/learnings/mobile-e2e-android-a11y-phantom-expanded-band.md
 delete mode 100644 .kilo_workflow/learnings/mobile-e2e-maestro-concurrent-commands-driver-timeout.md
 delete mode 100644 .kilo_workflow/learnings/mobile-ios-maestro-session-row-and-back.md
 delete mode 100644 .kilo_workflow/learnings/mobile-ios-text-size-slider-maestro-swipe.md
 delete mode 100644 .kilo_workflow/learnings/mobile-ios26-maestro-under-load.md
 delete mode 100644 .kilo_workflow/learnings/mobile-maestro-childof-fails-flat-a11y-tree.md
 delete mode 100644 .kilo_workflow/learnings/mobile-maestro-ios-driver-timeout-kill-stale-only.md
 delete mode 100644 .kilo_workflow/learnings/mobile-maestro-ios-driver-timeout-stale-xcodebuild.md
 delete mode 100644 .kilo_workflow/learnings/mobile-maestro-swipe-eaten-by-sticky-header-overlay.md

diff --git a/.kilo_workflow/learnings/android-emulator-systemserver-restart-systemui-anr-under-load.md b/.kilo_workflow/learnings/android-emulator-systemserver-restart-systemui-anr-under-load.md
index 9a2e9cc088..6193773500 100644
--- a/.kilo_workflow/learnings/android-emulator-systemserver-restart-systemui-anr-under-load.md
+++ b/.kilo_workflow/learnings/android-emulator-systemserver-restart-systemui-anr-under-load.md
@@ -16,5 +16,5 @@ Cause: the guest's system_server restarted under memory/CPU pressure — treat t
 (`restarting adbd as root`), then `pnpm dev:mobile:android adb -s <serial> shell kill -9
 <systemui-pid>`; system_server restarts SystemUI in ~20 s, the ANR dialog clears, and the
 app process, adb reverse mappings, login session, and conversation state all survive. No emulator relaunch
-(never consume a launch attempt for this). Afterwards the repository Maestro wrapper, which also wedges
-under the load (hierarchy empty/timing out, test never writing its first log line), works again.
+(never consume a launch attempt for this). Afterwards the automation driver, which also wedges
+under the load (hierarchy empty/timing out, sessions never establishing), works again.
diff --git a/.kilo_workflow/learnings/android-picker-tap-races-and-toast-capture.md b/.kilo_workflow/learnings/android-picker-tap-races-and-toast-capture.md
index 592dfa9b7a..78fb1bcfd5 100644
--- a/.kilo_workflow/learnings/android-picker-tap-races-and-toast-capture.md
+++ b/.kilo_workflow/learnings/android-picker-tap-races-and-toast-capture.md
@@ -4,11 +4,11 @@ Two Android-emulator techniques confirmed on attach-oom-11fd (2026-07-28):
 
 1. `uiautomator dump` bounds can describe a view the picker has already left (a tap aimed at them hit the wrong
    Recent row). Before a `pnpm dev:mobile:android adb -s <serial> shell input tap`, cross-check
-   the same node's bounds with `apps/mobile/e2e/maestro.sh <serial> hierarchy` — only tap when
-   both agree. Prefer Maestro flows for navigation and reserve ADB taps for the final pick when sub-second screenshot timing matters.
+   the same node's bounds with `apps/mobile/e2e/appium.sh <serial> hierarchy` — only tap when
+   both agree. Prefer driver flows for navigation and reserve ADB taps for the final pick when sub-second screenshot timing matters.
 2. `sonner-native` toasts are catchable deterministically with a wrapped ADB tap immediately followed by burst
-   screencaps at +0.5s/+1.2s/+2.2s/+3.5s (`pnpm dev:mobile:android adb -s <serial> exec-out screencap -p > f.png`). A Maestro flow's
-   teardown latency (seconds) is too slow — the toast dismisses before the shell regains control. The first
+   screencaps at +0.5s/+1.2s/+2.2s/+3.5s (`pnpm dev:mobile:android adb -s <serial> exec-out screencap -p > f.png`). A driver flow's
+   session latency (seconds) is too slow — the toast dismisses before the shell regains control. The first
    burst frame usually still shows the picker; the second (+1.2s) reliably showed the toast.
 3. Files pushed with `pnpm dev:mobile:android adb -s <serial> push` to /sdcard/Download appear in the picker's Downloads root immediately, but only enter its
    Recent view after being picked once — do not rely on Recent containing a freshly pushed fixture.
diff --git a/.kilo_workflow/learnings/maestro-remote-exit-flow.md b/.kilo_workflow/learnings/maestro-remote-exit-flow.md
deleted file mode 100644
index 9017d4ecf6..0000000000
--- a/.kilo_workflow/learnings/maestro-remote-exit-flow.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# Driving remote `/exit` on iOS via Maestro (remote-cli E2E)
-
-Learned 2026-07-28 during plan 1.7 (Defect A) round r3 verification.
-
-1. **`hideKeyboard` fails in the chat composer.** Maestro reports "Couldn't hide
-   the keyboard... app uses a custom input". Omit `hideKeyboard`; the "Send
-   message" button sits above the keyboard and the tap lands fine (contrast
-   with `maestro-tap-swallowed-by-ios-keyboard.md`, which covers taps *under*
-   the keyboard window).
-2. **Exact-typed `/exit` does not exit immediately.** The app shows a native
-   confirmation dialog "Exit session?" with buttons "Exit session" and
-   "Keep session running" ("This stops the running session but keeps its
-   history."). A flow must tap "Exit session" before asserting the
-   "Session exited" success toast.
-3. **`inputText: "/exit"` lands as `/exit ` (trailing space)** — the slash
-   suggestion UI commits a trailing space. Harmless: the composer parser
-   trims input before matching, so it still routes to `exit-session`.
-4. **Selecting a remote CLI instance collapses the new-session form** to just
-   "Run on" + "Start session" (`RemoteSpawnComposer`): model / mode / repo /
-   prompt are hidden by design, so no model selection or prompt typing step
-   exists for remote CLI spawns. The session composer later shows the CLI's
-   own model (observed "Auto Efficient").
-5. **Instance row label format**: the Run-on sheet rows are
-   `<Host> on <worktree>` (e.g. `Igor-MacBook.local on remote-cli-69f6`)
-   while the collapsed form value is `Run on: <Host> · <worktree>` (`·`
-   separator). Maestro `text:` matching is full-string — match the exact
-   label including the separator.
-6. After a successful exit the app routes to the Agents tab; the exited
-   session stays listed ("... from CLI" row). Assert "New session" visible +
-   `assertNotVisible` "Session owner changed" and "Try again" to prove the
-   Defect-A regression is gone.
diff --git a/.kilo_workflow/learnings/maestro-takescreenshot-output-dir.md b/.kilo_workflow/learnings/maestro-takescreenshot-output-dir.md
deleted file mode 100644
index d12f634265..0000000000
--- a/.kilo_workflow/learnings/maestro-takescreenshot-output-dir.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# maestro takeScreenshot output location (iOS, Maestro 2.7.0)
-
-Symptom: `takeScreenshot: <name>` in a flow does NOT write to the process cwd.
-Cause: Maestro writes to `~/.maestro/tests/<yyyy-MM-dd_HHmmss>/<flow-name>/takeScreenshot/<name>.png`.
-Fix: after the flow, `cp` from that directory; find with
-`find ~/.maestro/tests -name "<name>.png" -newer <flow-file>`.
-Related: `mobile-maestro-ios-driver-timeout-stale-xcodebuild.md` — never let a
-shell-tool timeout kill `maestro test` mid-wait; confirmed again 2026-07-28
-(load avg 650+, wedge needed sim shutdown/boot + one driver-check retry).
diff --git a/.kilo_workflow/learnings/maestro-tap-swallowed-by-ios-keyboard.md b/.kilo_workflow/learnings/maestro-tap-swallowed-by-ios-keyboard.md
deleted file mode 100644
index e9de535ad5..0000000000
--- a/.kilo_workflow/learnings/maestro-tap-swallowed-by-ios-keyboard.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# mobile: Maestro reports a tap COMPLETED that the iOS keyboard swallowed
-
-Symptom: a flow taps a button, Maestro logs `Tap on "<label>"... COMPLETED`, and nothing happens — the next `assertVisible` times out with Maestro's generic "this could be a real regression" advice, sending the reader after a product bug that does not exist. Typing into the field above the button worked, so the screen looks healthy in the failure screenshot.
-
-Cause: Maestro taps an element's **centre**, and iOS delivers any touch inside `UIRemoteKeyboardWindow` to the keyboard, not to the app. A control that is only partly covered by the keyboard therefore looks tappable and is not: the keyboard window's frame starts a few points above the visible keys, so a centre that clears the keys by a couple of points still lands in it. Maestro cannot see this — it gets no hit-test result back.
-
-Verify it in two commands, both cheap:
-
-```bash
-apps/mobile/e2e/maestro.sh <udid> hierarchy  # control centre vs the keyboard window's top bound
-grep -E "Tapping [0-9]" ~/.maestro/tests/<run>/<flow>/logs/device-xctest.log
-grep -A2 "Sending UIEvent" ~/.maestro/tests/<run>/<flow>/logs/device-simulator.log
-```
-
-The simulator log names the receiving window verbatim — `to window: <UIRemoteKeyboardWindow: 0x…>` is proof the app never saw the touch, `<UIWindow…>` (the app's) means look elsewhere.
-
-Because the margin is a handful of points on a centred layout, this is device-model dependent: the same flow passes on a taller simulator and fails on a shorter one, which reads as "it used to work" when the pool hands out a different iPhone.
-
-Fix: keep the control clear of the keyboard in the product (a root `KeyboardAvoidingView` on iOS, not `automaticallyAdjustKeyboardInsets` — that only makes the ScrollView scrollable, it never scrolls, and iOS auto-reveals only the focused field). Do not work around it in the flow with pasteboard tricks or coordinate taps; assert the reachable state instead, and never read a swallowed tap as a product regression.
diff --git a/.kilo_workflow/learnings/mobile-android-a11y-bounds-clamped-to-viewport.md b/.kilo_workflow/learnings/mobile-android-a11y-bounds-clamped-to-viewport.md
index 62f6edb8fc..cf27ea0eb4 100644
--- a/.kilo_workflow/learnings/mobile-android-a11y-bounds-clamped-to-viewport.md
+++ b/.kilo_workflow/learnings/mobile-android-a11y-bounds-clamped-to-viewport.md
@@ -1,6 +1,6 @@
 # mobile: Android a11y bounds are clamped to the visible viewport — clip probes need pixels or control offsets
 
-Symptom: on Android, `maestro hierarchy` bounds for a partially off-screen React Native
+Symptom: on Android, a11y hierarchy bounds for a partially off-screen React Native
 card report only the VISIBLE band (clamped at the screen's content edge, e.g. y=444 on a
 2560px-tall emulator), unlike iOS which reports window/content coordinates past the edge.
 Consequences for E2E geometry probes:
@@ -9,7 +9,10 @@ Consequences for E2E geometry probes:
   the card "stuck" at the edge value. Compute the true top from a child control's reported
   offset (PR-review thread cards: control row sits ~35px below the card's true top).
 - Taps on a control whose band is clamped to a few px (e.g. reported `[72,444][775,453]`)
-  are unreliable and usually miss — Maestro and ADB/uiautomator taps alike.
+  are unreliable and usually miss — driver and ADB/uiautomator taps alike.
+- The Expand/Collapse control DISAPPEARS from the dump when its true bounds are fully above
+  the clamp edge — a missing control is itself evidence the header is off-screen. Treat the
+  raw `adb uiautomator dump` as ground truth for which rows are truly on screen.
 - Zero-motion assertions remain valid with clamped bands: if neither the card's true rect
   nor the viewport moved, the clamped band is byte-identical; any true motion changes it.
 
diff --git a/.kilo_workflow/learnings/mobile-android-maestro-flow-pitfalls.md b/.kilo_workflow/learnings/mobile-android-maestro-flow-pitfalls.md
deleted file mode 100644
index 42adab9705..0000000000
--- a/.kilo_workflow/learnings/mobile-android-maestro-flow-pitfalls.md
+++ /dev/null
@@ -1,24 +0,0 @@
-# mobile-android-maestro-flow-pitfalls
-
-Symptom: a Maestro iteration flow on Android fails or hangs in ways the exit
-code does not reveal.
-
-Cause/fix (three independent traps, all hit in the hermes-mem baseline round):
-1. `maestro test` exits 0 even when a flow assertion FAILED (observed on
-   maestro 2.7.0, Android). `apps/mobile/e2e/maestro.sh` checks the JUnit result
-   and returns nonzero; always use it.
-2. Maestro text matching is full-string regex: the Agents list search field is
-   `Search sessions...` (with ellipsis), so `visible: 'Search sessions'` never
-   matches. Use `Search sessions.*` (and generally re-dump and copy exact
-   strings after any UI change).
-3. Under parallel-workflow host load (load avg >100) a cold dev-client launch
-   can sit on a blank Compose splash for 3-15 min and the emulator throws
-   `Process system isn't responding` ANR dialogs. `open-app.yaml`'s 30 s wait
-   is too short. A verifier temp flow needs: a 420 s launch wait, a
-   `.*isn.t responding.*` → `tapOn: 'Wait'` handler after the launch wait and
-   after settle, and 60-120 s waits for list/transcript asserts. `dumpsys
-   meminfo` itself can hit its 10 s service timeout under load — retry it.
-
-Screenshots: `pnpm dev:mobile:android adb -s <serial> exec-out screencap -p >
-"$SCRATCH/shot.png"` writes wherever you point it — no `~/.maestro/tests` hunt like on iOS
-(`maestro-takescreenshot-output-dir.md`).
diff --git a/.kilo_workflow/learnings/mobile-e2e-android-a11y-phantom-expanded-band.md b/.kilo_workflow/learnings/mobile-e2e-android-a11y-phantom-expanded-band.md
deleted file mode 100644
index 6b0e4f38a4..0000000000
--- a/.kilo_workflow/learnings/mobile-e2e-android-a11y-phantom-expanded-band.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# mobile: Android Maestro hierarchy invents phantom-tall bounds for clamped expanded cards — verify with uiautomator text rows
-
-Symptom: after expanding a PR-review thread whose header flew off-screen, `maestro
-hierarchy` reports the card as e.g. `[37,444][1043,1496]` (a 1052px-tall band starting at
-the a11y clamp edge), suggesting the card is merely clamped at top. `adb uiautomator dump`
-on the same screen shows the truth: the card's tail (last comment + Reply row) ends ~y510
-and the next thread starts at y520 — the reported 1052px band is phantom.
-
-Consequence: never read expand-state or card geometry from Maestro bounds once the a11y
-clamp (y=444 on pixel9 API35) is involved. The reliable probes:
-
-- `adb shell uiautomator dump /sdcard/window.xml` — text rows keep true y per visible row;
-  a thread's title ABSENT from the dump means its header is off-screen (the flow-4 failure
-  signature). Identify which expanded thread a clamped tail belongs to by matching its
-  comment text against the fixture (`grep body: server.mjs`), not by position.
-- The thread's Expand/Collapse control DISAPPEARS from both dumps when its true bounds are
-  fully above the clamp edge — a missing control is itself evidence the header is off-screen.
-
-Tap geometry note (Android, same runs): the expand pressable is the title row — its band is
-title-text-top +20 to +63 (e.g. title y555 → tappable ~555-598). Taps even ~10px below the
-band hit the badge/meta row and silently do nothing; derive the tap point from the CURRENT
-uiautomator title row (+35/+50), never from a stale dump or a previous thread's offsets.
diff --git a/.kilo_workflow/learnings/mobile-e2e-drag-cancel-race-instrument-timing.md b/.kilo_workflow/learnings/mobile-e2e-drag-cancel-race-instrument-timing.md
index d043bb1d58..87fe1b5236 100644
--- a/.kilo_workflow/learnings/mobile-e2e-drag-cancel-race-instrument-timing.md
+++ b/.kilo_workflow/learnings/mobile-e2e-drag-cancel-race-instrument-timing.md
@@ -1,4 +1,4 @@
-# mobile: D3 drag-cancel race (7b) — iOS drag NEVER lands mid-settle with Maestro; Android adb combined instrument works
+# mobile: D3 drag-cancel race (7b) — iOS drag NEVER lands mid-settle through the driver; Android adb combined instrument works
 
 Symptom: verifying "drag the list mid-settle cancels the deferred expand" (D3 guard). Tap a
 top-clipped thread's expander, then swipe. The thread expands anyway. On iOS this is NOT a
@@ -6,8 +6,8 @@ product defect and NOT (as an earlier version of this learning claimed) a drag t
 in time".
 
 Cause, measured on-device 2026-07-29 (pr-review-d957 r4, iOS 26.5 sim): the deferred settle
-completes in **~316ms** (scrollToIndex animated park + promise resolution). Maestro's
-tap→swipe turnaround in ONE flow file is **~700ms+** on iOS. The drag's `onScrollBeginDrag`
+completes in **~316ms** (scrollToIndex animated park + promise resolution). A driver's
+tap→swipe turnaround (HTTP round trips between commands) is **~700ms+** on iOS. The drag's `onScrollBeginDrag`
 arrives ~400ms AFTER the expansion applied; the "failure" is the product correctly
 expanding post-settle and the drag then scrolling the expanded list. r2's iOS 7b "pass" was
 the same artifact (the cancel verdict was luck, not mechanism).
@@ -23,8 +23,8 @@ Working instruments:
    (~30-50ms gap) on an UNclamped control (top > a11y clamp edge, e.g. y=444 on pixel9
    API35). Confirmed again in r4: drag landed 51ms into the settle, `match false`, thread
    stayed collapsed.
-2. iOS: NO sanctioned instrument lands mid-settle (simctl has no touch injection; a second
-   concurrent Maestro process wedges the driver). Report iOS 7b as instrument-blocked with
-   the trace, and rely on (a) the wiring trace (`invalidateSettle from drag` DOES fire for
-   real drags) plus (b) Android 7b for the cancel verdict. Do NOT classify an iOS expansion
-   after a Maestro tap→swipe as a product failure without the trace.
+2. iOS: NO sanctioned instrument lands mid-settle (simctl has no touch injection, and the
+   per-device wrapper lock prevents a second concurrent session by design). Report iOS 7b as
+   instrument-blocked with the trace, and rely on (a) the wiring trace (`invalidateSettle
+   from drag` DOES fire for real drags) plus (b) Android 7b for the cancel verdict. Do NOT
+   classify an iOS expansion after a driver tap→swipe as a product failure without the trace.
diff --git a/.kilo_workflow/learnings/mobile-e2e-ios-mvcp-suppress-toggle-blanks-list.md b/.kilo_workflow/learnings/mobile-e2e-ios-mvcp-suppress-toggle-blanks-list.md
index f20a057712..79018a7bca 100644
--- a/.kilo_workflow/learnings/mobile-e2e-ios-mvcp-suppress-toggle-blanks-list.md
+++ b/.kilo_workflow/learnings/mobile-e2e-ios-mvcp-suppress-toggle-blanks-list.md
@@ -21,10 +21,11 @@ more severe failure mode. Diagnose with a temporary console.log of
 settle-resolved, and +600ms post-expand (the D3R5 trace pattern, 7 anchored insertions in
 `pr-review-discussion-tab.tsx`); the -997949 offset is the smoking gun. Verify blank vs
 flown with a screenshot pixel scan (uniform (251,250,245) below the chrome = blank) plus
-`maestro hierarchy` showing no `Discussion thread` rows.
+the driver hierarchy showing no `Discussion thread` rows.
 
 iOS tap gotcha recorded on the same runs: coordinate taps at y ≤ ~182pt just under the PR
-screen's tab chrome are silently swallowed (Maestro logs COMPLETED, handler never runs);
+screen's tab chrome are silently swallowed (the driver reports delivery, the handler never runs —
+see `ios-tap-swallowed-by-keyboard.md`);
 taps at y ≥ 187pt land. Place clipped-thread expand taps at ≥ y190pt.
 
 Fix direction for the product (not applied): do not toggle `disabled` around the commit on
diff --git a/.kilo_workflow/learnings/mobile-e2e-maestro-concurrent-commands-driver-timeout.md b/.kilo_workflow/learnings/mobile-e2e-maestro-concurrent-commands-driver-timeout.md
deleted file mode 100644
index 3b5a30054d..0000000000
--- a/.kilo_workflow/learnings/mobile-e2e-maestro-concurrent-commands-driver-timeout.md
+++ /dev/null
@@ -1,24 +0,0 @@
-# mobile: never run two maestro commands concurrently on one UDID; screenshot loops finish before maestro's slow startup
-
-Symptom: `IOSDriverTimeoutException: iOS driver not ready in time` mid-run on iOS when a
-background `maestro test` (tap) overlapped a `maestro hierarchy` started 1.5s later on the
-same simulator. Two XCUITest channels on one UDID wedge the driver.
-
-Recovery: kill only the stale `xcodebuild test-without-building` PID bound to the UDID
-(see `mobile-maestro-ios-driver-timeout-kill-stale-only.md`); app state, scroll position,
-and login all survive. Retry with `MAESTRO_DRIVER_STARTUP_TIMEOUT=300000`.
-
-Second, related timing fact (iOS, machine under parallel-workflow load): maestro's JVM +
-driver startup takes 15-25+s before the tap lands. A `xcrun simctl io screenshot` loop
-(10-30 shots, ~0.5s each) started concurrently with the tap command ALWAYS finishes before
-the tap lands — every frame is pre-tap. Timed screenshot/hierarchy capture of sub-second
-windows (e.g. an 800ms probe delay) is not achievable this way, and concurrent maestro
-for the window is what causes the timeout above.
-
-What works instead: instrument the app with temporary `console.log` probes (captured from
-`pnpm dev:capture mobile`), take hierarchy dumps at leisure before and after the
-interaction, and DERIVE mid-window screen geometry from the logged scroll values:
-screen_y = (layoutY + firstItemOffset) - absoluteLastScrollOffset + K, where K (the
-screen-y of the list viewport's content-top edge) is calibrated from a moment where both a
-hierarchy bound and the logged offsets are known. On pr-review-d957 iOS K=367, confirmed
-within ±1.3pt at five independent moments across three runs and scroll regions.
diff --git a/.kilo_workflow/learnings/mobile-e2e-top-clip-positioning-flashlist-clamp.md b/.kilo_workflow/learnings/mobile-e2e-top-clip-positioning-flashlist-clamp.md
index d2808fda8a..ba47e65583 100644
--- a/.kilo_workflow/learnings/mobile-e2e-top-clip-positioning-flashlist-clamp.md
+++ b/.kilo_workflow/learnings/mobile-e2e-top-clip-positioning-flashlist-clamp.md
@@ -12,15 +12,15 @@ Cause: two independent constraints.
    y228 until page 2 was loaded via "Load more" — r1's own flow-4 setup dump shows page-2
    threads (zeta/eta) already loaded for the same reason. On Android (2424px), zeta could
    not be clipped until theta (below it) was expanded, adding ~850px below.
-2. Short Maestro swipes (<~10% of screen height, e.g. 1-6%) are silently ignored on both
+2. Short swipes (<~10% of screen height, e.g. 1-6%) are silently ignored on both
    platforms (velocity/distance below the scroll-recognition threshold); hierarchy bounds
    stay byte-identical. Do not retry them in a loop — they never land.
 
 Working sequence per platform:
 - Load page 2 first (`scrollUntilVisible` 'Load more comments' + tap), or expand a thread
   below the target to grow content.
-- Approach with 30% Maestro swipes, one command at a time with a hierarchy probe between
-  (back-to-back commands after big swipes get ignored intermittently).
+- Approach with 30% swipes, one gesture at a time with a hierarchy probe between
+  (back-to-back gestures after big swipes get ignored intermittently).
 - Final 40-100px positioning: iOS — a 6-8% swipe usually lands once the clamp is released;
   Android — `adb shell input swipe x y1 x y2 300` works reliably but ONLY once the offset
   can grow (it is also clamped, not broken).
diff --git a/.kilo_workflow/learnings/mobile-file-navigator-sheet-clipped-ios26.md b/.kilo_workflow/learnings/mobile-file-navigator-sheet-clipped-ios26.md
index 4d72bd02d3..da0458434a 100644
--- a/.kilo_workflow/learnings/mobile-file-navigator-sheet-clipped-ios26.md
+++ b/.kilo_workflow/learnings/mobile-file-navigator-sheet-clipped-ios26.md
@@ -1,7 +1,7 @@
 # mobile: file-navigator formSheet renders clipped on iOS 26 simulator — filter unreachable visually
 
-Symptom: the PR-review file-navigator sheet (`/(app)/pr-review/[o]/[r]/[n]/file-navigator`, opened via the Files tab "Open file navigator" header or a deep link) shows ONLY the file rows under the grabber — the ScreenHeader, the "Filter files by path" input, and the viewed-counter are not on screen. Yet the a11y tree CONTAINS the filter (Maestro `extendedWaitUntil`/`tapOn` on 'Filter files by path' succeed), and row bounds overlap the grabber bounds (e.g. row1 y=466 vs grabber 455–479), i.e. the content is laid out shifted up, top section clipped. A tap on the filter's a11y frame lands on whatever is visually at those coordinates (it expanded a file row on the underlying tab).
+Symptom: the PR-review file-navigator sheet (`/(app)/pr-review/[o]/[r]/[n]/file-navigator`, opened via the Files tab "Open file navigator" header or a deep link) shows ONLY the file rows under the grabber — the ScreenHeader, the "Filter files by path" input, and the viewed-counter are not on screen. Yet the a11y tree CONTAINS the filter (driver waits/taps on 'Filter files by path' succeed), and row bounds overlap the grabber bounds (e.g. row1 y=466 vs grabber 455–479), i.e. the content is laid out shifted up, top section clipped. A tap on the filter's a11y frame lands on whatever is visually at those coordinates (it expanded a file row on the underlying tab).
 
-Cause: unresolved — same iOS 26 RN sheet/Modal presentation family as `mobile-ios26-maestro-under-load.md` (a11y/pixel divergence). Not caused by the `leading-[normal]` sweep: the clipped region includes non-input chrome (header, counter) and the sweep only removes TextInput lineHeight. Reproduced on both the deep-link and the UI paths on head 3a29c371f.
+Cause: unresolved — an iOS 26 RN sheet/Modal presentation-family a11y/pixel divergence (the hierarchy contains chrome that is not on screen). Not caused by the `leading-[normal]` sweep: the clipped region includes non-input chrome (header, counter) and the sweep only removes TextInput lineHeight. Reproduced on both the deep-link and the UI paths on head 3a29c371f.
 
 Fix: none found this round. Visual verification of the navigator filter placeholder baseline/clipping is impossible while the clip persists; future rounds should check whether a full detent, a real device, or an iOS 18 simulator renders the sheet fully.
diff --git a/.kilo_workflow/learnings/mobile-ios-maestro-session-row-and-back.md b/.kilo_workflow/learnings/mobile-ios-maestro-session-row-and-back.md
deleted file mode 100644
index 3a0311611a..0000000000
--- a/.kilo_workflow/learnings/mobile-ios-maestro-session-row-and-back.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# mobile-ios-maestro-session-row-and-back
-
-Symptom: on iOS, a Maestro flow that matches the Agents session row and navigates
-back fails two ways: (1) `visible: '<session title>'` never matches even though the
-row renders; (2) the `back` command does not leave a pushed session-detail screen.
-
-Cause: iOS exposes the session row as ONE accessibility element whose label is the
-comma-joined summary (`Hermes-mem-c716 baseline session setup, CLOUD, cost 5 cents,
-6 hours ago, from CLI`), not the bare title; and Maestro's `back` is a no-op on this
-pushed screen — the app renders an explicit `Go back` accessibility element instead.
-
-Fix: match with a prefix regex (`'<title>,.*'`) and tap `Go back` to return. Also
-make reruns self-normalizing: start with an optional `Go back` tap and a
-Home-tab gate before driving tabs.
-
-Bonus zsh trap: `"$CLI:relay"` expands as `$CLI` with zsh's `:r` modifier plus
-literal `elay` (target becomes `<session>elay`, tmux "can't find pane"). Always
-brace: `"${CLI}:relay"`.
diff --git a/.kilo_workflow/learnings/mobile-ios-simulator-e2e-limitations.md b/.kilo_workflow/learnings/mobile-ios-simulator-e2e-limitations.md
index 14601a930b..ac30b60ce2 100644
--- a/.kilo_workflow/learnings/mobile-ios-simulator-e2e-limitations.md
+++ b/.kilo_workflow/learnings/mobile-ios-simulator-e2e-limitations.md
@@ -4,7 +4,7 @@ Symptom: an E2E flow stalls typing into a composer, waits forever for speech rec
 
 Cause: simulator and environment limits, verified on iPhone 17 / iOS 26.5:
 
-- The software keyboard stays hidden while the simulator's hardware-keyboard setting is on, so Maestro cannot tap keys. The session-detail composer also resists programmatic focus.
+- The software keyboard stays hidden while the simulator's hardware-keyboard setting is on, so automation cannot tap keys. The session-detail composer also resists programmatic focus.
 - The speech recognizer never reaches `listening` on a simulator — voice flows cannot be driven end to end.
 - Notification banners cannot be screenshot: the simulator lacks notification authorization for pixel-level banner capture.
 - Real push delivery (and tap-through) requires `EXPO_ACCESS_TOKEN` in the environment; without it only the deterministic in-app UI and session behaviors are testable.
diff --git a/.kilo_workflow/learnings/mobile-ios-text-size-slider-maestro-swipe.md b/.kilo_workflow/learnings/mobile-ios-text-size-slider-maestro-swipe.md
deleted file mode 100644
index 82eb1b83b7..0000000000
--- a/.kilo_workflow/learnings/mobile-ios-text-size-slider-maestro-swipe.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# iOS Settings text-size slider: reliable Maestro swipe technique
-
-Symptom: restoring Settings > Display & Brightness > Text Size from 100% (XXXL) back to the
-default via Maestro swipe keeps failing — swipes from the right edge (91%/98% starts) and track
-taps do not move the thumb.
-
-Cause: at 100% the slider thumb sits at roughly 78% of track width, not at the right edge; a swipe
-that starts right of the thumb grabs empty track. Taps on the track do not reposition this slider.
-
-Fix: swipe with unquoted integer percentages (Maestro 2.7.0 rejects quoted values), starting ON
-the thumb: `swipe: { start: 78%, 89% ... end: 10%, 89% }` style coordinates (adjust the y to the
-slider row), then verify visually with a screenshot — the a11y tree does not expose the slider
-value reliably. Same technique drives the slider up to 100% (start at the current thumb position,
-e.g. 50% for the L default).
diff --git a/.kilo_workflow/learnings/mobile-ios26-maestro-under-load.md b/.kilo_workflow/learnings/mobile-ios26-maestro-under-load.md
deleted file mode 100644
index 828afcadd5..0000000000
--- a/.kilo_workflow/learnings/mobile-ios26-maestro-under-load.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# mobile: iOS 26 + Maestro quirks under load
-
-Observed on iOS 26.5 sim + Maestro 2.7.0 with several sibling verifiers sharing the host. Related: `mobile-maestro-ios-driver-timeout-stale-xcodebuild.md` (driver wedge + reboot fix, including the no-xcodebuild variant).
-
-1. **Failed/killed Maestro flows leave the app at SpringBoard — and so can a flow-start `launchApp` right after a successful flow.** After any flow boundary, do not assume the app is still foreground: the next run's `launchApp` can bounce the dev client to the home screen (the first assert then fails; hierarchy shows only SpringBoard text like `Page 2 of 2` and icon labels). Recovery: a tiny scratch flow — `stopApp` → conditional `tapOn: {text: 'Kilo'}` (the home icon, never `launchApp`) → `extendedWaitUntil` a known element of the previous screen (route persistence restores it) — then rerun the real flow. Gate every follow-on flow on a known element rather than rerunning it blindly.
-2. **iOS 26 software keyboard has no `space` a11y label.** `assertVisible: 'space'` fails even with the keyboard fully up. Verify keyboard-up via `return`, `delete`, `numbers`, or letter keys instead. The hardware-keyboard plist fix (`mobile-ios-simulator-e2e-limitations.md`) survives `simctl shutdown/boot`.
-3. **RN Modal a11y tree intermittently collapses to keyboard-only under load.** With a native Modal visibly open and focused, the XCTest hierarchy can show only keyboard keys + status bar; `Cancel`/`Save` taps by text fail. Working fallback: extract the buttons' `bounds` from an earlier same-screen hierarchy dump and `tapOn: { point: "x,y" }` (points, verified consistent with screenshot scale). Text input still works: the modal auto-focuses the field on open, so `eraseText`/`inputText` need no element tap.
-4. **Maestro text assertions are full-string, not substring.** `assertVisible: 'Context'` fails against a header titled `Context usage` — assert the full visible string (or a regex), never a fragment. A failed assert of this kind is a flow bug, not a product regression.
-5. **Point taps reject decimal percentages.** `NumberFormatException: For input string: "34.4"` — use absolute coordinates (`"201,301"`) or integer percents.
diff --git a/.kilo_workflow/learnings/mobile-maestro-childof-fails-flat-a11y-tree.md b/.kilo_workflow/learnings/mobile-maestro-childof-fails-flat-a11y-tree.md
deleted file mode 100644
index 92da06fc5e..0000000000
--- a/.kilo_workflow/learnings/mobile-maestro-childof-fails-flat-a11y-tree.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# mobile: Maestro childOf never matches RN a11y cards on iOS — tap by bounds-derived point
-
-Symptom: `tapOn: {text: 'Expand thread', childOf: {text: 'Discussion thread src/gamma.ts L33 (RIGHT)'}}`
-fails with "Element not found: Text matching regex: Expand thread", while `maestro hierarchy`
-clearly shows both labels on screen.
-
-Cause: in Maestro's flattened iOS a11y tree, a RN View with `accessibilityLabel` (the thread card)
-and the Pressables INSIDE it (`Expand thread`, `Unresolve thread`) are SIBLINGS at the same depth,
-not parent/descendant — verified by walking the hierarchy JSON. `childOf` finds zero parents, and
-the error misleadingly names the child selector.
-
-Fix: parse `maestro --device <udid> hierarchy` output — every element carries `bounds` as
-`[x1,y1][x2,y2]` — and `tapOn: {point: <center-x>,<center-y>}`. Verify positions with a fresh
-hierarchy dump immediately before the point tap; positions were stable across repeated dumps.
-
-Second trap: taps whose y is under the app's fixed header chrome are silently swallowed — Maestro
-logs COMPLETED but nothing happens (same signature as the keyboard swallow). On the PR-review
-screen the tab selector row ends at y≈166 (iPhone 17 Pro) and the effective dead zone extends to
-about y≈178-180; a tap at y=174 was eaten, y=180 worked. When positioning a row for a header tap,
-leave its control at y≳185; a collapsed thread card's expand control sits only 13pt below the card
-top, so a "partially clipped at the list top" card's control is always inside the dead zone.
-
-Also: Maestro text matching treats the pattern as regex — literal parens in labels like
-`L33 (RIGHT)` still MATCH because the matching is not strict full-string in every code path
-(`scrollUntilVisible` found the element with the unescaped pattern).
diff --git a/.kilo_workflow/learnings/mobile-maestro-ios-driver-timeout-kill-stale-only.md b/.kilo_workflow/learnings/mobile-maestro-ios-driver-timeout-kill-stale-only.md
deleted file mode 100644
index fa4e091956..0000000000
--- a/.kilo_workflow/learnings/mobile-maestro-ios-driver-timeout-kill-stale-only.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# mobile: IOSDriverTimeoutException — killing ONLY the stale xcodebuild sufficed (no sim reboot)
-
-Update to `mobile-maestro-ios-driver-timeout-stale-xcodebuild.md` (which prescribes
-kill xcodebuild + `simctl shutdown && boot`).
-
-Observed 2026-07-29 (pr-review-d957 repro run, sibling section thrashing Maestro driver restarts
-on their own UDID every ~8s): `IOSDriverTimeoutException: iOS driver not ready in time` mid-run.
-`ps aux | grep "xcodebuild test-without-building" | grep <UDID>` showed exactly one stale driver
-bound to my UDID. Killing just that PID (no simulator shutdown, no reboot) and retrying with
-`MAESTRO_DRIVER_STARTUP_TIMEOUT=300000` recovered immediately — app state, scroll position, and
-login all survived, so the in-flight E2E probe sequence continued without re-navigation.
-
-Try the kill-only path first; keep the learning's shutdown+boot as the fallback when the driver
-still won't come up.
diff --git a/.kilo_workflow/learnings/mobile-maestro-ios-driver-timeout-stale-xcodebuild.md b/.kilo_workflow/learnings/mobile-maestro-ios-driver-timeout-stale-xcodebuild.md
deleted file mode 100644
index 8291337db2..0000000000
--- a/.kilo_workflow/learnings/mobile-maestro-ios-driver-timeout-stale-xcodebuild.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# mobile: Maestro IOSDriverTimeoutException under multi-simulator load
-
-Symptom: every Maestro command against a claimed iOS simulator fails with `xcuitest.installer.LocalXCTestInstaller$IOSDriverTimeoutException: iOS driver not ready in time`, even with `MAESTRO_DRIVER_STARTUP_TIMEOUT=300000`; `simctl openurl` may also time out (`NSPOSIXErrorDomain code=60`).
-
-Cause: a stale `xcodebuild test-without-building` process left bound to the UDID after a killed Maestro run, compounded by several same-type simulators booted by sibling worktrees.
-
-Fix: stop the round, run `.kilo_workflow/e2e-stop-resource.sh ios`, then free its E2E slot. The simulator wrapper shuts down only a device the worktree claim booted; never kill `xcodebuild` or run `simctl shutdown` by hand. Redispatch fresh, take a slot, and validate through `apps/mobile/e2e/maestro.sh`.
-
-Variant — no stale xcodebuild at all (observed 2026-07-28, load avg 45+): the same `IOSDriverTimeoutException` after a killed Maestro run, but no matching xcodebuild exists — the driver wedged under load. The same release-and-redispatch recovery applies. Size command timeouts above the flow's worst case so the harness does not kill Maestro mid-wait.
diff --git a/.kilo_workflow/learnings/mobile-maestro-swipe-eaten-by-sticky-header-overlay.md b/.kilo_workflow/learnings/mobile-maestro-swipe-eaten-by-sticky-header-overlay.md
deleted file mode 100644
index 05011437c4..0000000000
--- a/.kilo_workflow/learnings/mobile-maestro-swipe-eaten-by-sticky-header-overlay.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# mobile: Maestro `direction: DOWN` swipe is eaten by a sticky FlashList header overlay
-
-Symptom: on a list with `stickyHeaderIndices` (PR-review Files tab), swipes that scroll
-content DOWN (offset decreases, e.g. `direction: DOWN` or start≈30% end≈70%) silently do
-nothing — Maestro logs COMPLETED, hierarchy is byte-identical. Up-swipes work fine.
-
-Cause: FlashList's StickyHeaders overlay is an absolute-positioned sibling ON TOP of the
-list, not part of the scroll content. A gesture starting inside the overlay's frame (on the
-PR Files screen it sits at the list top, y≈233-267 ≈ 27-30% of an 874pt screen) does not
-scroll the list. Maestro's directional DOWN swipe starts near y≈30%, inside the overlay.
-
-Fix: use explicit-coordinate swipes whose start is below the overlay
-(`start: 50%, 40%` → `end: 50%, 75%`). Verify movement with a before/after hierarchy grep
-(bounds of a stable row). Note: real users dragging from the stuck header row hit the same
-non-scrollable strip — standard FlashList StickyHeaders behavior, not a defect to report
-unless the product wants drag-from-header scrolling.
diff --git a/.kilo_workflow/learnings/mobile-pr-review-deep-link-route.md b/.kilo_workflow/learnings/mobile-pr-review-deep-link-route.md
index 43421526fa..363e07ea6e 100644
--- a/.kilo_workflow/learnings/mobile-pr-review-deep-link-route.md
+++ b/.kilo_workflow/learnings/mobile-pr-review-deep-link-route.md
@@ -4,4 +4,4 @@ Symptom: `xcrun simctl openurl <udid> "exp+kilo-app://expo-development-client/?u
 
 Cause: the dev client treats the entire `url` param as the Metro packager root; a route path appended to it makes the manifest fetch 404. The dev client does not parse app routes out of the packager URL (Expo SDK 54 dev client, iOS).
 
-Fix: two-step navigation: (1) connect with the BARE Metro URL (`...?url=http%3A%2F%2F<ip>%3A<port>`), wait for `iOS Bundled`; (2) `xcrun simctl openurl <udid> "kiloapp://<route>"` (app scheme `kiloapp`, no SpringBoard confirmation). In a Maestro flow use `openLink: kiloapp://<route>` — but only after the app has finished cold-booting (gate on a restored-route element first; an openLink fired during boot is dropped).
+Fix: two-step navigation: (1) connect with the BARE Metro URL (`...?url=http%3A%2F%2F<ip>%3A<port>`), wait for `iOS Bundled`; (2) `xcrun simctl openurl <udid> "kiloapp://<route>"` (app scheme `kiloapp`, no SpringBoard confirmation). Drive the `kiloapp://<route>` link with `simctl openurl` (iOS) or `adb am start` (Android, see runbook "App Links") — but only after the app has finished cold-booting (gate on a restored-route element first; a link fired during boot is dropped).

From cc55cd822a47dde5dcd45ebec28e1a7b607ac9c0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 02:47:04 +0200
Subject: [PATCH 18/34] feat(e2e)!: remove the maestro wrapper and YAML flows

Replaced by appium.sh + flows/*.js earlier in this branch. BREAKING:
maestro.sh and the YAML flow files are gone.
---
 apps/mobile/e2e/flows/login-assert-home.yaml  |  5 --
 apps/mobile/e2e/flows/login-request-code.yaml | 33 -----------
 apps/mobile/e2e/flows/login-verify-code.yaml  | 37 -------------
 apps/mobile/e2e/flows/logout.yaml             | 51 -----------------
 apps/mobile/e2e/flows/open-app.js             | 24 +++++++-
 apps/mobile/e2e/flows/open-app.yaml           | 32 -----------
 apps/mobile/e2e/flows/settle-app.yaml         | 55 -------------------
 apps/mobile/e2e/maestro.sh                    | 44 ---------------
 8 files changed, 22 insertions(+), 259 deletions(-)
 delete mode 100644 apps/mobile/e2e/flows/login-assert-home.yaml
 delete mode 100644 apps/mobile/e2e/flows/login-request-code.yaml
 delete mode 100644 apps/mobile/e2e/flows/login-verify-code.yaml
 delete mode 100644 apps/mobile/e2e/flows/logout.yaml
 delete mode 100644 apps/mobile/e2e/flows/open-app.yaml
 delete mode 100644 apps/mobile/e2e/flows/settle-app.yaml
 delete mode 100755 apps/mobile/e2e/maestro.sh

diff --git a/apps/mobile/e2e/flows/login-assert-home.yaml b/apps/mobile/e2e/flows/login-assert-home.yaml
deleted file mode 100644
index eedb2ffeff..0000000000
--- a/apps/mobile/e2e/flows/login-assert-home.yaml
+++ /dev/null
@@ -1,5 +0,0 @@
-# Confirms the login helper's already-authenticated branch leaves the app on Home.
-appId: com.kilocode.kiloapp
----
-- tapOn: 'HOME|Home, tab, 1 of 4'
-- assertVisible: 'Good (morning|afternoon|evening)'
diff --git a/apps/mobile/e2e/flows/login-request-code.yaml b/apps/mobile/e2e/flows/login-request-code.yaml
deleted file mode 100644
index 4e9f4b2f5e..0000000000
--- a/apps/mobile/e2e/flows/login-request-code.yaml
+++ /dev/null
@@ -1,33 +0,0 @@
-# Login step 1/2 — request an email sign-in code.
-#
-# Establishes a signed-out baseline, then submits EMAIL to reach the "Enter the
-# code" screen. The 6-digit code is emailed to the local outbox
-# (dev/logs/emails/); read it there and pass it to login-verify-code.yaml.
-#
-#   apps/mobile/e2e/maestro.sh <udid> test -e EMAIL=e2e-mobile@example.com \
-#     e2e/flows/login-request-code.yaml
-#
-# EMAIL is required (-e). Do NOT add it as a flow-level `env:` default — a
-# default silently overrides the -e value in this Maestro version.
-#
-# Prefer the one-shot wrapper e2e/login.sh, which runs both steps and pulls the
-# code for you. See e2e/AGENTS.md ("Sign In and Out").
-appId: com.kilocode.kiloapp
----
-- runFlow: logout.yaml
-# Tap the input via its placeholder — the "Email address" label shares the
-# field's accessibility text and would match the (non-focusable) label.
-- tapOn: 'you@example.com'
-# The field is uncontrolled, so a login page left on screen by an earlier run
-# still holds its address, and `inputText` inserts at the caret the tap just
-# dropped mid-string — two attempts interleave into a malformed address.
-- eraseText: 100
-- inputText: ${EMAIL}
-# Fail here, immediately and legibly, instead of 15s later on a missing
-# "Verify code": a mismatch means typing landed in a field that was not empty.
-- assertVisible: ${EMAIL}
-- tapOn: 'Send sign-in code'
-# Wait for the code screen — sending is a network round-trip.
-- extendedWaitUntil:
-    visible: 'Verify code'
-    timeout: 15000
diff --git a/apps/mobile/e2e/flows/login-verify-code.yaml b/apps/mobile/e2e/flows/login-verify-code.yaml
deleted file mode 100644
index 1b26491855..0000000000
--- a/apps/mobile/e2e/flows/login-verify-code.yaml
+++ /dev/null
@@ -1,37 +0,0 @@
-# Login step 2/2 — verify the emailed sign-in code.
-#
-# Enters OTP on the "Enter the code" screen and lands on Home. Assumes
-# login-request-code.yaml already reached that screen.
-#
-#   apps/mobile/e2e/maestro.sh <udid> test -e OTP=123456 e2e/flows/login-verify-code.yaml
-#
-# Prefer the one-shot wrapper e2e/login.sh. See e2e/AGENTS.md.
-appId: com.kilocode.kiloapp
----
-- assertVisible: 'Verify code'
-- tapOn: 'Sign-in code'
-- eraseText: 6
-- inputText: ${OTP}
-# The number pad has no dismiss key; "Verify code" sits above it, so tap directly.
-- tapOn: 'Verify code'
-# A brand-new account's first sign-in shows a consent screen before Home.
-- extendedWaitUntil:
-    visible:
-      text: 'Accept and continue|“Kilo” Would Like to Send You Notifications|HOME|Home, tab, 1 of 4'
-    timeout: 20000
-- runFlow:
-    when:
-      visible: 'Accept and continue'
-    commands:
-      - tapOn: 'Accept and continue'
-- extendedWaitUntil:
-    visible: '“Kilo” Would Like to Send You Notifications|HOME|Home, tab, 1 of 4'
-    timeout: 15000
-- runFlow:
-    when:
-      visible: '“Kilo” Would Like to Send You Notifications'
-    commands:
-      - tapOn: 'Allow'
-- extendedWaitUntil:
-    visible: 'HOME|Home, tab, 1 of 4'
-    timeout: 15000
diff --git a/apps/mobile/e2e/flows/logout.yaml b/apps/mobile/e2e/flows/logout.yaml
deleted file mode 100644
index 1291e4dc85..0000000000
--- a/apps/mobile/e2e/flows/logout.yaml
+++ /dev/null
@@ -1,51 +0,0 @@
-# Logout helper — ends on the login page ("Welcome to Kilo Code").
-#
-# Idempotent: if the app is already signed out, it just lands on the login page.
-#
-#   apps/mobile/e2e/maestro.sh <udid> test e2e/flows/logout.yaml
-#
-# See e2e/AGENTS.md for the full workflow.
-appId: com.kilocode.kiloapp
----
-- runFlow:
-    when:
-      visible: 'Verify code'
-    commands:
-      - tapOn: 'Back'
-- runFlow:
-    when:
-      notVisible: 'Welcome to Kilo Code'
-    commands:
-      - runFlow:
-          when:
-            notVisible: 'HOME|Home, tab, 1 of 4'
-          commands:
-            - runFlow: settle-app.yaml
-# Booted into the consent gate (signed in, not consented) -> accept it to reach
-# Home, then sign out below.
-- runFlow:
-    when:
-      visible: 'Accept and continue'
-    commands:
-      - tapOn: 'Accept and continue'
-      - extendedWaitUntil:
-          visible: 'Home, tab, 1 of 4'
-          timeout: 15000
-# Signed in: Profile tab -> Sign Out -> confirm the native alert.
-- runFlow:
-    when:
-      notVisible: 'Welcome to Kilo Code'
-    commands:
-      - tapOn: 'Profile, tab, 4 of 4'
-      - scrollUntilVisible:
-          element: 'Sign Out'
-          direction: DOWN
-      - tapOn: 'Sign Out'
-      - assertVisible: 'Sign out?'
-      # The alert's confirm ("Sign out") and the screen button ("Sign Out")
-      # collide under Maestro's case-insensitive match; index 0 is the alert
-      # button (topmost by position).
-      - tapOn:
-          text: 'Sign out'
-          index: 0
-- assertVisible: 'you@example.com'
diff --git a/apps/mobile/e2e/flows/open-app.js b/apps/mobile/e2e/flows/open-app.js
index a7a6213af8..60d6c6b9d3 100644
--- a/apps/mobile/e2e/flows/open-app.js
+++ b/apps/mobile/e2e/flows/open-app.js
@@ -5,6 +5,11 @@ const { BUNDLE_ID } = require('../wdio/client');
 const settleApp = require('./settle-app');
 const S = require('./states');
 
+// Under parallel-workflow host load a cold Android launch can sit on a blank
+// splash for minutes and the emulator throws `Process system isn't responding`
+// ANR dialogs; answer Wait and keep waiting instead of failing the round.
+const ANR_DIALOG = /.*isn.t responding.*/;
+
 module.exports = async function openApp(ctx) {
   const { h, when } = ctx;
 
@@ -19,7 +24,22 @@ module.exports = async function openApp(ctx) {
   await h.stopApp(BUNDLE_ID);
   await h.launchApp(BUNDLE_ID);
 
-  // Cold launch and bundling are slow; wait for any known state before settling.
-  await h.waitVisible(S.ANY_STATE, { timeout: 30000 });
+  // Cold launch and bundling are slow; wait for any known state before
+  // settling. Android under load gets the long budget; it returns as soon as
+  // a state renders, so healthy runs never pay it.
+  const launchTimeout = ctx.platform === 'android' ? 420000 : 30000;
+  for (let anr = 0; ; anr++) {
+    try {
+      await h.waitVisible(S.ANY_STATE, { timeout: launchTimeout });
+      break;
+    } catch (err) {
+      if (anr < 3 && (await ctx.h.visible(ANR_DIALOG))) {
+        await h.tapOn('Wait');
+        continue;
+      }
+      throw err;
+    }
+  }
+  await when(ctx, ANR_DIALOG, () => h.tapOn('Wait'));
   await settleApp(ctx);
 };
diff --git a/apps/mobile/e2e/flows/open-app.yaml b/apps/mobile/e2e/flows/open-app.yaml
deleted file mode 100644
index 487e8ba4bc..0000000000
--- a/apps/mobile/e2e/flows/open-app.yaml
+++ /dev/null
@@ -1,32 +0,0 @@
-# Standalone cold-launch flow: clears any prompt left on screen, relaunches the
-# dev client from SpringBoard, waits for it to render a known state, then
-# delegates prompt handling to settle-app.yaml.
-appId: com.kilocode.kiloapp
----
-- runFlow:
-    when:
-      visible: 'Ask App Not to Track'
-    commands:
-      - tapOn: 'Ask App Not to Track'
-- runFlow:
-    when:
-      visible: 'This is the developer menu.*'
-    commands:
-      - tapOn: 'Continue'
-- runFlow:
-    when:
-      visible: 'Fast Refresh|Element Inspector'
-    commands:
-      - tapOn: 'Close'
-- stopApp
-- runFlow:
-    when:
-      visible: 'Kilo'
-    commands:
-      - tapOn:
-          text: 'Kilo'
-# Cold launch and bundling are slow; wait for any known state before settling.
-- extendedWaitUntil:
-    visible: 'Open this page in "Kilo"\?|Open in ["“”]Kilo["“”]\?|Allow “Kilo” to track your activity across other companies’ apps and websites\?|Ask App Not to Track|This is the developer menu.*|Fast Refresh|Element Inspector|“Kilo” Would Like to Send You Notifications|HOME|Home, tab, 1 of 4|Welcome to Kilo Code|Accept and continue'
-    timeout: 30000
-- runFlow: settle-app.yaml
diff --git a/apps/mobile/e2e/flows/settle-app.yaml b/apps/mobile/e2e/flows/settle-app.yaml
deleted file mode 100644
index 1240094ecb..0000000000
--- a/apps/mobile/e2e/flows/settle-app.yaml
+++ /dev/null
@@ -1,55 +0,0 @@
-# Settles an already-running app: handles the Safari external-app prompt and
-# the SpringBoard custom-scheme confirmation (`Open in "Kilo"?`, shown by
-# `simctl openurl` since universal links were configured), the tracking prompt,
-# Expo developer-menu introduction and menu, and notification permission,
-# ending on Home, the login page, or the consent gate. Never restarts the app;
-# open-app.yaml is the cold-launch wrapper around this flow.
-appId: com.kilocode.kiloapp
----
-- extendedWaitUntil:
-    visible: 'Open this page in "Kilo"\?|Open in ["“”]Kilo["“”]\?|Allow “Kilo” to track your activity across other companies’ apps and websites\?|Ask App Not to Track|This is the developer menu.*|Fast Refresh|Element Inspector|“Kilo” Would Like to Send You Notifications|HOME|Home, tab, 1 of 4|Welcome to Kilo Code|Accept and continue'
-    timeout: 15000
-- extendedWaitUntil:
-    visible: 'Open this page in "Kilo"\?|Open in ["“”]Kilo["“”]\?|Ask App Not to Track|This is the developer menu.*|Fast Refresh|Element Inspector|“Kilo” Would Like to Send You Notifications'
-    timeout: 3000
-    optional: true
-- runFlow:
-    when:
-      visible: 'Open this page in "Kilo"\?|Open in ["“”]Kilo["“”]\?'
-    commands:
-      - tapOn: 'Open'
-- extendedWaitUntil:
-    visible: 'Ask App Not to Track|This is the developer menu.*|Fast Refresh|Element Inspector|“Kilo” Would Like to Send You Notifications|HOME|Home, tab, 1 of 4|Welcome to Kilo Code|Accept and continue'
-    timeout: 5000
-- runFlow:
-    when:
-      visible: 'Ask App Not to Track'
-    commands:
-      - tapOn: 'Ask App Not to Track'
-- extendedWaitUntil:
-    visible: 'This is the developer menu.*|Fast Refresh|Element Inspector|“Kilo” Would Like to Send You Notifications|HOME|Home, tab, 1 of 4|Welcome to Kilo Code|Accept and continue'
-    timeout: 5000
-- runFlow:
-    when:
-      visible: 'This is the developer menu.*'
-    commands:
-      - tapOn: 'Continue'
-- extendedWaitUntil:
-    visible: 'Fast Refresh|Element Inspector|“Kilo” Would Like to Send You Notifications|HOME|Home, tab, 1 of 4|Welcome to Kilo Code|Accept and continue'
-    timeout: 5000
-- runFlow:
-    when:
-      visible: 'Fast Refresh|Element Inspector'
-    commands:
-      - tapOn: 'Close'
-- extendedWaitUntil:
-    visible: '“Kilo” Would Like to Send You Notifications|HOME|Home, tab, 1 of 4|Welcome to Kilo Code|Accept and continue'
-    timeout: 5000
-- runFlow:
-    when:
-      visible: '“Kilo” Would Like to Send You Notifications'
-    commands:
-      - tapOn: 'Allow'
-- extendedWaitUntil:
-    visible: 'HOME|Home, tab, 1 of 4|Welcome to Kilo Code|Accept and continue'
-    timeout: 15000
diff --git a/apps/mobile/e2e/maestro.sh b/apps/mobile/e2e/maestro.sh
deleted file mode 100755
index 1ef5cdde2e..0000000000
--- a/apps/mobile/e2e/maestro.sh
+++ /dev/null
@@ -1,44 +0,0 @@
-#!/usr/bin/env bash
-# Serialize Maestro per device and turn its JUnit result into a trustworthy exit
-# code. `--exec` holds the same device lock around a multi-command helper.
-set -euo pipefail
-
-DEVICE="${1:?usage: maestro.sh <device> <maestro-args...>}"
-shift
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel)"
-LOCK="${TMPDIR:-/tmp}/kilo-maestro-locks/$DEVICE"
-
-if [ "${KILO_MAESTRO_LOCKED:-}" != "1" ]; then
-  exec "$REPO_ROOT/node_modules/.bin/tsx" "$REPO_ROOT/dev/local/process-lock.ts" \
-    --wait 1200 "$LOCK" -- env KILO_MAESTRO_LOCKED=1 "$0" "$DEVICE" "$@"
-fi
-
-if [ "${1:-}" = "--exec" ]; then
-  shift
-  [ $# -gt 0 ] || { echo "maestro.sh: --exec needs a command" >&2; exit 1; }
-  exec "$@"
-fi
-
-if [ "${1:-}" != "test" ]; then
-  exec maestro --device "$DEVICE" "$@"
-fi
-
-REPORT_DIR=$(mktemp -d "${TMPDIR:-/tmp}/kilo-maestro-report.XXXXXX")
-trap 'rm -rf "$REPORT_DIR"' EXIT
-REPORT="$REPORT_DIR/junit.xml"
-set +e
-maestro --device "$DEVICE" "$@" --format JUNIT --output "$REPORT"
-rc=$?
-set -e
-
-if [ "$rc" -eq 0 ]; then
-  if [ ! -s "$REPORT" ]; then
-    echo "maestro.sh: test exited 0 without a JUnit report" >&2
-    rc=1
-  elif grep -Eq '<(failure|error)([ >])|(failures|errors)="[1-9][0-9]*"' "$REPORT"; then
-    echo "maestro.sh: JUnit reports a failed assertion" >&2
-    rc=1
-  fi
-fi
-exit "$rc"

From 61a8e105456a3273617b31d233ee67da989dc7be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 02:47:05 +0200
Subject: [PATCH 19/34] docs(e2e): rewrite runbook and references for appium +
 webdriverio

---
 .kilo/agent/e2e-verifier.md                   |  2 +-
 apps/mobile/AGENTS.md                         |  2 +-
 apps/mobile/e2e/AGENTS.md                     | 37 ++++++++++---------
 .../src/components/agents/chat-composer.tsx   |  2 +-
 .../kilo-chat/message-bubble-a11y.test.ts     |  2 +-
 5 files changed, 24 insertions(+), 21 deletions(-)

diff --git a/.kilo/agent/e2e-verifier.md b/.kilo/agent/e2e-verifier.md
index 89c6f1f738..6b1168855c 100644
--- a/.kilo/agent/e2e-verifier.md
+++ b/.kilo/agent/e2e-verifier.md
@@ -35,7 +35,7 @@ During verification:
 - Retryable and empty states: a meaningful message plus a CTA that performs the expected recovery or next step. Non-retryable states: a meaningful message with no CTA at all.
 - Inspect backend or service logs when a flow crosses those boundaries.
 - Capture concise evidence: screenshots, exact visible state, and bounded log excerpts. Never credentials.
-- Run every Maestro command through `apps/mobile/e2e/maestro.sh <device> ...`; do not use Maestro MCP tools, which bypass the device mutex.
+- Run every Appium command through `apps/mobile/e2e/appium.sh <device> ...`; never a direct driver connection or an MCP automation tool, which bypass the device mutex.
 - Never create proxies, redirects, tunnels, NAT rules, or listeners to compensate for stale client or bundler state — with any tool.
 - Never dispatch agents, and never commit, push, or create or update a PR. Permissions restrict nothing except agent dispatch (`task`); this boundary is the instruction — the orchestrator owns all Git and PR actions.
 - Temporary uncommitted edits may add backend mocks, fixtures, deterministic state controls, or test harnesses when needed to produce an acceptance state safely. Use the smallest localized change and record every touched file.
diff --git a/apps/mobile/AGENTS.md b/apps/mobile/AGENTS.md
index 7f1de4f798..926d014e01 100644
--- a/apps/mobile/AGENTS.md
+++ b/apps/mobile/AGENTS.md
@@ -4,7 +4,7 @@
 
 Expo Router app for iOS and Android only. Use dev builds, never Expo Go. No web-specific code.
 
-- Backend, simulator, login, Maestro, remote CLI, logs, cleanup: follow [e2e/AGENTS.md](e2e/AGENTS.md). Start what you need yourself; never ask the user to start Metro or backend services.
+- Backend, simulator, login, Appium, remote CLI, logs, cleanup: follow [e2e/AGENTS.md](e2e/AGENTS.md). Start what you need yourself; never ask the user to start Metro or backend services.
 - Substantial mobile work: follow the kilo workflow in [.kilo_workflow/WORKFLOW.md](../../.kilo_workflow/WORKFLOW.md). Plans may require edits to backend, shared packages, infrastructure, or sibling repositories; that is in scope.
 
 ## Stack
diff --git a/apps/mobile/e2e/AGENTS.md b/apps/mobile/e2e/AGENTS.md
index 6c7f3307bb..fcca14ed13 100644
--- a/apps/mobile/e2e/AGENTS.md
+++ b/apps/mobile/e2e/AGENTS.md
@@ -134,7 +134,7 @@ xcrun simctl openurl <udid> \
 
 ## Sign In and Out
 
-Backend and Metro must be running. These idempotent wrappers verify simulator ownership, required services, the generated API port, and Metro project provenance, then reconnect the dev client to this worktree's exact Metro URL before Maestro runs. Never bypass their preflight or call the login YAML flows directly:
+Backend and Metro must be running. These idempotent wrappers verify simulator ownership, required services, the generated API port, and Metro project provenance, then reconnect the dev client to this worktree's exact Metro URL before Appium runs. Never bypass their preflight or call the flow files directly:
 
 ```bash
 apps/mobile/e2e/login.sh <udid> [email]   # default: e2e-mobile-<worktree>-<ios|android>@example.com
@@ -143,7 +143,7 @@ apps/mobile/e2e/logout.sh <udid>
 
 The default email is `e2e-mobile-<worktree-basename>-<ios|android>@example.com`, derived from the worktree and device serial. Parallel platform shards therefore use separate backend users. Pass an explicit email only when a test needs a specific account.
 
-Login requests an email OTP, waits up to 30 seconds for the worktree-local outbox, verifies the code, accepts first-account consent, and asserts Home. If the request half fails it cold-relaunches through `flows/open-app.yaml` and retries once — that clears both a half-started dev client and an email field left dirty by an earlier run — and if the retry fails too it says which half broke: no outbox email means the app never reached `POST /api/auth/native/otp`, a new outbox email means the request worked and only the code screen was never reached. `flows/settle-app.yaml` handles late tracking and Expo developer-menu prompts without restarting the app; `flows/open-app.yaml` is the standalone cold-launch flow.
+Login requests an email OTP, waits up to 30 seconds for the worktree-local outbox, verifies the code, accepts first-account consent, and asserts Home. If the request half fails it cold-relaunches through `flows/open-app.js` and retries once — that clears both a half-started dev client and an email field left dirty by an earlier run — and if the retry fails too it says which half broke: no outbox email means the app never reached `POST /api/auth/native/otp`, a new outbox email means the request worked and only the code screen was never reached. `flows/settle-app.js` handles late tracking and Expo developer-menu prompts without restarting the app; `flows/open-app.js` is the standalone cold-launch flow.
 
 Native prompts are states in the flow, not errors to tap through blindly:
 
@@ -152,7 +152,7 @@ Native prompts are states in the flow, not errors to tap through blindly:
 - Feature-triggered prompts (speech recognition, microphone): handle only when the flow reaches that feature. Inspect the hierarchy, copy the exact button accessibility text (`Allow` or `Don’t Allow`), and choose the state the test requires.
 - Never use a generic `tapOn: 'Allow'` before identifying which prompt is visible.
 
-Maestro can emit a large interactive transcript. Keep successful output out of context; show only a bounded failure tail:
+Appium can emit a large server and driver transcript. Keep successful output out of context; show only a bounded failure tail:
 
 ```bash
 LOGIN_LOG=$(mktemp /tmp/kilo-login.XXXXXX)
@@ -162,12 +162,11 @@ apps/mobile/e2e/login.sh <udid> >"$LOGIN_LOG" 2>&1 || \
 
 When editing the flows, preserve these device-tested constraints:
 
-- Tap the Kilo home-screen icon; Maestro `launchApp` can bounce the Expo dev client to SpringBoard.
-- Pass `EMAIL` and `OTP` with `-e`; flow-level defaults override `-e` values in the installed Maestro version.
+- Pass `EMAIL` and `OTP` with `-e`; the flows require them and fail fast when absent.
 - Target the email field by its placeholder `you@example.com`, and tap `Verify code` without trying to dismiss the number pad.
-- The email field is uncontrolled, so a login page left on screen by an earlier run still holds its address, and `inputText` inserts at the caret the tap just dropped mid-string. Erase the field first and assert the typed address before submitting; without that, two attempts interleave into one malformed address and the flow dies 15s later on a missing `Verify code`.
-- Keep every control a flow taps clear of the keyboard. Maestro taps an element's centre, and iOS hands a touch inside `UIRemoteKeyboardWindow` to the keyboard while Maestro still logs the tap `COMPLETED` — a silent no-op. Verify with `e2e/maestro.sh <udid> hierarchy`: the control's centre must be above the keyboard window's top bound. See `.kilo_workflow/learnings/maestro-tap-swallowed-by-ios-keyboard.md`.
-- The native sign-out confirmation is the first case-insensitive `Sign Out` match (`index: 0`).
+- The email field is uncontrolled, so a login page left on screen by an earlier run still holds its address, and typing inserts at the caret the tap just dropped mid-string. Erase the field first and assert the typed address before submitting; without that, two attempts interleave into one malformed address and the flow dies 15s later on a missing `Verify code`.
+- Keep every control a flow taps clear of the keyboard. Taps land on the element's centre, and iOS hands a touch inside `UIRemoteKeyboardWindow` to the keyboard while the driver still reports the tap delivered — a silent no-op. Verify with `e2e/appium.sh <udid> hierarchy`: the control's centre must be above the keyboard window's top bound. The same mechanism creates a dead zone under fixed header chrome; never read a swallowed tap as a product regression.
+- The native sign-out confirmation is the first case-insensitive `Sign Out` match (`index: 0`, topmost by position).
 
 Seed only when needed. `pnpm dev:seed` with no arguments lists every topic and its usage:
 
@@ -178,24 +177,28 @@ pnpm dev:seed app:add-credits <user-id> <usd>    # grant credits
 pnpm dev:seed app:api-token <email>              # mint a bearer token (used by remote-cli.sh)
 ```
 
-## Maestro
+## Appium + WebdriverIO
 
-One-time machine setup: `brew install maestro`. Workflow verification never uses Maestro Model Context Protocol (MCP) tools because they bypass the device lock; use the repository wrapper below.
+Setup is automatic: the repository install provides Appium and the webdriverio client, and the wrapper below installs the XCUITest / UiAutomator2 drivers into a machine-global `APPIUM_HOME` (`~/.cache/kilo-appium`, override with `KILO_APPIUM_HOME`) on first use. Never use MCP automation tools or a hand-rolled driver connection: they bypass the per-device lock; use the repository wrapper.
 
-- Maestro is the primary automation driver on both iOS and Android. Fall back to `xcrun simctl` (iOS) or repository-wrapped ADB (Android) only when Maestro cannot inspect or operate a native state, or when low-level device control is required. Setup still uses `simctl`/ADB for boot, install, dev-client URL reconnection, and screenshots; the repository wrappers own shutdown and cleanup.
-- With more than one simulator booted (parallel worktrees), always target by UDID and go through `e2e/maestro.sh <udid> ...` — it serializes per device (the driver is single-tenant) and without an explicit device Maestro picks an arbitrary booted simulator, so taps silently land on another worktree’s device. The Maestro MCP tools mis-target the same way; prefer the CLI plus `simctl` screenshots when several simulators are up.
+- Appium is the primary automation driver on both iOS and Android. Fall back to `xcrun simctl` (iOS) or repository-wrapped ADB (Android) only when Appium cannot inspect or operate a native state, or when low-level device control is required. Setup still uses `simctl`/ADB for boot, install, dev-client URL reconnection, and screenshots; the repository wrappers own shutdown and cleanup.
+- With more than one device booted (parallel worktrees), always go through `e2e/appium.sh <udid> ...` — it serializes per device (one Appium server per device on a deterministic port, one session at a time), so taps can never silently land on another worktree's device.
 - Inspect the screen before selecting elements; re-inspect after UI changes.
-- Never guess a selector from a visible label or screenshot. Copy the exact text or accessibility value from `e2e/maestro.sh <udid> hierarchy`. Maestro text matching is full-string regex, not substring.
-- Tab buttons expose React Navigation's full accessibility labels, not the visible uppercase text. Current iOS labels: `Home, tab, 1 of 4`, `KiloClaw, tab, 2 of 4`, `Agents, tab, 3 of 4`, `Profile, tab, 4 of 4`. `tapOn: 'Agents'` is wrong. Inspect again before relying on these examples; the count and labels can change.
+- Never guess a selector from a visible label or screenshot. Copy the exact text or accessibility value from `e2e/appium.sh <udid> hierarchy` (writes the XML page source; redirect to a file and grep it). Matching is full-string regex against the element label (iOS) or text / content-desc (Android), not substring.
+- Tab buttons expose React Navigation's full accessibility labels, not the visible uppercase text. Current iOS labels: `Home, tab, 1 of 4`, `KiloClaw, tab, 2 of 4`, `Agents, tab, 3 of 4`, `Profile, tab, 4 of 4`. `tapOn('Agents')` is wrong. Inspect again before relying on these examples; the count and labels can change.
+- Flows are plain node modules in `e2e/flows/*.js` using the helpers in `e2e/wdio/helpers.js` (`tapOn`, `assertVisible`, `waitVisible`, `inputText`, `eraseText`, `scrollUntilVisible`, `stopApp`/`launchApp`, `when`/`whenNot`). A failed helper throws and the process exit code is the verdict — no report files to inspect.
 
-CLI fallback — always through `e2e/maestro.sh`, which serializes per device (Maestro's per-device driver is single-tenant; two concurrent sessions against one UDID interleave taps and fail flows in ways that read as product defects):
+CLI usage — always through `e2e/appium.sh`, which serializes per device (two concurrent sessions against one UDID interleave taps and fail flows in ways that read as product defects):
 
 ```bash
-apps/mobile/e2e/maestro.sh <udid|emulator-5554> test -e KEY=VALUE <flow.yaml>
+apps/mobile/e2e/appium.sh <udid|emulator-5554> test -e KEY=VALUE <flow.js>
+apps/mobile/e2e/appium.sh <udid> hierarchy > /tmp/hierarchy.xml
 xcrun simctl io <udid> screenshot <path>      # iOS
 pnpm dev:mobile:android adb -s <serial> exec-out screencap -p > <path>  # Android
 ```
 
+The Appium server per device starts on demand and keeps running for the bundle's lifetime; stop it during bundle cleanup with `apps/mobile/e2e/appium.sh <udid> server stop`.
+
 Attach a screenshot of a changed flow to the PR when it helps review. For transitions, prefer a short screenshot loop over `simctl io recordVideo`, which can produce one-frame recordings.
 
 ## Remote CLI Session Flows
@@ -306,7 +309,7 @@ pnpm dev:mobile:android adb -s <serial> shell am start -a android.intent.action.
 
 Drives a real App Link through Android intent resolution.
 
-### ADB fallback (Maestro stays primary)
+### ADB fallback (Appium stays primary)
 
 Derive tap coordinates from the current `uiautomator` bounds, never from screenshots or remembered positions. Re-dump after every navigation or prompt.
 
diff --git a/apps/mobile/src/components/agents/chat-composer.tsx b/apps/mobile/src/components/agents/chat-composer.tsx
index 3281da420b..85e035ea7f 100644
--- a/apps/mobile/src/components/agents/chat-composer.tsx
+++ b/apps/mobile/src/components/agents/chat-composer.tsx
@@ -1,6 +1,6 @@
 /* eslint-disable max-lines -- Composer owns its uncontrolled input, slash suggestions, and submission flow end-to-end.
  * The wiring between the TextInput and SlashCommandSuggestions is covered by
- * Maestro E2E; this app has no @testing-library/react-native dependency, so it
+ * Appium E2E; this app has no @testing-library/react-native dependency, so it
  * is not expressed as a unit test.
  */
 import * as Haptics from 'expo-haptics';
diff --git a/apps/mobile/src/components/kilo-chat/message-bubble-a11y.test.ts b/apps/mobile/src/components/kilo-chat/message-bubble-a11y.test.ts
index 2bf505c7f3..7ff15743e9 100644
--- a/apps/mobile/src/components/kilo-chat/message-bubble-a11y.test.ts
+++ b/apps/mobile/src/components/kilo-chat/message-bubble-a11y.test.ts
@@ -107,6 +107,6 @@ describe('buildMessageBubbleAccessibilityProps', () => {
  * focusable and whether the navigation order avoids double-announcement — can
  * only be verified on a real device or simulator with VoiceOver running. Unit
  * tests here cover the prop contract; the visual/accessibility tree layout must
- * be confirmed with an on-device pass (Maestro + VoiceOver or Accessibility
+ * be confirmed with an on-device pass (Appium + VoiceOver or Accessibility
  * Inspector).
  */

From 09ef15d9054b4596e5adb5edb680207665b515c4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 02:47:05 +0200
Subject: [PATCH 20/34] feat(e2e): ANR-resilient cold launch, port-bump server
 start, wrapper tests

- open-app.js answers Android 'isn\u0027t responding' ANR dialogs with Wait
  and gives Android a 420s launch budget under load (returns early when
  healthy); iOS keeps 30s
- appium.sh bumps whole port blocks when the hashed block is occupied
  and records the winning port for reconnects
- mobile-workflow tests assert the JS flows; appium-wrapper tests cover
  port determinism, slugs, and usage errors
---
 apps/mobile/e2e/appium.sh         |  47 +++++--
 dev/local/appium-wrapper.test.ts  |  36 +++++
 dev/local/mobile-workflow.test.ts | 224 +++++++++++-------------------
 package.json                      |   2 +-
 4 files changed, 154 insertions(+), 155 deletions(-)
 create mode 100644 dev/local/appium-wrapper.test.ts

diff --git a/apps/mobile/e2e/appium.sh b/apps/mobile/e2e/appium.sh
index d6e44d7a09..0427d30b58 100755
--- a/apps/mobile/e2e/appium.sh
+++ b/apps/mobile/e2e/appium.sh
@@ -51,23 +51,44 @@ server_status() {
   curl -sf -o /dev/null --max-time 3 "http://127.0.0.1:$APPIUM_PORT/status"
 }
 
+port_free() {
+  ! nc -z 127.0.0.1 "$1" 2>/dev/null
+}
+
 ensure_server() {
+  # Reconnect to a previously bumped server when one was recorded.
+  if [ -f "$STATE_DIR/server.port" ]; then
+    APPIUM_PORT=$(cat "$STATE_DIR/server.port")
+  fi
   if server_status; then return 0; fi
   ensure_drivers
-  echo "appium.sh: starting appium server for $DEVICE on port $APPIUM_PORT" >&2
-  nohup "$APPIUM_BIN" --port "$APPIUM_PORT" --log-level warn \
-    >"$STATE_DIR/appium.log" 2>&1 &
-  echo $! >"$STATE_DIR/appium.pid"
-  for _ in $(seq 1 60); do
-    if server_status; then return 0; fi
-    if ! kill -0 "$(cat "$STATE_DIR/appium.pid")" 2>/dev/null; then
-      echo "appium.sh: appium server died at launch; last log lines:" >&2
-      tail -n 20 "$STATE_DIR/appium.log" >&2
-      return 1
+  local base_port=$APPIUM_PORT attempt
+  # Hash collisions and foreign listeners both resolve by bumping one block.
+  for attempt in $(seq 0 49); do
+    APPIUM_PORT=$((base_port + attempt * 10))
+    port_free "$APPIUM_PORT" || continue
+    if [ "$attempt" -gt 0 ]; then
+      echo "appium.sh: bumping to port block $APPIUM_PORT" >&2
     fi
-    sleep 1
+    echo "appium.sh: starting appium server for $DEVICE on port $APPIUM_PORT" >&2
+    nohup "$APPIUM_BIN" --port "$APPIUM_PORT" --log-level warn \
+      >"$STATE_DIR/appium.log" 2>&1 &
+    echo $! >"$STATE_DIR/appium.pid"
+    for _ in $(seq 1 60); do
+      if server_status; then
+        echo "$APPIUM_PORT" >"$STATE_DIR/server.port"
+        return 0
+      fi
+      if ! kill -0 "$(cat "$STATE_DIR/appium.pid")" 2>/dev/null; then
+        break
+      fi
+      sleep 1
+    done
+    stop_server
+    echo "appium.sh: server attempt on port $APPIUM_PORT failed; last log lines:" >&2
+    tail -n 10 "$STATE_DIR/appium.log" >&2
   done
-  echo "appium.sh: appium server did not answer /status within 60s ($STATE_DIR/appium.log)" >&2
+  echo "appium.sh: no appium server came up after 50 port blocks ($STATE_DIR/appium.log)" >&2
   return 1
 }
 
@@ -75,7 +96,7 @@ stop_server() {
   if [ -f "$STATE_DIR/appium.pid" ] && kill -0 "$(cat "$STATE_DIR/appium.pid")" 2>/dev/null; then
     kill "$(cat "$STATE_DIR/appium.pid")" || true
   fi
-  rm -f "$STATE_DIR/appium.pid"
+  rm -f "$STATE_DIR/appium.pid" "$STATE_DIR/server.port"
 }
 
 cmd="${1:-}"
diff --git a/dev/local/appium-wrapper.test.ts b/dev/local/appium-wrapper.test.ts
new file mode 100644
index 0000000000..0fc2e76ae1
--- /dev/null
+++ b/dev/local/appium-wrapper.test.ts
@@ -0,0 +1,36 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import test from 'node:test';
+
+const { portsFor, slugFor } = await import('../../apps/mobile/e2e/wdio/ports.js');
+
+test('appium port assignment is deterministic and block-shaped', () => {
+  const first = portsFor('A1B2C3D4-0000-0000-0000-000000000000');
+  assert.deepEqual(first, portsFor('A1B2C3D4-0000-0000-0000-000000000000'));
+
+  // Server, WDA, and system ports stay inside the device's own block of 10,
+  // in valid unprivileged-port territory; the wrapper bumps whole blocks when
+  // one is occupied, so hash collisions never cross-talk.
+  assert.equal(first.wda, first.server + 1);
+  assert.equal(first.system, first.server + 2);
+  assert.ok(first.server >= 4730 && first.server <= 9730);
+  assert.ok(first.system < first.server + 10);
+});
+
+test('appium device slug is filesystem- and tmux-safe', () => {
+  assert.equal(slugFor('A1B2C3D4-0000-0000-0000-000000000000'), 'A1B2C3D4-0000-0000-0000-000000000000');
+  assert.equal(slugFor('emulator-5554'), 'emulator-5554');
+  assert.equal(slugFor('192.168.1.10:5555'), '192-168-1-10-5555');
+});
+
+test('appium wrapper rejects a missing device and unknown commands', () => {
+  const noArgs = spawnSync('apps/mobile/e2e/appium.sh', [], { encoding: 'utf8' });
+  assert.notEqual(noArgs.status, 0);
+  assert.match(noArgs.stderr, /usage: appium\.sh/);
+
+  const unknown = spawnSync('apps/mobile/e2e/appium.sh', ['some-device', 'bogus'], {
+    encoding: 'utf8',
+  });
+  assert.notEqual(unknown.status, 0);
+  assert.match(unknown.stderr, /usage: appium\.sh/);
+});
diff --git a/dev/local/mobile-workflow.test.ts b/dev/local/mobile-workflow.test.ts
index b27ec5f5b2..38f776ee29 100644
--- a/dev/local/mobile-workflow.test.ts
+++ b/dev/local/mobile-workflow.test.ts
@@ -3,77 +3,80 @@ import fs from 'node:fs';
 import test from 'node:test';
 
 test('cold launch clears leftover prompts, relaunches, then settles via the shared flow', () => {
-  const flow = fs.readFileSync('apps/mobile/e2e/flows/open-app.yaml', 'utf8');
-  const trackingGuardIndex = flow.indexOf("visible: 'Ask App Not to Track'");
-  const stopIndex = flow.indexOf('- stopApp');
-  const launchIndex = flow.indexOf("text: 'Kilo'");
-  const readyWaitIndex = flow.indexOf('- extendedWaitUntil:', launchIndex);
-  const settleIndex = flow.indexOf('- runFlow: settle-app.yaml');
+  const flow = fs.readFileSync('apps/mobile/e2e/flows/open-app.js', 'utf8');
+  const trackingGuardIndex = flow.indexOf('S.TRACKING_BUTTON');
+  const stopIndex = flow.indexOf('h.stopApp(BUNDLE_ID)');
+  const launchIndex = flow.indexOf('h.launchApp(BUNDLE_ID)');
+  const readyWaitIndex = flow.indexOf('h.waitVisible(S.ANY_STATE', launchIndex);
+  const settleIndex = flow.indexOf('settleApp(ctx)');
 
   assert.ok(trackingGuardIndex >= 0 && trackingGuardIndex < stopIndex);
   assert.ok(stopIndex < launchIndex);
   assert.ok(launchIndex < readyWaitIndex);
   assert.ok(readyWaitIndex < settleIndex);
-  assert.match(flow.slice(readyWaitIndex, settleIndex), /timeout: 30000/);
+  // iOS keeps the 30s budget; Android under load gets a long one that healthy
+  // runs never pay (the wait returns on first match).
+  assert.match(flow, /launchTimeout = ctx\.platform === 'android' \? 420000 : 30000/);
+  assert.match(flow, /isn\.t responding/, 'open-app should answer Android ANR dialogs');
   assert.doesNotMatch(flow.slice(readyWaitIndex), /optional: true/);
 });
 
 test('settle flow closes the Expo developer menu after its introduction', () => {
-  const flow = fs.readFileSync('apps/mobile/e2e/flows/settle-app.yaml', 'utf8');
-  const continueIndex = flow.indexOf("tapOn: 'Continue'");
-  const closeGuardIndex = flow.indexOf("visible: 'Fast Refresh|Element Inspector'", continueIndex);
-  const closeIndex = flow.indexOf("tapOn: 'Close'", closeGuardIndex);
+  const flow = fs.readFileSync('apps/mobile/e2e/flows/settle-app.js', 'utf8');
+  const continueIndex = flow.indexOf("h.tapOn('Continue')");
+  const closeGuardIndex = flow.indexOf('S.DEVMENU_OPEN, () =>', continueIndex);
+  const closeIndex = flow.indexOf("h.tapOn('Close')", closeGuardIndex);
 
   assert.ok(continueIndex >= 0, 'settle-app should accept the developer-menu introduction');
   assert.ok(closeGuardIndex > continueIndex, 'settle-app should detect the opened menu');
   assert.ok(closeIndex > closeGuardIndex, 'settle-app should close the opened menu');
-  assert.doesNotMatch(flow, /when:\n\s+visible: 'Close'/);
+  assert.doesNotMatch(flow, /when\(ctx, 'Close'/);
 });
 
 test('launch flows never use an unidentified generic Allow selector', () => {
-  const request = fs.readFileSync('apps/mobile/e2e/flows/login-request-code.yaml', 'utf8');
-  const settle = fs.readFileSync('apps/mobile/e2e/flows/settle-app.yaml', 'utf8');
-
-  assert.doesNotMatch(request, /visible: 'Allow'/);
-  assert.match(settle, /“Kilo” Would Like to Send You Notifications/);
+  const request = fs.readFileSync('apps/mobile/e2e/flows/login-request-code.js', 'utf8');
+  const settle = fs.readFileSync('apps/mobile/e2e/flows/settle-app.js', 'utf8');
+  const states = fs.readFileSync('apps/mobile/e2e/flows/states.js', 'utf8');
+
+  assert.doesNotMatch(request, /Allow/);
+  assert.match(states, /“Kilo” Would Like to Send You Notifications/);
+  // The only Allow tap in the launch flows is guarded by the notification prompt.
+  assert.match(settle, /S.NOTIF_PROMPT, \(\) => h\.tapOn\('Allow'\)/);
 });
 
 test('login verification does not pay a fixed optional notification wait', () => {
-  const verify = fs.readFileSync('apps/mobile/e2e/flows/login-verify-code.yaml', 'utf8');
+  const verify = fs.readFileSync('apps/mobile/e2e/flows/login-verify-code.js', 'utf8');
 
   assert.doesNotMatch(verify, /optional: true/);
-  assert.match(verify, /“Kilo” Would Like to Send You Notifications\|HOME/);
+  assert.match(verify, /S\.NOTIF_PROMPT\.source, S\.HOME\.source/);
 });
 
 test('login request establishes a signed-out baseline before requesting a fresh OTP', () => {
-  const request = fs.readFileSync('apps/mobile/e2e/flows/login-request-code.yaml', 'utf8');
-  assert.ok(request.indexOf('logout.yaml') < request.indexOf("tapOn: 'Send sign-in code'"));
+  const request = fs.readFileSync('apps/mobile/e2e/flows/login-request-code.js', 'utf8');
+  assert.ok(request.indexOf('await logout(ctx)') < request.indexOf("h.tapOn('Send sign-in code')"));
 });
 
 test('login retry resets an already-open verification screen to the email form', () => {
-  const logout = fs.readFileSync('apps/mobile/e2e/flows/logout.yaml', 'utf8');
-  const verificationIndex = logout.indexOf("visible: 'Verify code'");
-  const backIndex = logout.indexOf("tapOn: 'Back'", verificationIndex);
-  const signedOutGuardIndex = logout.indexOf(
-    "notVisible: 'Welcome to Kilo Code'",
-    verificationIndex
-  );
+  const logout = fs.readFileSync('apps/mobile/e2e/flows/logout.js', 'utf8');
+  const verificationIndex = logout.indexOf("when(ctx, 'Verify code'");
+  const backIndex = logout.indexOf("h.tapOn('Back')", verificationIndex);
+  const signedOutGuardIndex = logout.indexOf('whenNot(ctx, S.LOGIN', verificationIndex);
 
   assert.ok(verificationIndex >= 0);
   assert.ok(backIndex > verificationIndex);
   assert.ok(signedOutGuardIndex > backIndex);
-  assert.match(logout, /assertVisible: 'you@example\.com'/);
+  assert.match(logout, /assertVisible\('you@example\.com'\)/);
 });
 
 test('login reuses the app state established by logout instead of relaunching each step', () => {
-  const request = fs.readFileSync('apps/mobile/e2e/flows/login-request-code.yaml', 'utf8');
-  const verify = fs.readFileSync('apps/mobile/e2e/flows/login-verify-code.yaml', 'utf8');
+  const request = fs.readFileSync('apps/mobile/e2e/flows/login-request-code.js', 'utf8');
+  const verify = fs.readFileSync('apps/mobile/e2e/flows/login-verify-code.js', 'utf8');
   const login = fs.readFileSync('apps/mobile/e2e/login.sh', 'utf8');
 
-  assert.doesNotMatch(request, /open-app\.yaml/);
-  assert.doesNotMatch(verify, /open-app\.yaml/);
-  assert.doesNotMatch(login, /maestro .*logout\.yaml/);
-  assert.doesNotMatch(login, /login-assert-home\.yaml/);
+  assert.doesNotMatch(request, /open-app/);
+  assert.doesNotMatch(verify, /open-app/);
+  assert.doesNotMatch(login, /appium\.sh.*logout\.js/);
+  assert.doesNotMatch(login, /login-assert-home\.js/);
 });
 
 test('login polls the local outbox without one-second latency', () => {
@@ -88,9 +91,9 @@ test('parallel platform logins default to separate accounts', () => {
 });
 
 test('shared launch prompt grace periods total at most five seconds', () => {
-  const settle = fs.readFileSync('apps/mobile/e2e/flows/settle-app.yaml', 'utf8');
-  const openApp = fs.readFileSync('apps/mobile/e2e/flows/open-app.yaml', 'utf8');
-  const optionalWaits = [...settle.matchAll(/timeout: (\d+)\n\s+optional: true/g)].map(match =>
+  const settle = fs.readFileSync('apps/mobile/e2e/flows/settle-app.js', 'utf8');
+  const openApp = fs.readFileSync('apps/mobile/e2e/flows/open-app.js', 'utf8');
+  const optionalWaits = [...settle.matchAll(/timeout: (\d+), optional: true/g)].map(match =>
     Number(match[1])
   );
 
@@ -99,123 +102,62 @@ test('shared launch prompt grace periods total at most five seconds', () => {
 });
 
 test('settle flow handles the exact iOS external-app prompt within existing waits', () => {
-  const flow = fs.readFileSync('apps/mobile/e2e/flows/settle-app.yaml', 'utf8');
-  const finalReadyWaitIndex = flow.lastIndexOf('- extendedWaitUntil:');
-  const waitBlocks = [...flow.matchAll(/- extendedWaitUntil:\n[\s\S]*?(?=\n- |$)/g)].map(
-    match => match[0]
-  );
-  const secondWaitEnd = flow.indexOf(waitBlocks[1]) + waitBlocks[1].length;
-  const promptGuardIndex = flow.indexOf('- runFlow:', secondWaitEnd);
-  const openActionIndex = flow.indexOf("tapOn: 'Open'", promptGuardIndex);
+  const states = fs.readFileSync('apps/mobile/e2e/flows/states.js', 'utf8');
+  const flow = fs.readFileSync('apps/mobile/e2e/flows/settle-app.js', 'utf8');
   const timeouts = [...flow.matchAll(/timeout: (\d+)/g)].map(match => Number(match[1]));
 
-  assert.match(
-    waitBlocks[0],
-    /Open this page in "Kilo"\\\?/,
-    'settle-app should recognize the prompt as its initial visible state'
-  );
-  assert.match(
-    waitBlocks[1],
-    /Open this page in "Kilo"\\\?/,
-    'settle-app should recognize the prompt inside its optional wait'
-  );
-  assert.match(waitBlocks[1], /timeout: 3000\n\s+optional: true/);
-  assert.ok(promptGuardIndex > flow.indexOf(waitBlocks[1]), 'settle-app should guard Open');
-  assert.match(
-    flow.slice(promptGuardIndex, openActionIndex),
-    /Open this page in "Kilo"\\\?/,
-    'settle-app should guard Open with the exact prompt'
-  );
-  assert.ok(openActionIndex > promptGuardIndex, 'settle-app should tap the exact Open action');
-
-  const promptChain = [
-    {
-      action: "tapOn: 'Open'",
-      nextGuard: 'Ask App Not to Track',
-      visible:
-        'Ask App Not to Track|This is the developer menu.*|Fast Refresh|Element Inspector|“Kilo” Would Like to Send You Notifications|HOME|Home, tab, 1 of 4|Welcome to Kilo Code|Accept and continue',
-    },
-    {
-      action: "tapOn: 'Ask App Not to Track'",
-      nextGuard: 'This is the developer menu.*',
-      visible:
-        'This is the developer menu.*|Fast Refresh|Element Inspector|“Kilo” Would Like to Send You Notifications|HOME|Home, tab, 1 of 4|Welcome to Kilo Code|Accept and continue',
-    },
-    {
-      action: "tapOn: 'Continue'",
-      nextGuard: 'Fast Refresh|Element Inspector',
-      visible:
-        'Fast Refresh|Element Inspector|“Kilo” Would Like to Send You Notifications|HOME|Home, tab, 1 of 4|Welcome to Kilo Code|Accept and continue',
-    },
-    {
-      action: "tapOn: 'Close'",
-      nextGuard: '“Kilo” Would Like to Send You Notifications',
-      visible:
-        '“Kilo” Would Like to Send You Notifications|HOME|Home, tab, 1 of 4|Welcome to Kilo Code|Accept and continue',
-    },
-  ];
-
-  let searchFrom = openActionIndex;
-  for (const step of promptChain) {
-    const actionIndex = flow.indexOf(step.action, searchFrom);
-    const nextGuardIndex = flow.indexOf(
-      `- runFlow:\n    when:\n      visible: '${step.nextGuard}'`,
-      actionIndex
-    );
-    const betweenActionAndGuard = flow.slice(actionIndex, nextGuardIndex);
-
-    assert.ok(actionIndex >= searchFrom, `settle-app should include ${step.action}`);
-    assert.ok(
-      nextGuardIndex > actionIndex,
-      `settle-app should guard ${step.nextGuard} after ${step.action}`
-    );
-    assert.match(
-      betweenActionAndGuard,
-      new RegExp(
-        `- extendedWaitUntil:\\n    visible: '${step.visible.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}'\\n    timeout: 5000`
-      ),
-      `settle-app should poll for the next state immediately after ${step.action}`
-    );
-    assert.doesNotMatch(
-      betweenActionAndGuard,
-      /timeout: (?:500|1000)\n|optional: true/,
-      `settle-app should use a robust non-optional state gate after ${step.action}`
-    );
-    assert.doesNotMatch(
-      betweenActionAndGuard.replace(/^- runFlow:[\s\S]*?commands:\n\s+- tapOn: '[^']+'/, ''),
-      /- runFlow:/,
-      `settle-app should not insert another one-shot guard before polling`
-    );
-    searchFrom = nextGuardIndex;
-  }
-  assert.ok(
-    finalReadyWaitIndex > openActionIndex,
-    'settle-app should still wait for its final ready state'
-  );
+  assert.match(states, /Open this page in "Kilo"\\\?/, 'states should name the Safari wording');
+  assert.match(states, /Open in \["“”\]Kilo/, 'states should name the SpringBoard wording');
+  assert.match(flow, /when\(ctx, S\.OPEN_IN_KILO, \(\) => h\.tapOn\('Open'\)\)/);
   assert.deepEqual(
     timeouts,
     [15000, 3000, 5000, 5000, 5000, 5000, 15000],
-    'settle-app should not add a fixed wait'
+    'settle-app should keep its wait budget and add no fixed wait'
   );
-  assert.doesNotMatch(flow, /visible: '(?:Allow|Open)'/);
-  assert.doesNotMatch(flow, /tapOn: '(?:Allow\|Open|Open\|Allow)'/);
+  assert.doesNotMatch(flow, /when\(ctx, '(?:Allow|Open)'/);
+  assert.doesNotMatch(flow, /tapOn\('(?:Allow\|Open|Open\|Allow)'\)/);
+});
+
+test('settle flow polls for the next state immediately after every prompt answer', () => {
+  const flow = fs.readFileSync('apps/mobile/e2e/flows/settle-app.js', 'utf8');
+  const steps = [
+    ["h.tapOn('Open')", 'S.TRACKING_PROMPT.source'],
+    ['h.tapOn(S.TRACKING_BUTTON)', 'S.DEVMENU_INTRO.source'],
+    ["h.tapOn('Continue')", 'S.DEVMENU_OPEN.source'],
+    ["h.tapOn('Close')", 'S.NOTIF_PROMPT.source'],
+  ];
+
+  let searchFrom = 0;
+  for (const [action, nextState] of steps) {
+    const actionIndex = flow.indexOf(action, searchFrom);
+    assert.ok(actionIndex >= searchFrom, `settle-app should include ${action}`);
+    // The next waitVisible gate sits between this action and the next step.
+    const gateIndex = flow.indexOf('h.waitVisible(', actionIndex);
+    const gate = flow.slice(gateIndex, flow.indexOf('}', gateIndex));
+    assert.ok(gateIndex > actionIndex, `settle-app should gate after ${action}`);
+    assert.match(gate, new RegExp(nextState.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')),
+      `settle-app should poll for ${nextState} after ${action}`);
+    assert.match(gate, /timeout: 5000/);
+    assert.doesNotMatch(gate, /optional: true/);
+    searchFrom = gateIndex;
+  }
 });
 
 test('helper-driven logout settles the app already launched by preflight', () => {
-  const logout = fs.readFileSync('apps/mobile/e2e/flows/logout.yaml', 'utf8');
-  const settle = fs.readFileSync('apps/mobile/e2e/flows/settle-app.yaml', 'utf8');
+  const logout = fs.readFileSync('apps/mobile/e2e/flows/logout.js', 'utf8');
+  const settle = fs.readFileSync('apps/mobile/e2e/flows/settle-app.js', 'utf8');
 
-  assert.match(logout, /settle-app\.yaml/);
-  assert.doesNotMatch(logout, /open-app\.yaml/);
-  assert.doesNotMatch(settle, /stopApp|text: 'Kilo'/);
+  assert.match(logout, /require\('\.\/settle-app'\)/);
+  assert.doesNotMatch(logout, /open-app/);
+  assert.doesNotMatch(settle, /stopApp|launchApp/);
 });
 
 test('logout skips prompt settling for stable signed-in and signed-out states', () => {
-  const logout = fs.readFileSync('apps/mobile/e2e/flows/logout.yaml', 'utf8');
-  const settleIndex = logout.indexOf('settle-app.yaml');
+  const logout = fs.readFileSync('apps/mobile/e2e/flows/logout.js', 'utf8');
+  const settleIndex = logout.indexOf('settleApp(ctx)');
 
-  assert.ok(logout.indexOf("notVisible: 'Welcome to Kilo Code'") < settleIndex);
-  assert.ok(logout.indexOf("notVisible: 'HOME|Home, tab, 1 of 4'") < settleIndex);
+  assert.ok(logout.indexOf('whenNot(ctx, S.LOGIN') < settleIndex);
+  assert.ok(logout.indexOf('whenNot(ctx, S.HOME') < settleIndex);
 });
 
 test('tab layout exposes the exact documented accessibility labels', () => {
diff --git a/package.json b/package.json
index fff7e37959..1e0d1d46d8 100644
--- a/package.json
+++ b/package.json
@@ -36,7 +36,7 @@
     "dev:mobile:android": "tsx dev/local/mobile-android.ts",
     "dev:mobile:ios": "tsx dev/local/mobile-ios-build.ts",
     "test:dev-local": "tsx --test dev/local/*.test.ts dev/local/env-sync/*.test.ts dev/local/scripts/*.test.ts",
-    "test:mobile-workflow": "tsx --test dev/local/mobile-simulator.test.ts dev/local/mobile-native-build.test.ts dev/local/mobile-ios-build.test.ts dev/local/mobile-android-build.test.ts dev/local/mobile-android.test.ts dev/local/mobile-workflow.test.ts dev/local/maestro-wrapper.test.ts",
+    "test:mobile-workflow": "tsx --test dev/local/mobile-simulator.test.ts dev/local/mobile-native-build.test.ts dev/local/mobile-ios-build.test.ts dev/local/mobile-android-build.test.ts dev/local/mobile-android.test.ts dev/local/mobile-workflow.test.ts dev/local/appium-wrapper.test.ts",
     "dev:setup-env": "tsx dev/local/setup-env.ts",
     "dev:seed": "tsx dev/seed/index.ts",
     "dev:discord-gateway-cron": "tsx dev/discord-gateway-cron.ts",

From 44b7ac82b9e8c59fe8258610180a0941a0c26ab1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 02:47:13 +0200
Subject: [PATCH 21/34] fix(e2e): honor the wrapper-recorded appium port in the
 wdio client

---
 apps/mobile/e2e/wdio/client.js | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/apps/mobile/e2e/wdio/client.js b/apps/mobile/e2e/wdio/client.js
index f20f506ac7..a1f2f2ebfa 100644
--- a/apps/mobile/e2e/wdio/client.js
+++ b/apps/mobile/e2e/wdio/client.js
@@ -12,7 +12,11 @@ function platformFor(device) {
 
 async function connect(device) {
   const platform = platformFor(device);
-  const ports = portsFor(device);
+  // The wrapper passes the port of the server it actually started (it bumps
+  // past occupied blocks); fall back to the deterministic default.
+  const derived = portsFor(device);
+  const serverPort = Number(process.env.APPIUM_PORT || derived.server);
+  const ports = { server: serverPort, wda: serverPort + 1, system: serverPort + 2 };
   const capabilities =
     platform === 'ios'
       ? {

From 2a616c3c3a9ab9be897499903d30d9a06d37aa46 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 02:58:36 +0200
Subject: [PATCH 22/34] chore(learnings): prune obsolete, fold general lessons
 into docs

Triage of every learning, one by one:
- folded 9 into the runbook / WORKFLOW.md / extension AGENTS.md
  (git-token-service binding, deep-link route rule, CLI model id prefix,
  claim-killed-mid-boot recovery, oxfmt yaml caution, fixture patch
  discipline, dispatch --auto rationale, extension analytics key,
  firefox newSession flake)
- deleted 12 obsolete or product-bug learnings (fixes landed: mvcp
  suppression, share-extension pods root, seed collision doc'd; tablet
  startup is a product bug)
- updated 4 stale ones for the appium JS flows and current code
41 -> 28 committed learnings; system copies updated in the main checkout.
---
 .kilo_workflow/WORKFLOW.md                    |  5 +--
 ...nalytics-e2e-needs-posthog-key-at-build.md |  7 ----
 ...nsion-firefox-e2e-newsession-under-load.md |  7 ----
 ...android-dev-client-cold-start-deep-link.md | 25 +++++++-------
 .../mobile-android-edge-to-edge-ime-insets.md | 17 +++++-----
 ...2e-ios-mvcp-suppress-toggle-blanks-list.md | 33 -------------------
 ...2e-top-clip-positioning-flashlist-clamp.md |  8 +++--
 ...obile-github-stub-git-token-service-503.md |  7 ----
 ...thub-stub-seed-github-user-id-collision.md | 24 --------------
 ...ios-cold-build-shareextension-pods-root.md | 19 -----------
 .../mobile-pr-review-deep-link-route.md       |  7 ----
 .../mobile-remote-cli-model-id-prefix.md      | 18 ----------
 ...-rename-entry-points-and-field-clearing.md | 18 +++++-----
 .../mobile-simulator-claim-killed-mid-boot.md | 29 ----------------
 .../mobile-tablet-app-startup-broken.md       | 17 ----------
 .../oxfmt-formats-yaml-workflow-files.md      | 16 ---------
 ...stub-edit-extraction-from-verifier-logs.md | 25 --------------
 apps/extension/AGENTS.md                      |  4 +++
 apps/mobile/e2e/AGENTS.md                     | 12 ++++++-
 19 files changed, 56 insertions(+), 242 deletions(-)
 delete mode 100644 .kilo_workflow/learnings/extension-analytics-e2e-needs-posthog-key-at-build.md
 delete mode 100644 .kilo_workflow/learnings/extension-firefox-e2e-newsession-under-load.md
 delete mode 100644 .kilo_workflow/learnings/mobile-e2e-ios-mvcp-suppress-toggle-blanks-list.md
 delete mode 100644 .kilo_workflow/learnings/mobile-github-stub-git-token-service-503.md
 delete mode 100644 .kilo_workflow/learnings/mobile-github-stub-seed-github-user-id-collision.md
 delete mode 100644 .kilo_workflow/learnings/mobile-ios-cold-build-shareextension-pods-root.md
 delete mode 100644 .kilo_workflow/learnings/mobile-pr-review-deep-link-route.md
 delete mode 100644 .kilo_workflow/learnings/mobile-remote-cli-model-id-prefix.md
 delete mode 100644 .kilo_workflow/learnings/mobile-simulator-claim-killed-mid-boot.md
 delete mode 100644 .kilo_workflow/learnings/mobile-tablet-app-startup-broken.md
 delete mode 100644 .kilo_workflow/learnings/oxfmt-formats-yaml-workflow-files.md
 delete mode 100644 .kilo_workflow/learnings/pr-review-d957-stub-edit-extraction-from-verifier-logs.md

diff --git a/.kilo_workflow/WORKFLOW.md b/.kilo_workflow/WORKFLOW.md
index d7dd601d50..366a376baa 100644
--- a/.kilo_workflow/WORKFLOW.md
+++ b/.kilo_workflow/WORKFLOW.md
@@ -59,6 +59,7 @@ What the script encodes (details in its header comments):
 - tmux wrapping — harness command timeouts kill bare long runs. Roles run as windows in the dispatcher's session, resolved through `$TMUX_PANE`; a dispatcher outside tmux gives the role its own session. The script appends a unique dispatch id: names are `<section>-<role>-<label>-<id>`, logs `$SCRATCH/<role>-<label>-<id>.log`; parallel and repeated labels cannot share artifacts.
 - Full `KILO_*`/`OPENCODE*` env strip — a child kilo inheriting `KILO_*`/`OPENCODE*` (from a parent kilo or the tmux server environment) misattaches sessions and auth. If the tmux server itself is poisoned, clear it with `tmux set-environment -g -u <var>`.
 - Output redirected, never piped (`| tee` makes `$?` report the pipe's exit, not kilo's), with `EXITCODE=$?` appended as the log's last line.
+- `--auto` on every dispatch — a plain `kilo run` auto-rejects any permission ask (some paths ask regardless of what the agent definition grants) and still exits 0 with no verdict, which reads as a pass. Never strip the flag; any non-interactive `kilo run` outside `dispatch-role.sh` must pass it explicitly.
 
 Wait with [`await-role.sh`](await-role.sh) — never a hand-rolled loop (exit codes lie, whole-log sentinel greps false-pass on quoted sentinels, and a stalled run never writes its marker):
 
@@ -131,7 +132,7 @@ Every dispatch to a role agent includes:
 - Priority order, minimum complete outcome, optional work to drop, and a clean stopping rule before budget exhaustion (estimate roughly one step per planned tool call; when in doubt, split the task); on early stop, the required continuation state (completed work, remaining work, failures, files touched, checks run or deferred, safest next action)
 - For long tool-heavy phases: output discipline — cap every shell command's output (`| tail -c 1500` / `| tail -5`), write dumps and captures to files and print only greps or counts, bound the final report. Oversized session payloads kill kilo runs silently mid-task.
 - The GitHub comment rule (see GitHub Communication)
-- Fixture rule: never commit generated E2E fixtures; create them in a temporary directory and clean up before returning
+- Fixture rule: never commit generated E2E fixtures; create them in a temporary directory and clean up before returning. Save every sanctioned temporary worktree edit (stub fixtures, test patches) as a patch file under `$SCRATCH` and name it in the report — Edit-tool entries in a dispatch log are not recoverable state (terminal echo corrupts the logged diff, so it does not `git apply`)
 
 Write handoffs to temporary files outside every repository, and never ask a role agent to infer context from a conversation it cannot see.
 
@@ -286,7 +287,7 @@ Check the mechanical half with [`pr-gate.sh`](pr-gate.sh) — it pins every fact
 - All accepted plan tasks are implemented, with automated coverage for every applicable feature state
 - A fresh impl reviewer has cleared the cumulative section diff (step 4), including any repair or orchestrator edit since
 - A fresh E2E verifier returned `VERIFICATION PASSED.` for the plan's goals — or E2E was skipped as inert, with the rationale in the PR description
-- Changes are organized into small, coherent commits; format, typecheck, lint, and tests pass in every changed repository, using the check commands the nearest `AGENTS.md` or `package.json` defines for each changed package
+- Changes are organized into small, coherent commits; format, typecheck, lint, and tests pass in every changed repository, using the check commands the nearest `AGENTS.md` or `package.json` defines for each changed package. oxfmt covers `*.yml`/`*.yaml`: after writing or editing workflow YAML, run `pnpm format` and diff its rewrite before committing — never let a formatter rewrite load-bearing whitespace unreviewed
 - The PR exists with what/why/how sections and is assigned to the requesting human
 - If any accepted task has a UI, the PR description renders screenshots of the final behavior from the latest head, uploaded to that repository as GitHub `user-attachments`; visual changes include before/after evidence when a meaningful before state exists. A non-UI PR records `Visual Changes: N/A`
 - Kilobot has posted an approving summary comment on the latest head and no actionable posted comment is unresolved — or Kilobot's absence after two retriggers is noted with the exact waiver sentence from the Kilobot loop
diff --git a/.kilo_workflow/learnings/extension-analytics-e2e-needs-posthog-key-at-build.md b/.kilo_workflow/learnings/extension-analytics-e2e-needs-posthog-key-at-build.md
deleted file mode 100644
index 8d832580ed..0000000000
--- a/.kilo_workflow/learnings/extension-analytics-e2e-needs-posthog-key-at-build.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# extension: analytics e2e specs need VITE_POSTHOG_API_KEY at build time
-
-Symptom: every analytics e2e spec fails waiting on posthog identify/capture events after `pnpm --filter kilo-extension build`, even with `VITE_POSTHOG_API_KEY=e2e-test-key` on the playwright invocation.
-
-Cause: the key is inlined at build time; without it the build logs "VITE_POSTHOG_API_KEY is not set; extension analytics will be disabled in this build" and analytics is compiled out.
-
-Fix: set the key on the build — `VITE_POSTHOG_API_KEY=e2e-test-key pnpm --filter kilo-extension build` — before running targeted playwright specs. The `e2e:chrome` script already does this; only manual targeted runs forget it. Verified 2026-07-27.
diff --git a/.kilo_workflow/learnings/extension-firefox-e2e-newsession-under-load.md b/.kilo_workflow/learnings/extension-firefox-e2e-newsession-under-load.md
deleted file mode 100644
index e116193973..0000000000
--- a/.kilo_workflow/learnings/extension-firefox-e2e-newsession-under-load.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# extension: Firefox Selenium e2e dies with `UnsupportedOperationError: newSession` under machine load
-
-Symptom: `e2e:firefox` dies mid-run with `UnsupportedOperationError: newSession` after a varying number of passing scenarios (17, then 9), never on a product assertion.
-
-Cause: geckodriver cannot spawn the next per-scenario Firefox instance while the machine is under heavy load (several parallel agent runs; load average >10). Sessions are created and quit per scenario, so the failure point moves with system pressure.
-
-Fix: retry the command; do not patch product code or the harness for this. A green full run (33/33) followed on the third attempt once load dipped. Verified 2026-07-27.
diff --git a/.kilo_workflow/learnings/mobile-android-dev-client-cold-start-deep-link.md b/.kilo_workflow/learnings/mobile-android-dev-client-cold-start-deep-link.md
index 699742bee3..287b367126 100644
--- a/.kilo_workflow/learnings/mobile-android-dev-client-cold-start-deep-link.md
+++ b/.kilo_workflow/learnings/mobile-android-dev-client-cold-start-deep-link.md
@@ -4,17 +4,19 @@ Symptom: after wrapped ADB `shell am force-stop com.kilocode.kiloapp`, relaunchi
 `am start -n com.kilocode.kiloapp/.MainActivity` lands on the Expo dev-client launcher
 ("Development Build", server URL list) instead of the app; `monkey -p ... LAUNCHER 1` fails
 outright. Separately, `apps/mobile/e2e/login.sh <serial>` fails its settle assert
-("Welcome to Kilo Code|HOME|..." not visible in 15s) and never reaches
+(a known state not visible within the launch budget) and never reaches
 `POST /api/auth/native/otp` — yet minutes later the app is visibly settled on the login screen.
 
 Cause: the dev client needs the Metro URL passed via the preflight deep link
 (`exp+kilo-app://expo-development-client/?url=<url-encoded http://127.0.0.1:$METRO_PORT>`, see
 `apps/mobile/e2e/preflight.sh`). After a force-stop — and on every `login.sh` run, because
 preflight re-opens the deep link — the JS bundle is re-fetched and rebuilt by Metro: 25–65s on
-this machine, and 1–2 minutes under parallel-workflow load, far beyond `settle-app.yaml` (15s)
-and `open-app.yaml` (30s) budgets. The retry path cold-relaunches (`stopApp`), restarting the
-clock. During the reload the screen is uniform white and uiautomator dumps show only the
-status-bar clock.
+this machine, and 1–2 minutes under parallel-workflow load. `settle-app.js`'s first
+`waitVisible(S.ANY_STATE)` budget is 15s; `open-app.js` gives Android cold launches 420s and
+answers `Wait` on ANR dialogs, and login.sh's one retry goes through `open-app.js` — but any
+hand-rolled probe with a short budget still fails during the reload. The retry path
+cold-relaunches (`stopApp`/`launchApp`), restarting the clock. During the reload the screen is
+uniform white and uiautomator dumps show only the status-bar clock.
 
 Fix:
 
@@ -25,9 +27,10 @@ Fix:
   shows static text on screen while the interactive subtree is missing for 60s+).
 - If the AVD may hold a foreign worktree's persisted auth (AVDs are machine-global), run
   `pm clear com.kilocode.kiloapp` first.
-- When `login.sh` fails but the app has since settled (probe with a 20s `extendedWaitUntil`
-  scratch flow), drive sign-in from scratch flows instead of re-running it: tap
-  `you@example.com` → `eraseText` → `inputText $EMAIL` → `pressKey Enter` (submits via
-  `returnKeyType=go`); read the OTP from `dev/logs/emails`, ignoring the 6-digit number in the
-  postal footer; handle `Accept and continue` and the notifications prompt. Preflight's effects
-  (claim check, adb reverses, Metro provenance) survive the failed runs.
+- When `login.sh` fails but the app has since settled (probe with a scratch JS flow that waits
+  ~20s for `you@example.com`), drive sign-in from a scratch JS flow instead of re-running it:
+  `h.tapOn('you@example.com')` → `h.eraseText()` → `h.inputText(EMAIL)` →
+  `h.tapOn('Send sign-in code')`; read the OTP from `dev/logs/emails`, ignoring the 6-digit
+  number in the postal footer; handle `Accept and continue` and the notifications prompt (or
+  reuse `flows/login-request-code.js` / `flows/login-verify-code.js` with `-e`). Preflight's
+  effects (claim check, adb reverses, Metro provenance) survive the failed runs.
diff --git a/.kilo_workflow/learnings/mobile-android-edge-to-edge-ime-insets.md b/.kilo_workflow/learnings/mobile-android-edge-to-edge-ime-insets.md
index 62c96a22b3..b235d1cfab 100644
--- a/.kilo_workflow/learnings/mobile-android-edge-to-edge-ime-insets.md
+++ b/.kilo_workflow/learnings/mobile-android-edge-to-edge-ime-insets.md
@@ -8,14 +8,15 @@ IME but not the other".
 Cause: on API 35 the window carries `pfl=EDGE_TO_EDGE_ENFORCED` + `fl=LAYOUT_IN_SCREEN
 LAYOUT_INSET_DECOR`, so `sim={adjust=resize}` is nominal only — the OS never shrinks the
 window for any IME. The IME arrives purely as a `WindowInsets` source. All layout movement
-is app-side: RN's `KeyboardAvoidingView behavior="height"` is inert (the ScrollView stays
-full-height because the window frame never changes), and the only thing that moves content
-is JS consuming `Keyboard` events — on the login screens that is the OTP form's
-`bottomSpacer = keyboardHeight + 16` padding, which grew the form view by exactly 746px
-(268dp + 16dp) under the number pad and re-centered the `justify-center` container by
-spacer/2 = 373px. `keyboardDidShow` DOES fire with a real height on Android for the number
-pad (268dp = IME height above the nav bar); a listener that attaches while the keyboard is
-already up observes 0 and wrongly concludes the spacer is inert.
+is app-side: RN's `KeyboardAvoidingView` is inert on Android (the window frame never changes —
+login-screen.tsx now enables KAV only on iOS, `behavior="padding"`), and the only thing that
+moves content is JS consuming `Keyboard` events — currently a `paddingBottom:
+androidKeyboardPad` wrapper (`androidKeyboardHeight + insets.bottom`, via
+`resolveAppAwareKeyboardPadding`); under the number pad that padding grows the layout and the
+`justify-center` container re-centers by half the pad (measured 373px for a 268dp IME in the
+r0 build's `keyboardHeight + 16` spacer form). `keyboardDidShow` DOES fire with a real height
+on Android for the number pad (268dp = IME height above the nav bar); a listener that
+attaches while the keyboard is already up observes 0 and wrongly concludes the padding is inert.
 
 How to verify (no code changes):
 
diff --git a/.kilo_workflow/learnings/mobile-e2e-ios-mvcp-suppress-toggle-blanks-list.md b/.kilo_workflow/learnings/mobile-e2e-ios-mvcp-suppress-toggle-blanks-list.md
deleted file mode 100644
index 79018a7bca..0000000000
--- a/.kilo_workflow/learnings/mobile-e2e-ios-mvcp-suppress-toggle-blanks-list.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# mobile: iOS FlashList blanks entirely when maintainVisibleContentPosition is toggled off for one commit and back on (Android tolerates it)
-
-Symptom (pr-review-d957 r5, head df4b6c379): with the deferred-expand path suppressing
-`maintainVisibleContentPosition` for exactly the expand commit (`{disabled: true}` for one
-auto-batched render, re-enabled on a 150ms timeout), EVERY fired top-clipped deferred
-expand on iOS (4/4: gamma, epsilon, zeta geometries, incl. one uninstrumented) leaves the
-discussion list COMPLETELY BLANK — no thread rows in the a11y tree, uniform page-colored
-viewport, not recoverable by swipes; only a remount (tab switch) brings content back.
-`getAbsoluteLastScrollOffset()` at +600ms post-expand reads the deterministic garbage
-value `-997949.6666666666` (identical across runs). The settle itself is healthy
-(`scrollToIndex resolved … match true` at +330-400ms, offset ~786 — the pre-expand park
-lands correctly); the corruption happens at/after the suppressed expand commit or at
-re-enable. Android on the same build PASSES all geometries: offset stable post-expand,
-header parked at y1300 px on screen (gamma 1248 / epsilon 1314 / zeta 1140 dark px in the
-header band, uiautomator title row present).
-
-Consequence for E2E: an iOS blank list after a deferred expand is reproducible 100% and is
-NOT the r1-r4 flight signature (header off-screen by expansion height) — it is a distinct,
-more severe failure mode. Diagnose with a temporary console.log of
-`getLayout(index).y` / `getFirstItemOffset()` / `getAbsoluteLastScrollOffset()` at tap,
-settle-resolved, and +600ms post-expand (the D3R5 trace pattern, 7 anchored insertions in
-`pr-review-discussion-tab.tsx`); the -997949 offset is the smoking gun. Verify blank vs
-flown with a screenshot pixel scan (uniform (251,250,245) below the chrome = blank) plus
-the driver hierarchy showing no `Discussion thread` rows.
-
-iOS tap gotcha recorded on the same runs: coordinate taps at y ≤ ~182pt just under the PR
-screen's tab chrome are silently swallowed (the driver reports delivery, the handler never runs —
-see `ios-tap-swallowed-by-keyboard.md`);
-taps at y ≥ 187pt land. Place clipped-thread expand taps at ≥ y190pt.
-
-Fix direction for the product (not applied): do not toggle `disabled` around the commit on
-iOS — e.g. gate the suppression to Android, or replace it with the recorded fallback
-(exact `scrollToOffset` settle, completion-polled) so mVCP is never cycled.
diff --git a/.kilo_workflow/learnings/mobile-e2e-top-clip-positioning-flashlist-clamp.md b/.kilo_workflow/learnings/mobile-e2e-top-clip-positioning-flashlist-clamp.md
index ba47e65583..57992de3a7 100644
--- a/.kilo_workflow/learnings/mobile-e2e-top-clip-positioning-flashlist-clamp.md
+++ b/.kilo_workflow/learnings/mobile-e2e-top-clip-positioning-flashlist-clamp.md
@@ -17,10 +17,12 @@ Cause: two independent constraints.
    stay byte-identical. Do not retry them in a loop — they never land.
 
 Working sequence per platform:
-- Load page 2 first (`scrollUntilVisible` 'Load more comments' + tap), or expand a thread
+- Load page 2 first (`scrollUntilVisible('Load more comments')` + tap), or expand a thread
   below the target to grow content.
-- Approach with 30% swipes, one gesture at a time with a hierarchy probe between
-  (back-to-back gestures after big swipes get ignored intermittently).
+- Approach with long drags (~30% of screen height) via a raw W3C-actions swipe — the helpers
+  expose only `swipeUp(sign)` flicks, so build the drag with `driver.performActions` — one
+  gesture at a time with an `appium.sh <device> hierarchy` probe between (back-to-back
+  gestures after big swipes get ignored intermittently).
 - Final 40-100px positioning: iOS — a 6-8% swipe usually lands once the clamp is released;
   Android — `adb shell input swipe x y1 x y2 300` works reliably but ONLY once the offset
   can grow (it is also clamped, not broken).
diff --git a/.kilo_workflow/learnings/mobile-github-stub-git-token-service-503.md b/.kilo_workflow/learnings/mobile-github-stub-git-token-service-503.md
deleted file mode 100644
index 46d9733872..0000000000
--- a/.kilo_workflow/learnings/mobile-github-stub-git-token-service-503.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# mobile: "GitHub connection expired" against hermetic stub = git-token-service 503
-
-Symptom: PR-review E2E with the hermetic GitHub stub opens the PR then stalls on "GitHub connection expired / Check connection"; the stub request log shows only the first `pulls/<n>` fetch; nextjs logs repeated `githubPrReview.getPullRequest 412`.
-
-Cause: `withGitHubUserTokenRetry` resolves the user's GitHub token through git-token-service before any outbound call; the service's `POST /internal/github-user-authorizations/token` returned `503 authentication_unavailable` because its `NEXTAUTH_SECRET_DEV` Secrets Store binding had never been created in this worktree (Secrets Store state is local to each Worker directory). A missing-URL or key-drift `USER_GITHUB_APP_TOKEN_*` envelope produces the same 412 surface.
-
-Fix: `pnpm dev:env -y cloudflare-git-token-service` (creates `NEXTAUTH_SECRET_DEV` and syncs the `USER_GITHUB_APP_TOKEN_*` envelope into the worker env from root `.env.local`), then `pnpm dev:restart cloudflare-git-token-service`. Smoke with an authenticated `GET /api/trpc/githubPrReview.getPullRequest?...owner=kilo-stub...` — expect 200, not 412. Note nextjs reads `GIT_TOKEN_SERVICE_API_URL` from `apps/web/.env.development.local`, not from root `.env.local`.
diff --git a/.kilo_workflow/learnings/mobile-github-stub-seed-github-user-id-collision.md b/.kilo_workflow/learnings/mobile-github-stub-seed-github-user-id-collision.md
deleted file mode 100644
index 968df3b73d..0000000000
--- a/.kilo_workflow/learnings/mobile-github-stub-seed-github-user-id-collision.md
+++ /dev/null
@@ -1,24 +0,0 @@
-# mobile: devSeedUserGithubToken 500s when a sibling e2e user already owns github_user_id 999001
-
-Symptom: `githubApps.devSeedUserGithubToken` with `githubUserId: "999001"` returns a 500
-("Failed query: insert into user_github_app_tokens ... on conflict ..."), even though the
-runbook says a sibling seed should surface as a benign `upserted: false`.
-
-Cause: the local postgres on this machine is SHARED across worktrees (this worktree's stack
-used the base `postgres` DB on localhost:5432 — the `postgres-N` DBs belong to other flows;
-find yours via `select count(*) from user_auth_provider where provider_account_id='<e2e email>'`
-across DBs). A previous section seeded github_user_id 999001 for a DIFFERENT kilo_user_id
-(`e2e-mobile-mobile-audit-w1-pr-safety@example.com`). The upsert targets
-(kilo_user_id, github_app_type); with no row for YOUR user it attempts a plain insert, which
-violates unique index `UQ_user_github_app_tokens_github_user_app` on (github_user_id, app_type).
-
-Fix: list existing ids first —
-`psql -h localhost -p 5432 -U postgres -d postgres -c "select github_user_id, github_login from user_github_app_tokens"`
-— and seed with a FREE id (999003 worked). The github_user_id value only feeds the token
-envelope AAD, which round-trips through the same row, so any unique value works against the stub.
-
-Also: the seed mutation needs an authenticated call. The web fake-login cookie path did NOT
-satisfy tRPC (`UNAUTHORIZED`). Working path with curl, same as the app's own native login:
-`POST /api/auth/native/otp {email}` → read the 6-digit code from the newest `dev/logs/emails/*.html`
-→ `POST /api/auth/native/token {provider:'email', email, code}` → `{token}` → call tRPC with
-`Authorization: Bearer <token>`.
diff --git a/.kilo_workflow/learnings/mobile-ios-cold-build-shareextension-pods-root.md b/.kilo_workflow/learnings/mobile-ios-cold-build-shareextension-pods-root.md
deleted file mode 100644
index 02c1cf5010..0000000000
--- a/.kilo_workflow/learnings/mobile-ios-cold-build-shareextension-pods-root.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# mobile-ios-cold-build-shareextension-pods-root
-
-Symptom: a genuinely cold `pnpm dev:mobile:ios build <udid>` (cache-busted) fails at
-link with `(3 failures)` and one root error:
-`error: unable to spawn process '/../../../../node_modules/.pnpm/react-native@0.86.0[_patch_hash=...]/node_modules/react-native/scripts/xcode/ccache-clang.sh' (No such file or directory) (in target 'ShareExtension' from project 'Kilo')`.
-
-Cause: the generated `apps/mobile/ios/Kilo.xcodeproj` sets project-level
-`REACT_NATIVE_PATH = "${PODS_ROOT}/../../../../node_modules/...react-native"` and
-`CC/CXX/LD/LDPLUSPLUS = "$(REACT_NATIVE_PATH)/scripts/xcode/ccache-clang[++] .sh"`.
-`PODS_ROOT` is defined only by Pods target xcconfigs, so for the ShareExtension
-target (no Pods xcconfig) `PODS_ROOT` expands empty and the spawn path resolves to
-`/node_modules/...`. Warm-cache iOS runs never hit this; the template is
-tree-independent (present with or without the Hermes patch).
-
-Workaround used in the round (temporary, in the gitignored generated project):
-replace the project-level Debug `REACT_NATIVE_PATH` line with the absolute correct
-path (delete duplicates — a later duplicate key wins). Build then succeeds.
-Proper fix candidate for the repo: have the ShareExtension config plugin set an
-absolute REACT_NATIVE_PATH (or stop overriding CC/LD) for that target.
diff --git a/.kilo_workflow/learnings/mobile-pr-review-deep-link-route.md b/.kilo_workflow/learnings/mobile-pr-review-deep-link-route.md
deleted file mode 100644
index 363e07ea6e..0000000000
--- a/.kilo_workflow/learnings/mobile-pr-review-deep-link-route.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# mobile: deep-linking an app route via the exp+kilo-app dev-client URL fails; use the kiloapp scheme
-
-Symptom: `xcrun simctl openurl <udid> "exp+kilo-app://expo-development-client/?url=http%3A%2F%2F<ip>%3A<metro-port>%2Fpr-review"` lands on the dev client error screen "There was a problem loading the project. Failed to load app from http://<ip>:<port>/pr-review".
-
-Cause: the dev client treats the entire `url` param as the Metro packager root; a route path appended to it makes the manifest fetch 404. The dev client does not parse app routes out of the packager URL (Expo SDK 54 dev client, iOS).
-
-Fix: two-step navigation: (1) connect with the BARE Metro URL (`...?url=http%3A%2F%2F<ip>%3A<port>`), wait for `iOS Bundled`; (2) `xcrun simctl openurl <udid> "kiloapp://<route>"` (app scheme `kiloapp`, no SpringBoard confirmation). Drive the `kiloapp://<route>` link with `simctl openurl` (iOS) or `adb am start` (Android, see runbook "App Links") — but only after the app has finished cold-booting (gate on a restored-route element first; a link fired during boot is dropped).
diff --git a/.kilo_workflow/learnings/mobile-remote-cli-model-id-prefix.md b/.kilo_workflow/learnings/mobile-remote-cli-model-id-prefix.md
deleted file mode 100644
index 91482b6df5..0000000000
--- a/.kilo_workflow/learnings/mobile-remote-cli-model-id-prefix.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# mobile: remote-cli.sh exec run -m kilo-auto/efficient fails ProviderModelNotFoundError — CLI ids need the kilo/ prefix
-
-Symptom: `apps/mobile/e2e/remote-cli.sh exec run -m kilo-auto/efficient --auto "<prompt>"` fails
-with `ProviderModelNotFoundError` / `Model not found: kilo-auto/efficient`, and the run still
-creates an empty session row in the mobile Agents list.
-
-Cause: the handoff/workflow "kilo-auto/efficient" id is the IN-APP id. The CLI's provider/model
-format needs the provider prefix: `kilo/kilo-auto/efficient` (WORKFLOW.md's "kilo/kilo-auto/* are
-the same models as CLI ids" is the only place this is stated, and it is easy to read past).
-
-Fix: run `apps/mobile/e2e/remote-cli.sh exec models` first and copy the exact id
-(`kilo/kilo-auto/efficient`); never guess from the in-app id. Side effect to expect: each failed
-run leaves an empty `New session - <ts>` row in the session list — harmless, but do not confuse
-it with the content session when picking rows to tap.
-
-Bonus: a fresh E2E account starts with $0 credit; `kilo/kilo-auto/efficient` then fails with
-"Add credits to continue". Seed first:
-`pnpm dev:seed app:user-id <email>` then `pnpm dev:seed app:add-credits <user-id> 10`.
diff --git a/.kilo_workflow/learnings/mobile-rename-entry-points-and-field-clearing.md b/.kilo_workflow/learnings/mobile-rename-entry-points-and-field-clearing.md
index 9fb397bd83..44b2cad6c3 100644
--- a/.kilo_workflow/learnings/mobile-rename-entry-points-and-field-clearing.md
+++ b/.kilo_workflow/learnings/mobile-rename-entry-points-and-field-clearing.md
@@ -9,11 +9,13 @@ session-detail header (pressable title, a11y label `Rename session: <title>`, op
 A live session is hoisted out of history into the tray, so while it is live its only row is the
 non-renameable tray row. To rename a live session on device: tray row tap → detail → tap title.
 
-Fix (flow notes, verified on iOS 26.5 simulator):
-- History row: `longPressOn: '<title>(.)*'` → tap `Rename` → native Alert.prompt: `eraseText: 40`
-  then `inputText: '<new>'`, VERIFY the field value via hierarchy before tapping the alert's
-  `Rename` button (this machine's inputText appends/doubles on non-empty fields; erase-first worked
-  on both the native prompt and the RN RenameModal field `Session name`).
-- Detail header: tap `Rename session:(.)*` → field a11y `Session name` → same erase+input+verify →
-  tap `Save`. Tap target `Rename` regex is full-string: `Rename session: <title>` will not match a
-  bare `Rename` pattern — the sheet option and the alert button both match `Rename` exactly.
+Fix (flow notes, JS flows in `apps/mobile/e2e/flows/`):
+- History row: long-press (W3C actions longPress) the row matching /<title>(.)*/ → tap
+  `Rename` → native prompt: `await h.eraseText(40)` then `await h.inputText('<new>')`,
+  VERIFY the field value via `appium.sh <device> hierarchy` before tapping the alert's
+  `Rename` button (inputText appends/doubles on non-empty fields; erase-first worked on both
+  the native prompt and the RN RenameModal field `Session name`).
+- Detail header: tap /Rename session:(.)*/ → field a11y `Session name` → same
+  erase+input+verify → tap `Save`. The header target regex is full-string: a bare `Rename`
+  pattern will not match it — the sheet option and the alert button both match `Rename`
+  exactly.
diff --git a/.kilo_workflow/learnings/mobile-simulator-claim-killed-mid-boot.md b/.kilo_workflow/learnings/mobile-simulator-claim-killed-mid-boot.md
deleted file mode 100644
index 1953f2d068..0000000000
--- a/.kilo_workflow/learnings/mobile-simulator-claim-killed-mid-boot.md
+++ /dev/null
@@ -1,29 +0,0 @@
-# mobile: a simulator claim killed mid-boot reclaims as alreadyOwned but leaves the device Shutdown (build then fails code=405)
-
-Symptom: `.kilo_workflow/e2e-start-resource.sh ios` is interrupted (e.g. the invoking shell's own
-command timeout kills it) after it wrote the claim lock but before the boot finished.
-(A fresh claim boots before it renames, so the `Kilo E2E - <worktree>` label may or may
-not have been applied yet at the moment of the kill.) A later
-`.kilo_workflow/e2e-start-resource.sh ios` returns instantly with `alreadyOwned: true` and does
-**not** boot the device. `pnpm dev:mobile:ios build <udid>` then fails:
-
-```
-An error was encountered processing the command (domain=com.apple.CoreSimulator.SimError, code=405):
-Unable to lookup in current state: Shutdown
-```
-
-Cause: the reclaim path (`alreadyOwned`) returns before the boot step entirely; only a
-fresh claim boots. The device is left Shutdown with the claim lock in place (the reclaim
-reapplies the label if the killed attempt never got to it).
-
-Fix (no re-claim needed, claim is idempotent):
-
-```bash
-xcrun simctl boot <udid>
-xcrun simctl bootstatus <udid> -b   # wait for readiness
-pnpm dev:mobile:ios build <udid>    # now installs
-```
-
-Prevention: run `.kilo_workflow/e2e-start-resource.sh ios` with a generous timeout (>= 10 min) —
-booting an iPhone under parallel-workflow load exceeds 3 minutes on this machine, and the
-default 2–3 minute shell timeouts kill the claim at exactly the wrong moment.
diff --git a/.kilo_workflow/learnings/mobile-tablet-app-startup-broken.md b/.kilo_workflow/learnings/mobile-tablet-app-startup-broken.md
deleted file mode 100644
index 86e045d5c7..0000000000
--- a/.kilo_workflow/learnings/mobile-tablet-app-startup-broken.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# mobile: app startup/consent unusable on tablet simulators (iPad + tablet AVD) — blocks tablet E2E login
-
-Symptom (observed 2026-07-29, pr-review-d957, both surfaces on the same day):
-- iPad Pro 11-inch (iOS 26.5): app boots to "Welcome to Kilo Code" but the consent body
-  and `Accept and continue` button never enter the a11y tree (logo + title only, "1 page"
-  scroll bars). `login.sh` and its cold-relaunch retry both fail — never reaches the email
-  field.
-- kilo_pixel_tablet_api35 (Android): after the dev-client deep link, the resumed
-  MainActivity exposes NO app content (a11y tree = status bar only; screenshot pixels are
-  mostly black + page-bg). Metro serves the Android bundle fine. force-stop + deep-link
-  relaunch (the one supported recovery) does not recover.
-
-The phone surfaces (iPhone 17 Pro iOS 26.5, kilo_pixel9_api35) work the same day, so this
-is tablet-form-factor specific. The welcome/consent screen and startup are outside any
-PR-review change area. Impact: tablet side-by-side regression checks (PR-review flow 9)
-are environment-limited until app startup on tablets is fixed; do not classify PR-area
-failures from tablet evidence until login works there.
diff --git a/.kilo_workflow/learnings/oxfmt-formats-yaml-workflow-files.md b/.kilo_workflow/learnings/oxfmt-formats-yaml-workflow-files.md
deleted file mode 100644
index 7124e4d12e..0000000000
--- a/.kilo_workflow/learnings/oxfmt-formats-yaml-workflow-files.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# oxfmt formats YAML — workflow files must pass `pnpm format:check` too
-
-Symptom: `pnpm format:check` fails on a newly written GitHub Actions workflow YAML even when the
-content was copied verbatim from a reviewed plan whose evidence claimed "oxfmt has no YAML
-coverage".
-
-Cause: oxfmt (repo root formatter, 0.40.0) does cover `*.yml`/`*.yaml` — observed 2026-07-28 on
-`.github/workflows/extension-store-release.yml`, where it collapsed comment-alignment whitespace
-(`contents: write       # comment` → `contents: write # comment`). A plan written against the
-"no YAML coverage" assumption produces files that fail the check, and `ci.yml` enforces
-format-check on every PR.
-
-Fix: after writing or editing workflow YAML, run `pnpm format` and accept oxfmt's rewrite before
-declaring the slice done. Block-scalar (`run: |`) bodies are preserved — including heredoc
-indentation — but diff the formatter's output against the intended content before committing so a
-future formatter version cannot silently alter load-bearing whitespace.
diff --git a/.kilo_workflow/learnings/pr-review-d957-stub-edit-extraction-from-verifier-logs.md b/.kilo_workflow/learnings/pr-review-d957-stub-edit-extraction-from-verifier-logs.md
deleted file mode 100644
index e550f89190..0000000000
--- a/.kilo_workflow/learnings/pr-review-d957-stub-edit-extraction-from-verifier-logs.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# pr-review-d957: re-applying the GitHub-stub temp fixture edits from prior verifier logs
-
-The sanctioned temp edits to `apps/mobile/e2e/github-api-stub/server.mjs` (9 threads
-[a,b,c open + r1-r6 resolved], 8 long-patch files, `/files` route, page cap 5,
-per-fixture counts) exist only inside `e2e-verifier-r0.log` / `-r1.log` as Edit-tool
-unified diffs — no patch file was ever saved.
-
-Extraction traps (cost ~30min in r3):
-1. Each Edit block appears TWICE consecutively in the log (terminal echo) — dedupe
-   consecutive identical blocks (12 blocks → 6 unique).
-2. The diffs' context lines lost leading whitespace (a log artifact; dedent varies per
-   hunk: 2-4 spaces) — they do NOT match the pristine file, so `git apply` of the
-   concatenated hunks fails.
-3. The `+` lines and the `@@` line numbers ARE intact; `@@` numbers are in
-   evolving-file coordinates (each Edit diffed the already-edited file).
-
-Working recipe: `git apply` hunks 1-2 (their context survived), then for hunks 3-6
-extract only the `+` lines, re-indent to match sibling code, and insert by anchored line
-surgery at the real file locations (thread-array close, `conversationComment(2006,...)`,
-`changed_files: 2,` triple, before the check-runs route). r1's page-cap edit (not in r0)
-goes in the `PrReviewThreads` handler verbatim from the r1 log. Verify with
-`node --check` plus curl probes: `/pulls/1/files` → 8 files with 4-13KB patches;
-GraphQL `PrReviewThreads` page 1 → 5 threads hasNextPage=true, page 2 → 4 threads
-(r4-r6,c). r3's ready-made hunk files and insert content are in
-`$SCRATCH/e2e-r3/hunk*.patch` / `hunk*-insert.txt`.
diff --git a/apps/extension/AGENTS.md b/apps/extension/AGENTS.md
index 0cd6405603..69b6c313a4 100644
--- a/apps/extension/AGENTS.md
+++ b/apps/extension/AGENTS.md
@@ -29,6 +29,10 @@ pnpm --filter kilo-extension zip:firefox
 pnpm --filter kilo-extension validate:firefox
 ```
 
+Analytics E2E specs need the key at BUILD time: targeted manual runs must rebuild with `VITE_POSTHOG_API_KEY=e2e-test-key pnpm --filter kilo-extension build` first (the `e2e:chrome` script does this itself; without the key analytics is compiled out and every event wait fails).
+
+Under heavy machine load `e2e:firefox` can die mid-run with `UnsupportedOperationError: newSession` (geckodriver cannot spawn the next per-scenario Firefox). Retry the command; never patch product code or the harness for this.
+
 Before committing extension changes, run `pnpm format`. Prefer `pnpm --filter kilo-extension verify` over full-repo typecheck unless the change crosses package boundaries.
 
 ## Browser Targets
diff --git a/apps/mobile/e2e/AGENTS.md b/apps/mobile/e2e/AGENTS.md
index fcca14ed13..3f059b1f0a 100644
--- a/apps/mobile/e2e/AGENTS.md
+++ b/apps/mobile/e2e/AGENTS.md
@@ -99,6 +99,12 @@ PR-review E2E needs a local GitHub API instead of `api.github.com`. Three steps,
    `tmux new-session -d -s "kilo-e2e-github-stub-$(basename "$PWD")" -c "$PWD/apps/mobile/e2e/github-api-stub" "node server.mjs <port>"`.
    Stop that session when finished. Request logs go to `GITHUB_STUB_LOG` or `./github-api-stub-requests.log` under the process cwd — keep them out of the tree (temp dir) and delete them after the run.
 
+If the app stalls on "GitHub connection expired" with nextjs logging repeated
+`githubPrReview.getPullRequest 412` and the stub log shows only the first fetch,
+git-token-service is missing its per-worktree Secrets Store binding:
+`pnpm dev:env -y cloudflare-git-token-service && pnpm dev:restart cloudflare-git-token-service`.
+Note nextjs reads `GIT_TOKEN_SERVICE_API_URL` from `apps/web/.env.development.local`, not root `.env.local`.
+
 Pinned surface only: REST pull/repo/check-runs/statuses/`pulls/{n}/files` (paginated via `page`/`per_page`) plus GraphQL ops `PrReviewDecision`, `PrReviewThreads`, `PrReviewThreadComments`, `PrReviewConversationComments`. Fixture identities: `kilo-stub/discussion-mixed#1`, `kilo-stub/discussion-conversation-only#2`, `kilo-stub/discussion-empty#3`.
 
 ## iOS Simulator
@@ -112,7 +118,7 @@ and boots it:
 .kilo_workflow/e2e-stop-resource.sh ios          # this worktree's claims
 ```
 
-The wrapper renames the claimed device to `Kilo E2E - <sanitized-worktree-basename>` and restores the original name on release. Never call `xcrun simctl rename` yourself. The claim also records whether it was the thing that booted the device, which is what lets release power off only the devices it started — so never boot or shut down an E2E simulator with `xcrun simctl` behind the wrapper's back. A claim is stale — and silently reclaimable — once its owning worktree is deleted.
+The wrapper renames the claimed device to `Kilo E2E - <sanitized-worktree-basename>` and restores the original name on release. Never call `xcrun simctl rename` yourself. The claim also records whether it was the thing that booted the device, which is what lets release power off only the devices it started — so never boot or shut down an E2E simulator with `xcrun simctl` behind the wrapper's back. A claim is stale — and silently reclaimable — once its owning worktree is deleted. One exception: a claim killed mid-boot returns instantly as already-owned WITHOUT booting on the next claim, and `pnpm dev:mobile:ios build` then fails `code=405 "Unable to lookup in current state: Shutdown"` — recover with `xcrun simctl boot <udid> && xcrun simctl bootstatus <udid> -b`, and give claims a >=10-minute timeout under parallel-workflow load.
 
 Install a validated cached native build. A compatible fingerprint skips rebuilding; a cache miss serializes through the host-wide native compiler semaphore. Never install an arbitrary DerivedData app or run a separate Expo native build:
 
@@ -127,6 +133,8 @@ xcrun simctl openurl <udid> \
   "exp+kilo-app://expo-development-client/?url=http%3A%2F%2F<lan-ip>%3A<metro-port>"
 ```
 
+Never append an app route to the dev-client `url` param — the dev client treats the whole param as the Metro packager root and the manifest fetch 404s. Connect with the BARE Metro URL, wait for `iOS Bundled`, then drive routes via `xcrun simctl openurl <udid> "kiloapp://<route>"` (app scheme `kiloapp`, no SpringBoard confirmation) — only after cold-boot finishes; a link fired during boot is dropped.
+
 - Prefer `simctl openurl` for scheme reconnection; it skips Safari's external-app confirmation. Since universal links (`associatedDomains`) were configured, iOS may instead show a SpringBoard confirmation with the exact message `Open in "Kilo"?` (curly or straight quotes) — the shared launch flows match both wordings and tap `Open`. When a flow intentionally goes through Safari or a WebView, look for the exact message `Open this page in "Kilo"?` and tap the exact `Open` accessibility action — one bounded optional prompt inside the existing five-second optional-prompt budget, never a new fixed wait.
 - Before testing, capture the `mobile` pane and verify `Starting project at <this-worktree>/apps/mobile` plus a fresh `iOS Bundled` line. Seeing the Kilo login screen does not prove the bundle came from this worktree.
 - The dev client reads `expoConfig.extra.apiBaseUrl` and `_internal.projectRoot` from Metro's manifest; the login preflight checks both against this worktree. After env changes: regenerate env, restart Metro, reconnect the dev client to the exact Metro URL, and reload. Rebuild only when native config or plugins changed.
@@ -222,6 +230,8 @@ apps/mobile/e2e/remote-cli.sh exec run "say hello"     # non-interactive run
 
 The real-time relay (`remote`) blocks until SIGTERM — a one-shot `exec remote` exits and the relay dies with it. Run it persistently in its own `kilo-e2e-*` tmux window (or send `/remote` to the running TUI session) and keep it alive for the whole flow.
 
+`-m` takes CLI provider/model ids, not in-app ids: use `kilo/kilo-auto/efficient`, never `kilo-auto/efficient` (that fails `ProviderModelNotFoundError` and leaves an empty `New session - <ts>` row — harmless, but do not confuse it with the content session). Run `remote-cli.sh exec models` and copy the exact id. A fresh E2E account has $0 credit — seed with `pnpm dev:seed app:add-credits <user-id> 10` first.
+
 Role agents reuse the orchestrator-prepared session and verify discovery and mirroring by inspecting its pane and the mobile list:
 
 ```bash

From bd971807972b0a6bf000ae83ec8a698b4f9e6870 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 03:28:31 +0200
Subject: [PATCH 23/34] feat(workflow): idiot-proof slot lifecycle, drop dead
 options, automate guards

Ponytail deletions: pr-threads reply/resolve (close covers both), pr-gate
--bot, await --timeout/--stall/--quiet knobs, upload --version mode,
launch-gate impossible clamp, duplicated prose in WORKFLOW.md/README.

Automation (learning graduation):
- dispatch-role refuses e2e-verifier onto a dirty worktree (baseline
  restore would read concurrent edits as false failures)
- e2e-free-slot refuses while the worktree owns a live stack, emulator
  session, remote CLI, stub, or device claim
- e2e-stop-resource ios/android stops the Appium servers of claimed devices
- e2e-start-resource stack refreshes session-ingest bindings, migrates,
  and fails fast on services or the docker bridge never coming up
- same-worktree simulator reclaim boots a device left Shutdown by a
  killed-mid-boot claim (was: alreadyOwned + build 405)
- dev:restart mobile clears this worktree's stale Metro file-map
  (white-screen-after-relayout learning graduated and deleted)
---
 .kilo_workflow/README.md                      |  2 +-
 .kilo_workflow/WORKFLOW.md                    | 13 ++---
 .kilo_workflow/await-interactive.sh           |  8 +--
 .kilo_workflow/await-role.sh                  | 14 ++----
 .kilo_workflow/dispatch-role.sh               | 10 ++++
 .kilo_workflow/e2e-free-slot.sh               | 37 +++++++++++++-
 .kilo_workflow/e2e-start-resource.sh          | 28 ++++++++++-
 .kilo_workflow/e2e-stop-resource.sh           | 20 +++++++-
 .kilo_workflow/launch-gate.sh                 |  1 -
 ...e-map-stale-after-node-modules-relayout.md | 20 --------
 .kilo_workflow/pr-gate.sh                     |  4 +-
 .kilo_workflow/pr-threads.sh                  | 11 +---
 .kilo_workflow/upload-pr-attachment.sh        | 50 ++++++++-----------
 apps/mobile/e2e/AGENTS.md                     | 28 ++++-------
 dev/local/cli.ts                              | 27 ++++++++++
 dev/local/mobile-simulator.test.ts            | 38 +++++++++++++-
 dev/local/mobile-simulator.ts                 | 22 ++++++++
 dev/local/workflow-scripts.test.ts            | 30 +++++++++--
 18 files changed, 251 insertions(+), 112 deletions(-)
 delete mode 100644 .kilo_workflow/learnings/mobile-metro-file-map-stale-after-node-modules-relayout.md

diff --git a/.kilo_workflow/README.md b/.kilo_workflow/README.md
index b5ee0ec032..ae7d970e1f 100644
--- a/.kilo_workflow/README.md
+++ b/.kilo_workflow/README.md
@@ -68,4 +68,4 @@ A section can still take hours of unattended machine time when builds or live E2
 
 A standing rule from the spec: **anything that can be automated away, should be automated away.** Agents' tokens go to the work, not to battling the workflow or the environment — when a run stumbles on something a script or a document could have prevented, the run fixes the script or the document in the same PR, and learnings that graduate into automation get deleted.
 
-Role definitions live in the repository root `.kilo/agent/` (the kilo CLI only discovers agents there). The workflow self-heals: when a run stumbles on something this documentation could have prevented, it fixes the documentation in the same PR.
+Role definitions live in the repository root `.kilo/agent/` (the kilo CLI only discovers agents there). 
\ No newline at end of file
diff --git a/.kilo_workflow/WORKFLOW.md b/.kilo_workflow/WORKFLOW.md
index 366a376baa..0430b07ba2 100644
--- a/.kilo_workflow/WORKFLOW.md
+++ b/.kilo_workflow/WORKFLOW.md
@@ -21,7 +21,7 @@ These apply to every role. Later sections do not repeat them.
 - Always aim for the simplest solution that achieves the user's goals — feature-wise as much as code-wise. Reuse existing helpers, components, and contracts. Do not add abstraction or scope without evidence it is required.
 - Commit in small, logically scoped commits. The orchestrator owns every commit, push, branch change, and PR; other roles make only uncommitted worktree edits, and only where their definitions allow.
 - Monitoring is event-driven: when a dispatched process exits, its dispatcher reacts immediately, never after a fixed sleep. Periodic checks exist only to detect a wedge.
-- Tokens go to the work, never to fighting the workflow or the environment. Every mechanical step that can be scripted is scripted — `init-section.sh`, `dispatch-role.sh`, `await-role.sh`, `launch-interactive.sh`, `launch-gate.sh`, `await-interactive.sh`, `steer.sh`, the five `e2e-*` lifecycle scripts, `slice-diff.sh`, `baseline.sh`, `pr-threads.sh`, `pr-gate.sh`, `pick-reviewers.sh`, `upload-pr-attachment.sh` — use the script, never hand-assemble its steps. **Anything that can be automated away, should be automated away:** when a run stumbles on something a script or an instruction could have prevented, fix the script or the document in the same run (see Learnings).
+- Tokens go to the work, never to fighting the workflow or the environment. Every mechanical step that can be scripted is scripted — `init-section.sh`, `dispatch-role.sh`, `await-role.sh`, `launch-interactive.sh`, `launch-gate.sh`, `await-interactive.sh`, `steer.sh`, the five `e2e-*` lifecycle scripts, `slice-diff.sh`, `baseline.sh`, `pr-threads.sh`, `pr-gate.sh`, `pick-reviewers.sh`, `upload-pr-attachment.sh` — use the script, never hand-assemble its steps. **Anything that can be automated away, should be** (see Learnings).
 - Learnings are the residue automation cannot reach. Before any environment-dependent phase, list both learnings directories — the worktree's `.kilo_workflow/learnings/` and the main checkout's `~/Projects/cloud/.kilo_workflow/learnings/system/` (the canonical machine-local set, which mid-run writes go to and worktree copies lag) — and read the entries whose names match your surface; filenames are symptom-keyed. When a tool or environment failure blocks you mid-run, grep both directories for the error text before debugging from scratch: a prior run has usually already paid for the answer.
 
 ### Models
@@ -56,9 +56,9 @@ The cwd/worktree is always the **cloud** worktree, even when the slice edits a s
 
 What the script encodes (details in its header comments):
 
-- tmux wrapping — harness command timeouts kill bare long runs. Roles run as windows in the dispatcher's session, resolved through `$TMUX_PANE`; a dispatcher outside tmux gives the role its own session. The script appends a unique dispatch id: names are `<section>-<role>-<label>-<id>`, logs `$SCRATCH/<role>-<label>-<id>.log`; parallel and repeated labels cannot share artifacts.
+The script prints the log path for `await-role.sh`; it guarantees tmux wrapping (a dispatcher outside tmux gives the role its own session), unique per-dispatch names and logs, and the redirection + `EXITCODE` marker the await script judges.
+
 - Full `KILO_*`/`OPENCODE*` env strip — a child kilo inheriting `KILO_*`/`OPENCODE*` (from a parent kilo or the tmux server environment) misattaches sessions and auth. If the tmux server itself is poisoned, clear it with `tmux set-environment -g -u <var>`.
-- Output redirected, never piped (`| tee` makes `$?` report the pipe's exit, not kilo's), with `EXITCODE=$?` appended as the log's last line.
 - `--auto` on every dispatch — a plain `kilo run` auto-rejects any permission ask (some paths ask regardless of what the agent definition grants) and still exits 0 with no verdict, which reads as a pass. Never strip the flag; any non-interactive `kilo run` outside `dispatch-role.sh` must pass it explicitly.
 
 Wait with [`await-role.sh`](await-role.sh) — never a hand-rolled loop (exit codes lie, whole-log sentinel greps false-pass on quoted sentinels, and a stalled run never writes its marker):
@@ -94,12 +94,7 @@ Worker roles are steered by re-dispatching them (see Escalation). The interactiv
 printf '%s' "$AMENDMENT" | .kilo_workflow/steer.sh <section>-orchestrator -   # long or multi-line text via stdin
 ```
 
-It prints `running` when the session took the message immediately and `queued` when the message is waiting behind the active turn; either way it is delivered. A non-zero exit means it is **not** delivered — inspect the target rather than sending a second copy. What the script encodes (details in its header comments):
-
-- Enter as its own keystroke after the text. A trailing `Enter` in the same `send-keys` call submits short messages but is swallowed by long ones, which then sit unsent in the composer — the "wedged" session that is really an undelivered message.
-- Bracketed paste, so a multi-line message stays one prompt. An unbracketed paste submits at every newline, and the first fragment gets acted on before the rest arrives.
-- A refusal to paste into a pane that is not running the kilo CLI — a mistargeted steer executes in a shell.
-- Delivery confirmed from the pane, never assumed.
+It prints `running` when the session took the message immediately and `queued` when the message is waiting behind the active turn; either way it is delivered. A non-zero exit means it is **not** delivered — inspect the target rather than sending a second copy. Delivery mechanics (Enter as its own keystroke, bracketed paste, non-kilo-pane refusal, pane-confirmed delivery) are enforced by the script — see its header.
 
 **`N queued` in the footer is delivery working, not a wedge.** Queued messages land one at a time at turn boundaries, in order, and a session that chains tool calls for tens of minutes holds the whole queue that entire time. Never kill, relaunch, or escalate on a queue count; a wedge needs its own evidence (frozen build timer, stream or api error, dead process — see Monitor Mode). `Escape` does not flush the queue.
 
diff --git a/.kilo_workflow/await-interactive.sh b/.kilo_workflow/await-interactive.sh
index 1e277d6f53..b889d0443f 100755
--- a/.kilo_workflow/await-interactive.sh
+++ b/.kilo_workflow/await-interactive.sh
@@ -5,7 +5,7 @@
 # leaves a final report in it — and a dead window is only a crash when
 # neither of those happened.
 #
-#   await-interactive.sh <tmux-target> <scratch-dir> [--log <file>] [--timeout <sec>] [--quiet <sec>]
+#   await-interactive.sh <tmux-target> <scratch-dir> [--log <file>]
 #
 # Blocks up to --timeout (default 1500s, the ~25-minute monitor cadence),
 # then reports. Prints exactly one line:
@@ -14,7 +14,7 @@
 #   BLOCKED <report>    exit 5  final-report.md present — relay it, leave scratch
 #   DEAD                exit 2  target gone, scratch present, no report — a
 #                               crash; relaunch fresh with a continuation handoff
-#   QUIET <sec>s        exit 3  --log given and stagnant past --quiet (default
+#   QUIET <sec>s        exit 3  --log given and stagnant past the quiet budget (default
 #                               1200s) with the target alive. NOT a verdict:
 #                               read the pane first — a hands-on question or
 #                               queued steers look exactly like this
@@ -23,12 +23,12 @@ set -euo pipefail
 
 TARGET=${1:?tmux target} SCRATCH=${2:?scratch dir}
 shift 2
+# 25 minutes per invocation; 20 quiet transcript seconds reports QUIET.
+# Tune by editing these two numbers — never by adding call-site options.
 LOGFILE="" TIMEOUT=1500 QUIET=1200
 while [ $# -gt 0 ]; do
   case $1 in
     --log) LOGFILE=${2:?}; shift 2 ;;
-    --timeout) TIMEOUT=${2:?}; shift 2 ;;
-    --quiet) QUIET=${2:?}; shift 2 ;;
     *) echo "await-interactive: unknown option $1" >&2; exit 1 ;;
   esac
 done
diff --git a/.kilo_workflow/await-role.sh b/.kilo_workflow/await-role.sh
index 088e52b602..a63e90846e 100755
--- a/.kilo_workflow/await-role.sh
+++ b/.kilo_workflow/await-role.sh
@@ -5,7 +5,7 @@
 # sentinel false-passes when the agent quoted one, and a stalled run can sit
 # forever without ever writing its marker.
 #
-#   await-role.sh <log> [--timeout <sec>] [--stall <sec>]
+#   await-role.sh <log>
 #
 # Completion is proven by the wrapper-owned `<log>.exit` file dispatch-role.sh
 # writes — never by text in the log, which the agent also writes. The
@@ -33,17 +33,11 @@
 # counts as liveness.
 set -euo pipefail
 
-LOG=${1:?usage: await-role.sh <log> [--timeout <sec>] [--stall <sec>]}
-shift
+LOG=${1:?usage: await-role.sh <log>}
+# 8 minutes to produce a verdict; 20 minutes of log silence reads as STALLED.
+# Tune by editing these two numbers — never by adding call-site options.
 TIMEOUT=480
 STALL=1200
-while [ $# -gt 0 ]; do
-  case $1 in
-    --timeout) TIMEOUT=${2:?}; shift 2 ;;
-    --stall) STALL=${2:?}; shift 2 ;;
-    *) echo "await-role: unknown option $1" >&2; exit 1 ;;
-  esac
-done
 
 ROLE=""
 MODE=""
diff --git a/.kilo_workflow/dispatch-role.sh b/.kilo_workflow/dispatch-role.sh
index 6b620cb248..c05f1511fe 100755
--- a/.kilo_workflow/dispatch-role.sh
+++ b/.kilo_workflow/dispatch-role.sh
@@ -31,6 +31,16 @@ esac
 [ -d "$WT" ] || { echo "dispatch-role: no such worktree: $WT" >&2; exit 1; }
 [ -f "$WT/.kilo/agent/$ROLE.md" ] || { echo "dispatch-role: $WT has no .kilo/agent/$ROLE.md — the worktree must be the CLOUD worktree (role definitions are only discovered there)" >&2; exit 1; }
 [ -d "$SCRATCH" ] || { echo "dispatch-role: no such scratch dir: $SCRATCH" >&2; exit 1; }
+if [ "$ROLE" = "e2e-verifier" ]; then
+  # The verifier restores a byte-identical baseline; concurrent uncommitted
+  # edits (learnings included) would read as false product failures.
+  DIRTY=$(git -C "$WT" status --porcelain)
+  [ -z "$DIRTY" ] || {
+    echo "dispatch-role: $WT must be fully committed before e2e-verifier dispatch:" >&2
+    echo "$DIRTY" >&2
+    exit 1
+  }
+fi
 # Only `--mode repro` (e2e-verifier repro gate) and repeated `--file
 # <existing path>` may follow — anything else (a --model override, a typo)
 # silently disagrees with the pinned role definition.
diff --git a/.kilo_workflow/e2e-free-slot.sh b/.kilo_workflow/e2e-free-slot.sh
index 898702630d..5992f70db8 100755
--- a/.kilo_workflow/e2e-free-slot.sh
+++ b/.kilo_workflow/e2e-free-slot.sh
@@ -1,3 +1,38 @@
 #!/usr/bin/env bash
+# Free this session's E2E slot. Refuses while this worktree still owns live
+# resources — a slot freed with leftovers is exactly the UNACCOUNTED state
+# e2e-slot-status.sh reports, and it starves parallel runs. Stop resources
+# through e2e-stop-resource.sh first.
 set -euo pipefail
-exec "$(dirname "$0")/.e2e-slot-state.sh" release "$@"
+HERE=$(dirname "$0")
+ROOT="$(git -C "$HERE" rev-parse --show-toplevel)"
+SLUG_="$(basename "$ROOT" | tr -cs 'a-zA-Z0-9_-' '_' | sed 's/_*$//')"
+SLUG_DASH="$(basename "$ROOT" | tr -cs 'a-zA-Z0-9' '-' | sed 's/^-*//;s/-*$//')"
+
+leftovers=()
+if command -v tmux >/dev/null; then
+  while IFS= read -r session; do
+    case "$session" in
+      "kilo-dev-$SLUG_"|"kilo-e2e-android-$SLUG_"|"kilo-e2e-cli-$SLUG_DASH"|"kilo-e2e-github-stub-$(basename "$ROOT")")
+        leftovers+=("tmux session: $session") ;;
+    esac
+  done < <(tmux ls -F '#S' 2>/dev/null || true)
+fi
+
+for claims_dir in "${TMPDIR:-/tmp}/kilo-mobile-simulator-claims" "${TMPDIR:-/tmp}/kilo-mobile-android-claims"; do
+  [ -d "$claims_dir" ] || continue
+  for json in "$claims_dir"/*.json; do
+    [ -f "$json" ] || continue
+    grep -q "\"worktreeRoot\": \"$ROOT\"" "$json" 2>/dev/null || continue
+    leftovers+=("device claim: $json")
+  done
+done
+
+if [ "${#leftovers[@]}" -gt 0 ]; then
+  printf 'refusing to free the slot while this worktree still owns resources:\n' >&2
+  printf '  %s\n' "${leftovers[@]}" >&2
+  printf 'stop them first: %s/e2e-stop-resource.sh stack|ios|android\n' "$HERE" >&2
+  exit 1
+fi
+
+exec "$HERE/.e2e-slot-state.sh" release "$@"
diff --git a/.kilo_workflow/e2e-start-resource.sh b/.kilo_workflow/e2e-start-resource.sh
index 8e77657e3b..05fda50c62 100755
--- a/.kilo_workflow/e2e-start-resource.sh
+++ b/.kilo_workflow/e2e-start-resource.sh
@@ -14,7 +14,33 @@ shift
 # otherwise start the wrong stack while the slot record names this one.
 cd "$(git -C "$(dirname "$0")" rev-parse --show-toplevel)"
 case "$resource" in
-  stack) exec pnpm dev:start --no-attach --reuse-running "$@" ;;
+  stack)
+    # Idempotent bindings (a fresh worktree's session-ingest rejects every
+    # request until its Secrets Store binding exists), then the stack, then
+    # migrations. Preflight probes readiness per device later; here we fail
+    # fast when a requested service never comes up or the kiloclaw docker
+    # bridge is dead.
+    pnpm dev:env -y cloudflare-session-ingest
+    pnpm dev:start --no-attach --reuse-running "$@"
+    pnpm drizzle migrate
+    STATUS="$(pnpm -s dev:status --json)"
+    node - "$STATUS" "$@" <<'NODE'
+const [statusJson, ...targets] = process.argv.slice(2);
+const status = JSON.parse(statusJson);
+const required = ['mobile', 'nextjs', 'cloudflare-session-ingest', ...targets];
+const down = required.filter(name => status.services.find(s => s.name === name)?.status !== 'up');
+if (down.length) {
+  console.error(`e2e-start-resource: services not up: ${down.join(', ')}`);
+  process.exit(1);
+}
+NODE
+    case " $* " in
+      *kiloclaw*) curl -sf --max-time 5 http://127.0.0.1:23750/v1.44/_ping >/dev/null || {
+        echo "e2e-start-resource: kiloclaw docker bridge not answering on 23750" >&2
+        exit 1
+      } ;;
+    esac
+    ;;
   ios) exec pnpm dev:mobile:simulator claim "$@" ;;
   android) exec pnpm dev:mobile:android emulator-start "$@" ;;
   command)
diff --git a/.kilo_workflow/e2e-stop-resource.sh b/.kilo_workflow/e2e-stop-resource.sh
index c5cd1546c7..c904f31302 100755
--- a/.kilo_workflow/e2e-stop-resource.sh
+++ b/.kilo_workflow/e2e-stop-resource.sh
@@ -9,11 +9,29 @@ cd "$(git -C "$(dirname "$0")" rev-parse --show-toplevel)"
 
 resource=${1:?usage: $0 stack | ios | android | command <cmd> [args...]}
 shift
+stop_appium_servers() {
+  # Every claim record naming this worktree may have a live Appium server.
+  local claims_dir json id
+  for claims_dir in "${TMPDIR:-/tmp}/kilo-mobile-simulator-claims" "${TMPDIR:-/tmp}/kilo-mobile-android-claims"; do
+    [ -d "$claims_dir" ] || continue
+    for json in "$claims_dir"/*.json; do
+      [ -f "$json" ] || continue
+      grep -q ""worktreeRoot": "$PWD"" "$json" 2>/dev/null || continue
+      id=$(node -e 'const r=JSON.parse(require("fs").readFileSync(process.argv[1]));process.stdout.write(r.deviceId||r.serial||"")' "$json" 2>/dev/null || true)
+      [ -n "$id" ] && apps/mobile/e2e/appium.sh "$id" server stop || true
+    done
+  done
+}
+
 case "$resource" in
   stack) exec pnpm dev:stop ;;
-  ios) exec pnpm dev:mobile:simulator release-all ;;
+  ios)
+    stop_appium_servers
+    exec pnpm dev:mobile:simulator release-all
+    ;;
   android)
     failed=0
+    stop_appium_servers
     pnpm dev:mobile:android emulator-stop || failed=1
     pnpm dev:mobile:android release-all || failed=1
     exit "$failed"
diff --git a/.kilo_workflow/launch-gate.sh b/.kilo_workflow/launch-gate.sh
index f578bfcf65..dedbdb7dc7 100755
--- a/.kilo_workflow/launch-gate.sh
+++ b/.kilo_workflow/launch-gate.sh
@@ -15,7 +15,6 @@ if [ "${1:-}" = "--locked" ]; then
   last=$(cat "$GATE/last" 2>/dev/null || echo 0)
   case "$last" in ''|*[!0-9]*) last=0 ;; esac
   remaining=$(( 3 - (now - last) ))
-  [ "$remaining" -le 3 ] || remaining=3
   [ "$remaining" -le 0 ] || sleep "$remaining"
   date +%s > "$GATE/last"
   exit 0
diff --git a/.kilo_workflow/learnings/mobile-metro-file-map-stale-after-node-modules-relayout.md b/.kilo_workflow/learnings/mobile-metro-file-map-stale-after-node-modules-relayout.md
deleted file mode 100644
index a5763f36da..0000000000
--- a/.kilo_workflow/learnings/mobile-metro-file-map-stale-after-node-modules-relayout.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# mobile-metro-file-map-stale-after-node-modules-relayout
-
-Symptom: after a dependency-layout change (e.g. a root patch changes pnpm peer-hash
-dirs), the dev client deterministically white-screens and logcat shows
-`ReactNativeJS: [runtime not ready]: RangeError: Maximum call stack size exceeded`,
-stack `metroRequire` → repeated `get NativeModules@<line>:56`. Metro serves a bundle
-in which a proxy module (here `react-native-css/dist/commonjs/components/index.cjs`)
-has `require("react-native")` resolved back to itself.
-
-Cause: Metro's jest-haste-map cache in `$TMPDIR/metro-file-map-expo-*` persists per
-project root across `pnpm install`s. Stale entries pointing into old `.pnpm` peer-hash
-directories still validate while those dirs exist on disk (pnpm keeps them), so the
-resolver serves modules from the stale instance and NativeWind's
-"am I inside react-native-css?" exclusion misfires.
-
-Fix: identify the project file-map (`grep -ac '<worktree-name>'` the
-`$TMPDIR/metro-file-map-expo-*` files — only one matches), delete it, restart Metro
-(`pnpm dev:restart mobile`), re-fetch the bundle with a cache-bust query param, and
-verify the proxy's dep map points at the real `react-native/index.js` module id.
-Never diagnose "the patch broke the app" from a bundle served before this check.
diff --git a/.kilo_workflow/pr-gate.sh b/.kilo_workflow/pr-gate.sh
index ab748a0267..386be31191 100755
--- a/.kilo_workflow/pr-gate.sh
+++ b/.kilo_workflow/pr-gate.sh
@@ -6,11 +6,10 @@
 # the comment actually approve, are the screenshots real — stay with the
 # agent; this script pins the facts to one head SHA.
 #
-#   pr-gate.sh <owner/repo> <pr> [--assignee <handle>] [--label <name>] [--bot <login>] [--wait <sec>]
+#   pr-gate.sh <owner/repo> <pr> [--assignee <handle>] [--label <name>] [--wait <sec>]
 #
 #   --assignee   gate-fail unless this handle is among the assignees
 #   --label      gate-fail unless this label is present (monitors: human-ready)
-#   --bot        the reviewing bot's exact login (default kilo-code-bot);
 #                substring 'bot' matching would let any bot vouch for the head
 #   --wait       poll every 120s up to this budget for the bot summary (or
 #                waiver) to appear before reporting; retriggering stays the
@@ -34,7 +33,6 @@ while [ $# -gt 0 ]; do
   case $1 in
     --assignee) ASSIGNEE=${2:?}; shift 2 ;;
     --label) LABEL=${2:?}; shift 2 ;;
-    --bot) BOT=${2:?}; shift 2 ;;
     --wait) WAIT=${2:?}; shift 2 ;;
     *) echo "pr-gate: unknown option $1" >&2; exit 1 ;;
   esac
diff --git a/.kilo_workflow/pr-threads.sh b/.kilo_workflow/pr-threads.sh
index 22a8d8a1c3..c02ec5f594 100755
--- a/.kilo_workflow/pr-threads.sh
+++ b/.kilo_workflow/pr-threads.sh
@@ -7,15 +7,13 @@
 #   pr-threads.sh list <owner/repo> <pr>                 # every thread: id, state, path, comments, first-comment id/author/body
 #   pr-threads.sh unresolved <owner/repo> <pr>           # just the unresolved ones (empty output = clean)
 #   pr-threads.sh close <owner/repo> <thread-id> <body>  # reply in-thread AND resolve it, asserting both
-#   pr-threads.sh reply <owner/repo> <thread-id> <body>  # reply only (e.g. while more work is coming)
-#   pr-threads.sh resolve <owner/repo> <thread-id>       # resolve only
 #
 # <body> may be `-` to read stdin. Replies get the mandatory "(bot) " prefix
 # added when missing. A fix without its in-thread reply and resolution is not
 # done — `close` is the normal move.
 set -euo pipefail
 
-CMD=${1:?usage: pr-threads.sh list|unresolved|close|reply|resolve ...}
+CMD=${1:?usage: pr-threads.sh list|unresolved|close ...}
 REPO=${2:?owner/repo}
 [[ "$REPO" =~ ^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$ ]] || { echo "repository must be owner/repo" >&2; exit 1; }
 OWNER=${REPO%%/*}
@@ -122,12 +120,5 @@ case $CMD in
     do_reply "${3:?thread id}" "$BODY"
     do_resolve "$3"
     ;;
-  reply)
-    BODY=$(read_body "${4:?body or -}")
-    do_reply "${3:?thread id}" "$BODY"
-    ;;
-  resolve)
-    do_resolve "${3:?thread id}"
-    ;;
   *) echo "usage: pr-threads.sh list|unresolved|close|reply|resolve ..." >&2; exit 1 ;;
 esac
diff --git a/.kilo_workflow/upload-pr-attachment.sh b/.kilo_workflow/upload-pr-attachment.sh
index 641410bf03..29daa2e3b0 100755
--- a/.kilo_workflow/upload-pr-attachment.sh
+++ b/.kilo_workflow/upload-pr-attachment.sh
@@ -4,31 +4,28 @@
 set -euo pipefail
 
 VERSION=v1.2.0
-[ "$#" -eq 1 ] && [ "$1" = "--version" ] && VERSION_ONLY=1 || VERSION_ONLY=0
-if [ "$VERSION_ONLY" -eq 0 ]; then
-  [ "$#" -eq 3 ] && [ "$2" = "--repo" ] || {
-    echo "usage: $0 <screenshot> --repo <owner/repo>" >&2
-    exit 1
-  }
-  SCREENSHOT=$1
-  REPO=$3
-  [ -f "$SCREENSHOT" ] && [ ! -L "$SCREENSHOT" ] || {
-    echo "screenshot must be a regular, non-symlink file" >&2
-    exit 1
-  }
-  [[ "$REPO" =~ ^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$ ]] || {
-    echo "repository must be owner/repo" >&2
-    exit 1
-  }
-  case "$(file -b --mime-type "$SCREENSHOT")" in
-    image/png | image/jpeg | image/gif | image/webp) ;;
-    *) echo "only PNG, JPEG, GIF, or WebP screenshots are allowed" >&2; exit 1 ;;
-  esac
-  [ "$(wc -c < "$SCREENSHOT")" -le 10485760 ] || {
-    echo "screenshot exceeds GitHub's 10 MB image limit" >&2
-    exit 1
-  }
-fi
+[ "$#" -eq 3 ] && [ "$2" = "--repo" ] || {
+  echo "usage: $0 <screenshot> --repo <owner/repo>" >&2
+  exit 1
+}
+SCREENSHOT=$1
+REPO=$3
+[ -f "$SCREENSHOT" ] && [ ! -L "$SCREENSHOT" ] || {
+  echo "screenshot must be a regular, non-symlink file" >&2
+  exit 1
+}
+[[ "$REPO" =~ ^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$ ]] || {
+  echo "repository must be owner/repo" >&2
+  exit 1
+}
+case "$(file -b --mime-type "$SCREENSHOT")" in
+  image/png | image/jpeg | image/gif | image/webp) ;;
+  *) echo "only PNG, JPEG, GIF, or WebP screenshots are allowed" >&2; exit 1 ;;
+esac
+[ "$(wc -c < "$SCREENSHOT")" -le 10485760 ] || {
+  echo "screenshot exceeds GitHub's 10 MB image limit" >&2
+  exit 1
+}
 
 case "$(uname -s)-$(uname -m)" in
   Darwin-arm64) ASSET=darwin-arm64; EXPECTED=e0d7670f263dc495cca358b3676f049c51e3c1bafcab7836ba1d0557c099c15b ;;
@@ -62,7 +59,4 @@ else
 fi
 
 [ "$ACTUAL" = "$EXPECTED" ] || { echo "cached gh-image checksum mismatch" >&2; exit 1; }
-if [ "$VERSION_ONLY" -eq 1 ]; then
-  exec "$BINARY" --version
-fi
 exec "$BINARY" "$SCREENSHOT" --repo "$REPO"
diff --git a/apps/mobile/e2e/AGENTS.md b/apps/mobile/e2e/AGENTS.md
index 3f059b1f0a..884d3ba36e 100644
--- a/apps/mobile/e2e/AGENTS.md
+++ b/apps/mobile/e2e/AGENTS.md
@@ -4,13 +4,9 @@ Interactive verification against a local backend. Run commands from the reposito
 
 ## E2E Bundle: Required First Step
 
-This machine is shared by parallel workflows. One slot permits one round's
-complete bundle: one dev stack, up to one iOS simulator, up to one Android
-emulator, plus its remote CLIs and other resources. It is not one slot per
-resource or platform verifier.
-
-The planner owns a repro bundle; the orchestrator owns later verification
-bundles. Before dispatching verifiers, that owner runs:
+E2E device/stack work runs only inside a slot bundle. Bundle contents,
+ownership, blocked-take, and release rules: `.kilo_workflow/WORKFLOW.md` "E2E
+Slots". Before dispatching verifiers, the owner runs:
 
 ```bash
 .kilo_workflow/e2e-take-slot.sh      # run from your own tmux session; blocks until a slot frees
@@ -19,13 +15,9 @@ bundles. Before dispatching verifiers, that owner runs:
 
 The owner starts every bundle resource through `e2e-start-resource.sh`, passes
 the ready services and device identifiers in each verifier handoff, then stops
-every resource through `e2e-stop-resource.sh` before freeing the slot. Parallel
-iOS and Android verifiers share this bundle and never take another slot.
-
-- Default 3 slots, machine-global, owned by tmux session name; a dead session's slot is reclaimed automatically, so a crash cannot wedge the queue.
-- A blocked take is correct behavior, not a hang and not a wedge. Wait for it.
-- Taking is idempotent per session; every E2E round needs one bundle slot.
-- Release as soon as the device phase ends. Planning, implementation, review, checks, and CI waits are uncapped — never hold a slot through them.
+every resource through `e2e-stop-resource.sh` before freeing the slot. Taking
+is idempotent per session. Parallel iOS and Android verifiers share this bundle
+and never take another slot.
 
 ## Fresh Worktree Quickstart
 
@@ -52,16 +44,14 @@ If this worktree has no stack, the bundle owner starts the complete mobile flow
 after taking its slot:
 
 ```bash
-pnpm dev:env -y cloudflare-session-ingest
 .kilo_workflow/e2e-start-resource.sh stack mobile cloud-agent-next kiloclaw event-service
-pnpm drizzle migrate
-pnpm dev:status --json
 ```
 
+The script also refreshes the session-ingest Secrets Store binding, applies migrations, and fails fast when a requested service or the kiloclaw docker bridge never comes up.
+
 Rules:
 
 - Do not export `KILO_PORT_OFFSET` or source `apps/mobile/.env`; stale shell values select the wrong bundle endpoints. Secondary worktrees get an isolated port offset automatically, and startup injects this worktree's LAN URLs before Metro starts. When the automatic offset lands on occupied ports (AirPlay on 5000/7000, another worktree's stack), `dev:start` probes for a free offset itself and persists it before services launch; later `dev:restart`/`dev:env` reuse the persisted value, so no manual prefix is needed. A per-command `KILO_PORT_OFFSET=<n>` prefix still overrides everything when you must pin one — never `export` it.
-- The `dev:env` step creates the JWT Secrets Store binding. Without it, session-ingest looks healthy but rejects every session request.
 - Secrets Store state is local to each Worker directory. `dev:start` refreshes every source-backed secret for its service graph before launching Workers; a secret-creation failure is fatal, not something to retry past.
 - `event-service` is required for presence and notification behavior.
 - Never run bare `wrangler secrets-store` commands. Use `pnpm dev:env -y <group>` from the repository root so values come from the canonical local source.
@@ -118,7 +108,7 @@ and boots it:
 .kilo_workflow/e2e-stop-resource.sh ios          # this worktree's claims
 ```
 
-The wrapper renames the claimed device to `Kilo E2E - <sanitized-worktree-basename>` and restores the original name on release. Never call `xcrun simctl rename` yourself. The claim also records whether it was the thing that booted the device, which is what lets release power off only the devices it started — so never boot or shut down an E2E simulator with `xcrun simctl` behind the wrapper's back. A claim is stale — and silently reclaimable — once its owning worktree is deleted. One exception: a claim killed mid-boot returns instantly as already-owned WITHOUT booting on the next claim, and `pnpm dev:mobile:ios build` then fails `code=405 "Unable to lookup in current state: Shutdown"` — recover with `xcrun simctl boot <udid> && xcrun simctl bootstatus <udid> -b`, and give claims a >=10-minute timeout under parallel-workflow load.
+The wrapper renames the claimed device to `Kilo E2E - <sanitized-worktree-basename>` and restores the original name on release. Never call `xcrun simctl rename` yourself. The claim also records whether it was the thing that booted the device, which is what lets release power off only the devices it started — so never boot or shut down an E2E simulator with `xcrun simctl` behind the wrapper's back. A claim is stale — and silently reclaimable — once its owning worktree is deleted. A claim killed mid-boot boots the Shutdown device again on reclaim automatically; give claims a >=10-minute timeout under parallel-workflow load (booting is slow).
 
 Install a validated cached native build. A compatible fingerprint skips rebuilding; a cache miss serializes through the host-wide native compiler semaphore. Never install an arbitrary DerivedData app or run a separate Expo native build:
 
diff --git a/dev/local/cli.ts b/dev/local/cli.ts
index 8881aed046..f330f842ab 100644
--- a/dev/local/cli.ts
+++ b/dev/local/cli.ts
@@ -960,6 +960,32 @@ async function cmdStatus(repoRoot: string, isJson = false): Promise<void> {
   }
 }
 
+
+// Metro's jest-haste-map cache ($TMPDIR/metro-file-map-*) persists per project
+// root across dependency relayouts and then serves stale module instances
+// (deterministic white screen + metroRequire stack overflow). Clearing this
+// worktree's file-map on every mobile restart makes the recovery automatic.
+function clearStaleMetroFileMaps(repoRoot: string): void {
+  let entries: string[];
+  try {
+    entries = fs.readdirSync(os.tmpdir());
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith('metro-file-map-')) continue;
+    const full = path.join(os.tmpdir(), entry);
+    try {
+      if (!fs.statSync(full).isFile()) continue;
+      if (!fs.readFileSync(full).includes(repoRoot)) continue;
+      fs.rmSync(full, { force: true });
+      console.log(`Cleared stale Metro file-map ${entry}`);
+    } catch {
+      // Another worktree's file or a race with Metro — leave it.
+    }
+  }
+}
+
 async function cmdRestart(serviceName: string, repoRoot: string): Promise<void> {
   if (!services.has(serviceName)) {
     console.error(`Unknown service: ${serviceName}`);
@@ -990,6 +1016,7 @@ async function cmdRestart(serviceName: string, repoRoot: string): Promise<void>
     if (!host) throw new Error('Could not detect LAN IP. Set MOBILE_DEV_HOST explicitly.');
     restartEnv = prepareMobileEnvironment(repoRoot, host).sessionEnv;
     setSessionEnvironment(sessionName, restartEnv);
+    clearStaleMetroFileMaps(repoRoot);
   }
 
   console.log(`Restarting ${serviceName} (waiting for the old process to shut down)...`);
diff --git a/dev/local/mobile-simulator.test.ts b/dev/local/mobile-simulator.test.ts
index acefc7faee..b9e53f903c 100644
--- a/dev/local/mobile-simulator.test.ts
+++ b/dev/local/mobile-simulator.test.ts
@@ -239,7 +239,7 @@ test('same-worktree reclaim is idempotent: no boot, no rename when the label is
   const { rename, calls: renames } = recordingRename();
   const prepared: string[] = [];
   const args = {
-    devices: [device()],
+    devices: [device({ state: 'Booted' })],
     lockRoot,
     worktreeRoot,
     rename,
@@ -257,6 +257,42 @@ test('same-worktree reclaim is idempotent: no boot, no rename when the label is
   assert.equal(renames.length, 1);
 });
 
+test('same-worktree reclaim boots a device the previous claim left Shutdown', () => {
+  // A claim killed mid-boot leaves the record but not the device; the next
+  // claim must boot it again instead of returning alreadyOwned over a
+  // Shutdown device (the old behavior failed the build with code=405).
+  const lockRoot = tempDir('sim-claims-');
+  const worktreeRoot = tempDir('worktree-');
+  const { rename } = recordingRename();
+  fs.writeFileSync(
+    path.join(lockRoot, 'UDID-1.json'),
+    JSON.stringify({
+      deviceId: 'UDID-1',
+      worktreeRoot,
+      claimedAt: new Date().toISOString(),
+      originalDeviceName: 'iPhone 16',
+      currentDeviceName: buildSimulatorLabel(worktreeRoot),
+      bootedByClaim: false,
+    })
+  );
+  const prepared: string[] = [];
+
+  const result = claimSimulator({
+    devices: [device({ state: 'Shutdown' })],
+    lockRoot,
+    worktreeRoot,
+    rename,
+    prepare: (d: SimulatorDevice) => {
+      prepared.push(d.id);
+      return true;
+    },
+  });
+
+  assert.equal(result.alreadyOwned, true);
+  assert.deepEqual(prepared, ['UDID-1']);
+  assert.equal(readRecord(lockRoot, 'UDID-1').bootedByClaim, true);
+});
+
 test('same-worktree reclaim reapplies a stale label and preserves the original name', () => {
   const lockRoot = tempDir('sim-claims-');
   const worktreeRoot = tempDir('worktree-');
diff --git a/dev/local/mobile-simulator.ts b/dev/local/mobile-simulator.ts
index 52a2b26ad3..3138eceaa4 100644
--- a/dev/local/mobile-simulator.ts
+++ b/dev/local/mobile-simulator.ts
@@ -319,6 +319,28 @@ function claimSimulator(args: ClaimArgs): { device: SimulatorDevice; alreadyOwne
       });
 
       if (reclaimed) {
+        if (device.state === 'Booted') {
+          return { device: { ...device, name: targetLabel }, alreadyOwned: true };
+        }
+        // A previous claim died mid-boot: the record exists but the device
+        // is down. Boot through the same prepare hook as a fresh claim and
+        // record bootedByClaim so release powers off what this reclaim
+        // started (prepare holds no mutation lock, matching the fresh path).
+        const bootedByClaim = args.prepare?.(device) === true;
+        withClaimMutationLock(lockRoot, device.id, () => {
+          const current = readClaim(
+            lockRoot,
+            device.id,
+            args.fileOperations?.readFileSync ?? fs.readFileSync
+          );
+          if (current) {
+            fs.writeFileSync(
+              lockPath(lockRoot, device.id),
+              JSON.stringify({ ...current, bootedByClaim }),
+              { flag: 'w' }
+            );
+          }
+        });
         return { device: { ...device, name: targetLabel }, alreadyOwned: true };
       }
 
diff --git a/dev/local/workflow-scripts.test.ts b/dev/local/workflow-scripts.test.ts
index cd5acfe83c..2f7bf285de 100644
--- a/dev/local/workflow-scripts.test.ts
+++ b/dev/local/workflow-scripts.test.ts
@@ -102,6 +102,18 @@ test('role dispatches allocate distinct artifacts and verifier scratch', () => {
       'exit 0\n'
   );
   fs.chmodSync(tmux, 0o755);
+  // The verifier refuses a dirty worktree, so dispatch targets a minimal
+  // clean repo, never the live one (which may legitimately be dirty).
+  const wt = path.join(root, 'wt');
+  fs.mkdirSync(path.join(wt, '.kilo/agent'), { recursive: true });
+  for (const role of ['implementer', 'plan-reviewer', 'impl-reviewer', 'e2e-verifier']) {
+    fs.writeFileSync(path.join(wt, `.kilo/agent/${role}.md`), '# role\n');
+  }
+  execFileSync('git', ['init', '-q'], { cwd: wt });
+  execFileSync('git', ['add', '.'], { cwd: wt });
+  execFileSync('git', ['-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-qm', 'init'], {
+    cwd: wt,
+  });
   const script = path.join(repoRoot, '.kilo_workflow/dispatch-role.sh');
   const env = {
     ...process.env,
@@ -113,7 +125,7 @@ test('role dispatches allocate distinct artifacts and verifier scratch', () => {
   const dispatch = (role = 'implementer', extraArgs: string[] = []) =>
     execFileSync(
       script,
-      [role, 'test-abcd', 'r1', repoRoot, scratch, 'Exercise the role.', ...extraArgs],
+      [role, 'test-abcd', 'r1', wt, scratch, 'Exercise the role.', ...extraArgs],
       {
         cwd: root,
         encoding: 'utf8',
@@ -129,6 +141,11 @@ test('role dispatches allocate distinct artifacts and verifier scratch', () => {
     assert.ok(fs.existsSync(`${second}.meta`));
     assert.match(fs.readFileSync(`${first}.meta`, 'utf8'), /^tmux=@42$/m);
     fs.writeFileSync(path.join(home, '.cache/kilo-launch-gate/last'), '0\n');
+    // Uncommitted state in the target worktree blocks only the verifier.
+    fs.writeFileSync(path.join(wt, 'dirty.txt'), 'uncommitted\n');
+    assert.throws(() => dispatch('e2e-verifier'), /must be fully committed/);
+    dispatch('implementer');
+    fs.rmSync(path.join(wt, 'dirty.txt'));
     const verifier = dispatch('e2e-verifier');
     const verifierScratch = fs
       .readFileSync(`${verifier}.meta`, 'utf8')
@@ -328,7 +345,10 @@ test('E2E lifecycle scripts take, start, stop, and free one slot', () => {
   fs.writeFileSync(path.join(bin, 'git'), `#!/bin/sh\nprintf '%s\\n' '${repoRoot}'\n`);
   fs.writeFileSync(
     path.join(bin, 'pnpm'),
-    '#!/bin/sh\nprintf "%s: %s\\n" "$PWD" "$*" >> "$COMMAND_LOG"\n'
+    '#!/bin/sh\nprintf "%s: %s\\n" "$PWD" "$*" >> "$COMMAND_LOG"\n' +
+      'if [ "$2" = "dev:status" ]; then\n' +
+      '  printf \'%s\\n\' \'{"services":[{"name":"mobile","status":"up"},{"name":"nextjs","status":"up"},{"name":"cloudflare-session-ingest","status":"up"},{"name":"web","status":"up"}]}\'\n' +
+      'fi\n'
   );
   for (const command of ['tmux', 'git', 'pnpm']) fs.chmodSync(path.join(bin, command), 0o755);
   const env = {
@@ -370,7 +390,11 @@ test('E2E lifecycle scripts take, start, stop, and free one slot', () => {
     assert.match(run('e2e-slot-status.sh').stdout, /0\/3 held/);
     assert.equal(
       fs.readFileSync(commandLog, 'utf8'),
-      `${repoRoot}: dev:start --no-attach --reuse-running mobile web\n${repoRoot}: dev:stop\n`
+      `${repoRoot}: dev:env -y cloudflare-session-ingest\n` +
+        `${repoRoot}: dev:start --no-attach --reuse-running mobile web\n` +
+        `${repoRoot}: drizzle migrate\n` +
+        `${repoRoot}: -s dev:status --json\n` +
+        `${repoRoot}: dev:stop\n`
     );
   } finally {
     fs.rmSync(root, { recursive: true, force: true });

From 45f43aa3c53bf483645ff6f9ccbe3b23aab0e9c3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 03:38:55 +0200
Subject: [PATCH 24/34] =?UTF-8?q?feat(workflow):=20idiot-proofing=20pass?=
 =?UTF-8?q?=20=E2=80=94=20remove=20wrong-action=20ambiguities?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

From two independent read-only reviews, applied:
- free-slot refusal names per-kind remedies and matches the runner's
  per-char slug rule; cleanup docs stop the remote CLI and stub first
- appium.sh adopts only its own recorded server (a hash-colliding
  foreign server is skipped by the bump loop) and rejects two flows per
  test invocation
- preflight session-ingest probe prints its fix; stop-resource surfaces
  an Appium server that would not stop
- planner learnings go to $SCRATCH (dirty tree now blocks repro dispatch)
- slice-diff snapshot is per-round; E2E slot teardown waits for
  serialized cases; VOID/VIOLATION escalation unified; pr-threads
  close-only wording; starter-turned-planner needs tmux; mock exception
  keeps justification; yml/yaml format rule covers every file
---
 .kilo/agent/e2e-verifier.md         |  2 +-
 .kilo_workflow/WORKFLOW.md          | 14 +++++++-------
 .kilo_workflow/await-interactive.sh |  2 +-
 .kilo_workflow/e2e-free-slot.sh     |  5 +++--
 .kilo_workflow/e2e-stop-resource.sh |  4 +++-
 .kilo_workflow/pr-threads.sh        |  2 +-
 apps/mobile/e2e/AGENTS.md           | 13 +++++++++----
 apps/mobile/e2e/appium.sh           |  9 ++++++---
 apps/mobile/e2e/preflight.sh        |  1 +
 9 files changed, 32 insertions(+), 20 deletions(-)

diff --git a/.kilo/agent/e2e-verifier.md b/.kilo/agent/e2e-verifier.md
index 6b1168855c..bb852657f1 100644
--- a/.kilo/agent/e2e-verifier.md
+++ b/.kilo/agent/e2e-verifier.md
@@ -64,4 +64,4 @@ Return:
 - Learnings written or updated, if any
 - If stopping early: completed work, remaining work, failures, resources touched, checks run or deferred, and the safest next action
 
-End your report with exactly one sentinel line — and the sentinel must follow from the report, never precede it: `VERIFICATION PASSED.` only when every criterion and feature state in your assigned scope either passed in this round or has accepted carried-forward proof, and the cleanup baseline matched; a product failure is `VERIFICATION FAILED.`; a skipped required state, test-environment failure, inconclusive classification, or baseline mismatch is `VERIFICATION BLOCKED.`; otherwise `STOPPED EARLY.` A weak carry-forward rationale means run the case; it blocks only when the required case itself cannot be run. In repro mode, use `REPRODUCED.`, `CANNOT REPRODUCE.`, or `VERIFICATION BLOCKED.` under the same environment/inconclusive rule. Your dispatcher treats a log without a sentinel as a void round — a crashed run, never a pass.
+End your report with exactly one sentinel line — and the sentinel must follow from the report, never precede it: `VERIFICATION PASSED.` only when every criterion and feature state in your assigned scope either passed in this round or has accepted carried-forward proof, and the cleanup baseline matched; a product failure is `VERIFICATION FAILED.`; a required state that could have been produced safely and deterministically but was skipped, a test-environment failure, inconclusive classification, or baseline mismatch is `VERIFICATION BLOCKED.` — a state skipped because it cannot be produced safely and deterministically is reported with its rationale and does not block `VERIFICATION PASSED.`; otherwise `STOPPED EARLY.` A weak carry-forward rationale means run the case; it blocks only when the required case itself cannot be run. In repro mode, use `REPRODUCED.`, `CANNOT REPRODUCE.`, or `VERIFICATION BLOCKED.` under the same environment/inconclusive rule. Your dispatcher treats a log without a sentinel as a void round — a crashed run, never a pass.
diff --git a/.kilo_workflow/WORKFLOW.md b/.kilo_workflow/WORKFLOW.md
index 0430b07ba2..9d4f5265c1 100644
--- a/.kilo_workflow/WORKFLOW.md
+++ b/.kilo_workflow/WORKFLOW.md
@@ -81,7 +81,7 @@ Two checks stay with the dispatcher, since only it knows the slice — both are
 .kilo_workflow/slice-diff.sh --check implementer "$SNAP" <worktree> "$SCRATCH/<slice>.diff" -- <owned paths>   # after an implementer round: no commit on the owned paths (edits expected)
 ```
 
-`$SNAP` is the `SNAPSHOT=...` line the pre-round emit printed. A `VIOLATION` voids the round. Void rounds count toward the loop's round cap, and three consecutive void rounds are an infrastructure blocker (auth wedge, provider outage), never something to redispatch through.
+`$SNAP` is the `SNAPSHOT=...` line printed by the emit made immediately before that same round — every round gets its own emit (for a reviewer round the emit doubles as the diff under review); never reuse a snapshot across rounds. A `VIOLATION` voids the round. Void rounds count toward the loop's round cap; after two consecutive voids shrink the handoff, and three consecutive rounds voided by either check — await-`VOID` or `VIOLATION` — are an infrastructure blocker (auth wedge, provider outage): stop redispatching, and the loop's remaining moves are takeover or a BLOCKED section.
 
 Role boundaries — reviewers never modify the tree, the implementer never commits, no role dispatches agents — are enforced by instruction, not permission. This is deliberate: permission deny lists caused void review rounds (a reviewer whose blocked command made it exit with no verdict, which read as a pass) and takeover churn. The single exception is `task: deny` in the definitions — blocking agent dispatch costs nothing and cannot void a round. The workflow otherwise trades enforcement for reliable rounds and accepts that a misbehaving agent can do what it was told not to; do not "fix" this by re-adding deny lists.
 
@@ -151,7 +151,7 @@ The session the user invokes the workflow from is the starter, running on the ha
   claude "You are the planner in .kilo_workflow/WORKFLOW.md. Plan the work in the brief at $SCRATCH/brief.md."
 ```
 
-One planner per section; each section flows through its own planner, orchestrator, and PR. A single-section run launches a single planner. If the starter's own session already fits the planner role (right model, user agrees), it may become the single planner itself instead of launching one. After launch, the starter follows Monitor Mode below for its planners until every section reaches a terminal state.
+One planner per section; each section flows through its own planner, orchestrator, and PR. A single-section run launches a single planner. If the starter's own session already fits the planner role (right model, user agrees), it may become the single planner itself instead of launching one — only when the starter already runs inside tmux on the default server: the repro gate's slot scripts refuse to run outside tmux, and a starter-turned-planner has no separate monitor to relaunch it. After launch, the starter follows Monitor Mode below for its planners until every section reaches a terminal state.
 
 ### Interaction Modes
 
@@ -253,14 +253,14 @@ Request the top one or two names it prints: `gh pr edit <number> --add-reviewer
 
 ### E2E Loop
 
-1. The orchestrator takes one slot and starts the whole E2E bundle: one stack, up to one iOS simulator, up to one Android emulator, and any other resources this round needs. Then dispatch a fresh `e2e-verifier` with the plan goals and acceptance criteria. When both iOS and Android are required, dispatch one verifier per platform in parallel; both share this one slot bundle and `apps/mobile/e2e/login.sh` gives them separate `-ios` and `-android` accounts. Each handoff names the orchestrator as bundle owner and gives the exact assigned device and services. `dispatch-role.sh` gives every verifier a unique `$SCRATCH`, so parallel shards and later rounds cannot share baselines or temporary files. After all shards return, the orchestrator stops every bundle resource and frees the slot. Serialize only a genuinely cross-platform flow or a test that needs shared mutable fixtures or temporary worktree edits. Never dispatch while implementers are active or uncommitted changes sit in an in-scope worktree — the verifier's byte-identical baseline restore turns concurrent edits into false failures. If a verifier round dies or is killed, the orchestrator still owns and cleans the bundle before redispatching.
+1. The orchestrator takes one slot and starts the whole E2E bundle: one stack, up to one iOS simulator, up to one Android emulator, and any other resources this round needs. Then dispatch a fresh `e2e-verifier` with the plan goals and acceptance criteria. When both iOS and Android are required, dispatch one verifier per platform in parallel; both share this one slot bundle and `apps/mobile/e2e/login.sh` gives them separate `-ios` and `-android` accounts. Each handoff names the orchestrator as bundle owner and gives the exact assigned device and services. `dispatch-role.sh` gives every verifier a unique `$SCRATCH`, so parallel shards and later rounds cannot share baselines or temporary files. After all shards return — and after any serialized cross-platform or shared-fixture cases from the next step have run — the orchestrator stops every bundle resource and frees the slot. Serialize only a genuinely cross-platform flow or a test that needs shared mutable fixtures or temporary worktree edits. Never dispatch while implementers are active or uncommitted changes sit in an in-scope worktree — the verifier's byte-identical baseline restore turns concurrent edits into false failures. If a verifier round dies or is killed, the orchestrator still owns and cleans the bundle before redispatching.
 2. Each verifier fails fast on the first confirmed product failure in its platform scope after capturing reproducible evidence; later cases in that scope are intentionally unrun. A sibling platform verifier already running continues its independent scope. Collect every in-flight shard's sentinel and wait for all of them to return before editing, committing, or dispatching an implementer. If every parallel shard passed, run any serialized cross-platform or shared-fixture cases now; otherwise leave them unrun for the follow-up. Then act on the union of sentinels: `VERIFICATION FAILED.` → triage the remarks (untrusted) and run the implementer → impl-reviewer loop to fix them, commit and push. `VERIFICATION BLOCKED.` → one environment recovery attempt and a fresh dispatch; if it blocks again, the section is BLOCKED.
 3. Re-verify with the repaired failing case first. Then rerun every prior case in the same page, flow, component, or shared-dependency area and every case no completed round has proved. Carry forward a prior pass only when the handoff names the case, cites its round and evidence, and gives concrete changed-file or dependency evidence that the fix cannot affect it — for example, a page-2-only fix may carry forward page-1 cases with no shared dependency. The fresh verifier independently rejects weak carry-forward claims and runs those cases.
 4. Exit when every platform shard returns `VERIFICATION PASSED.` and the current rounds plus explicitly justified carried-forward proof cover every criterion. After five rounds without that, the remaining moves are takeover or BLOCKED (see Escalation).
 
 ### Kilobot Loop
 
-1. Wait for Kilobot to review the latest head — `pr-gate.sh <owner/repo> <n> --wait 1200` blocks until a bot summary (or waiver) postdates the head commit, then prints the whole mechanical picture; thread state is GraphQL-only — list, reply to, and resolve threads with [`pr-threads.sh`](pr-threads.sh), never hand-written GraphQL. Kilobot can crash: if the wait expires with no summary, retrigger it (`git commit --allow-empty -m "chore: retrigger review" && git push`, or a `(bot) @kilocode-bot please review` PR comment), then resume waiting. After two failed retriggers, stop waiting: post `(bot) Kilobot posted no approving summary on this head after two retriggers` on the PR and treat the gate's Kilobot item as waived — the pending human review covers it. A green `Kilo Code Review` check only says the review finished; it carries no verdict. The clean state is a Kilobot summary comment on the current head that approves it (`gh pr view <n> --json comments` — read the verdict the comment states, do not match an exact string; bot wording drifts) plus zero **unresolved** review threads. A green check with no approving summary is not a clean head: keep waiting, then retrigger.
+1. Wait for Kilobot to review the latest head — `pr-gate.sh <owner/repo> <n> --wait 1200` blocks until a bot summary (or waiver) postdates the head commit, then prints the whole mechanical picture; thread state is GraphQL-only — list threads with `pr-threads.sh list|unresolved` and reply-plus-resolve them with [`pr-threads.sh`](pr-threads.sh) `close`, never hand-written GraphQL. Kilobot can crash: if the wait expires with no summary, retrigger it (`git commit --allow-empty -m "chore: retrigger review" && git push`, or a `(bot) @kilocode-bot please review` PR comment), then resume waiting. After two failed retriggers, stop waiting: post `(bot) Kilobot posted no approving summary on this head after two retriggers` on the PR and treat the gate's Kilobot item as waived — the pending human review covers it. A green `Kilo Code Review` check only says the review finished; it carries no verdict. The clean state is a Kilobot summary comment on the current head that approves it (`gh pr view <n> --json comments` — read the verdict the comment states, do not match an exact string; bot wording drifts) plus zero **unresolved** review threads. A green check with no approving summary is not a clean head: keep waiting, then retrigger.
 2. For each comment: verify it (untrusted), then route valid findings through the implementer → impl-reviewer loop; commit, push, then `pr-threads.sh close <owner/repo> <thread-id> "<what was done>"` — it replies in-thread and resolves in one step. Invalid finding: `close` with the technical evidence and do not change correct code. A fix without its in-thread reply and thread resolution is not done. Follow the repository-root `AGENTS.md` "Kilobot Review Remarks" contract.
 3. Comments already posted by other reviewers — bots or humans — get the same triage flow, but never wait for anyone except Kilobot to review or re-review.
 4. CI failures are findings too: route the fix through the implementer loop; rerun a flaky check once (`gh run rerun <id> --failed`); a check still failing after two fix rounds makes the section BLOCKED.
@@ -282,7 +282,7 @@ Check the mechanical half with [`pr-gate.sh`](pr-gate.sh) — it pins every fact
 - All accepted plan tasks are implemented, with automated coverage for every applicable feature state
 - A fresh impl reviewer has cleared the cumulative section diff (step 4), including any repair or orchestrator edit since
 - A fresh E2E verifier returned `VERIFICATION PASSED.` for the plan's goals — or E2E was skipped as inert, with the rationale in the PR description
-- Changes are organized into small, coherent commits; format, typecheck, lint, and tests pass in every changed repository, using the check commands the nearest `AGENTS.md` or `package.json` defines for each changed package. oxfmt covers `*.yml`/`*.yaml`: after writing or editing workflow YAML, run `pnpm format` and diff its rewrite before committing — never let a formatter rewrite load-bearing whitespace unreviewed
+- Changes are organized into small, coherent commits; format, typecheck, lint, and tests pass in every changed repository, using the check commands the nearest `AGENTS.md` or `package.json` defines for each changed package. oxfmt covers `*.yml`/`*.yaml`: after writing or editing any `*.yml` or `*.yaml` file, run `pnpm format` and diff its rewrite before committing — never let a formatter rewrite load-bearing whitespace unreviewed
 - The PR exists with what/why/how sections and is assigned to the requesting human
 - If any accepted task has a UI, the PR description renders screenshots of the final behavior from the latest head, uploaded to that repository as GitHub `user-attachments`; visual changes include before/after evidence when a meaningful before state exists. A non-UI PR records `Visual Changes: N/A`
 - Kilobot has posted an approving summary comment on the latest head and no actionable posted comment is unresolved — or Kilobot's absence after two retriggers is noted with the exact waiver sentence from the Kilobot loop
@@ -296,7 +296,7 @@ A PR waiting on required human review is COMPLETE — the workflow never approve
 
 ### Real LLM Responses
 
-Any step where an agent or LLM must actually respond — cloud-agent sessions, chat flows, acceptance states — uses real model calls on `kilo-auto/efficient` (the in-app id; `kilo/kilo-auto/*` are the same models as CLI ids), always. If an `efficient` call stalls or errors, retry on `efficient`; never switch models. LLM mocking (fake-llm or otherwise) is prohibited unless a real call cannot produce the required state; each use must be named and justified in the handoff and the PR. One standing exception qualifies: forcing a specific provider failure.
+Any step where an agent or LLM must actually respond — cloud-agent sessions, chat flows, acceptance states — uses real model calls on `kilo-auto/efficient` (the in-app id; `kilo/kilo-auto/*` are the same models as CLI ids), always. If an `efficient` call stalls or errors, retry on `efficient`; never switch models. LLM mocking (fake-llm or otherwise) is prohibited unless a real call cannot produce the required state; each use must be named and justified in the handoff and the PR. One standing exception to the prohibition qualifies: forcing a specific provider failure; the naming and justification requirement applies to it too.
 
 ## E2E Slots
 
@@ -349,7 +349,7 @@ Environment blockers and their fixes — broken local stacks, credential traps,
 - Role agents whose rules forbid dirtying the tree (the E2E verifier's byte-identical baseline restore) write their learnings to `$SCRATCH/learnings/` instead and list them in their report; the orchestrator moves them into `.kilo_workflow/learnings/` and commits them.
 - Read before writing: when an existing entry covers the blocker, update it instead of appending a duplicate. When a run proves an entry wrong or stale, fix the entry in the same run.
 - **Graduation:** a learning is a workaround waiting for a fix. When the blocker can be prevented by a script change (a flag, a guard, a wrapper) or by a line where agents already look (this document, a runbook, a role definition), make that change instead of — or in the same PR as — writing the learning, and delete any learning the change supersedes. Keep as learnings only what genuinely cannot be automated or folded away: environment trivia, one-off incident evidence, niche device quirks.
-- Every role records blockers it resolves, immediately after resolving them.
+- Every role records blockers it resolves, immediately after resolving them. The orchestrator commits learnings to the section worktree's `.kilo_workflow/learnings/`; the planner cannot commit, and an uncommitted worktree file blocks its own repro-gate dispatch, so a planner-authored learning goes to `$SCRATCH/learnings/` and is named in the orchestrator handoff for the first commit.
 - Never keep a workflow learning only in a harness's private memory; it belongs in these folders so runs on other harnesses can use it.
 - The same rule applies to this document: when a run stumbles on something `WORKFLOW.md` could have prevented — a missing command, an ambiguous rule, a wrong assumption — the orchestrator fixes the document in the same run and ships the fix with the PR. Role-definition fixes from a kilo session go through shell (`cat > .kilo/agent/<name>.md <<'EOF'`) because kilo's edit tool blocks `.kilo/` paths (the bash tool is not config-gated; `.kilo_workflow/` paths are unaffected). Mistakes that recur are workflow bugs, not agent bugs.
 
diff --git a/.kilo_workflow/await-interactive.sh b/.kilo_workflow/await-interactive.sh
index b889d0443f..395c8a7bf6 100755
--- a/.kilo_workflow/await-interactive.sh
+++ b/.kilo_workflow/await-interactive.sh
@@ -23,7 +23,7 @@ set -euo pipefail
 
 TARGET=${1:?tmux target} SCRATCH=${2:?scratch dir}
 shift 2
-# 25 minutes per invocation; 20 quiet transcript seconds reports QUIET.
+# 25 minutes per invocation; 20 quiet transcript minutes (QUIET=1200) reports QUIET.
 # Tune by editing these two numbers — never by adding call-site options.
 LOGFILE="" TIMEOUT=1500 QUIET=1200
 while [ $# -gt 0 ]; do
diff --git a/.kilo_workflow/e2e-free-slot.sh b/.kilo_workflow/e2e-free-slot.sh
index 5992f70db8..0aa85b8b45 100755
--- a/.kilo_workflow/e2e-free-slot.sh
+++ b/.kilo_workflow/e2e-free-slot.sh
@@ -6,7 +6,8 @@
 set -euo pipefail
 HERE=$(dirname "$0")
 ROOT="$(git -C "$HERE" rev-parse --show-toplevel)"
-SLUG_="$(basename "$ROOT" | tr -cs 'a-zA-Z0-9_-' '_' | sed 's/_*$//')"
+# Per-character replacement, matching dev/local/tmux.ts getSessionName.
+SLUG_="$(basename "$ROOT" | sed 's/[^A-Za-z0-9_-]/_/g')"
 SLUG_DASH="$(basename "$ROOT" | tr -cs 'a-zA-Z0-9' '-' | sed 's/^-*//;s/-*$//')"
 
 leftovers=()
@@ -31,7 +32,7 @@ done
 if [ "${#leftovers[@]}" -gt 0 ]; then
   printf 'refusing to free the slot while this worktree still owns resources:\n' >&2
   printf '  %s\n' "${leftovers[@]}" >&2
-  printf 'stop them first: %s/e2e-stop-resource.sh stack|ios|android\n' "$HERE" >&2
+  printf 'stop each by kind: stack/device claim -> %s/e2e-stop-resource.sh stack|ios|android; kilo-e2e-cli-* -> apps/mobile/e2e/remote-cli.sh stop; kilo-e2e-github-stub-* -> tmux kill-session -t <name>\n' "$HERE" >&2
   exit 1
 fi
 
diff --git a/.kilo_workflow/e2e-stop-resource.sh b/.kilo_workflow/e2e-stop-resource.sh
index c904f31302..75b8f666ff 100755
--- a/.kilo_workflow/e2e-stop-resource.sh
+++ b/.kilo_workflow/e2e-stop-resource.sh
@@ -18,7 +18,9 @@ stop_appium_servers() {
       [ -f "$json" ] || continue
       grep -q ""worktreeRoot": "$PWD"" "$json" 2>/dev/null || continue
       id=$(node -e 'const r=JSON.parse(require("fs").readFileSync(process.argv[1]));process.stdout.write(r.deviceId||r.serial||"")' "$json" 2>/dev/null || true)
-      [ -n "$id" ] && apps/mobile/e2e/appium.sh "$id" server stop || true
+      [ -n "$id" ] || continue
+      apps/mobile/e2e/appium.sh "$id" server stop || \
+        echo "e2e-stop-resource: appium server for $id still up — retry: apps/mobile/e2e/appium.sh $id server stop" >&2
     done
   done
 }
diff --git a/.kilo_workflow/pr-threads.sh b/.kilo_workflow/pr-threads.sh
index c02ec5f594..50ead83f8f 100755
--- a/.kilo_workflow/pr-threads.sh
+++ b/.kilo_workflow/pr-threads.sh
@@ -120,5 +120,5 @@ case $CMD in
     do_reply "${3:?thread id}" "$BODY"
     do_resolve "$3"
     ;;
-  *) echo "usage: pr-threads.sh list|unresolved|close|reply|resolve ..." >&2; exit 1 ;;
+  *) echo "usage: pr-threads.sh list|unresolved|close ..." >&2; exit 1 ;;
 esac
diff --git a/apps/mobile/e2e/AGENTS.md b/apps/mobile/e2e/AGENTS.md
index 884d3ba36e..02e0da26f1 100644
--- a/apps/mobile/e2e/AGENTS.md
+++ b/apps/mobile/e2e/AGENTS.md
@@ -37,8 +37,10 @@ xcrun simctl list devices booted
 ```
 
 Reuse an existing stack only when it belongs to the current live slot bundle.
-Otherwise it is unaccounted: stop it through `e2e-stop-resource.sh stack`, then
-take a slot and start fresh. Never stop an unrelated `kilo-dev-*` session.
+An unaccounted stack whose `kilo-dev-<slug>` slug matches this worktree's
+basename is yours: stop it through `e2e-stop-resource.sh stack`, then take a
+slot and start fresh. An unaccounted stack from another worktree is not yours —
+leave it alone and never stop an unrelated `kilo-dev-*` session.
 
 If this worktree has no stack, the bundle owner starts the complete mobile flow
 after taking its slot:
@@ -331,14 +333,17 @@ Each verifier removes only its own temporary files:
 rm -f "$LOGIN_LOG"
 ```
 
-After all verifiers return, the bundle owner stops everything it started, then
+After all verifiers return, the bundle owner stops everything it started —
+conditional resources first (skip any never started), then the bundle — and
 frees the slot:
 
 ```bash
+apps/mobile/e2e/remote-cli.sh stop                                                 # only after remote-cli.sh start
+tmux kill-session -t "kilo-e2e-github-stub-$(basename "$PWD")" 2>/dev/null || true  # only after the GitHub stub
 .kilo_workflow/e2e-stop-resource.sh android
 .kilo_workflow/e2e-stop-resource.sh ios
 .kilo_workflow/e2e-stop-resource.sh stack
-.kilo_workflow/e2e-free-slot.sh
+.kilo_workflow/e2e-free-slot.sh   # refuses while any resource above is still live
 rm -f "$EMULATOR_LOG"
 ```
 
diff --git a/apps/mobile/e2e/appium.sh b/apps/mobile/e2e/appium.sh
index 0427d30b58..72b9119e8a 100755
--- a/apps/mobile/e2e/appium.sh
+++ b/apps/mobile/e2e/appium.sh
@@ -56,11 +56,13 @@ port_free() {
 }
 
 ensure_server() {
-  # Reconnect to a previously bumped server when one was recorded.
+  # Adopt only our own recorded server: an unrecorded Appium answering on the
+  # base port belongs to another device whose hash collided with this block,
+  # and attaching here would interleave taps across devices.
   if [ -f "$STATE_DIR/server.port" ]; then
     APPIUM_PORT=$(cat "$STATE_DIR/server.port")
+    if server_status; then return 0; fi
   fi
-  if server_status; then return 0; fi
   ensure_drivers
   local base_port=$APPIUM_PORT attempt
   # Hash collisions and foreign listeners both resolve by bumping one block.
@@ -121,7 +123,8 @@ case "$cmd" in
     while [ $# -gt 0 ]; do
       case "$1" in
         -e) ENV_ARGS+=("$2"); shift 2 ;;
-        *) FLOW="$1"; shift ;;
+        *) [ -z "$FLOW" ] || { echo "appium.sh: one flow per test invocation (got '$FLOW' and '$1')" >&2; exit 1; }
+           FLOW="$1"; shift ;;
       esac
     done
     [ -n "$FLOW" ] || { echo "usage: appium.sh <device> test [-e K=V]... <flow.js>" >&2; exit 1; }
diff --git a/apps/mobile/e2e/preflight.sh b/apps/mobile/e2e/preflight.sh
index d2d0e552d8..54c5be116a 100755
--- a/apps/mobile/e2e/preflight.sh
+++ b/apps/mobile/e2e/preflight.sh
@@ -28,6 +28,7 @@ SESSION_STATUS="$(curl -sS -o "$SESSION_PROBE" -w '%{http_code}' \
 if [ "$SESSION_STATUS" != "401" ] || ! grep -Fq 'Invalid or expired token' "$SESSION_PROBE"; then
   printf 'session-ingest secret readiness probe failed with HTTP %s\n' "$SESSION_STATUS" >&2
   cat "$SESSION_PROBE" >&2
+  printf 'fix: pnpm dev:env -y cloudflare-session-ingest && pnpm dev:restart cloudflare-session-ingest (the binding exists but the running Worker has not picked it up)\n' >&2
   exit 1
 fi
 

From df38dc298301ab5b60f8892c79b6f46e6995a063 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 03:42:07 +0200
Subject: [PATCH 25/34] fix(e2e): normalize raw findElements refs, long
 first-session budget

driver.findElements returns protocol references, not WDIO Element
objects, so element commands need the extracted id. First XCUITest
session on a device builds WebDriverAgent and blows a 15s connection
timeout; give session creation 5 minutes with retries.
---
 apps/mobile/e2e/wdio/client.js  |  5 ++++-
 apps/mobile/e2e/wdio/helpers.js | 16 ++++++++++++----
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/apps/mobile/e2e/wdio/client.js b/apps/mobile/e2e/wdio/client.js
index a1f2f2ebfa..88ef959e68 100644
--- a/apps/mobile/e2e/wdio/client.js
+++ b/apps/mobile/e2e/wdio/client.js
@@ -47,7 +47,10 @@ async function connect(device) {
     hostname: '127.0.0.1',
     port: ports.server,
     logLevel: 'warn',
-    connectionRetryTimeout: 15000,
+    // The first XCUITest session on a device builds WebDriverAgent (minutes);
+    // later sessions reuse the cached build. Never time this out at 15s.
+    connectionRetryTimeout: 300000,
+    connectionRetryCount: 3,
     capabilities,
   });
 }
diff --git a/apps/mobile/e2e/wdio/helpers.js b/apps/mobile/e2e/wdio/helpers.js
index 2e896bbb23..ea75bcdce6 100644
--- a/apps/mobile/e2e/wdio/helpers.js
+++ b/apps/mobile/e2e/wdio/helpers.js
@@ -25,6 +25,13 @@ function javaEscape(s) {
   return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
 }
 
+// driver.findElements returns raw protocol references
+// ({ 'element-6066-11e4-a52e-4f735466cecf': <id> }), not WDIO Element
+// objects; normalize the id for element commands.
+function elementIdOf(el) {
+  return el.elementId ?? el['element-6066-11e4-a52e-4f735466cecf'] ?? el.ELEMENT;
+}
+
 function make(driver, platform) {
   async function findAll(pattern, { ci = false } = {}) {
     const source = regexSource(pattern);
@@ -52,15 +59,16 @@ function make(driver, platform) {
       const seen = new Set();
       elements = [];
       for (const el of [...byText, ...byDesc]) {
-        if (!seen.has(el.elementId)) {
-          seen.add(el.elementId);
+        const id = elementIdOf(el);
+        if (!seen.has(id)) {
+          seen.add(id);
           elements.push(el);
         }
       }
     }
     if (elements.length <= 1) return elements;
     const withRect = await Promise.all(
-      elements.map(async el => ({ el, rect: await driver.getElementRect(el.elementId) }))
+      elements.map(async el => ({ el, rect: await driver.getElementRect(elementIdOf(el)) }))
     );
     withRect.sort((a, b) => a.rect.y - b.rect.y || a.rect.x - b.rect.x);
     return withRect.map(({ el }) => el);
@@ -96,7 +104,7 @@ function make(driver, platform) {
     if (index >= els.length) {
       throw new Error(`index ${index} out of range (${els.length} matches) for ${describe(pattern)}`);
     }
-    await driver.elementClick(els[index].elementId);
+    await driver.elementClick(elementIdOf(els[index]));
   }
 
   async function assertVisible(pattern, opts) {

From 9e5873719a4123a03231e68bdef59380dd53c4b3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 03:47:08 +0200
Subject: [PATCH 26/34] fix(e2e): type via elementSendKeys, clear via
 elementClear, wait out sign-out

XCUITest rejects W3C key-action batches, so text entry goes through
Element Send Keys on the active element and field clearing through
Element Clear. The logout flow's terminal assert raced the sign-out
API call; it now waits for the login page.
---
 apps/mobile/e2e/flows/logout.js |  3 ++-
 apps/mobile/e2e/wdio/helpers.js | 27 +++++++++++++++++++++++----
 2 files changed, 25 insertions(+), 5 deletions(-)

diff --git a/apps/mobile/e2e/flows/logout.js b/apps/mobile/e2e/flows/logout.js
index a6adb0c1b3..294ec264ad 100644
--- a/apps/mobile/e2e/flows/logout.js
+++ b/apps/mobile/e2e/flows/logout.js
@@ -36,5 +36,6 @@ module.exports = async function logout(ctx) {
     await h.tapOn('Sign out', { index: 0, ci: true });
   });
 
-  await h.assertVisible('you@example.com');
+  // Signing out is an API call plus navigation back to the login page.
+  await h.waitVisible('you@example.com', { timeout: 15000 });
 };
diff --git a/apps/mobile/e2e/wdio/helpers.js b/apps/mobile/e2e/wdio/helpers.js
index ea75bcdce6..f7191f2e4f 100644
--- a/apps/mobile/e2e/wdio/helpers.js
+++ b/apps/mobile/e2e/wdio/helpers.js
@@ -113,15 +113,34 @@ function make(driver, platform) {
     }
   }
 
+  // Types into the focused field via Element Send Keys — driver.keys uses
+  // the W3C actions API, whose per-character key-downs XCUITest rejects.
   async function inputText(text) {
+    try {
+      const active = await driver.getActiveElement();
+      await driver.elementSendKeys(elementIdOf(active), String(text));
+      return;
+    } catch {
+      // No focused element — fall back to key events.
+    }
     await driver.keys(String(text));
   }
 
-  // Types backspaces into the focused field. iOS wants the raw backspace
-  // character; Android wants the WebDriver BACKSPACE key.
+  // Empties the focused field: a direct element clear, with a bounded
+  // backspace loop as fallback. (Batches of BACKSPACE key actions are
+  // rejected by XCUITest as unpaired key-downs, and the raw control
+  // character is not typeable — the flows only ever erase to empty.)
   async function eraseText(count = 100) {
-    const key = platform === 'ios' ? '\u0008' : '\uE003';
-    await driver.keys(new Array(count).fill(key));
+    try {
+      const active = await driver.getActiveElement();
+      await driver.elementClear(elementIdOf(active));
+      return;
+    } catch {
+      // No clearable focused element — fall through to key events.
+    }
+    for (let i = 0; i < count; i++) {
+      await driver.keys(['\uE003']);
+    }
   }
 
   // One flick of the content; sign=1 scrolls DOWN (content moves up).

From 87756442a16536bfc4620adc20cac17ac29dfc84 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 04:14:00 +0200
Subject: [PATCH 27/34] fix(e2e): proven parity on iOS and Android

- UiSelector consumes backslash escapes silently; regex escapes become
  character classes on the Android selector path
- the sign-out alert title carries a literal '?', matched escaped now;
  a leftover alert from an interrupted run is confirmed and handled
- settle-app's first wait gets the long Android budget (bundle refetch
  after a preflight reconnect), early-returning when healthy
- ANDROID_HOME/SDK_ROOT exported by the wrapper for the uiautomator2
  driver, mirroring the repo's resolution

Verified live: login/logout/re-login on iOS 26.5 sim and Android API 35
emulator, hierarchy on iOS, open-app cold launch on Android.
---
 apps/mobile/e2e/appium.sh           | 10 ++++++++++
 apps/mobile/e2e/flows/logout.js     | 11 ++++++++++-
 apps/mobile/e2e/flows/settle-app.js |  7 +++++--
 apps/mobile/e2e/wdio/helpers.js     | 11 +++++++----
 4 files changed, 32 insertions(+), 7 deletions(-)

diff --git a/apps/mobile/e2e/appium.sh b/apps/mobile/e2e/appium.sh
index 72b9119e8a..42de2b1f15 100755
--- a/apps/mobile/e2e/appium.sh
+++ b/apps/mobile/e2e/appium.sh
@@ -18,6 +18,16 @@ shift
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_ROOT="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel)"
 export APPIUM_HOME="${KILO_APPIUM_HOME:-$HOME/.cache/kilo-appium}"
+# The uiautomator2 driver locates the SDK through these; mirror the repo's
+# resolution (dev/local/mobile-android.ts) so the agent's PATH never matters.
+if [ -z "${ANDROID_HOME:-}" ] && [ -z "${ANDROID_SDK_ROOT:-}" ]; then
+  for candidate in /opt/homebrew/share/android-commandlinetools "$HOME/Library/Android/sdk"; do
+    if [ -d "$candidate" ]; then
+      export ANDROID_HOME="$candidate" ANDROID_SDK_ROOT="$candidate"
+      break
+    fi
+  done
+fi
 APPIUM_BIN="$REPO_ROOT/node_modules/.bin/appium"
 LOCK="${TMPDIR:-/tmp}/kilo-appium-locks/$DEVICE"
 
diff --git a/apps/mobile/e2e/flows/logout.js b/apps/mobile/e2e/flows/logout.js
index 294ec264ad..3586f12da3 100644
--- a/apps/mobile/e2e/flows/logout.js
+++ b/apps/mobile/e2e/flows/logout.js
@@ -11,6 +11,13 @@ module.exports = async function logout(ctx) {
   // An open code-verification screen backs out to the email form.
   await when(ctx, 'Verify code', () => h.tapOn('Back'));
 
+  // A leftover sign-out confirmation from an interrupted run: confirm it.
+  if (await h.visible(/Sign out\?/)) {
+    await h.tapOn('Sign out', { index: 0, ci: true });
+    await h.waitVisible('you@example.com', { timeout: 15000 });
+    return;
+  }
+
   // Signed out already? Land on the login page. Anything else that is not
   // Home gets settled first (prompts, developer menu, consent gate).
   await whenNot(ctx, S.LOGIN, async () => {
@@ -29,7 +36,9 @@ module.exports = async function logout(ctx) {
     await h.tapOn('Profile, tab, 4 of 4');
     await h.scrollUntilVisible('Sign Out', { direction: 'DOWN' });
     await h.tapOn('Sign Out');
-    await h.assertVisible('Sign out?');
+    // The confirmation alert animates in. The title carries a literal '?',
+    // which is a regex quantifier — match it escaped.
+    await h.waitVisible(/Sign out\?/, { timeout: 5000 });
     // The alert's confirm ("Sign out") and the screen button ("Sign Out")
     // collide under a case-insensitive match; index 0 is topmost by position,
     // which is the alert button.
diff --git a/apps/mobile/e2e/flows/settle-app.js b/apps/mobile/e2e/flows/settle-app.js
index ebb399cde9..0e2999d091 100644
--- a/apps/mobile/e2e/flows/settle-app.js
+++ b/apps/mobile/e2e/flows/settle-app.js
@@ -9,8 +9,11 @@ const S = require('./states');
 module.exports = async function settleApp(ctx) {
   const { h, when } = ctx;
 
-  // Something known must render before we settle.
-  await h.waitVisible(S.ANY_STATE, { timeout: 15000 });
+  // Something known must render before we settle. A preflight reconnect
+  // refetches the JS bundle on Android (a minute or more under load); the
+  // long budget returns as soon as anything renders, so healthy runs and
+  // iOS never pay it.
+  await h.waitVisible(S.ANY_STATE, { timeout: ctx.platform === 'android' ? 300000 : 15000 });
 
   // A deep-link reconnect may raise the external-app confirmation; one
   // bounded optional look, then move on (the only optional wait here).
diff --git a/apps/mobile/e2e/wdio/helpers.js b/apps/mobile/e2e/wdio/helpers.js
index f7191f2e4f..27b61258fa 100644
--- a/apps/mobile/e2e/wdio/helpers.js
+++ b/apps/mobile/e2e/wdio/helpers.js
@@ -46,14 +46,17 @@ function make(driver, platform) {
       );
     } else {
       // UiSelector matches whole strings already; the (?:..) wrap keeps
-      // alternation precedence identical to the iOS side.
-      const re = javaEscape(anchored);
+      // alternation precedence identical to the iOS side. Backslash escapes
+      // (\?, \., ...) are consumed by the selector parser and silently match
+      // nothing — translate every escaped char into a character class.
+      const classed = anchored.replace(/\\(.)/g, '[$1]');
+      const re = javaEscape(classed);
       const byText = await driver.findElements(
-        'android uiautomator',
+        '-android uiautomator',
         `new UiSelector().textMatches("${re}")`
       );
       const byDesc = await driver.findElements(
-        'android uiautomator',
+        '-android uiautomator',
         `new UiSelector().descriptionMatches("${re}")`
       );
       const seen = new Set();

From 8c48e3b5fee607eb5432d6d567fa63449fe10131 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 04:14:37 +0200
Subject: [PATCH 28/34] test(e2e): align flow structure tests with proven
 budgets

---
 dev/local/mobile-workflow.test.ts | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/dev/local/mobile-workflow.test.ts b/dev/local/mobile-workflow.test.ts
index 38f776ee29..5fcddad237 100644
--- a/dev/local/mobile-workflow.test.ts
+++ b/dev/local/mobile-workflow.test.ts
@@ -65,7 +65,8 @@ test('login retry resets an already-open verification screen to the email form',
   assert.ok(verificationIndex >= 0);
   assert.ok(backIndex > verificationIndex);
   assert.ok(signedOutGuardIndex > backIndex);
-  assert.match(logout, /assertVisible\('you@example\.com'\)/);
+  // Signing out is an API call plus navigation; the terminal check waits.
+  assert.match(logout, /waitVisible\('you@example\.com', \{ timeout: 15000 \}\)/);
 });
 
 test('login reuses the app state established by logout instead of relaunching each step', () => {
@@ -111,9 +112,11 @@ test('settle flow handles the exact iOS external-app prompt within existing wait
   assert.match(flow, /when\(ctx, S\.OPEN_IN_KILO, \(\) => h\.tapOn\('Open'\)\)/);
   assert.deepEqual(
     timeouts,
-    [15000, 3000, 5000, 5000, 5000, 5000, 15000],
+    [3000, 5000, 5000, 5000, 5000, 15000],
     'settle-app should keep its wait budget and add no fixed wait'
   );
+  // The first wait is platform-aware: 15s on iOS, long-but-early-return on Android.
+  assert.match(flow, /timeout: ctx\.platform === 'android' \? 300000 : 15000/);
   assert.doesNotMatch(flow, /when\(ctx, '(?:Allow|Open)'/);
   assert.doesNotMatch(flow, /tapOn\('(?:Allow\|Open|Open\|Allow)'\)/);
 });

From 6954357bfde625a72c749f1804a7fa4e994d2482 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 04:31:52 +0200
Subject: [PATCH 29/34] =?UTF-8?q?feat(workflow):=20wall-time=20pass=20?=
 =?UTF-8?q?=E2=80=94=20parallel=20bundle,=20faster=20polls,=20shared=20ses?=
 =?UTF-8?q?sions?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Wall-time optimizer findings applied (no quality/safety trade):
- e2e-start-resource bundle: stack ∥ iOS claim+build ∥ Android
  start+claim+build, one log per chain — slowest chain sets wall time
- emulator-start --wait polls liveness/visibility/boot_completed in the
  wrapper (8-min envelope); manual boot polling prose graduated away
- appium.sh test runs N flows on one driver session (5-20s saved each)
- selector probes skip the topmost-first sort unless tapping
- pr-gate Kilobot wait polls 30s (was 120); await-role 5s (was 15);
  await-interactive 10s (was 30); pr-threads close fetches thread_info
  once; preflight takes the wrappers' platform hint
Verified: multi-flow runs pass on iOS and Android.
---
 .kilo_workflow/WORKFLOW.md           |  2 +-
 .kilo_workflow/await-interactive.sh  |  2 +-
 .kilo_workflow/await-role.sh         |  2 +-
 .kilo_workflow/e2e-start-resource.sh | 39 ++++++++++++++++++++++++--
 .kilo_workflow/pr-gate.sh            |  2 +-
 .kilo_workflow/pr-threads.sh         | 13 +++++----
 apps/mobile/e2e/AGENTS.md            | 29 ++++++++++---------
 apps/mobile/e2e/appium.sh            |  9 +++---
 apps/mobile/e2e/login.sh             |  1 +
 apps/mobile/e2e/logout.sh            |  3 ++
 apps/mobile/e2e/preflight.sh         |  6 ++--
 apps/mobile/e2e/wdio/helpers.js      | 11 +++++---
 apps/mobile/e2e/wdio/run-flow.js     | 29 +++++++++++--------
 dev/local/mobile-android.test.ts     |  6 ++++
 dev/local/mobile-android.ts          | 42 ++++++++++++++++++++++++----
 15 files changed, 140 insertions(+), 56 deletions(-)

diff --git a/.kilo_workflow/WORKFLOW.md b/.kilo_workflow/WORKFLOW.md
index 9d4f5265c1..b28bc9fc71 100644
--- a/.kilo_workflow/WORKFLOW.md
+++ b/.kilo_workflow/WORKFLOW.md
@@ -253,7 +253,7 @@ Request the top one or two names it prints: `gh pr edit <number> --add-reviewer
 
 ### E2E Loop
 
-1. The orchestrator takes one slot and starts the whole E2E bundle: one stack, up to one iOS simulator, up to one Android emulator, and any other resources this round needs. Then dispatch a fresh `e2e-verifier` with the plan goals and acceptance criteria. When both iOS and Android are required, dispatch one verifier per platform in parallel; both share this one slot bundle and `apps/mobile/e2e/login.sh` gives them separate `-ios` and `-android` accounts. Each handoff names the orchestrator as bundle owner and gives the exact assigned device and services. `dispatch-role.sh` gives every verifier a unique `$SCRATCH`, so parallel shards and later rounds cannot share baselines or temporary files. After all shards return — and after any serialized cross-platform or shared-fixture cases from the next step have run — the orchestrator stops every bundle resource and frees the slot. Serialize only a genuinely cross-platform flow or a test that needs shared mutable fixtures or temporary worktree edits. Never dispatch while implementers are active or uncommitted changes sit in an in-scope worktree — the verifier's byte-identical baseline restore turns concurrent edits into false failures. If a verifier round dies or is killed, the orchestrator still owns and cleans the bundle before redispatching.
+1. The orchestrator takes one slot and starts the whole E2E bundle: one stack, up to one iOS simulator, up to one Android emulator, and any other resources this round needs — `e2e-start-resource.sh bundle <avd>` brings up the stack and both device chains in parallel. Then dispatch a fresh `e2e-verifier` with the plan goals and acceptance criteria. When both iOS and Android are required, dispatch one verifier per platform in parallel; both share this one slot bundle and `apps/mobile/e2e/login.sh` gives them separate `-ios` and `-android` accounts. Each handoff names the orchestrator as bundle owner and gives the exact assigned device and services. `dispatch-role.sh` gives every verifier a unique `$SCRATCH`, so parallel shards and later rounds cannot share baselines or temporary files. After all shards return — and after any serialized cross-platform or shared-fixture cases from the next step have run — the orchestrator stops every bundle resource and frees the slot. Serialize only a genuinely cross-platform flow or a test that needs shared mutable fixtures or temporary worktree edits. Never dispatch while implementers are active or uncommitted changes sit in an in-scope worktree — the verifier's byte-identical baseline restore turns concurrent edits into false failures. If a verifier round dies or is killed, the orchestrator still owns and cleans the bundle before redispatching.
 2. Each verifier fails fast on the first confirmed product failure in its platform scope after capturing reproducible evidence; later cases in that scope are intentionally unrun. A sibling platform verifier already running continues its independent scope. Collect every in-flight shard's sentinel and wait for all of them to return before editing, committing, or dispatching an implementer. If every parallel shard passed, run any serialized cross-platform or shared-fixture cases now; otherwise leave them unrun for the follow-up. Then act on the union of sentinels: `VERIFICATION FAILED.` → triage the remarks (untrusted) and run the implementer → impl-reviewer loop to fix them, commit and push. `VERIFICATION BLOCKED.` → one environment recovery attempt and a fresh dispatch; if it blocks again, the section is BLOCKED.
 3. Re-verify with the repaired failing case first. Then rerun every prior case in the same page, flow, component, or shared-dependency area and every case no completed round has proved. Carry forward a prior pass only when the handoff names the case, cites its round and evidence, and gives concrete changed-file or dependency evidence that the fix cannot affect it — for example, a page-2-only fix may carry forward page-1 cases with no shared dependency. The fresh verifier independently rejects weak carry-forward claims and runs those cases.
 4. Exit when every platform shard returns `VERIFICATION PASSED.` and the current rounds plus explicitly justified carried-forward proof cover every criterion. After five rounds without that, the remaining moves are takeover or BLOCKED (see Escalation).
diff --git a/.kilo_workflow/await-interactive.sh b/.kilo_workflow/await-interactive.sh
index 395c8a7bf6..c6087674ca 100755
--- a/.kilo_workflow/await-interactive.sh
+++ b/.kilo_workflow/await-interactive.sh
@@ -65,5 +65,5 @@ while :; do
     echo "RUNNING"
     exit 4
   fi
-  sleep 30
+  sleep 10
 done
diff --git a/.kilo_workflow/await-role.sh b/.kilo_workflow/await-role.sh
index a63e90846e..6d9e9e54db 100755
--- a/.kilo_workflow/await-role.sh
+++ b/.kilo_workflow/await-role.sh
@@ -110,5 +110,5 @@ while :; do
     echo "RUNNING — no verdict after ${TIMEOUT}s; invoke again to keep waiting"
     exit 4
   fi
-  sleep 15
+  sleep 5
 done
diff --git a/.kilo_workflow/e2e-start-resource.sh b/.kilo_workflow/e2e-start-resource.sh
index 05fda50c62..a149652c0b 100755
--- a/.kilo_workflow/e2e-start-resource.sh
+++ b/.kilo_workflow/e2e-start-resource.sh
@@ -7,7 +7,7 @@ HERE=$(dirname "$0")
   exit 1
 }
 
-resource=${1:?usage: $0 stack [targets...] | ios [udid] | android <avd> [--gpu ...] | command <cmd> [args...]}
+resource=${1:?usage: $0 stack [targets...] | ios [udid] | android <avd> [--gpu ...] [--wait] | bundle <avd> [--gpu ...] | command <cmd> [args...]}
 shift
 # Run repo wrappers from this script's own repository, never the caller's
 # CWD — invoked by absolute path from a sibling worktree, pnpm would
@@ -42,7 +42,42 @@ NODE
     esac
     ;;
   ios) exec pnpm dev:mobile:simulator claim "$@" ;;
-  android) exec pnpm dev:mobile:android emulator-start "$@" ;;
+  android) exec pnpm dev:mobile:android emulator-start --wait "$@" ;;
+  bundle)
+    # Whole E2E bundle at once: stack ∥ iOS chain ∥ Android chain, one log per
+    # chain. The slowest chain sets the wall time, not the sum of the three.
+    AVD=${1:?usage: $0 bundle <avd> [--gpu ...]}
+    shift
+    LOGD=$(mktemp -d "${TMPDIR:-/tmp}/kilo-bundle.XXXXXX")
+    echo "bundle setup logs: $LOGD"
+    (
+      "$HERE/e2e-start-resource.sh" stack mobile cloud-agent-next kiloclaw event-service
+    ) >"$LOGD/stack.log" 2>&1 &
+    P_STACK=$!
+    (
+      CLAIM=$("$HERE/e2e-start-resource.sh" ios | tail -1) &&
+        UDID=$(printf '%s' "$CLAIM" | node -e 'process.stdout.write(JSON.parse(require("fs").readFileSync(0,"utf8")).device.id)') &&
+        pnpm dev:mobile:ios build "$UDID"
+    ) >"$LOGD/ios.log" 2>&1 &
+    P_IOS=$!
+    (
+      RECORD=$("$HERE/e2e-start-resource.sh" android "$AVD" "$@") &&
+        SERIAL=$(printf '%s' "$RECORD" | grep -o '"serial": *"[^"]*"' | cut -d'"' -f4) &&
+        [ -n "$SERIAL" ] &&
+        pnpm -s dev:mobile:android claim "$SERIAL" >/dev/null &&
+        pnpm dev:mobile:android build "$SERIAL"
+    ) >"$LOGD/android.log" 2>&1 &
+    P_ANDROID=$!
+    FAILED=0
+    for p in $P_STACK $P_IOS $P_ANDROID; do
+      wait "$p" || FAILED=1
+    done
+    [ "$FAILED" -eq 0 ] || {
+      echo "bundle setup failed — inspect $LOGD" >&2
+      exit 1
+    }
+    echo "bundle ready (logs kept at $LOGD)"
+    ;;
   command)
     [ "$#" -gt 0 ] || { echo "command requires a command to run" >&2; exit 1; }
     exec "$@"
diff --git a/.kilo_workflow/pr-gate.sh b/.kilo_workflow/pr-gate.sh
index 386be31191..423339c5e1 100755
--- a/.kilo_workflow/pr-gate.sh
+++ b/.kilo_workflow/pr-gate.sh
@@ -54,7 +54,7 @@ while :; do
       | "\(.user.login) @ \(.updated_at): \(.body | gsub("\\s+"; " ") | .[0:200])"] | .[]' <<<"$COMMENTS")
   [ -n "$BOTCOMMENTS" ] && break
   [ "$(date +%s)" -ge "$DEADLINE" ] && break
-  sleep 120
+  sleep 30
 done
 
 echo "head=$HEAD_OID ($HEAD_TIME)"
diff --git a/.kilo_workflow/pr-threads.sh b/.kilo_workflow/pr-threads.sh
index 50ead83f8f..1d73545959 100755
--- a/.kilo_workflow/pr-threads.sh
+++ b/.kilo_workflow/pr-threads.sh
@@ -82,8 +82,7 @@ thread_info() {
 }
 
 do_reply() {
-  local thread=$1 body=$2 info repo pr comment
-  info=$(thread_info "$thread")
+  local thread=$1 body=$2 info=$3 repo pr comment
   repo=$(jq -r '.repo' <<<"$info")
   [ "$repo" = "$REPO" ] || { echo "pr-threads: thread $thread belongs to $repo, not $REPO" >&2; exit 1; }
   pr=$(jq -r '.pr' <<<"$info")
@@ -96,8 +95,7 @@ do_reply() {
 }
 
 do_resolve() {
-  local thread=$1 info repo resolved
-  info=$(thread_info "$thread")
+  local thread=$1 info=$2 repo resolved
   repo=$(jq -r '.repo' <<<"$info")
   [ "$repo" = "$REPO" ] || { echo "pr-threads: thread $thread belongs to $repo, not $REPO" >&2; exit 1; }
   resolved=$(gh api graphql \
@@ -117,8 +115,11 @@ case $CMD in
     ;;
   close)
     BODY=$(read_body "${4:?body or -}")
-    do_reply "${3:?thread id}" "$BODY"
-    do_resolve "$3"
+    # One thread fetch feeds both the reply idempotency check and the
+    # repository assertion — thread_info is a GraphQL round trip.
+    INFO=$(thread_info "${3:?thread id}")
+    do_reply "$3" "$BODY" "$INFO"
+    do_resolve "$3" "$INFO"
     ;;
   *) echo "usage: pr-threads.sh list|unresolved|close ..." >&2; exit 1 ;;
 esac
diff --git a/apps/mobile/e2e/AGENTS.md b/apps/mobile/e2e/AGENTS.md
index 02e0da26f1..317613543f 100644
--- a/apps/mobile/e2e/AGENTS.md
+++ b/apps/mobile/e2e/AGENTS.md
@@ -51,6 +51,12 @@ after taking its slot:
 
 The script also refreshes the session-ingest Secrets Store binding, applies migrations, and fails fast when a requested service or the kiloclaw docker bridge never comes up.
 
+To bring the whole bundle up at once (stack, iOS claim+build, Android start+claim+build — three chains in parallel, the slowest sets the wall time instead of the sum):
+
+```bash
+.kilo_workflow/e2e-start-resource.sh bundle <avd-name> [--gpu host]
+```
+
 Rules:
 
 - Do not export `KILO_PORT_OFFSET` or source `apps/mobile/.env`; stale shell values select the wrong bundle endpoints. Secondary worktrees get an isolated port offset automatically, and startup injects this worktree's LAN URLs before Metro starts. When the automatic offset lands on occupied ports (AirPlay on 5000/7000, another worktree's stack), `dev:start` probes for a free offset itself and persists it before services launch; later `dev:restart`/`dev:env` reuse the persisted value, so no manual prefix is needed. A per-command `KILO_PORT_OFFSET=<n>` prefix still overrides everything when you must pin one — never `export` it.
@@ -242,10 +248,12 @@ pnpm dev:mobile:android doctor
 ```
 
 The bundle owner uses the wrappers for emulator lifecycle and the Expo/Gradle
-build before dispatch: take slot → `emulator-start` → claim its exact serial at
-first ADB visibility → bounded boot wait → `build`. The verifier starts with
-`login.sh`. Never use unbounded `adb wait-for-device`, manual `adb reverse`, or
-dev-client `am start`; `login.sh` preflight handles the last two.
+build before dispatch. `e2e-start-resource.sh android` starts the emulator and
+waits for `sys.boot_completed=1` (process-liveness checked, 8-minute envelope)
+— device visibility is not readiness, and there is no manual boot polling.
+The verifier starts with `login.sh`. Never use unbounded `adb wait-for-device`,
+manual `adb reverse`, or dev-client `am start`; `login.sh` preflight handles
+the last two.
 
 ### Launch and GPU policy
 
@@ -260,25 +268,16 @@ EMULATOR_LOG=$(jq -r .log <<<"$EMULATOR")
 
 Record `SERIAL`, `EMULATOR_PID`, and `EMULATOR_LOG` in the round handoff. Never drive or kill a device claimed by another worktree, and never delete a foreign claim file.
 
-### Bounded boot wait
-
-From the moment of launch, poll about every 15 s until the envelope expires. Cold boot on an idle host ≈ 1–3 minutes; under parallel-workflow load allow up to 8 minutes before declaring the attempt failed (relaunch-rule bounds, not SLAs). Each poll, check in order:
-
-1. **Liveness** — `kill -0 "$EMULATOR_PID"` succeeds. If not, the attempt died.
-2. **Visibility** — `$SERIAL` appears with state `device` in `pnpm dev:mobile:android adb devices -l`. Claim it immediately: `pnpm dev:mobile:android claim "$SERIAL"`.
-3. **Readiness** — once visible, `pnpm dev:mobile:android adb -s "$SERIAL" shell getprop sys.boot_completed` prints `1`.
-
-Device visibility is not readiness. Never gate on `adb devices` output alone, and never wait on any one stage without the liveness check.
-
 ### Failed attempt → stop exactly yours → relaunch once
 
 On failure run `.kilo_workflow/e2e-stop-resource.sh android`; it uses the recorded session and verifies the recorded PID before sending a signal, so it cannot kill a sibling's same-AVD emulator. Relaunch once per the GPU policy with the same envelope. If the second attempt also fails, stop and return a test-environment blocker with `tail -200 "$EMULATOR_LOG"`; never a third launch.
 
 ### Build and login
 
-The claim already happened at adb visibility (claim is idempotent — re-running it is harmless):
+Claim the serial (idempotent), then build:
 
 ```bash
+pnpm dev:mobile:android claim <serial>
 pnpm dev:mobile:android build <serial>   # validated cached APK only
 apps/mobile/e2e/login.sh <serial>
 ```
diff --git a/apps/mobile/e2e/appium.sh b/apps/mobile/e2e/appium.sh
index 42de2b1f15..c145a7af6f 100755
--- a/apps/mobile/e2e/appium.sh
+++ b/apps/mobile/e2e/appium.sh
@@ -129,18 +129,17 @@ case "$cmd" in
   test)
     shift
     ENV_ARGS=()
-    FLOW=""
+    FLOWS=()
     while [ $# -gt 0 ]; do
       case "$1" in
         -e) ENV_ARGS+=("$2"); shift 2 ;;
-        *) [ -z "$FLOW" ] || { echo "appium.sh: one flow per test invocation (got '$FLOW' and '$1')" >&2; exit 1; }
-           FLOW="$1"; shift ;;
+        *) FLOWS+=("$1"); shift ;;
       esac
     done
-    [ -n "$FLOW" ] || { echo "usage: appium.sh <device> test [-e K=V]... <flow.js>" >&2; exit 1; }
+    [ "${#FLOWS[@]}" -gt 0 ] || { echo "usage: appium.sh <device> test [-e K=V]... <flow.js> [more-flows.js]" >&2; exit 1; }
     ensure_server
     env DEVICE="$DEVICE" APPIUM_PORT="$APPIUM_PORT" "${ENV_ARGS[@]}" \
-      node "$SCRIPT_DIR/wdio/run-flow.js" "$FLOW"
+      node "$SCRIPT_DIR/wdio/run-flow.js" "${FLOWS[@]}"
     ;;
   hierarchy)
     ensure_server
diff --git a/apps/mobile/e2e/login.sh b/apps/mobile/e2e/login.sh
index cb167084aa..4ddc1f776b 100755
--- a/apps/mobile/e2e/login.sh
+++ b/apps/mobile/e2e/login.sh
@@ -30,6 +30,7 @@ case "$DEVICE" in
   emulator-*) PLATFORM=android ;;
   *) PLATFORM=ios ;;
 esac
+export KILO_E2E_PLATFORM="$PLATFORM"
 EMAIL="${2:-e2e-mobile-${WORKTREE_SLUG}-${PLATFORM}@example.com}"
 
 if [ "${KILO_APPIUM_LOCKED:-}" != "1" ]; then
diff --git a/apps/mobile/e2e/logout.sh b/apps/mobile/e2e/logout.sh
index c64186e714..6edaa39cd4 100755
--- a/apps/mobile/e2e/logout.sh
+++ b/apps/mobile/e2e/logout.sh
@@ -10,6 +10,9 @@ set -euo pipefail
 
 DEVICE="${1:?usage: logout.sh <device-udid>}"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+case "$DEVICE" in
+  emulator-*) export KILO_E2E_PLATFORM=android ;;
+esac
 
 if [ "${KILO_APPIUM_LOCKED:-}" != "1" ]; then
   exec "$SCRIPT_DIR/appium.sh" "$DEVICE" --exec "$0" "$@"
diff --git a/apps/mobile/e2e/preflight.sh b/apps/mobile/e2e/preflight.sh
index 54c5be116a..01a3617e50 100755
--- a/apps/mobile/e2e/preflight.sh
+++ b/apps/mobile/e2e/preflight.sh
@@ -32,8 +32,10 @@ if [ "$SESSION_STATUS" != "401" ] || ! grep -Fq 'Invalid or expired token' "$SES
   exit 1
 fi
 
-PLATFORM="ios"
-if (cd "$REPO_ROOT" && pnpm -s dev:mobile:android adb devices | awk -v device="$DEVICE" '$1 == device && $2 == "device" { found=1 } END { exit !found }'); then
+# login.sh/logout.sh pass the platform they already derived; the adb probe is
+# the fallback for direct invocations.
+PLATFORM="${KILO_E2E_PLATFORM:-ios}"
+if [ -z "${KILO_E2E_PLATFORM:-}" ] && (cd "$REPO_ROOT" && pnpm -s dev:mobile:android adb devices | awk -v device="$DEVICE" '$1 == device && $2 == "device" { found=1 } END { exit !found }'); then
   PLATFORM="android"
   CLAIM="$(cd "$REPO_ROOT" && pnpm -s dev:mobile:android claim "$DEVICE")"
 else
diff --git a/apps/mobile/e2e/wdio/helpers.js b/apps/mobile/e2e/wdio/helpers.js
index 27b61258fa..9637d10782 100644
--- a/apps/mobile/e2e/wdio/helpers.js
+++ b/apps/mobile/e2e/wdio/helpers.js
@@ -33,7 +33,7 @@ function elementIdOf(el) {
 }
 
 function make(driver, platform) {
-  async function findAll(pattern, { ci = false } = {}) {
+  async function findAll(pattern, { ci = false, sort = false } = {}) {
     const source = regexSource(pattern);
     const flags = regexFlags(pattern, ci);
     const anchored = flags.includes('i') ? `(?i)(?:${source})` : `(?:${source})`;
@@ -69,7 +69,10 @@ function make(driver, platform) {
         }
       }
     }
-    if (elements.length <= 1) return elements;
+    // Sorting costs one HTTP round trip per match; callers that only probe
+    // (visible/when/waitVisible) skip it. tapOn and scrollUntilVisible keep
+    // topmost-first order — index: 0 is load-bearing there.
+    if (!sort || elements.length <= 1) return elements;
     const withRect = await Promise.all(
       elements.map(async el => ({ el, rect: await driver.getElementRect(elementIdOf(el)) }))
     );
@@ -102,7 +105,7 @@ function make(driver, platform) {
   }
 
   async function tapOn(pattern, { index = 0, ci = false } = {}) {
-    const els = await findAll(pattern, { ci });
+    const els = await findAll(pattern, { ci, sort: true });
     if (els.length === 0) throw new Error(`no element matching ${describe(pattern)}`);
     if (index >= els.length) {
       throw new Error(`index ${index} out of range (${els.length} matches) for ${describe(pattern)}`);
@@ -170,7 +173,7 @@ function make(driver, platform) {
 
   async function scrollUntilVisible(pattern, { direction = 'DOWN', maxScrolls = 10 } = {}) {
     for (let i = 0; i < maxScrolls; i++) {
-      const els = await findAll(pattern).catch(() => []);
+      const els = await findAll(pattern, { sort: true }).catch(() => []);
       if (els.length > 0) return els[0];
       await swipeUp(direction === 'UP' ? -1 : 1);
     }
diff --git a/apps/mobile/e2e/wdio/run-flow.js b/apps/mobile/e2e/wdio/run-flow.js
index 0c2f2fc27a..270b3a9186 100644
--- a/apps/mobile/e2e/wdio/run-flow.js
+++ b/apps/mobile/e2e/wdio/run-flow.js
@@ -1,8 +1,10 @@
-// Runs one flow module against a device. Exit code is the verdict: 0 when the
-// flow completes, 1 on any assertion, selector, or driver error — no report
-// files to second-guess.
+// Runs flow modules against a device on one driver session. Exit code is the
+// verdict: 0 when every flow completes, 1 on any assertion, selector, or
+// driver error — no report files to second-guess. Flows manage app lifecycle
+// themselves, so sequential flows on one session behave exactly like
+// sequential invocations, minus the session setup each.
 //
-//   DEVICE=<udid> node run-flow.js <flow-file.js>
+//   DEVICE=<udid> node run-flow.js <flow-file.js> [more-flows.js]
 //
 // Flow modules export an async function receiving
 //   { driver, h, env, device, platform, when, whenNot }
@@ -13,18 +15,17 @@ const { connect, platformFor } = require('./client');
 const helpers = require('./helpers');
 
 async function main() {
-  const flowPath = process.argv[2];
+  const flowPaths = process.argv.slice(2);
   const device = process.env.DEVICE;
-  if (!flowPath || !device) {
-    console.error('usage: DEVICE=<udid> node run-flow.js <flow-file.js>');
+  if (flowPaths.length === 0 || !device) {
+    console.error('usage: DEVICE=<udid> node run-flow.js <flow-file.js> [more-flows.js]');
     process.exit(1);
   }
-  const flow = require(path.resolve(flowPath));
   const platform = platformFor(device);
   const driver = await connect(device);
   try {
     const h = helpers.make(driver, platform);
-    await flow({
+    const ctx = {
       device,
       driver,
       env: process.env,
@@ -32,8 +33,12 @@ async function main() {
       platform,
       when: helpers.when,
       whenNot: helpers.whenNot,
-    });
-    console.log(`FLOW OK ${path.basename(flowPath)} (${platform} ${device})`);
+    };
+    for (const flowPath of flowPaths) {
+      const flow = require(path.resolve(flowPath));
+      await flow(ctx);
+      console.log(`FLOW OK ${path.basename(flowPath)} (${platform} ${device})`);
+    }
   } finally {
     await driver.deleteSession().catch(() => {});
   }
@@ -41,6 +46,6 @@ async function main() {
 
 main().catch(err => {
   const message = err && err.message ? err.message.split('\n')[0] : String(err);
-  console.error(`FLOW FAILED ${process.argv[2] || ''}: ${message}`);
+  console.error(`FLOW FAILED: ${message}`);
   process.exit(1);
 });
diff --git a/dev/local/mobile-android.test.ts b/dev/local/mobile-android.test.ts
index 8309e377cc..f56c675b31 100644
--- a/dev/local/mobile-android.test.ts
+++ b/dev/local/mobile-android.test.ts
@@ -89,6 +89,12 @@ test('rejects emulator-start when the flag appears where the AVD name belongs',
   assert.deepEqual(parseEmulatorStartArgs(['Pixel_9', '--gpu', 'host']), {
     avd: 'Pixel_9',
     gpu: 'host',
+    wait: false,
+  });
+  assert.deepEqual(parseEmulatorStartArgs(['Pixel_9', '--gpu', 'host', '--wait']), {
+    avd: 'Pixel_9',
+    gpu: 'host',
+    wait: true,
   });
 });
 
diff --git a/dev/local/mobile-android.ts b/dev/local/mobile-android.ts
index b7e80c184e..6fe22f9384 100644
--- a/dev/local/mobile-android.ts
+++ b/dev/local/mobile-android.ts
@@ -435,11 +435,12 @@ function getAndroidSerials(env: AndroidEnvironment): string[] {
     .map(([serial]) => serial);
 }
 
-function parseEmulatorStartArgs(args: string[]): { avd: string; gpu: string } {
+function parseEmulatorStartArgs(args: string[]): { avd: string; gpu: string; wait: boolean } {
   const avd = args[0];
   const gpuIndex = args.indexOf('--gpu');
   const gpu = gpuIndex === -1 ? 'host' : args[gpuIndex + 1];
-  const expectedArgs = gpuIndex === -1 ? 1 : 3;
+  const wait = args.includes('--wait');
+  const expectedArgs = (gpuIndex === -1 ? 1 : 3) + (wait ? 1 : 0);
   if (
     !avd ||
     avd.startsWith('-') ||
@@ -448,10 +449,37 @@ function parseEmulatorStartArgs(args: string[]): { avd: string; gpu: string } {
     args.length !== expectedArgs
   ) {
     throw new Error(
-      'Usage: pnpm dev:mobile:android emulator-start <avd-name> [--gpu host|swiftshader_indirect]'
+      'Usage: pnpm dev:mobile:android emulator-start <avd-name> [--gpu host|swiftshader_indirect] [--wait]'
     );
   }
-  return { avd, gpu };
+  return { avd, gpu, wait };
+}
+
+// Poll until the emulator is fully booted: process alive, serial visible as
+// `device`, and sys.boot_completed=1. Console-port bind alone does not mean
+// the guest is ready for installs or taps.
+async function waitForAndroidBoot(env: AndroidEnvironment, record: EmulatorRecord): Promise<void> {
+  const deadline = Date.now() + 8 * 60_000;
+  for (;;) {
+    if (!processIsAlive(record.pid))
+      throw new Error(`${record.session} died while booting; see ${record.log}`);
+    try {
+      const ready =
+        getAndroidSerials(env).includes(record.serial) &&
+        execFileSync(env.adb, ['-s', record.serial, 'shell', 'getprop', 'sys.boot_completed'], {
+          encoding: 'utf8',
+          env: { ...process.env, PATH: env.path },
+        }).trim() === '1';
+      if (ready) return;
+    } catch (error) {
+      // adb errors mid-boot are transient; a dead emulator is not.
+      if (error instanceof Error && !processIsAlive(record.pid))
+        throw new Error(`${record.session} died while booting; see ${record.log}`);
+    }
+    if (Date.now() > deadline)
+      throw new Error(`${record.serial} did not reach sys.boot_completed=1 within 8 minutes; see ${record.log}`);
+    await delay(15_000);
+  }
 }
 
 // Identity of the running emulator instance, stable for its whole life and
@@ -647,8 +675,10 @@ async function main(): Promise<void> {
     return;
   }
   if (command === 'emulator-start') {
-    const { avd, gpu } = parseEmulatorStartArgs(args);
-    console.log(JSON.stringify(await startAndroidEmulator(env, worktreeRoot, avd, gpu), null, 2));
+    const { avd, gpu, wait } = parseEmulatorStartArgs(args);
+    const record = await startAndroidEmulator(env, worktreeRoot, avd, gpu);
+    if (wait) await waitForAndroidBoot(env, record);
+    console.log(JSON.stringify(record, null, 2));
     return;
   }
   if (command === 'emulator-stop') {

From 7024c49a5497152036006a2e59aa0ac8a1b65f73 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 04:50:29 +0200
Subject: [PATCH 30/34] fix(workflow): lifecycle rehearsal hardening

Found by rehearsing the full slot lifecycle end to end:
- stack arm retries a failed reuse once, then stops and starts fresh
  (the runner's own remedy for down never-startable services)
- android arm reuses a live own emulator (record + boot check) and
  starts with --wait otherwise; arg order fixed
- stop-resource's claim grep matched nothing (mangled quoting), so
  Appium servers outlived their bundles
- preflight's platform hint skipped the probe but not the claim branch
---
 .kilo_workflow/e2e-free-slot.sh      |  2 +-
 .kilo_workflow/e2e-start-resource.sh | 31 ++++++++++++++++++++++++++--
 .kilo_workflow/e2e-stop-resource.sh  |  2 +-
 apps/mobile/e2e/preflight.sh         | 11 +++++++---
 4 files changed, 39 insertions(+), 7 deletions(-)

diff --git a/.kilo_workflow/e2e-free-slot.sh b/.kilo_workflow/e2e-free-slot.sh
index 0aa85b8b45..e4748ff3c6 100755
--- a/.kilo_workflow/e2e-free-slot.sh
+++ b/.kilo_workflow/e2e-free-slot.sh
@@ -24,7 +24,7 @@ for claims_dir in "${TMPDIR:-/tmp}/kilo-mobile-simulator-claims" "${TMPDIR:-/tmp
   [ -d "$claims_dir" ] || continue
   for json in "$claims_dir"/*.json; do
     [ -f "$json" ] || continue
-    grep -q "\"worktreeRoot\": \"$ROOT\"" "$json" 2>/dev/null || continue
+    grep -q "\"worktreeRoot\": *\"$ROOT\"" "$json" 2>/dev/null || continue
     leftovers+=("device claim: $json")
   done
 done
diff --git a/.kilo_workflow/e2e-start-resource.sh b/.kilo_workflow/e2e-start-resource.sh
index a149652c0b..7b6f60fbb7 100755
--- a/.kilo_workflow/e2e-start-resource.sh
+++ b/.kilo_workflow/e2e-start-resource.sh
@@ -21,7 +21,18 @@ case "$resource" in
     # fast when a requested service never comes up or the kiloclaw docker
     # bridge is dead.
     pnpm dev:env -y cloudflare-session-ingest
-    pnpm dev:start --no-attach --reuse-running "$@"
+    # The reuse check rejects a live stack whose never-startable services
+    # (stripe/tunnel without secrets) are down. The runner's own remedy:
+    # retry once, then stop and start fresh — safe here because the slot
+    # owner starts the stack before any verifier uses it.
+    if ! pnpm dev:start --no-attach --reuse-running "$@"; then
+      echo "e2e-start-resource: retrying stack start once" >&2
+      if ! pnpm dev:start --no-attach --reuse-running "$@"; then
+        echo "e2e-start-resource: stopping the partial stack and starting fresh" >&2
+        pnpm dev:stop || true
+        pnpm dev:start --no-attach "$@"
+      fi
+    fi
     pnpm drizzle migrate
     STATUS="$(pnpm -s dev:status --json)"
     node - "$STATUS" "$@" <<'NODE'
@@ -42,7 +53,23 @@ NODE
     esac
     ;;
   ios) exec pnpm dev:mobile:simulator claim "$@" ;;
-  android) exec pnpm dev:mobile:android emulator-start --wait "$@" ;;
+  android)
+    # Idempotent per bundle: reuse a live own emulator, start otherwise.
+    RECORD_DIR="${TMPDIR:-/tmp}/kilo-mobile-android-emulators"
+    SLUG=$(basename "$PWD" | sed 's/[^A-Za-z0-9_-]/_/g')
+    RECORD="$RECORD_DIR/$SLUG.json"
+    if [ -f "$RECORD" ]; then
+      SERIAL=$(node -e 'process.stdout.write(JSON.parse(require("fs").readFileSync(process.argv[1])).serial)' "$RECORD")
+      if pnpm -s dev:mobile:android adb -s "$SERIAL" shell getprop sys.boot_completed 2>/dev/null | grep -q '^1'; then
+        echo "reusing running emulator $SERIAL ($RECORD)" >&2
+        cat "$RECORD"
+        exit 0
+      fi
+      echo "recorded emulator not booted; starting fresh" >&2
+      pnpm dev:mobile:android emulator-stop || true
+    fi
+    exec pnpm dev:mobile:android emulator-start "$@" --wait
+    ;;
   bundle)
     # Whole E2E bundle at once: stack ∥ iOS chain ∥ Android chain, one log per
     # chain. The slowest chain sets the wall time, not the sum of the three.
diff --git a/.kilo_workflow/e2e-stop-resource.sh b/.kilo_workflow/e2e-stop-resource.sh
index 75b8f666ff..090556d088 100755
--- a/.kilo_workflow/e2e-stop-resource.sh
+++ b/.kilo_workflow/e2e-stop-resource.sh
@@ -16,7 +16,7 @@ stop_appium_servers() {
     [ -d "$claims_dir" ] || continue
     for json in "$claims_dir"/*.json; do
       [ -f "$json" ] || continue
-      grep -q ""worktreeRoot": "$PWD"" "$json" 2>/dev/null || continue
+      grep -q "\"worktreeRoot\": *\"$PWD\"" "$json" 2>/dev/null || continue
       id=$(node -e 'const r=JSON.parse(require("fs").readFileSync(process.argv[1]));process.stdout.write(r.deviceId||r.serial||"")' "$json" 2>/dev/null || true)
       [ -n "$id" ] || continue
       apps/mobile/e2e/appium.sh "$id" server stop || \
diff --git a/apps/mobile/e2e/preflight.sh b/apps/mobile/e2e/preflight.sh
index 01a3617e50..ea45efdc85 100755
--- a/apps/mobile/e2e/preflight.sh
+++ b/apps/mobile/e2e/preflight.sh
@@ -34,9 +34,14 @@ fi
 
 # login.sh/logout.sh pass the platform they already derived; the adb probe is
 # the fallback for direct invocations.
-PLATFORM="${KILO_E2E_PLATFORM:-ios}"
-if [ -z "${KILO_E2E_PLATFORM:-}" ] && (cd "$REPO_ROOT" && pnpm -s dev:mobile:android adb devices | awk -v device="$DEVICE" '$1 == device && $2 == "device" { found=1 } END { exit !found }'); then
-  PLATFORM="android"
+PLATFORM="${KILO_E2E_PLATFORM:-}"
+if [ -z "$PLATFORM" ]; then
+  PLATFORM="ios"
+  if (cd "$REPO_ROOT" && pnpm -s dev:mobile:android adb devices | awk -v device="$DEVICE" '$1 == device && $2 == "device" { found=1 } END { exit !found }'); then
+    PLATFORM="android"
+  fi
+fi
+if [ "$PLATFORM" = "android" ]; then
   CLAIM="$(cd "$REPO_ROOT" && pnpm -s dev:mobile:android claim "$DEVICE")"
 else
   CLAIM="$(cd "$REPO_ROOT" && pnpm -s dev:mobile:simulator claim "$DEVICE")"

From 378feda2af7ac93ecc9b61973db97196553d155d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 05:57:32 +0200
Subject: [PATCH 31/34] fix(workflow,e2e): kimi k3 review findings, all 17
 applied
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

High: bash-3.2 empty-array fatality in appium.sh; server adoption now
requires the recorded pid alive AND status answering (dead pid + answer
means a hash-colliding sibling's server — never adopted); EMAIL escaped
before reaching the regex selector; await-role tolerates a missing log
instead of dying silently under pipefail.

Low: server status reads the recorded port; -e requires a value;
remote-cli status pipefail guard; baseline temp-dir cleanup on capture
failure and no hashing of non-regular files; regex-free worktree
matching in slot lifecycle scripts; pr-gate newest-first comments and
corrected --wait docs; atomic gh-image install and cache eviction;
slot-status scans all owned session prefixes; android launch lock 120s;
dead learning references removed.

97 workflow/e2e tests pass.
---
 .kilo_workflow/WORKFLOW.md                    |  2 +-
 .kilo_workflow/await-interactive.sh           |  2 +-
 .kilo_workflow/await-role.sh                  |  6 ++---
 .kilo_workflow/baseline.sh                    |  7 ++++--
 .kilo_workflow/e2e-free-slot.sh               |  2 +-
 .kilo_workflow/e2e-slot-status.sh             |  2 +-
 .kilo_workflow/e2e-stop-resource.sh           |  2 +-
 ...install-noop-leaves-virtual-store-drift.md |  4 ++--
 .kilo_workflow/pr-gate.sh                     |  4 ++--
 .kilo_workflow/upload-pr-attachment.sh        |  5 ++--
 apps/mobile/e2e/appium.sh                     | 24 ++++++++++++-------
 apps/mobile/e2e/flows/login-request-code.js   |  4 +++-
 apps/mobile/e2e/remote-cli.sh                 |  2 +-
 dev/local/mobile-android.ts                   |  4 +++-
 14 files changed, 43 insertions(+), 27 deletions(-)

diff --git a/.kilo_workflow/WORKFLOW.md b/.kilo_workflow/WORKFLOW.md
index b28bc9fc71..9fecfde21c 100644
--- a/.kilo_workflow/WORKFLOW.md
+++ b/.kilo_workflow/WORKFLOW.md
@@ -342,7 +342,7 @@ Never collapse retryable and non-retryable failures into one generic error state
 
 Environment blockers and their fixes — broken local stacks, credential traps, simulator quirks, tool wedges — recorded so future runs do not rediscover them. Product bugs never go in learnings.
 
-- Format: **symptom / cause / fix**, a few lines each, in a file whose name makes it findable from the symptom (for example `mobile-metro-file-map-stale-after-node-modules-relayout.md`).
+- Format: **symptom / cause / fix**, a few lines each, in a file whose name makes it findable from the symptom (for example `mobile-metro-file-map-stale-after-node-modules-relayout.md` before it graduated — a good learning names the symptom, then gets automated away).
 - System-specific learnings (true only of this machine: installed tools, local ports, OS quirks) go to `learnings/system/`, which is gitignored (only its `.gitkeep` is committed). Write them to the **main checkout's** copy — `~/Projects/cloud/.kilo_workflow/learnings/system/` — so they survive worktree deletion and reach parallel runs immediately; `pnpm dev:worktree:prepare` copies them into fresh worktrees. `learnings/system/` is the rare exception: when in doubt, commit in the section worktree.
 - Everything else goes to the section worktree's `.kilo_workflow/learnings/` and is committed — the orchestrator includes new learnings in the run's PR (they reach other runs once merged; that lag is accepted). Committed promptly, not at the end: an uncommitted learning blocks E2E dispatch (see E2E Loop) and is one stray cleanup away from vanishing. The planner cannot commit (the orchestrator owns Git), so a planner-authored learning is named in the orchestrator handoff as work for the first commit.
 - `.kilo_workflow/` is exempt from section disjointness — any section may write learnings or fix this document; overlaps resolve as ordinary merge conflicts.
diff --git a/.kilo_workflow/await-interactive.sh b/.kilo_workflow/await-interactive.sh
index c6087674ca..16877795af 100755
--- a/.kilo_workflow/await-interactive.sh
+++ b/.kilo_workflow/await-interactive.sh
@@ -7,7 +7,7 @@
 #
 #   await-interactive.sh <tmux-target> <scratch-dir> [--log <file>]
 #
-# Blocks up to --timeout (default 1500s, the ~25-minute monitor cadence),
+# Blocks up to TIMEOUT seconds (default 1500s, the ~25-minute monitor cadence),
 # then reports. Prints exactly one line:
 #
 #   COMPLETED           exit 0  scratch gone — verify the PR is in gate state
diff --git a/.kilo_workflow/await-role.sh b/.kilo_workflow/await-role.sh
index 6d9e9e54db..70317768c5 100755
--- a/.kilo_workflow/await-role.sh
+++ b/.kilo_workflow/await-role.sh
@@ -15,7 +15,7 @@
 # sidecar is VOID: every legitimate dispatch goes through dispatch-role.sh.
 # A dead tmux target with no exit file is VOID immediately.
 #
-# Blocks up to --timeout (default 480s — safely under harness command
+# Blocks up to TIMEOUT seconds (480 — safely under harness command
 # timeouts), then reports. Re-invoke while it prints RUNNING. Prints exactly
 # one line:
 #
@@ -72,12 +72,12 @@ while :; do
   NOW=$(date +%s)
   if [ -f "$LOG.exit" ]; then
     CODE=$(cat "$LOG.exit" 2>/dev/null || echo "?")
-    SENTINEL=$(tail -1 "$LOG" 2>/dev/null | sed 's/^EXITCODE=[0-9]*$//;s/[[:space:]]*$//')
+    SENTINEL=$({ tail -1 "$LOG" 2>/dev/null || true; } | sed 's/^EXITCODE=[0-9]*$//;s/[[:space:]]*$//')
     # The human-facing EXITCODE marker is the true last line; the sentinel is
     # the line above it. Tolerate either ordering in case the marker write
     # raced the exit-file write.
     if [ -z "$SENTINEL" ]; then
-      SENTINEL=$(tail -2 "$LOG" 2>/dev/null | head -1 | sed 's/[[:space:]]*$//')
+      SENTINEL=$({ tail -2 "$LOG" 2>/dev/null || true; } | head -1 | sed 's/[[:space:]]*$//')
     fi
     if [[ "$SENTINEL" =~ $SENTINELS ]]; then
       echo "DONE $SENTINEL"
diff --git a/.kilo_workflow/baseline.sh b/.kilo_workflow/baseline.sh
index 2a4b43d7be..41ae7130e7 100755
--- a/.kilo_workflow/baseline.sh
+++ b/.kilo_workflow/baseline.sh
@@ -53,6 +53,9 @@ capture() {
   git -C "$WT" ls-files --others --exclude-standard -z | while IFS= read -r -d '' p; do
     if [ -L "$WT/$p" ]; then
       printf 'link\t%s\t%s\n' "$(readlink "$WT/$p")" "$p"
+    elif [ ! -f "$WT/$p" ]; then
+      # FIFOs and sockets block readers; record existence only.
+      printf 'other\t%s\n' "$p"
     elif command -v sha256sum >/dev/null; then
       printf 'file\t%s\t%s\t%s\n' "$(stat -c %a "$WT/$p" 2>/dev/null || stat -f %p "$WT/$p")" \
         "$(sha256sum "$WT/$p" | cut -d' ' -f1)" "$p"
@@ -93,7 +96,7 @@ case $CMD in
     # Capture to a sibling temp dir and publish atomically, so a killed
     # snapshot can never pass for a complete one.
     TMP=$(mktemp -d "$DIR.tmp.XXXXXX")
-    capture "$TMP"
+    capture "$TMP" || { rm -rf "$TMP"; exit 1; }
     rmdir "$DIR" 2>/dev/null || { echo "baseline: $DIR exists and is not empty — refusing to overwrite" >&2; rm -rf "$TMP"; exit 1; }
     mv "$TMP" "$DIR"
     echo "baseline recorded in $DIR"
@@ -103,7 +106,7 @@ case $CMD in
     NOW=$(mktemp -d "${TMPDIR:-/tmp}/kilo-baseline-check.XXXXXX")
     # Kept on mismatch so the printed diff commands stay runnable.
     trap '[ "${fail:-1}" -eq 0 ] && rm -rf "$NOW"' EXIT
-    capture "$NOW"
+    capture "$NOW" || { rm -rf "$NOW"; exit 1; }
     fail=0
     for f in head status.z worktree.diff index.diff untracked.tsv included.tsv; do
       cmp -s "$DIR/$f" "$NOW/$f" && continue
diff --git a/.kilo_workflow/e2e-free-slot.sh b/.kilo_workflow/e2e-free-slot.sh
index e4748ff3c6..d7f91df118 100755
--- a/.kilo_workflow/e2e-free-slot.sh
+++ b/.kilo_workflow/e2e-free-slot.sh
@@ -24,7 +24,7 @@ for claims_dir in "${TMPDIR:-/tmp}/kilo-mobile-simulator-claims" "${TMPDIR:-/tmp
   [ -d "$claims_dir" ] || continue
   for json in "$claims_dir"/*.json; do
     [ -f "$json" ] || continue
-    grep -q "\"worktreeRoot\": *\"$ROOT\"" "$json" 2>/dev/null || continue
+    node -e 'const r=JSON.parse(require("fs").readFileSync(process.argv[1]));process.exit(r.worktreeRoot===process.argv[2]?0:1)' "$json" "$ROOT" 2>/dev/null || continue
     leftovers+=("device claim: $json")
   done
 done
diff --git a/.kilo_workflow/e2e-slot-status.sh b/.kilo_workflow/e2e-slot-status.sh
index a2b7683c05..bf1e830344 100755
--- a/.kilo_workflow/e2e-slot-status.sh
+++ b/.kilo_workflow/e2e-slot-status.sh
@@ -29,7 +29,7 @@ while IFS= read -r session; do
     echo "UNACCOUNTED stack: $session"
     unaccounted=1
   fi
-done < <(tmux list-sessions -F '#{session_name}' 2>/dev/null | grep '^kilo-dev-' || true)
+done < <(tmux list-sessions -F '#{session_name}' 2>/dev/null | grep -E '^(kilo-dev-|kilo-e2e-cli-|kilo-e2e-github-stub-)' || true)
 
 for root in "${TMPDIR:-/tmp}/kilo-mobile-simulator-claims" \
             "${TMPDIR:-/tmp}/kilo-mobile-android-claims" \
diff --git a/.kilo_workflow/e2e-stop-resource.sh b/.kilo_workflow/e2e-stop-resource.sh
index 090556d088..a408a448f3 100755
--- a/.kilo_workflow/e2e-stop-resource.sh
+++ b/.kilo_workflow/e2e-stop-resource.sh
@@ -16,7 +16,7 @@ stop_appium_servers() {
     [ -d "$claims_dir" ] || continue
     for json in "$claims_dir"/*.json; do
       [ -f "$json" ] || continue
-      grep -q "\"worktreeRoot\": *\"$PWD\"" "$json" 2>/dev/null || continue
+      node -e 'const r=JSON.parse(require("fs").readFileSync(process.argv[1]));process.exit(r.worktreeRoot===process.argv[2]?0:1)' "$json" "$PWD" 2>/dev/null || continue
       id=$(node -e 'const r=JSON.parse(require("fs").readFileSync(process.argv[1]));process.stdout.write(r.deviceId||r.serial||"")' "$json" 2>/dev/null || true)
       [ -n "$id" ] || continue
       apps/mobile/e2e/appium.sh "$id" server stop || \
diff --git a/.kilo_workflow/learnings/pnpm-install-noop-leaves-virtual-store-drift.md b/.kilo_workflow/learnings/pnpm-install-noop-leaves-virtual-store-drift.md
index d1dba6562d..1125cc5946 100644
--- a/.kilo_workflow/learnings/pnpm-install-noop-leaves-virtual-store-drift.md
+++ b/.kilo_workflow/learnings/pnpm-install-noop-leaves-virtual-store-drift.md
@@ -5,8 +5,8 @@ patches or recreate deleted `.pnpm` package dirs — even `pnpm install --force`
 removing `node_modules/.modules.yaml` no-op. Hand-edited files under
 `node_modules/.pnpm/<pkg>/` stay edited; deleted package dirs stay deleted (symlinks
 dangle), and stale duplicate peer-hash instances (react-native-css, nativewind,
-react-native) accumulate and poison Metro bundling (see
-mobile-metro-file-map-stale-after-node-modules-relayout.md).
+react-native) accumulate and poison Metro bundling (the stale file-map side of
+that wedge now self-heals: `pnpm dev:restart mobile` clears it).
 
 Cause: pnpm v11 short-circuits headless install when
 `node_modules/.pnpm-workspace-state-v1.json` matches the lockfile; it never
diff --git a/.kilo_workflow/pr-gate.sh b/.kilo_workflow/pr-gate.sh
index 423339c5e1..1701d7e7cc 100755
--- a/.kilo_workflow/pr-gate.sh
+++ b/.kilo_workflow/pr-gate.sh
@@ -11,7 +11,7 @@
 #   --assignee   gate-fail unless this handle is among the assignees
 #   --label      gate-fail unless this label is present (monitors: human-ready)
 #                substring 'bot' matching would let any bot vouch for the head
-#   --wait       poll every 120s up to this budget for the bot summary (or
+#   --wait       poll every 30s up to this budget for the bot summary (or
 #                waiver) to appear before reporting; retriggering stays the
 #                orchestrator's move — this only waits
 #
@@ -48,7 +48,7 @@ while :; do
   # createdAt filter never sees later approvals. The REST `since` parameter
   # filters by updated_at — exactly "bot activity postdating the head".
   # REST logins carry the [bot] suffix gh pr view normalizes away.
-  COMMENTS=$(gh api "repos/$REPO/issues/$PR/comments?since=$HEAD_TIME&per_page=100")
+  COMMENTS=$(gh api "repos/$REPO/issues/$PR/comments?since=$HEAD_TIME&per_page=100&sort=updated&direction=desc")
   BOTCOMMENTS=$(jq -r --arg bot "$BOT" --arg waiver "$WAIVER" \
     '[.[] | select((.user.login == $bot or .user.login == ($bot + "[bot]") or .body == $waiver))
       | "\(.user.login) @ \(.updated_at): \(.body | gsub("\\s+"; " ") | .[0:200])"] | .[]' <<<"$COMMENTS")
diff --git a/.kilo_workflow/upload-pr-attachment.sh b/.kilo_workflow/upload-pr-attachment.sh
index 29daa2e3b0..2c96cf6f9d 100755
--- a/.kilo_workflow/upload-pr-attachment.sh
+++ b/.kilo_workflow/upload-pr-attachment.sh
@@ -55,8 +55,9 @@ else
   ACTUAL=$(checksum "$KILO_IMAGE_TMP/$ASSET")
   [ "$ACTUAL" = "$EXPECTED" ] || { echo "gh-image checksum mismatch" >&2; exit 1; }
   mkdir -p "$(dirname "$BINARY")"
-  install -m 0755 "$KILO_IMAGE_TMP/$ASSET" "$BINARY"
+  install -m 0755 "$KILO_IMAGE_TMP/$ASSET" "$BINARY.tmp.$$"
+  mv -f "$BINARY.tmp.$$" "$BINARY"
 fi
 
-[ "$ACTUAL" = "$EXPECTED" ] || { echo "cached gh-image checksum mismatch" >&2; exit 1; }
+[ "$ACTUAL" = "$EXPECTED" ] || { echo "cached gh-image checksum mismatch" >&2; rm -f "$BINARY"; exit 1; }
 exec "$BINARY" "$SCREENSHOT" --repo "$REPO"
diff --git a/apps/mobile/e2e/appium.sh b/apps/mobile/e2e/appium.sh
index c145a7af6f..6470b818d2 100755
--- a/apps/mobile/e2e/appium.sh
+++ b/apps/mobile/e2e/appium.sh
@@ -66,12 +66,16 @@ port_free() {
 }
 
 ensure_server() {
-  # Adopt only our own recorded server: an unrecorded Appium answering on the
-  # base port belongs to another device whose hash collided with this block,
-  # and attaching here would interleave taps across devices.
-  if [ -f "$STATE_DIR/server.port" ]; then
+  # Adopt only our own recorded server — and only while its recorded pid is
+  # alive. A live pid with no /status is hung: kill it and start over. A dead
+  # pid with a status answer is a hash-colliding sibling on this port:
+  # adopting it would interleave taps across devices.
+  if [ -f "$STATE_DIR/server.port" ] && [ -f "$STATE_DIR/appium.pid" ]; then
     APPIUM_PORT=$(cat "$STATE_DIR/server.port")
-    if server_status; then return 0; fi
+    if kill -0 "$(cat "$STATE_DIR/appium.pid")" 2>/dev/null; then
+      if server_status; then return 0; fi
+      stop_server
+    fi
   fi
   ensure_drivers
   local base_port=$APPIUM_PORT attempt
@@ -122,7 +126,10 @@ case "$cmd" in
     case "${2:-}" in
       start) ensure_drivers && ensure_server ;;
       stop) stop_server ;;
-      status) server_status && echo "up ($DEVICE, port $APPIUM_PORT)" || { echo "down"; exit 1; } ;;
+      status)
+        [ -f "$STATE_DIR/server.port" ] && APPIUM_PORT=$(cat "$STATE_DIR/server.port")
+        server_status && echo "up ($DEVICE, port $APPIUM_PORT)" || { echo "down"; exit 1; }
+        ;;
       *) echo "usage: appium.sh <device> server start|stop|status" >&2; exit 1 ;;
     esac
     ;;
@@ -132,13 +139,14 @@ case "$cmd" in
     FLOWS=()
     while [ $# -gt 0 ]; do
       case "$1" in
-        -e) ENV_ARGS+=("$2"); shift 2 ;;
+        -e) [ $# -ge 2 ] || { echo "appium.sh: -e needs a KEY=VALUE" >&2; exit 1; }
+            ENV_ARGS+=("$2"); shift 2 ;;
         *) FLOWS+=("$1"); shift ;;
       esac
     done
     [ "${#FLOWS[@]}" -gt 0 ] || { echo "usage: appium.sh <device> test [-e K=V]... <flow.js> [more-flows.js]" >&2; exit 1; }
     ensure_server
-    env DEVICE="$DEVICE" APPIUM_PORT="$APPIUM_PORT" "${ENV_ARGS[@]}" \
+    env DEVICE="$DEVICE" APPIUM_PORT="$APPIUM_PORT" ${ENV_ARGS[@]+"${ENV_ARGS[@]}"} \
       node "$SCRIPT_DIR/wdio/run-flow.js" "${FLOWS[@]}"
     ;;
   hierarchy)
diff --git a/apps/mobile/e2e/flows/login-request-code.js b/apps/mobile/e2e/flows/login-request-code.js
index ad552a1420..768089ed50 100644
--- a/apps/mobile/e2e/flows/login-request-code.js
+++ b/apps/mobile/e2e/flows/login-request-code.js
@@ -28,7 +28,9 @@ module.exports = async function requestCode(ctx) {
   await h.inputText(email);
   // Fail here, immediately and legibly, instead of 15s later on a missing
   // "Verify code": a mismatch means typing landed in a field that was not empty.
-  await h.assertVisible(email);
+  // The address is text, not a pattern — escape before it reaches the regex
+  // selector (plus-sign and dot aliases never full-match otherwise).
+  await h.assertVisible(email.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
   await h.tapOn('Send sign-in code');
   // Sending is a network round-trip.
   await h.waitVisible('Verify code', { timeout: 15000 });
diff --git a/apps/mobile/e2e/remote-cli.sh b/apps/mobile/e2e/remote-cli.sh
index 179e9b48e0..bed528e174 100755
--- a/apps/mobile/e2e/remote-cli.sh
+++ b/apps/mobile/e2e/remote-cli.sh
@@ -217,7 +217,7 @@ cmd_exec() {
 cmd_status() {
   if tmux has-session -t "$SESSION" 2>/dev/null; then
     echo "Remote CLI session '$SESSION' is running."
-    tmux capture-pane -p -t "$SESSION" -S -40 | sed -e 's/[[:space:]]*$//' | grep -v '^$' | tail -20
+    tmux capture-pane -p -t "$SESSION" -S -40 | sed -e 's/[[:space:]]*$//' | grep -v '^$' | tail -20 || true
   else
     echo "No remote CLI session '$SESSION' is running."
     [ -f "$ENV_FILE" ] && echo "(env is prepared; run 'remote-cli.sh exec <args>' or 'start')" || true
diff --git a/dev/local/mobile-android.ts b/dev/local/mobile-android.ts
index 6fe22f9384..4129ebe3d4 100644
--- a/dev/local/mobile-android.ts
+++ b/dev/local/mobile-android.ts
@@ -418,7 +418,9 @@ async function startAndroidEmulator(
         throw error;
       }
     },
-    60_000
+    // Two slow holders (pid-file wait + 30s port bind + teardown each) must
+    // not starve a third slot's healthy launch.
+    120_000
   );
 }
 

From d64509ce81b0770a64df87400f4edc63b9bffa9d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 06:35:25 +0200
Subject: [PATCH 32/34] fix(workflow,e2e): kimi k3 round-2 findings
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- slot-status strips each session kind's prefix and compares with the
  matching slug scheme (cli/stub sessions no longer read as UNACCOUNTED
  while their worktree holds a slot)
- baseline validates capture output (non-empty head) — capture inside
  `|| {}` runs with errexit ignored, so internal git failures must be
  caught by the output check, and a clean tree's empty status.z is valid
- stop_server only signals a pid whose command is actually appium
  (recycled pids are never wrong-target killed)
---
 .kilo_workflow/baseline.sh        |  4 ++--
 .kilo_workflow/e2e-slot-status.sh | 15 +++++++++++++--
 apps/mobile/e2e/appium.sh         |  8 ++++++--
 3 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/.kilo_workflow/baseline.sh b/.kilo_workflow/baseline.sh
index 41ae7130e7..4cb70a252b 100755
--- a/.kilo_workflow/baseline.sh
+++ b/.kilo_workflow/baseline.sh
@@ -96,7 +96,7 @@ case $CMD in
     # Capture to a sibling temp dir and publish atomically, so a killed
     # snapshot can never pass for a complete one.
     TMP=$(mktemp -d "$DIR.tmp.XXXXXX")
-    capture "$TMP" || { rm -rf "$TMP"; exit 1; }
+    { capture "$TMP" && [ -s "$TMP/head" ]; } || { rm -rf "$TMP"; echo 'baseline: capture failed' >&2; exit 1; }
     rmdir "$DIR" 2>/dev/null || { echo "baseline: $DIR exists and is not empty — refusing to overwrite" >&2; rm -rf "$TMP"; exit 1; }
     mv "$TMP" "$DIR"
     echo "baseline recorded in $DIR"
@@ -106,7 +106,7 @@ case $CMD in
     NOW=$(mktemp -d "${TMPDIR:-/tmp}/kilo-baseline-check.XXXXXX")
     # Kept on mismatch so the printed diff commands stay runnable.
     trap '[ "${fail:-1}" -eq 0 ] && rm -rf "$NOW"' EXIT
-    capture "$NOW" || { rm -rf "$NOW"; exit 1; }
+    { capture "$NOW" && [ -s "$NOW/head" ]; } || { rm -rf "$NOW"; echo 'baseline: capture failed' >&2; exit 1; }
     fail=0
     for f in head status.z worktree.diff index.diff untracked.tsv included.tsv; do
       cmp -s "$DIR/$f" "$NOW/$f" && continue
diff --git a/.kilo_workflow/e2e-slot-status.sh b/.kilo_workflow/e2e-slot-status.sh
index bf1e830344..0bb7fb6d27 100755
--- a/.kilo_workflow/e2e-slot-status.sh
+++ b/.kilo_workflow/e2e-slot-status.sh
@@ -18,11 +18,22 @@ done > "$covered"
 
 unaccounted=0
 while IFS= read -r session; do
-  slug=${session#kilo-dev-}
+  # Slug extraction and candidate scheme must match how each session kind was
+  # named: kilo-dev-*/emulator records use per-char underscores, cli sessions
+  # the collapsing dash slug, stub sessions the raw basename.
+  case "$session" in
+    kilo-dev-*) slug=${session#kilo-dev-}; scheme=underscore ;;
+    kilo-e2e-cli-*) slug=${session#kilo-e2e-cli-}; scheme=dash ;;
+    kilo-e2e-github-stub-*) slug=${session#kilo-e2e-github-stub-}; scheme=raw ;;
+  esac
   found=0
   while IFS= read -r worktree; do
     [ -n "$worktree" ] || continue
-    candidate=$(basename "$worktree" | tr -c 'A-Za-z0-9_\n-' '_')
+    case "$scheme" in
+      underscore) candidate=$(basename "$worktree" | tr -c 'A-Za-z0-9_\n-' '_') ;;
+      dash) candidate=$(basename "$worktree" | tr -cs 'a-zA-Z0-9' '-' | sed 's/^-*//;s/-*$//') ;;
+      raw) candidate=$(basename "$worktree") ;;
+    esac
     [ "$candidate" = "$slug" ] && found=1
   done < "$covered"
   if [ "$found" -eq 0 ]; then
diff --git a/apps/mobile/e2e/appium.sh b/apps/mobile/e2e/appium.sh
index 6470b818d2..661e6b330d 100755
--- a/apps/mobile/e2e/appium.sh
+++ b/apps/mobile/e2e/appium.sh
@@ -109,8 +109,12 @@ ensure_server() {
 }
 
 stop_server() {
-  if [ -f "$STATE_DIR/appium.pid" ] && kill -0 "$(cat "$STATE_DIR/appium.pid")" 2>/dev/null; then
-    kill "$(cat "$STATE_DIR/appium.pid")" || true
+  if [ -f "$STATE_DIR/appium.pid" ]; then
+    PID=$(cat "$STATE_DIR/appium.pid")
+    # Pids get recycled; only signal a process that is actually our appium.
+    if kill -0 "$PID" 2>/dev/null && ps -o command= -p "$PID" 2>/dev/null | grep -q appium; then
+      kill "$PID" || true
+    fi
   fi
   rm -f "$STATE_DIR/appium.pid" "$STATE_DIR/server.port"
 }

From 96645eeba0001634bb45b02882b4ab8f5883d53d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 06:46:27 +0200
Subject: [PATCH 33/34] docs(workflow,e2e): smooth rough edges found by model
 Q&A

Eleven kilo-efficient sessions answered 40 workflow scenarios; three
recurring weak spots smoothed:
- foreign data on a claimed device: prove against the backend first,
  never a product defect from a capture alone (runbook section)
- verifier-authored documentation fixes follow the learning path
  ($SCRATCH -> orchestrator -> same PR), stated in Graduation
- exact helper signatures in the runbook (no positional variants)
---
 .kilo_workflow/WORKFLOW.md | 2 +-
 apps/mobile/e2e/AGENTS.md  | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/.kilo_workflow/WORKFLOW.md b/.kilo_workflow/WORKFLOW.md
index 9fecfde21c..8c0a4f8954 100644
--- a/.kilo_workflow/WORKFLOW.md
+++ b/.kilo_workflow/WORKFLOW.md
@@ -348,7 +348,7 @@ Environment blockers and their fixes — broken local stacks, credential traps,
 - `.kilo_workflow/` is exempt from section disjointness — any section may write learnings or fix this document; overlaps resolve as ordinary merge conflicts.
 - Role agents whose rules forbid dirtying the tree (the E2E verifier's byte-identical baseline restore) write their learnings to `$SCRATCH/learnings/` instead and list them in their report; the orchestrator moves them into `.kilo_workflow/learnings/` and commits them.
 - Read before writing: when an existing entry covers the blocker, update it instead of appending a duplicate. When a run proves an entry wrong or stale, fix the entry in the same run.
-- **Graduation:** a learning is a workaround waiting for a fix. When the blocker can be prevented by a script change (a flag, a guard, a wrapper) or by a line where agents already look (this document, a runbook, a role definition), make that change instead of — or in the same PR as — writing the learning, and delete any learning the change supersedes. Keep as learnings only what genuinely cannot be automated or folded away: environment trivia, one-off incident evidence, niche device quirks.
+- **Graduation:** a learning is a workaround waiting for a fix. When the blocker can be prevented by a script change (a flag, a guard, a wrapper) or by a line where agents already look (this document, a runbook, a role definition), make that change instead of — or in the same PR as — writing the learning, and delete any learning the change supersedes. Keep as learnings only what genuinely cannot be automated or folded away: environment trivia, one-off incident evidence, niche device quirks. A verifier cannot fix docs itself (its baseline restore must stay byte-identical), so a verifier-authored documentation fix follows the learning path: written under `$SCRATCH` (as a patch or a precise edit), named in the report, and applied by the orchestrator in the same PR.
 - Every role records blockers it resolves, immediately after resolving them. The orchestrator commits learnings to the section worktree's `.kilo_workflow/learnings/`; the planner cannot commit, and an uncommitted worktree file blocks its own repro-gate dispatch, so a planner-authored learning goes to `$SCRATCH/learnings/` and is named in the orchestrator handoff for the first commit.
 - Never keep a workflow learning only in a harness's private memory; it belongs in these folders so runs on other harnesses can use it.
 - The same rule applies to this document: when a run stumbles on something `WORKFLOW.md` could have prevented — a missing command, an ambiguous rule, a wrong assumption — the orchestrator fixes the document in the same run and ships the fix with the PR. Role-definition fixes from a kilo session go through shell (`cat > .kilo/agent/<name>.md <<'EOF'`) because kilo's edit tool blocks `.kilo/` paths (the bash tool is not config-gated; `.kilo_workflow/` paths are unaffected). Mistakes that recur are workflow bugs, not agent bugs.
diff --git a/apps/mobile/e2e/AGENTS.md b/apps/mobile/e2e/AGENTS.md
index 317613543f..a3f1ab6155 100644
--- a/apps/mobile/e2e/AGENTS.md
+++ b/apps/mobile/e2e/AGENTS.md
@@ -183,6 +183,10 @@ pnpm dev:seed app:add-credits <user-id> <usd>    # grant credits
 pnpm dev:seed app:api-token <email>              # mint a bearer token (used by remote-cli.sh)
 ```
 
+## Foreign Data on Your Device
+
+A hierarchy or screenshot that shows another worktree's data (rows, sessions, searches that cannot belong to the signed-in `e2e-mobile-*` account) is never a product defect on its own. Prove it against the backend first: row ownership in Postgres, this worktree's nextjs/ingest logs, and whether a pull-to-refresh reproduces it. Re-confirm the signed-in account (Profile tab) and Metro provenance before continuing. Backend evidence contradicting the capture means cross-device environment noise: re-run the affected check cleanly and report both.
+
 ## Appium + WebdriverIO
 
 Setup is automatic: the repository install provides Appium and the webdriverio client, and the wrapper below installs the XCUITest / UiAutomator2 drivers into a machine-global `APPIUM_HOME` (`~/.cache/kilo-appium`, override with `KILO_APPIUM_HOME`) on first use. Never use MCP automation tools or a hand-rolled driver connection: they bypass the per-device lock; use the repository wrapper.

From 7db6bce2fa5a0fcdf90ada71963bbcb7ebcafd3c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20=C5=A0=C4=87eki=C4=87?= <iscekic@protonmail.com>
Date: Thu, 30 Jul 2026 09:38:12 +0200
Subject: [PATCH 34/34] fix(workflow): address Kilobot threads + format

- e2e-start-resource appends --wait only when the caller did not pass it
- launch-gate restores the future-timestamp clamp (clock skew must not
  sleep unbounded and wedge every launch)
- pr-gate drops the orphaned --bot doc line
- oxfmt pass over the branch's hand-edited files
---
 .kilo_workflow/e2e-start-resource.sh       | 6 +++++-
 .kilo_workflow/launch-gate.sh              | 2 ++
 .kilo_workflow/pr-gate.sh                  | 1 -
 apps/mobile/e2e/flows/login-verify-code.js | 9 ++++++---
 apps/mobile/e2e/wdio/helpers.js            | 4 +++-
 dev/local/appium-wrapper.test.ts           | 5 ++++-
 dev/local/cli.ts                           | 1 -
 dev/local/mobile-android.ts                | 4 +++-
 dev/local/mobile-workflow.test.ts          | 7 +++++--
 9 files changed, 28 insertions(+), 11 deletions(-)

diff --git a/.kilo_workflow/e2e-start-resource.sh b/.kilo_workflow/e2e-start-resource.sh
index 7b6f60fbb7..9570e6296a 100755
--- a/.kilo_workflow/e2e-start-resource.sh
+++ b/.kilo_workflow/e2e-start-resource.sh
@@ -68,7 +68,11 @@ NODE
       echo "recorded emulator not booted; starting fresh" >&2
       pnpm dev:mobile:android emulator-stop || true
     fi
-    exec pnpm dev:mobile:android emulator-start "$@" --wait
+    case " $* " in
+      *" --wait "*) ;;
+      *) set -- "$@" --wait ;;
+    esac
+    exec pnpm dev:mobile:android emulator-start "$@"
     ;;
   bundle)
     # Whole E2E bundle at once: stack ∥ iOS chain ∥ Android chain, one log per
diff --git a/.kilo_workflow/launch-gate.sh b/.kilo_workflow/launch-gate.sh
index dedbdb7dc7..ef6e5638f3 100755
--- a/.kilo_workflow/launch-gate.sh
+++ b/.kilo_workflow/launch-gate.sh
@@ -15,6 +15,8 @@ if [ "${1:-}" = "--locked" ]; then
   last=$(cat "$GATE/last" 2>/dev/null || echo 0)
   case "$last" in ''|*[!0-9]*) last=0 ;; esac
   remaining=$(( 3 - (now - last) ))
+  # A future timestamp (clock skew, hand-edited file) must not sleep forever.
+  [ "$remaining" -le 3 ] || remaining=3
   [ "$remaining" -le 0 ] || sleep "$remaining"
   date +%s > "$GATE/last"
   exit 0
diff --git a/.kilo_workflow/pr-gate.sh b/.kilo_workflow/pr-gate.sh
index 1701d7e7cc..d717ae3e40 100755
--- a/.kilo_workflow/pr-gate.sh
+++ b/.kilo_workflow/pr-gate.sh
@@ -10,7 +10,6 @@
 #
 #   --assignee   gate-fail unless this handle is among the assignees
 #   --label      gate-fail unless this label is present (monitors: human-ready)
-#                substring 'bot' matching would let any bot vouch for the head
 #   --wait       poll every 30s up to this budget for the bot summary (or
 #                waiver) to appear before reporting; retriggering stays the
 #                orchestrator's move — this only waits
diff --git a/apps/mobile/e2e/flows/login-verify-code.js b/apps/mobile/e2e/flows/login-verify-code.js
index aca3a74717..6c39002716 100644
--- a/apps/mobile/e2e/flows/login-verify-code.js
+++ b/apps/mobile/e2e/flows/login-verify-code.js
@@ -21,9 +21,12 @@ module.exports = async function verifyCode(ctx) {
   await h.tapOn('Verify code');
 
   // A brand-new account's first sign-in shows a consent screen before Home.
-  await h.waitVisible(new RegExp([S.CONSENT.source, S.NOTIF_PROMPT.source, S.HOME.source].join('|')), {
-    timeout: 20000,
-  });
+  await h.waitVisible(
+    new RegExp([S.CONSENT.source, S.NOTIF_PROMPT.source, S.HOME.source].join('|')),
+    {
+      timeout: 20000,
+    }
+  );
   await when(ctx, S.CONSENT, () => h.tapOn(S.CONSENT));
   await h.waitVisible(new RegExp([S.NOTIF_PROMPT.source, S.HOME.source].join('|')), {
     timeout: 15000,
diff --git a/apps/mobile/e2e/wdio/helpers.js b/apps/mobile/e2e/wdio/helpers.js
index 9637d10782..46716f1358 100644
--- a/apps/mobile/e2e/wdio/helpers.js
+++ b/apps/mobile/e2e/wdio/helpers.js
@@ -108,7 +108,9 @@ function make(driver, platform) {
     const els = await findAll(pattern, { ci, sort: true });
     if (els.length === 0) throw new Error(`no element matching ${describe(pattern)}`);
     if (index >= els.length) {
-      throw new Error(`index ${index} out of range (${els.length} matches) for ${describe(pattern)}`);
+      throw new Error(
+        `index ${index} out of range (${els.length} matches) for ${describe(pattern)}`
+      );
     }
     await driver.elementClick(elementIdOf(els[index]));
   }
diff --git a/dev/local/appium-wrapper.test.ts b/dev/local/appium-wrapper.test.ts
index 0fc2e76ae1..db6529a673 100644
--- a/dev/local/appium-wrapper.test.ts
+++ b/dev/local/appium-wrapper.test.ts
@@ -18,7 +18,10 @@ test('appium port assignment is deterministic and block-shaped', () => {
 });
 
 test('appium device slug is filesystem- and tmux-safe', () => {
-  assert.equal(slugFor('A1B2C3D4-0000-0000-0000-000000000000'), 'A1B2C3D4-0000-0000-0000-000000000000');
+  assert.equal(
+    slugFor('A1B2C3D4-0000-0000-0000-000000000000'),
+    'A1B2C3D4-0000-0000-0000-000000000000'
+  );
   assert.equal(slugFor('emulator-5554'), 'emulator-5554');
   assert.equal(slugFor('192.168.1.10:5555'), '192-168-1-10-5555');
 });
diff --git a/dev/local/cli.ts b/dev/local/cli.ts
index f330f842ab..f80de553d5 100644
--- a/dev/local/cli.ts
+++ b/dev/local/cli.ts
@@ -960,7 +960,6 @@ async function cmdStatus(repoRoot: string, isJson = false): Promise<void> {
   }
 }
 
-
 // Metro's jest-haste-map cache ($TMPDIR/metro-file-map-*) persists per project
 // root across dependency relayouts and then serves stale module instances
 // (deterministic white screen + metroRequire stack overflow). Clearing this
diff --git a/dev/local/mobile-android.ts b/dev/local/mobile-android.ts
index 4129ebe3d4..10f5c1566e 100644
--- a/dev/local/mobile-android.ts
+++ b/dev/local/mobile-android.ts
@@ -479,7 +479,9 @@ async function waitForAndroidBoot(env: AndroidEnvironment, record: EmulatorRecor
         throw new Error(`${record.session} died while booting; see ${record.log}`);
     }
     if (Date.now() > deadline)
-      throw new Error(`${record.serial} did not reach sys.boot_completed=1 within 8 minutes; see ${record.log}`);
+      throw new Error(
+        `${record.serial} did not reach sys.boot_completed=1 within 8 minutes; see ${record.log}`
+      );
     await delay(15_000);
   }
 }
diff --git a/dev/local/mobile-workflow.test.ts b/dev/local/mobile-workflow.test.ts
index 5fcddad237..57b2043c86 100644
--- a/dev/local/mobile-workflow.test.ts
+++ b/dev/local/mobile-workflow.test.ts
@@ -138,8 +138,11 @@ test('settle flow polls for the next state immediately after every prompt answer
     const gateIndex = flow.indexOf('h.waitVisible(', actionIndex);
     const gate = flow.slice(gateIndex, flow.indexOf('}', gateIndex));
     assert.ok(gateIndex > actionIndex, `settle-app should gate after ${action}`);
-    assert.match(gate, new RegExp(nextState.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')),
-      `settle-app should poll for ${nextState} after ${action}`);
+    assert.match(
+      gate,
+      new RegExp(nextState.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')),
+      `settle-app should poll for ${nextState} after ${action}`
+    );
     assert.match(gate, /timeout: 5000/);
     assert.doesNotMatch(gate, /optional: true/);
     searchFrom = gateIndex;