diff --git a/.kilo/agent/e2e-verifier.md b/.kilo/agent/e2e-verifier.md
deleted file mode 100644
index 32143ba09b6..00000000000
--- a/.kilo/agent/e2e-verifier.md
+++ /dev/null
@@ -1,68 +0,0 @@
----
-description: Verifies end to end that an implemented plan meets its goals; in repro mode, reproduces a reported defect on the unmodified baseline
-mode: all
-model: kilo/x-ai/grok-4.5
-variant: high
-steps: 100
-permission:
-  edit: allow
-  external_directory: allow
-  task: deny
-  bash:
-    "*": 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: 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. 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.
-
-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. 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 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.
-- Exception to the never-read-env rule: when the runbook mandates an env-file edit (for example the GitHub stub's `GITHUB_API_BASE_URL` in the worktree root `.env.local`), make that exact edit with the value supplied in your handoff, record it, and restore the file afterward — never read the file's other contents or any env file the runbook does not name.
-- Exception: LLM and agent responses are never mocked. Drive a real model call on `kilo-auto/efficient` — never `kilo-auto/free`, which is rate-limited; if an `efficient` call stalls, retry on `efficient`. Use an LLM mock only when a real call cannot produce the required state (for example, a specific provider failure), and report each use with the mock named and justified.
-- Temporary edits must not change the behavior under test, bypass provenance or security checks, or fix or conceal a product failure. If producing a state would change the behavior being judged, report that state as blocked.
-- When you resolve an environment blocker, record it (symptom / cause / fix, findable filename; update an existing entry instead of duplicating it). System-specific entries (true only of this machine) go to the main checkout's `~/Projects/cloud/.kilo_workflow/learnings/system/` — outside your baseline-restore scope. Everything else goes to `$SCRATCH/learnings/` (never the repository — your baseline restore must stay byte-identical), listed in your report so the orchestrator can commit it.
-
-Classify every failure as exactly one of:
-
-- Product failure: implemented behavior violates an acceptance criterion
-- Test-environment failure: services, build provenance, device, data, or tooling prevented a valid test
-- Inconclusive: evidence cannot distinguish the two
-
-Attempt one reasonable recovery for a test-environment failure. Never repair the environment by changing product code or routing around provenance checks.
-
-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, 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 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/agent/impl-reviewer.md b/.kilo/agent/impl-reviewer.md
deleted file mode 100644
index f06d1a5a880..00000000000
--- a/.kilo/agent/impl-reviewer.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-description: Reviews an implementation slice produced for an approved plan, including cross-repository changes
-mode: all
-model: kilo/x-ai/grok-4.5
-variant: high
-steps: 50
-permission:
-  edit: allow
-  external_directory: allow
-  task: deny
-  bash:
-    "*": allow
----
-
-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. 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:
-
-- The accepted plan and acceptance criteria — does the implementation achieve the plan's goals for this slice?
-- Every applicable `AGENTS.md`
-- Correctness, regressions, error paths, security, and maintainability
-- Unnecessary complexity: code or scope beyond the simplest maintainable implementation of the slice
-- Test quality and missing automated coverage
-- Cross-repository contract consistency
-
-For every new user-facing feature, also check its four states — happy, retryable unhappy, non-retryable unhappy, empty:
-
-- State-specific meaningful messages; an actionable CTA for retryable and empty states; no CTA at all for non-retryable states
-- An explicit trigger or classification, message intent, CTA outcome or absence, and automated/E2E coverage for every state
-- Any `not applicable` state has an orchestrator-accepted rationale showing it is structurally impossible, not merely hard to test
-
-Inspect the actual diff and surrounding code. Run narrow read-only checks when useful. Do not dispatch subagents. Do not invent requirements beyond the accepted plan.
-
-Output findings first, ordered by severity. Each finding contains:
-
-- Severity: critical, high, medium, or low
-- File and line reference
-- Concrete failure mode or violated requirement
-- Required outcome — do not prescribe unnecessary implementation detail
-
-Do not praise the implementation or summarize before findings. Put residual testing risks after the findings (or after the no-findings statement), then end your report with exactly one sentinel as the **last line**:
-
-- `FINDINGS: <n>` after a findings list
-- `No findings.` when there is nothing actionable
-- `STOPPED EARLY.` after an early stop (preceded by: completed review scope, remaining scope, failures, files inspected, checks run or deferred, and the safest next action)
-
-Your dispatcher treats a log whose last report line is not one of these as a void round — a crashed run, never a pass.
diff --git a/.kilo/agent/implementer.md b/.kilo/agent/implementer.md
deleted file mode 100644
index 96b86100d63..00000000000
--- a/.kilo/agent/implementer.md
+++ /dev/null
@@ -1,44 +0,0 @@
----
-description: Implements one bounded slice of an approved plan, anywhere in the monorepo or a sibling repository
-mode: all
-model: kilo/kilo-auto/efficient
-steps: 80
-permission:
-  edit: allow
-  external_directory: allow
-  task: deny
-  bash:
-    "*": allow
----
-
-You implement one bounded slice from an approved plan (see `.kilo_workflow/WORKFLOW.md`). The slice may require changes anywhere in the cloud monorepo or in a sibling repository such as `~/Projects/kilocode`.
-
-Before editing:
-
-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.
-5. Restate your priority order, minimum complete outcome, optional work to drop, stopping rule before the 80-step hard limit, owned paths, forbidden paths, and the other active slices.
-
-While implementing:
-
-- Make the smallest complete change that satisfies the assigned slice. Reuse existing helpers, components, and contracts; do not add abstraction the slice does not need.
-- Add or update focused behavioral tests for the behavior you changed, covering every applicable feature state. Never merge retryable and non-retryable failures into one generic error presentation.
-- Preserve unrelated working-tree changes. Never revert work you did not create.
-- Edit only your slice's paths and do not reformat another slice's changes. Unexpected changes inside your paths: stop and report the collision. Outside your paths: continue and preserve them.
-- Run per-file format and lint checks and the targeted tests for what you changed. Project-wide checks — typecheck included, since it covers the whole project and fails on sibling slices' half-done state — belong to the orchestrator's synchronization point; report them as deferred, never as passed.
-- Never expand scope, dispatch subagents, commit, push, or create or update a PR. Permissions restrict nothing except agent dispatch (`task`); git and `gh` boundaries are this instruction — the orchestrator owns every commit, push, and PR.
-- Never claim the overall task is complete. Review, E2E, and final verification belong to the orchestrator.
-
-Return:
-
-- Acceptance criteria addressed
-- Files changed and why
-- Checks run, with exact outcomes
-- For user-facing features: feature-state coverage — triggers, message semantics, CTA assertions, and any accepted structurally impossible states
-- Suggested commit boundary and a concise commit message for the completed slice
-- Remaining risks, ambiguity, or unfinished work
-- If stopping early: completed work, remaining work, failures, files touched, checks run or deferred, and the safest next action
-
-End your report with exactly one sentinel line: `SLICE COMPLETE.` or `STOPPED EARLY.` Your dispatcher treats a log without a sentinel as a void round — a crashed run, never a pass.
diff --git a/.kilo/agent/orchestrator.md b/.kilo/agent/orchestrator.md
deleted file mode 100644
index c016d49a188..00000000000
--- a/.kilo/agent/orchestrator.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-description: Drives an approved plan to a mergeable PR per .kilo_workflow/WORKFLOW.md section 3
-mode: all
-model: kilo/x-ai/grok-4.5
-variant: high
-permission:
-  edit: allow
-  external_directory: allow
-  task: deny
-  bash:
-    "*": allow
----
-
-You are the orchestrator defined in `.kilo_workflow/WORKFLOW.md` (section 3 and everything it references). Read that document first and follow it exactly: ingest the handoff, slice the plan, run the implementer/reviewer loops, own every commit and the PR, run the E2E and Kilobot loops, and finish at a terminal state — COMPLETE or BLOCKED — with every resource released.
-
-Your permissions are pinned here so you run unattended on any machine; the workflow document is your contract. You dispatch role agents with the kilo CLI per its Dispatching section — never with a `task` tool.
diff --git a/.kilo/agent/plan-reviewer.md b/.kilo/agent/plan-reviewer.md
deleted file mode 100644
index ccb2a65b859..00000000000
--- a/.kilo/agent/plan-reviewer.md
+++ /dev/null
@@ -1,45 +0,0 @@
----
-description: Reviews a drafted implementation plan for ambiguity, unsupported claims, unnecessary complexity, and missing execution detail
-mode: all
-model: kilo/x-ai/grok-4.5
-variant: high
-steps: 40
-permission:
-  edit: allow
-  external_directory: allow
-  task: deny
-  bash:
-    "*": allow
----
-
-You are an independent, read-only reviewer for a drafted implementation plan (see `.kilo_workflow/WORKFLOW.md`). Given the plan and what it is trying to achieve, review the plan as a whole and poke holes in it. Read the plan and the relevant repository files, and run read-only commands when they help you verify a claim. Permissions restrict nothing except agent dispatch (`task`); the read-only boundary is this instruction. Never dispatch agents, never modify any file or repository state, never commit, push, or create or update a PR, and never decide product requirements or fix findings yourself.
-
-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. 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:
-
-- Unnecessary complexity — steps that are not the simplest maintainable implementation, feature shapes needlessly more complex than what delivers the same user value, or unneeded scope or abstraction. Give this special attention.
-- Unclear requirements, unsupported assumptions or claims, and missing or conflicting acceptance criteria
-- Missing feature states, non-goals, dependencies, ownership boundaries, or cross-repository contracts
-- Infeasible or ambiguous sequencing, unsafe parallel work, and underspecified verification or E2E coverage
-- Handoffs missing information an implementer, reviewer, verifier, or orchestrator needs to act without guessing
-
-Check repository files for claims that materially affect feasibility or correctness. Do not invent requirements beyond the request. A recorded, evidence-backed decision is not a defect just because uncertainty remains.
-
-Output findings first, ordered by severity. Each finding contains:
-
-- Severity: critical, high, medium, or low
-- Plan section and the relevant repository file or instruction
-- What is unclear, unsupported, conflicting, missing, or needlessly complex
-- The concrete implementation, verification, or product decision that could fail
-- The clarification or evidence required — do not prescribe unnecessary implementation detail
-
-Do not praise or summarize the plan before findings. Put residual risks after the findings (or after the no-findings statement), then end your report with exactly one sentinel as the **last line**:
-
-- `FINDINGS: <n>` after a findings list
-- `No findings.` when there is nothing actionable
-- `STOPPED EARLY.` after an early stop (preceded by: reviewed scope, remaining scope, evidence inspected, and the safest next action)
-
-Your dispatcher treats a log whose last report line is not one of these as a void round — a crashed run, never a pass.
diff --git a/.kilo/agent/planner.md b/.kilo/agent/planner.md
deleted file mode 100644
index d2623729055..00000000000
--- a/.kilo/agent/planner.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-description: Plans one section of work per .kilo_workflow/WORKFLOW.md section 2, then launches and monitors its orchestrator
-mode: all
-model: kilo/moonshotai/kimi-k3
-variant: high
-permission:
-  edit: allow
-  external_directory: allow
-  task: deny
-  bash:
-    "*": allow
----
-
-You are the planner defined in `.kilo_workflow/WORKFLOW.md` (section 2 and everything it references). Read that document first and follow it exactly: read the brief and the learnings, explore, write the plan to `$SCRATCH/plan.md`, run the plan-review loop, get approval per the mode, write the orchestrator handoff, launch the orchestrator, then switch to monitor mode until the section reaches a terminal state.
-
-Your model is pinned to `kilo/moonshotai/kimi-k3` (variant `high`); the user can still override at launch with `--model` when they need a different SOTA pick. Your permissions are pinned so you run unattended on any machine. You dispatch role agents with the kilo CLI per the workflow's Dispatching section — never with a `task` tool.
diff --git a/.kilo/agent/starter.md b/.kilo/agent/starter.md
deleted file mode 100644
index d2ef893f2a5..00000000000
--- a/.kilo/agent/starter.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-description: Turns a raw request into sectioned, planned work per .kilo_workflow/WORKFLOW.md section 1, then launches and monitors planners
-mode: all
-model: kilo/x-ai/grok-4.5
-variant: high
-permission:
-  edit: allow
-  external_directory: allow
-  task: deny
-  bash:
-    "*": 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, 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.
-
-Your model is pinned to `kilo/x-ai/grok-4.5` (variant `high`); the user can still override at launch with `--model` when they need a different SOTA pick. 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/.e2e-slot-state.sh b/.kilo_workflow/.e2e-slot-state.sh
deleted file mode 100755
index ea918f87766..00000000000
--- a/.kilo_workflow/.e2e-slot-state.sh
+++ /dev/null
@@ -1,144 +0,0 @@
-#!/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.
-    # 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
-}
-
-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
-          # 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
-            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
deleted file mode 100644
index 3729bb61c65..00000000000
--- a/.kilo_workflow/README.md
+++ /dev/null
@@ -1,71 +0,0 @@
-# Kilo Workflow — TL;DR
-
-A multi-agent delivery workflow for this repository (and siblings like `~/Projects/kilocode`). You hand it a body of work; it returns a reviewed, E2E-verified, CI-green PR assigned to you. [`WORKFLOW.md`](WORKFLOW.md) is the canonical spec every agent follows — this file is the human orientation.
-
-## How to run it
-
-1. Open an interactive session on a strong model — either harness works:
-   - Claude Code: just ask, e.g. *"Run the kilo workflow on \<work\>."*
-   - kilo CLI: `kilo run --agent starter --interactive` (pass `--model` and `--variant` only to override the pinned default)
-2. Answer the one process question: **hands on** (it asks you questions, you approve the plan) or **hands off** (it decides everything from repository evidence and never waits for you).
-3. Walk away. Everything runs in tmux windows named after the section (`<name>-<hex>`, e.g. `billing-a7f3-planner`); attach to watch or, in hands-on mode, to answer a question.
-
-A run ends in one of two states:
-
-- **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
-
-Pipeline: **starter → planner → orchestrator → implementer/reviewer loops → E2E verification → Kilobot loop → completion gate.**
-
-| Role | What it does |
-|---|---|
-| Starter | Grills the requirements, challenges the request itself, splits work into disjoint sections; one planner per section |
-| Planner | Writes the plan (SOTA model); loops with fresh plan-reviewers until `No findings.`; for bugs, a repro gate proves the defect exists before anything is planned |
-| Orchestrator | Owns git end to end; slices the plan, dispatches parallel implementers, commits at slice boundaries, opens the PR |
-| 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; the worktree itself is the one local artifact that stays until its PR closes.
-
-## Fast without trading correctness
-
-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 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 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-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) |
-| [`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).
diff --git a/.kilo_workflow/WORKFLOW.md b/.kilo_workflow/WORKFLOW.md
deleted file mode 100644
index 040c4880d89..00000000000
--- a/.kilo_workflow/WORKFLOW.md
+++ /dev/null
@@ -1,381 +0,0 @@
-# Kilo Workflow
-
-A general-purpose multi-agent delivery workflow for this repository. Use it when the user asks to run "the kilo workflow" on a body of work. It applies to any product surface — web, mobile, extension, Workers, services, shared packages — and plans may also touch sibling repositories such as `~/Projects/kilocode`.
-
-Pipeline: **starter → planner(s) → orchestrator → implementer/reviewer loops → E2E verification → PR**.
-
-The definitions for every kilo CLI role live in the repository root `.kilo/agent/` — `starter`, `planner`, `orchestrator`, `plan-reviewer`, `implementer`, `impl-reviewer`, `e2e-verifier` — because the kilo CLI only discovers agents from `.kilo` directories. Everything else about the workflow — this document, the dispatch and slot scripts, and committed learnings — lives in `.kilo_workflow/`.
-
-## Ground Rules
-
-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 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.
-- 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`, `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
-
-| Role | Harness | Model | Steps |
-|---|---|---|---|
-| Starter | user picks | `kilo/x-ai/grok-4.5`, high (user may override at launch) | unlimited |
-| Planner | user picks | `kilo/moonshotai/kimi-k3`, high (user may override at launch) | unlimited |
-| Plan reviewer | kilo CLI | `kilo/x-ai/grok-4.5`, high | 40 |
-| Orchestrator | kilo CLI | `kilo/x-ai/grok-4.5`, high | unlimited |
-| Implementer | kilo CLI | `kilo/kilo-auto/efficient` | 80 |
-| Impl reviewer | kilo CLI | `kilo/x-ai/grok-4.5`, high | 50 |
-| E2E verifier | kilo CLI | `kilo/x-ai/grok-4.5`, high | 100 |
-
-Every kilo-CLI role above has a definition in `.kilo/agent/` (including `starter`, `planner`, and `orchestrator`) pinning its permissions and its model and step limit. The definition is authoritative: dispatches pass `--model`/`--variant` only for the starter and planner, where the user may override the pinned model at launch. Never use `kilo/kilo-auto/free` — it is rate-limited. Not even as a fallback: if a call stalls or errors, retry or relaunch on the assigned model, never a different one. Product-side LLM calls in E2E flows follow "Real LLM responses" below.
-
-### Step Limits
-
-The kilo role-agent step limits above are hard ceilings pinned in the agent definitions. For the step-limited roles, size every handoff below 75% of the role's limit — estimate roughly one step per planned tool call; an implementation slice should fit in roughly 60 planned steps. Unlimited roles rely on stopping rules instead. Never raise a limit to fit an oversized task — split the task.
-
-### Dispatching Kilo Role Agents
-
-Dispatch worker role agents with [`dispatch-role.sh`](dispatch-role.sh) — it encodes the whole contract (tmux wrapping, env strip, naming, redirection, the `EXITCODE` marker) so nothing is hand-assembled:
-
-```bash
-LOG=$(.kilo_workflow/dispatch-role.sh plan-reviewer <section> r1 <cloud-worktree> "$SCRATCH" \
-  "Review the plan in the attached handoff per your role definition." \
-  --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 as shell commands.
-
-What the script encodes (details in its header comments):
-
-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>`.
-- `--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):
-
-```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.`/`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.
-
-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 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.
-
-### 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`:
-
-```bash
-.kilo_workflow/steer.sh <section>-orchestrator "Scope change: drop slice 4; commit what holds and open the PR."
-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. 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.
-
-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.
-
-### Escalation
-
-When a loop iteration fails, escalate in order:
-
-1. Re-dispatch the same role once with sharper steering: the diagnosis, the failing evidence, what was already tried, and a narrower goal.
-2. If the steered round failed but made progress, restructure: split the slice or change the approach in the handoff, then dispatch again.
-3. Take over directly as soon as any steered round produced zero new progress — step 2 is not a prerequisite. Record every takeover with a one-line justification in `$SCRATCH/decisions.md`.
-
-Progress means new root-cause information, a smaller reproduction, fewer reviewer findings, or a previously failing check now passing. The same error under the same theory twice is not progress. Never loop indefinitely.
-
-The ladder and the loop round caps work together, not against each other. One round = one full iteration of the loop's body (in the implementer loop, an implementer dispatch plus its reviewer dispatch; in single-role loops, one dispatch) — and every attempted round counts, whether steered, restructured, void, or `STOPPED EARLY.` A cap is a ceiling and never a budget (the ladder usually ends a loop well before it), and at the cap the steering and restructure rungs are spent — the only remaining moves are takeover or BLOCKED.
-
-### Handoff Requirements
-
-Every dispatch to a role agent includes:
-
-- The assigned task, explicit non-goals, and observable acceptance criteria
-- The scratch directory path
-- The worktree path for every repository in scope, with branch and working-tree state, and existing changes that must be preserved
-- 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-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.
-- 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. 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.
-
-## 1. Starter
-
-The session the user invokes the workflow from is the starter. A kilo starter defaults to its
-agent definition's pinned model and launches as `kilo run --agent starter --interactive`; pass
-`--model` and `--variant` only for an explicit user override. The definition pins its permissions.
-Its job is to turn a raw request into approved, sectioned work:
-
-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 model: default to the planner agent definition's pinned model (`kilo/moonshotai/kimi-k3`, high). Only use the starter's own model or another explicit user pick when the user specifically requested a different planner model; do not reuse the starter's model by default.
-2. Explore the relevant parts of the codebase.
-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:
-
-```bash
-# kilo planner (defaults to the planner agent definition's pinned model; pass --model/--variant only for an explicit user override):
-.kilo_workflow/launch-interactive.sh <section>-planner <worktree> --log "$SCRATCH/planner.log" \
-  kilo run 'Plan the work in the attached brief.' --agent planner \
-  --interactive --title '<section> planner' --file "$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 — 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
-
-- `hands on`: ask the user one question at a time until requirements, trade-offs, and acceptance criteria are unambiguous. The planner later gets explicit user approval of the plan before launching the orchestrator. After the handoff, user questions belong to the orchestrator — it asks directly in its interactive session when a repair loop or ambiguity cannot be resolved. Hands-on assumes the user can attach to the reported tmux windows; a question unanswered after a bounded wait (hours, not minutes) becomes a BLOCKED report, and a session waiting on one is not a wedge.
-- `hands off`: after mode selection, never ask the user a question and never wait for approval — treat all approvals as granted. Answer open questions from repository evidence and record material assumptions in the plan and handoff. Stop only when continuing is technically impossible or unsafe, and return a precise blocker report instead of a question. Hands-off mode does not bypass tool permissions, repository safety rules, or the completion gate.
-
-## 2. Planner
-
-The planner writes the implementation plan for its section. The plan is consumed by the orchestrator, implementers, and reviewers — all cheaper models — so it must:
-
-- Fulfil the assigned body of work
-- Be written in simple, explicit language a cheaper model can follow without guessing
-- Achieve the work in the simplest, most maintainable way
-
-Steps:
-
-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.
-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, 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. `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
-
-```bash
-.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, 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. (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, 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.
-
-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.
-
-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
-
-Given the plan and what it is trying to achieve, the `plan-reviewer` reviews the plan as a whole and pokes holes in it, with special attention to unnecessary complexity. It returns a list of remarks, or `No findings.` when it is confident the plan achieves the goal appropriately and is written so cheaper models can follow it. See `.kilo/agent/plan-reviewer.md`.
-
-## 3. Orchestrator
-
-The orchestrator drives the plan to completion. It is the expensive model steering cheap role agents: its output is judgment — handoffs, steering, triage, verification — not diffs. It may edit directly only for merge-conflict resolution, one-line configuration, and takeovers under the escalation ladder.
-
-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, 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; 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.
-7. Run the Kilobot loop (below).
-8. When both loops are clean, verify the completion gate, label the PR `human-ready` (`gh pr edit <n> --add-label human-ready`) as the last act before teardown, then shut the section down. The PR is the deliverable; everything else closes.
-
-Two terminal states, distinguished by what remains on disk:
-
-- **COMPLETE** — the gate fully holds (a PR awaiting required human review is COMPLETE). Release every held resource (local backends, simulators, emulators, browsers, slots), delete the scratch directory, and close its own tmux window (`tmux kill-window`). Nothing survives but the PR — its description carries everything a human needs; material process notes (E2E skips with rationale, simpler-shape decisions) belong in it.
-- **BLOCKED** — something made the gate unsatisfiable. Release every resource all the same, write `$SCRATCH/final-report.md` — first line `BLOCKED`, then the blocker, PR link and state, acceptance-criteria outcomes, takeovers with justifications, rejected findings, learnings written — leave the scratch directory as evidence, and close the window.
-
-### Picking 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
-.kilo_workflow/pick-reviewers.sh <owner/repo> <requesting-handle> <file> [file...]   # run in the changed repo, on its 2–3 most-changed files
-```
-
-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
-
-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 verifier has a hard 100-step ceiling: size its handoff below roughly 75 planned tool calls, and split a larger independent platform or flow scope into separate handoffs in the same bundle. 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 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.
-5. Rerun E2E for any repair that affects verified behavior (touched bits only). Three full E2E↔Kilobot alternations without converging is BLOCKED.
-6. Exit when Kilobot has posted an approving summary comment on the latest head — or its absence was waived per step 1 — no actionable posted comment is unresolved, and CI is green.
-
-Integrate the base branch **only when GitHub reports an actual conflict** (`mergeable: CONFLICTING`) or the run needs something that landed on the base. Integrate by merge, not rebase — `git fetch origin && git merge origin/main` — with the orchestrator resolving conflicts itself (its merge-conflict direct-edit allowance). Rebasing a conflict-free branch invalidates green CI and a completed Kilobot review for nothing. `mergeStateStatus: BLOCKED` on a `MERGEABLE` PR means a required human review is pending — that is the expected terminal state, not a problem to solve.
-
-### Completion Gate
-
-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> --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:
-
-- 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 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
-- 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
-- New committed learnings are included in the PR
-- The PR carries the `human-ready` label, added only after every item above holds
-
-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.
-
-### 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 to the prohibition qualifies: forcing a specific provider failure; the naming and justification requirement applies to it too.
-
-## E2E Slots
-
-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-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
-```
-
-The take/free scripts resolve the caller's own tmux session themselves and refuse to run outside one.
-
-`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.
-- 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 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
-
-For every new user-facing feature, define these four states before implementation:
-
-| State | Required experience |
-|---|---|
-| Happy | The task completes and the resulting state is clear. |
-| Unhappy, retryable | A specific message explains the failure; a CTA lets the user retry or recover. |
-| Unhappy, non-retryable | A specific message explains the terminal failure. No CTA. |
-| Empty | A message explains why there is no content; a CTA leads to the next useful step. |
-
-Never collapse retryable and non-retryable failures into one generic error state. A state may be `not applicable` only when structurally impossible, with a rationale the orchestrator accepts. Automated tests cover every applicable state; E2E exercises every applicable state that can be produced safely and deterministically.
-
-## Learnings
-
-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` 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.
-- 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. 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.
-
-## GitHub Communication
-
-Every GitHub issue comment, PR comment, review comment, review body, and thread reply written by this workflow begins exactly with `(bot) `, including replies to Kilobot and rejections of findings. Only the PR title and PR description carry no prefix.
-
-GitHub's public API and `gh pr comment` cannot upload attachments. Use the repository's
-checksum-pinned wrapper around the security-reviewed
-[`gh-image`](https://github.com/drogers0/gh-image) v1.2.0 binary. It performs the same
-repository-scoped upload as GitHub's comment box and prints ready-to-paste Markdown:
-
-```bash
-.kilo_workflow/upload-pr-attachment.sh "$SCREENSHOT" --repo <owner/repo>
-# ![screenshot.png](https://github.com/user-attachments/assets/<id>)
-```
-
-Put that Markdown in the PR's `Visual Changes` section (or a `(bot) ` comment when adding
-later), then fetch the PR body/comments with `gh` and verify the
-`github.com/user-attachments/` URL is present. `gh-image` uses an existing GitHub browser
-session because a normal `gh` API token cannot authorize this undocumented upload endpoint.
-It may trigger a one-time OS keychain approval; never print, pass on the command line, commit,
-or place its `user_session` cookie in a handoff; never invoke `gh-image` directly. The wrapper
-verifies the reviewed release digest before every execution and blocks every supported explicit
-token path. Its audit and residual risks are recorded in
-`learnings/gh-image-unverified-release-binary.md`. A missing browser session is a completion
-blocker for UI work, not a reason to commit screenshots into the product repository or use an
-unrelated public image host. Any version change requires a fresh security review and new committed
-digests.
diff --git a/.kilo_workflow/await-interactive.sh b/.kilo_workflow/await-interactive.sh
deleted file mode 100755
index 16877795af8..00000000000
--- a/.kilo_workflow/await-interactive.sh
+++ /dev/null
@@ -1,69 +0,0 @@
-#!/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>]
-#
-# 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
-#   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 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
-#   RUNNING             exit 4  none of the above; invoke again
-set -euo pipefail
-
-TARGET=${1:?tmux target} SCRATCH=${2:?scratch dir}
-shift 2
-# 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
-  case $1 in
-    --log) LOGFILE=${2:?}; shift 2 ;;
-    *) echo "await-interactive: unknown option $1" >&2; exit 1 ;;
-  esac
-done
-
-mtime() { stat -c %Y "$1" 2>/dev/null || stat -f %m "$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 10
-done
diff --git a/.kilo_workflow/await-role.sh b/.kilo_workflow/await-role.sh
deleted file mode 100755
index 70317768c5d..00000000000
--- a/.kilo_workflow/await-role.sh
+++ /dev/null
@@ -1,114 +0,0 @@
-#!/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 marker.
-#
-#   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
-# `<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 seconds (480 — 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 2  finished without a valid verdict — a crashed
-#                             run, never a pass; discard and dispatch fresh
-#   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 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>}
-# 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
-
-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/$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 -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
-}
-
-START=$(date +%s)
-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 || 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 || true; } | 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 exit file never landed; give the final
-      # writes a moment to flush, then re-check once before pronouncing.
-      sleep 5
-      [ -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 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
-    # The dispatch redirects into the log the moment kilo starts; a log still
-    # 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
-  if [ $(( NOW - START )) -ge "$TIMEOUT" ]; then
-    echo "RUNNING — no verdict after ${TIMEOUT}s; invoke again to keep waiting"
-    exit 4
-  fi
-  sleep 5
-done
diff --git a/.kilo_workflow/baseline.sh b/.kilo_workflow/baseline.sh
deleted file mode 100755
index 4cb70a252bd..00000000000
--- a/.kilo_workflow/baseline.sh
+++ /dev/null
@@ -1,131 +0,0 @@
-#!/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> [--include <ignored-path>]...
-#   baseline.sh check <worktree> <baseline-dir> [--include <ignored-path>]...
-#
-# <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> [--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).
-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 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"
-  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 [ ! -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"
-    else
-      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"
-
-  # 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 -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
-    else
-      printf 'missing\t-\t%s\n' "$p"
-    fi
-  done | sort > "$out/included.tsv"
-}
-
-case $CMD in
-  snapshot)
-    # 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" && [ -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"
-    ;;
-  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" && [ -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
-      fail=1
-      case $f in
-        head) echo "DIVERGED head: $(cat "$DIR/$f") -> $(cat "$NOW/$f")" ;;
-        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
-    if [ "$fail" -eq 0 ]; then
-      rm -rf "$DIR"
-      echo "OK"
-    fi
-    exit "$fail"
-    ;;
-  *) 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
deleted file mode 100755
index c05f1511fea..00000000000
--- a/.kilo_workflow/dispatch-role.sh
+++ /dev/null
@@ -1,127 +0,0 @@
-#!/usr/bin/env bash
-# Dispatch a kilo role agent per .kilo_workflow/WORKFLOW.md, encoding the
-# contract the learnings exist for: tmux-wrapped (harness timeouts kill bare
-# runs), full KILO_*/OPENCODE* env strip, canonical window/log naming, output
-# redirected (never piped), and the EXITCODE marker appended as the last line.
-#
-#   dispatch-role.sh <role> <section> <label> <worktree> <scratch> <message> [--file <path>]...
-#
-#   role     plan-reviewer | implementer | impl-reviewer | e2e-verifier
-#   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 on it with await-role.sh, never a hand-rolled
-# loop — it reports DONE with the role's sentinel, VOID, STALLED, or RUNNING.
-#
-# 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}
-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-]+-[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; }
-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.
-FILES=()
-MODE=verify
-while [ $# -gt 0 ]; do
-  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; }
-      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
-
-# 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.
-# 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)'
-
-# 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 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
-# 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 —
-# the most recently active one — so a dispatcher running outside tmux (a
-# harness shell, a stripped kilo env) silently drops its window into an
-# unrelated session. A freshly created `kilo-e2e-android-*` emulator session
-# is the usual victim, and it gets killed wholesale on device cleanup.
-CALLER_SESSION=""
-if [ -n "${TMUX_PANE:-}" ]; then
-  CALLER_SESSION=$(tmux display-message -p -t "$TMUX_PANE" '#S' 2>/dev/null || true)
-fi
-
-"$(dirname "$0")/launch-gate.sh"
-
-if [ -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".
-  # 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\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
deleted file mode 100755
index d7f91df1187..00000000000
--- a/.kilo_workflow/e2e-free-slot.sh
+++ /dev/null
@@ -1,39 +0,0 @@
-#!/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
-HERE=$(dirname "$0")
-ROOT="$(git -C "$HERE" rev-parse --show-toplevel)"
-# 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=()
-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
-    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
-
-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 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
-
-exec "$HERE/.e2e-slot-state.sh" release "$@"
diff --git a/.kilo_workflow/e2e-slot-status.sh b/.kilo_workflow/e2e-slot-status.sh
deleted file mode 100755
index 0bb7fb6d27c..00000000000
--- a/.kilo_workflow/e2e-slot-status.sh
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/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 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 "$@"
-
-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 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
-    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
-    echo "UNACCOUNTED stack: $session"
-    unaccounted=1
-  fi
-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" \
-            "${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-start-resource.sh b/.kilo_workflow/e2e-start-resource.sh
deleted file mode 100755
index 9570e6296ad..00000000000
--- a/.kilo_workflow/e2e-start-resource.sh
+++ /dev/null
@@ -1,117 +0,0 @@
-#!/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 ...] [--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
-# 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)
-    # 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
-    # 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'
-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)
-    # 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
-    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
-    # 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 "$@"
-    ;;
-  *) 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
deleted file mode 100755
index a408a448f34..00000000000
--- a/.kilo_workflow/e2e-stop-resource.sh
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/usr/bin/env bash
-# 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
-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
-      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 || \
-        echo "e2e-stop-resource: appium server for $id still up — retry: apps/mobile/e2e/appium.sh $id server stop" >&2
-    done
-  done
-}
-
-case "$resource" in
-  stack) exec pnpm dev:stop ;;
-  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"
-    ;;
-  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
deleted file mode 100755
index a534225acf4..00000000000
--- a/.kilo_workflow/e2e-take-slot.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/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
deleted file mode 100755
index 31f236a2c54..00000000000
--- a/.kilo_workflow/init-section.sh
+++ /dev/null
@@ -1,111 +0,0 @@
-#!/usr/bin/env bash
-# Create a section's run id, worktrees, prepared cloud checkout, and scratch
-# directory. `add-repo` adds a repository discovered during planning.
-set -euo pipefail
-
-CLOUD_REPO=$(cd "$(dirname "$0")/.." && pwd -P)
-WT_ROOT="$HOME/Projects/.worktrees"
-mkdir -p "$WT_ROOT"
-
-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 — 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 — delete it (git branch -D $SECTION) if it is stale" >&2; exit 1; }
-}
-
-add_worktree() {
-  local repo=$1 path=$2
-  git -C "$repo" worktree add "$path" -b "$SECTION" origin/main >&2
-  CREATED_REPOS+=("$repo")
-  CREATED_PATHS+=("$path")
-}
-
-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 ((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
deleted file mode 100755
index ef6e5638f34..00000000000
--- a/.kilo_workflow/launch-gate.sh
+++ /dev/null
@@ -1,29 +0,0 @@
-#!/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)
-  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
-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
deleted file mode 100755
index ca081aab8cd..00000000000
--- a/.kilo_workflow/launch-interactive.sh
+++ /dev/null
@@ -1,71 +0,0 @@
-#!/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
-#     — 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 and fail with "create window failed: index N in use".
-#
-#   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
-# --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; }
-
-"$(dirname "$0")/launch-gate.sh"
-
-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
-  # 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
-fi
-
-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/android-emulator-systemserver-restart-systemui-anr-under-load.md b/.kilo_workflow/learnings/android-emulator-systemserver-restart-systemui-anr-under-load.md
deleted file mode 100644
index 61937735003..00000000000
--- a/.kilo_workflow/learnings/android-emulator-systemserver-restart-systemui-anr-under-load.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# Android emulator SystemServer restart + SystemUI ANR deadlock under host load spikes (2026-07-28)
-
-Observed on attach-oom-11fd r2 while 3 slots were active (host load avg spiked to ~168):
-
-**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.
-
-**Aftermath:** SystemUI can deadlock afterwards: persistent `System UI isn't responding` ANR dialog,
-`Wait` taps are no-ops, guest CPU idle (so not starvation), `dumpsys window` shows
-`mCurrentFocus=... Application Not Responding: com.android.systemui`, SystemUI in S state, and a shell-user
-`kill <pid>` silently does nothing (PID unchanged).
-
-**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 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
deleted file mode 100644
index 78fb1bcfd50..00000000000
--- a/.kilo_workflow/learnings/android-picker-tap-races-and-toast-capture.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# Android DocumentsUI picker: stale-dump tap race + reliable sonner toast capture
-
-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/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 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/background-process-inline-quote-mangling.md b/.kilo_workflow/learnings/background-process-inline-quote-mangling.md
deleted file mode 100644
index 7e37ac24bbc..00000000000
--- a/.kilo_workflow/learnings/background-process-inline-quote-mangling.md
+++ /dev/null
@@ -1,23 +0,0 @@
-# background_process tool mangles inline ruby/perl one-liners AND shell for-loops — use a runner script
-
-**Symptom:** `background_process start` with a pipeline containing an inline scripting one-liner
-fails immediately: ruby reports `unexpected local variable or method`, perl reports
-`Execution of -e aborted due to compilation errors`. A `$VAR=value; ... > "$VAR/file"` prefix also
-expands empty in the redirect target (`read-only file system: /file.log`). A plain
-`for i in $(seq 1 N); do ...; sleep 8; done > out.log` one-liner fails the same way:
-`(eval):32: parse error near 'do'` (observed 2026-07-30, session-list-ux-19e2 iOS E2E r3).
-
-**Cause:** The tool evaluates the command through an extra eval/quoting layer that mangles nested
-quotes inside single-quoted one-liner programs, breaks variable scoping for the redirect, and
-mis-parses multi-construct shell (for/do/done) on one line.
-
-**Fix:** Write the whole pipeline (including env vars, `cd`, loops, timestamp filter, log path) as
-a literal shell script file under `$SCRATCH`, and pass only the script path plus arguments to
-`background_process start` (`bash "$SCRATCH/poll.sh" <arg>` worked first try). A plain
-`while [ $i -lt N ]` loop inside the script file is fine. A perl per-line timestamp filter that
-survives inside the script file:
-`perl -ne 'printf "%02d:%02d:%02d %s", (localtime)[2,1,0], $_'`
-(macOS awk has no strftime; ruby/perl are preinstalled.)
-
-Observed 2026-07-28 (docs-sync-cli-47f4 repro) and 2026-07-30 (session-list-ux-19e2 iOS E2E r3,
-for-loop variant) on this harness (zsh, macOS).
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
deleted file mode 100644
index dc67e1fbdde..00000000000
--- a/.kilo_workflow/learnings/dev-stack-died-mid-round-restart-in-place.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# 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. 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
-`.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
-interference, never as a product failure.
diff --git a/.kilo_workflow/learnings/docs-sync-repro-round-state-reset.md b/.kilo_workflow/learnings/docs-sync-repro-round-state-reset.md
deleted file mode 100644
index 8e1e6ceda4d..00000000000
--- a/.kilo_workflow/learnings/docs-sync-repro-round-state-reset.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# docs-sync edit-pass repro: reset round state between B1/B2
-
-**Symptom:** A second repro round of `.github/docs-sync/edit.mjs` returns instantly with
-"edit pass complete" while doing no agent work.
-
-**Cause:** `edit.mjs` has no stale-summary cleanup. After each `runKilo` call it checks
-`fs.existsSync(summaryFile)` (`edit.mjs:92`) and returns success immediately — so a leftover
-`docs-sync-out/edit-summary-<n>.json` from the previous round short-circuits the round. Leftover
-doc edits in `packages/kilo-docs` additionally change the agent's starting state (it will skip
-already-documented PRs), breaking comparability between rounds.
-
-**Fix:** Between rounds, in the kilocode worktree:
-`rm -rf docs-sync-out && git checkout -- packages/kilo-docs`, then re-copy the fixtures
-(`worthy.json`, `triage.json`) per the handoff setup. Also delete any stray
-`edit-summary-*.json` / `.docs-sync-summary.json` at the repo root (the agent sometimes drops the
-`docs-sync-out/` prefix; the script tolerates and renames those, see edit.mjs:94-97).
-
-Verified 2026-07-28 in the docs-sync-cli-47f4 repro (kilocode worktree, CLI 7.4.16).
diff --git a/.kilo_workflow/learnings/e2e-docker-exec-psql-heredoc-and-table-name.md b/.kilo_workflow/learnings/e2e-docker-exec-psql-heredoc-and-table-name.md
deleted file mode 100644
index 8a458d7171c..00000000000
--- a/.kilo_workflow/learnings/e2e-docker-exec-psql-heredoc-and-table-name.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# e2e: docker exec psql drops heredocs without -i; users table is kilocode_users
-
-Two Postgres-probe traps hit on session-list-ux-19e2 r4 (Android):
-
-1. `docker exec dev-postgres-1 psql ... <<'SQL'` silently runs NOTHING without
-   `-i` — psql reads EOF on the unattached stdin, exits 0, and every INSERT
-   no-ops (no error, no row count). Handoffs that pipe heredocs into
-   `docker exec` are broken as written. Use `psql ... -c "..."` (multi-statement
-   strings are fine) or add `-i`.
-
-2. The users table is `kilocode_users`, not `kilo_users` — handoff SQL with
-   `kilo_users` errors `relation does not exist`. Resolve ids through
-   `pnpm dev:seed app:user-id <email>` instead; it uses the worktree's
-   configured database. The per-worktree app database in the shared postgres
-   container can be identified by which `-d` candidate contains your user row
-   (`postgres` for this worktree; siblings use `postgres-N`).
diff --git a/.kilo_workflow/learnings/gh-image-unverified-release-binary.md b/.kilo_workflow/learnings/gh-image-unverified-release-binary.md
deleted file mode 100644
index 4b7905d0b28..00000000000
--- a/.kilo_workflow/learnings/gh-image-unverified-release-binary.md
+++ /dev/null
@@ -1,43 +0,0 @@
-# gh-image must be source-reviewed and checksum-pinned before cookie access
-
-Symptom: the screenshot-upload workflow installed a third-party release binary and then let it
-read a full-account GitHub `user_session` cookie. Pinning only the mutable release tag did not
-prove that agents would execute the code reviewed in this PR.
-
-Cause: GitHub has no public attachment-upload API. `gh-image` v1.2.0 implements GitHub's private
-web upload using browser authentication, but `gh extension install --pin` downloads and executes
-the upstream binary without a repository-owned integrity check.
-
-Fix: use `upload-pr-attachment.sh`. It permits only the reviewed v1.2.0 release assets whose
-SHA-256 digests are committed in the script, verifies the digest before first execution and on
-every cached execution, and discards `GH_SESSION_TOKEN`. Its interface accepts exactly one
-non-symlink PNG/JPEG/GIF/WebP under GitHub's 10 MB limit plus an explicit `owner/repo`, so the
-upstream token-export and arbitrary-file paths are unreachable.
-
-Security review, 2026-07-28:
-
-- Reviewed source tag `v1.2.0`, commit `44f4b93ecbbe22de6c45fa2f62f519aee564ca8c`,
-  including all non-test Go code, tests, the dependency manifest, release configuration, and
-  security policy.
-- Session-cookie values stay in memory and are attached only to hard-coded `https://github.com`
-  requests. The uploaded file goes separately to the presigned storage URL without GitHub cookies;
-  finalization is restricted to a root-relative GitHub path. No telemetry or unrelated network
-  destination exists in the reviewed source.
-- The binary can deliberately print the session through `extract-token` or accept it through
-  `--token`/`GH_SESSION_TOKEN`; the repository wrapper exposes none of those arguments and clears
-  the environment token.
-- The only direct external package is `browserutils/kooky` v0.2.10 (source commit
-  `0d54a50c33ecea7d703d4edda7571c3559dc485d`), used to read encrypted browser stores. Its reviewed
-  source performs local browser/keychain access and no network calls. The dependency manifest was
-  checked against GitHub's Advisory Database: current findings exist in `x/crypto` and `x/net`,
-  but the imported paths use only `hkdf`, `pbkdf2`, and `publicsuffix`, not the affected SSH or
-  HTML-parser code.
-- Upstream test, lint, and release jobs passed on the reviewed commit. The release workflow's
-  third-party actions use major-version tags rather than commit SHAs, so the build chain is not
-  independently reproducible; the committed release digests bind workflow execution to the exact
-  binaries exercised here. Any version bump requires a fresh source, dependency,
-  behavior, and digest review in a PR.
-- Residual risk: the tool necessarily gives a third-party binary a full-account session cookie and
-  relies on an undocumented GitHub endpoint. A compromised browser session or an undiscovered flaw
-  in the pinned binary retains that blast radius. Use only a logged-in account that needs write
-  access to the target repository; never use this in CI or persist a session token.
diff --git a/.kilo_workflow/learnings/ios-simulator-cannot-starve-location-fix.md b/.kilo_workflow/learnings/ios-simulator-cannot-starve-location-fix.md
deleted file mode 100644
index cd8f17e4e51..00000000000
--- a/.kilo_workflow/learnings/ios-simulator-cannot-starve-location-fix.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# iOS 26.5 simulator: cannot make getCurrentPositionAsync hang (locationd always answers)
-
-Symptom: an E2E flow needs `Location.getCurrentPositionAsync` to never resolve (e.g. to fire an
-app-side 10 s GPS-timeout race), but on iOS 26.5 simulators a fix always arrives immediately.
-
-Cause, verified on iPhone 17 Pro / iOS 26.5 (Xcode 26):
-- `xcrun simctl location <udid> clear` is non-functional: after `set A` then `clear`, CoreLocation
-  keeps serving A; on a freshly erased device it serves a built-in default (observed: Potrero
-  District, SF). The clear returns exit 0 and changes nothing.
-- `launchctl kill SIGSTOP system/com.apple.locationd` (via `xcrun simctl spawn`) does not produce a
-  position-request hang either: a warm app resolves from its in-process CLLocationManager cache
-  (Accuracy.Lowest accepts it), and a cold app hangs earlier — inside
-  `requestForegroundPermissionsAsync`, before any app-side timeout race starts. The button then
-  shows its busy state indefinitely (evidence that the spinner renders while awaiting).
-- `killall` does not exist in the sim userland; signal system daemons with
-  `xcrun simctl spawn <udid> launchctl kill <SIG> system/<label>` (heeds the
-  `user/foreground/<label>` warning; both resolve).
-
-Fix: drive the same outer-catch path with Location Services OFF instead:
-`xcrun simctl spawn <udid> defaults write /var/mobile/Library/Preferences/com.apple.locationd.plist
-LocationServicesEnabled -bool false`, then restart the daemon
-(`launchctl kill SIGTERM system/com.apple.locationd`). Per-app permission stays granted, so
-`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.
diff --git a/.kilo_workflow/learnings/kilo-interactive-orchestrator-wedges-relaunch.md b/.kilo_workflow/learnings/kilo-interactive-orchestrator-wedges-relaunch.md
deleted file mode 100644
index 0b5f6a46ed2..00000000000
--- a/.kilo_workflow/learnings/kilo-interactive-orchestrator-wedges-relaunch.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Long interactive kilo sessions die or wedge — relaunch fresh with a continuation handoff
-
-Symptom: an orchestrator running as `kilo run --interactive` stops making progress: the process died (stream stall, typically 10–15 minutes into a long run), it sits wedged after a provider error (`--interactive --auto` hard-wedges on these), or it dies loudly with a hard, repeated SDK error — observed: `Invalid prompt: The messages do not match the ModelMessage[] schema.` printed on every retry. Log bytes stagnate while the tmux window looks alive; a frozen context counter and queued steers that never flush confirm the silent variant, while the hard-error variant is detectable immediately from the pane with no stagnation timer.
-
-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: 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-run-startup-crash-transient.md b/.kilo_workflow/learnings/kilo-run-startup-crash-transient.md
deleted file mode 100644
index 7bb2ba90c6b..00000000000
--- a/.kilo_workflow/learnings/kilo-run-startup-crash-transient.md
+++ /dev/null
@@ -1,39 +0,0 @@
-# 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. 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:
-
-- **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_*`/`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
-`~/.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 the mid-run provider stream stall (exit 0 after real work, reported VOID by `await-role.sh`).
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
deleted file mode 100644
index 99208ce3f89..00000000000
--- a/.kilo_workflow/learnings/kiloclaw-docker-tcp-absent-from-worktree-status.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# `kiloclaw-docker-tcp` absent from a worktree's `dev:status` is expected when the shared 23750 bridge answers
-
-Symptom: `pnpm dev:status --json` for a worktree whose stack started cleanly lists no `kiloclaw-docker-tcp` service row, and the `dev:start` argv named `kiloclaw` (which expands the group that includes it). Provisioning or starting a docker-local KiloClaw instance looks under-provisioned.
-
-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`. 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: `.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/mobile-android-a11y-bounds-clamped-to-viewport.md b/.kilo_workflow/learnings/mobile-android-a11y-bounds-clamped-to-viewport.md
deleted file mode 100644
index cf27ea0eb41..00000000000
--- a/.kilo_workflow/learnings/mobile-android-a11y-bounds-clamped-to-viewport.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# mobile: Android a11y bounds are clamped to the visible viewport — clip probes need pixels or control offsets
-
-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:
-
-- A card's true top cannot be read once it crosses the viewport edge; repeated dumps show
-  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 — 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.
-
-For header-visibility questions (does a title render behind the app chrome), don't trust
-a11y at all: take a screenshot and scan pixels — locate the card background color's first
-visible row and count dark text pixels in the header band (PR-review card bg is
-(240,238,230), page bg (251,250,245); the chrome is opaque, not blurred).
diff --git a/.kilo_workflow/learnings/mobile-android-a11y-label-leaves-geometric-grouping.md b/.kilo_workflow/learnings/mobile-android-a11y-label-leaves-geometric-grouping.md
deleted file mode 100644
index 1a87f0f893b..00000000000
--- a/.kilo_workflow/learnings/mobile-android-a11y-label-leaves-geometric-grouping.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# mobile/android: RN a11y-label container nodes are LEAVES — group card content by geometric containment
-
-Symptom: an Appium page-source parse shows a PR-review thread card's label node
-(`Discussion thread ...`) with its full card bounds but ZERO children; the snippet,
-comments, and pills look "outside" the card when checked by XML parentage.
-
-Cause: on Android (uiautomator2), React Native hoists a labeled container's accessible
-children to siblings in the flattened a11y tree; the label node keeps the card's rect
-but stays a leaf.
-
-Fix: assign content to cards GEOMETRICALLY — a node belongs to the card whose
-label-node rect contains it (`inside(cardRect, nodeRect)` with a 2px tolerance). Works
-with the viewport-clamp learning (clamped bands still nest). Two companion traps:
-`scrollUntilVisible` stops the instant the label peeks past the clamp edge — the card's
-header controls are not necessarily rendered yet, so swipe in a bounded loop until the
-card's own control is INSIDE its rect; and after a settle swipe, re-query rects (the
-card moved) — a stale rect in a swipe loop reads as missing content. Expansion state is
-component state and survives Appium sessions: remount the tab (tap sibling tab, tap
-back) at flow start when a flow depends on default expansion.
diff --git a/.kilo_workflow/learnings/mobile-android-backhandler-event-name-ignored.md b/.kilo_workflow/learnings/mobile-android-backhandler-event-name-ignored.md
deleted file mode 100644
index 2e510eb22d3..00000000000
--- a/.kilo_workflow/learnings/mobile-android-backhandler-event-name-ignored.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# mobile: RN BackHandler ignores the event-name string — any registered handler fires on hardware back
-
-Symptom: static analysis concludes an Android component's hardware-back handling is broken because it registers `BackHandler.addEventListener('<some-custom-name>', handler)` instead of the documented `'hardwareBackPress'` name.
-
-Cause: on RN 0.86 (`apps/mobile/node_modules/react-native/Libraries/Utilities/BackHandler.android.js:86-101`), `addEventListener` ignores the event-name argument entirely — every registered handler is pushed into one `_backPressSubscriptions` array, and the native `hardwareBackPress` event invokes ALL of them in reverse registration order (lines 23-37), first `true` return wins. The name string is inert. Example verified in this repo: `@expo/react-native-action-sheet@4.1.1`'s default (non-Modal) sheet registers `'actionSheetHardwareBackPress'` and DOES dismiss on hardware back.
-
-Fix: never judge Android back-button wiring by the registered name string; a handler registered under any name fires. Verify behavior on device (E2E), not by reading the call site. (The type-level name `'backPress' | 'hardwareBackPress'` is only documentation.)
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
deleted file mode 100644
index 287b367126d..00000000000
--- a/.kilo_workflow/learnings/mobile-android-dev-client-cold-start-deep-link.md
+++ /dev/null
@@ -1,36 +0,0 @@
-# Android dev client: cold starts need the deep link, and the reload outlasts flow budgets
-
-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
-(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. `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:
-
-- 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+).
-- 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 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
deleted file mode 100644
index b235d1cfab6..00000000000
--- a/.kilo_workflow/learnings/mobile-android-edge-to-edge-ime-insets.md
+++ /dev/null
@@ -1,34 +0,0 @@
-# mobile/android: on API 35 the app window NEVER resizes for the IME — verify resize claims via dumpsys frames, not layout shifts
-
-Symptom (login-ui-d051 r0/r0b): with `android:windowSoftInputMode="adjustResize"` in the
-generated manifest, the Android login screens showed zero layout shift for the email IME
-but a uniform 373px shift for the OTP number pad — looking like "the OS resizes for one
-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` 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):
-
-- `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
-  (`InsetsSource id=3 type=ime frame=[0,top][w,h] visible=...`) — better than pixel scans.
-- uiautomator container bounds arbitrate the app-side mechanism: full-height ScrollView +
-  grown form-view height = JS spacer padding; shrunk ScrollView = KAV height.
-
-Also: on the RN login ScrollView, any `input swipe`/drag blurs the focused field and hides
-the IME (`keyboardShouldPersistTaps="handled"` governs taps only) — there is no
-swipe-scroll-while-IME-up fallback on Android; and a tap on a keyboard-covered control
-lands on the IME window and types into the focused field (app-side no-op, no navigation).
diff --git a/.kilo_workflow/learnings/mobile-android-global-render-wedge.md b/.kilo_workflow/learnings/mobile-android-global-render-wedge.md
deleted file mode 100644
index 5b42df8ee6b..00000000000
--- a/.kilo_workflow/learnings/mobile-android-global-render-wedge.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Android app renders nothing (white) mid-session despite healthy Metro/API
-
-Symptom: dev client loads the bundle ("Running 'main'" in ReactNativeJS) but mounts zero RN
-views — screen stays uniform white (native splash never hidden), uiautomator shows only
-FrameLayout/ComposeView containers, no errors anywhere. Onset mid-session: Android login UI
-rendered fine at 08:56 and 09:18, then every app start (any emulator, fresh VM, -wipe-data,
-pm clear, Metro restart, dev-menu Reload, force-stop + deep link) rendered white from ~09:19 on,
-while the iOS app kept rendering the same signed-out login branch through the same Metro/API.
-
-Not the cause (all eliminated): AVD disk state (-wipe-data did not help), app data (pm clear),
-emulator instance (two AVDs), network (toybox nc to reversed 5300/10381 OK), API health (200s),
-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 `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-pr-review-e2e-toast-a11y-deeplink-dedupe.md b/.kilo_workflow/learnings/mobile-android-pr-review-e2e-toast-a11y-deeplink-dedupe.md
deleted file mode 100644
index e44e0414901..00000000000
--- a/.kilo_workflow/learnings/mobile-android-pr-review-e2e-toast-a11y-deeplink-dedupe.md
+++ /dev/null
@@ -1,49 +0,0 @@
-# mobile/android PR-review E2E: toast a11y-invisibility, deep-link dedupe, disabled-Pressable attribute (pr-review-ux-7f22 r2, 2026-07-30)
-
-Non-machine-specific techniques confirmed on the pixel9 API35 emulator:
-
-1. **sonner-native toasts are NOT in the uiautomator tree at all.** A
-   `toast.error('Clipboard is empty')` rendered visually for ~4-8s while 10
-   consecutive UiSelector polls (text + content-desc, full-string) returned
-   zero matches. Detection must be pixel-based: screenshot ~1.2s after the
-   triggering tap, crop the top band (~y17-237 on 1080x2424), diff against a
-   baseline frame; auto-dismiss shows up as the band returning to baseline.
-   Extends `android-picker-tap-races-and-toast-capture` (which assumed the
-   toast is catchable by timing; on this build it is never in the tree).
-
-2. **RN disabled Pressable on Android exports `enabled="false"` but keeps
-   `clickable="true"`** (handler artifact). Assert `enabled === 'false'`, and
-   for a read-only control also do a functional no-op probe (elementClick,
-   then assert state + backend request log unchanged).
-
-3. **Same-route `mobile: deepLink` dedupes**: the router keeps the mounted
-   screen, so scroll offset, expansion state, and uncontrolled-field text all
-   survive across verifier runs. Scroll-to-top loops must not stop at the
-   first a11y sliver of a card (clamped band) — scroll until the needed child
-   (e.g. the first hunk gutter line) intersects the card rect. For a truly
-   fresh mount: `stopApp` + `launchApp`, then wait for a shell element
-   (`Home, tab, 1 of 4`) BEFORE the deep link — a link fired during boot is
-   dropped.
-
-4. **CSS `uppercase` transforms the a11y text**: the Resolved badge matches
-   `RESOLVED`, not `Resolved`. Check the source for text-transform classes
-   before pinning selectors.
-
-5. **DiffLine a11y labels (`Added line 9: ...`) are not exported to
-   uiautomator**; the visible per-line signal is the gutter glyph text
-   (`+ 9`, `- 8`, `· 15`) plus the merged code text node. Scope glyph/text
-   assertions to the card rect (sibling cards render the same strings).
-
-6. **Android uncontrolled-field cleanup**: the entry screen's clear button
-   calls `TextInput.clear()`, which on Android unmounts the button (state
-   says empty) but leaves the native text. Use driver-level
-   `eraseText()` (elementClear) — a real edit that fires onChangeText and
-   clears dependent helpers.
-
-7. **adb wedge recovery variant**: guest wedged under host load (3 slots,
-   load ~30-60) presented as adbd timeouts -> `adb devices` shows the device
-   OFFLINE with qemu at 0% CPU. `adb root` (then `unroot`) restarted adbd and
-   the guest came back; bounded polls of `getprop sys.boot_completed`,
-   `pidof system_server`, and `pm list packages` confirm health before
-   rerunning login.sh. No emulator relaunch needed. Same family as
-   `android-emulator-systemserver-restart-systemui-anr-under-load`.
diff --git a/.kilo_workflow/learnings/mobile-android-rename-modal-ime-eats-backdrop-taps.md b/.kilo_workflow/learnings/mobile-android-rename-modal-ime-eats-backdrop-taps.md
deleted file mode 100644
index e08c715bfd7..00000000000
--- a/.kilo_workflow/learnings/mobile-android-rename-modal-ime-eats-backdrop-taps.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# mobile-android: RenameModal autofocus raises the IME — taps at keyboard height type into the field
-
-Symptom: backdrop taps meant to dismiss `RenameModal` do nothing, and the name
-field gains stray characters ("bbbb").
-
-Cause: `RenameModal` focuses its field 100ms after mount on Android, raising
-the soft keyboard over the bottom half of the screen. Taps at keyboard height
-hit IME keys and type into the focused field. The first tap outside the field
-may only hide the IME (standard Android behavior) instead of reaching the
-modal's backdrop Pressable.
-
-Fix (flow notes):
-- To dismiss the modal via backdrop: tap the strip between the dialog bottom
-  and the keyboard top (e.g. (800, 740) on the tablet AVD) — this usually
-  hides the IME first — then tap the now-exposed backdrop (e.g. (1280, 900)).
-  Two taps, assert after each.
-- Simpler and deterministic: `driver.back()` — closed both the action sheet
-  and the modal in ONE press each on this build (RN Modal `onRequestClose`
-  fires even with the IME open). Prefer `driver.back()` over coordinate taps
-  for every dismiss-prelude.
-- Always verify the field text in the hierarchy before Save; erase via
-  `eraseText` (elementClear) and note UiAutomator2 returns the content-desc
-  ("Session name") as the element text when the value is empty — treat that
-  string as empty.
-- `h.tapOn('Save')` once silently no-op'd while the keyboard was animating
-  closed; an adb-coordinate tap at the button center worked. If a helper click
-  leaves the modal open with no error text, re-tap by bounds.
diff --git a/.kilo_workflow/learnings/mobile-android-tablet-centered-column-gutter-taps.md b/.kilo_workflow/learnings/mobile-android-tablet-centered-column-gutter-taps.md
deleted file mode 100644
index 4ccc12d1748..00000000000
--- a/.kilo_workflow/learnings/mobile-android-tablet-centered-column-gutter-taps.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# mobile-android: tablet AVD renders the app as a centered column — gutter taps are swallowed
-
-Symptom: W3C/adb taps at plausible coordinates silently no-op on
-`kilo_pixel_tablet_api35` (2560x1600): action-sheet backdrop taps, modal
-backdrop taps, button taps.
-
-Cause: the app renders as a centered phone-width column (physical x about
-680..1880) with black gutters on both sides. Taps in the gutters never reach
-the app, and elements report bounds inside the column only. A tap at
-(150, 250) — fine on a phone AVD — lands in dead space here.
-
-Fix: derive every tap from the live `uiautomator` bounds (never remembered
-coordinates), and keep ad-hoc backdrop taps inside the column: sheet backdrop
-(1000, 600), RenameModal backdrop (1280, 900) with the keyboard closed. When a
-tap "does nothing", screenshot first and check the column edges before blaming
-the product.
diff --git a/.kilo_workflow/learnings/mobile-cloud-agent-create-needs-github-integration.md b/.kilo_workflow/learnings/mobile-cloud-agent-create-needs-github-integration.md
deleted file mode 100644
index 6cd5752ffab..00000000000
--- a/.kilo_workflow/learnings/mobile-cloud-agent-create-needs-github-integration.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# mobile: in-app cloud-agent session creation needs a GitHub integration
-
-Symptom: the new-session screen cannot create a cloud-agent session on a fresh local stack — the repository section is empty and the flow dead-ends.
-
-Cause: the test account has no GitHub integration, so `listGitHubRepositories` returns nothing.
-
-Fix: run the flow as a user account that already has the GitHub integration set up, or copy that integration to the test account. If no account on the stack has one, ask the human to set up the GitHub integration for an account — the run is blocked on human action until they do. A blocked cloud-agent create on a fresh stack is a test-environment limitation, not a product failure.
diff --git a/.kilo_workflow/learnings/mobile-device-auth-stuck-pending-rows.md b/.kilo_workflow/learnings/mobile-device-auth-stuck-pending-rows.md
deleted file mode 100644
index cdbab6babf8..00000000000
--- a/.kilo_workflow/learnings/mobile-device-auth-stuck-pending-rows.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# mobile: device-auth "Too many pending" 500s — usually STUCK rows, not live traffic; probe the DB, reconcile via the real poll endpoint
-
-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 **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):
-
-```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 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-e2e-agents-tab-new-session-entry-zero-sessions.md b/.kilo_workflow/learnings/mobile-e2e-agents-tab-new-session-entry-zero-sessions.md
deleted file mode 100644
index 42474eb4569..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-agents-tab-new-session-entry-zero-sessions.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# mobile e2e: Agents tab "New session" header button is hidden on zero-session accounts — tap "New coding task"
-
-Symptom: flows that `tapOn('New session')` after switching to the Agents tab
-time out on fresh e2e accounts.
-
-Cause: `SessionListHeaderActions` gets `showNewSession={hasAnySessions}` —
-with zero sessions the header Plus button is not rendered and the list's
-empty-state CTA button `New coding task` (text match) is the only creation
-affordance. After a first session exists, both paths can appear.
-
-Fix: poll for either entry point (`New session` OR `New coding task`) and tap
-whichever appears. Also note when detecting a session detail's loaded-empty
-state: the header title text (`<instance> · <project>`) is NOT transcript
-content — exclude it; `No messages yet` remains the only definitive text
-signal for an idle remote session.
diff --git a/.kilo_workflow/learnings/mobile-e2e-android-emulator-died-between-rounds.md b/.kilo_workflow/learnings/mobile-e2e-android-emulator-died-between-rounds.md
deleted file mode 100644
index d00f2b88dce..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-android-emulator-died-between-rounds.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# mobile-e2e: assigned Android emulator cleanly shut down between rounds; handoff stale
-
-Symptom: a continuation handoff names a live emulator (serial, tmux session, signed-in
-account), but at dispatch `adb devices` shows only siblings' devices, the emulator tmux
-session (`kilo-e2e-android-<slug>`) is absent, and no qemu process exists for the port.
-
-Diagnosis (observed on session-list-ux-19e2 r3, 2026-07-30): the emulator log
-(`$TMPDIR/kilo-e2e-android-<slug>.log`) tail shows a graceful shutdown ("Wait for emulator
-(pid N) 20 seconds to shutdown gracefully before kill" then snapshot-save lines) minutes
-before dispatch; log mtime marks the death time. The emulator record in
-`$TMPDIR/kilo-mobile-android-emulators/<slug>.json` still lists the dead pid, and the
-serial claim in `$TMPDIR/kilo-mobile-android-claims/<serial>.json` still says
-`status: ready` — neither record reflects liveness. `e2e-slot-status.sh` reports
-"no unaccounted known resources" because the slot IS held; it does not probe emulator
-liveness.
-
-Verifier action: this is an assigned-resource-not-ready test-environment blocker. Do NOT
-relaunch the emulator yourself (`e2e-start-resource.sh android` is the bundle owner's
-tool; verifier rule: never start/stop/take bundle resources). Evidence to capture:
-`adb devices`, `tmux ls` grep for `kilo-e2e-android-<slug>`, `ps aux | grep qemu`,
-tail of the emulator log with its mtime, and the two JSON records. Return
-VERIFICATION BLOCKED; the orchestrator relaunches via
-`.kilo_workflow/e2e-start-resource.sh android <avd> --gpu host` and redispatches.
-App + sign-in survive in the AVD data partition (snapshots were disabled; cold boot only),
-so the next round can start at `login.sh` verification, not a rebuild.
diff --git a/.kilo_workflow/learnings/mobile-e2e-android-logbox-badge-intercepts-tab-taps.md b/.kilo_workflow/learnings/mobile-e2e-android-logbox-badge-intercepts-tab-taps.md
deleted file mode 100644
index 3c5f02a7ae3..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-android-logbox-badge-intercepts-tab-taps.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# mobile e2e Android: RN LogBox badge intercepts tab-bar taps — dismiss the EXPANDED overlay, not just the badge
-
-Symptom: `tapOn('Agents, tab, 3 of 4')` throws nothing, but the tab never
-switches; the next wait times out. A hierarchy dump then shows an expanded
-LogBox (`Component Stack`, `Copy`, `Dismiss`, `Minimize`,
-`qualified-entry.js:20`).
-
-Cause: a dev-mode RN warning (here "Can't perform a React state update...")
-surfaces as a collapsed LogBox badge floating over the tab bar. UiAutomator2
-`elementClick` resolves to a coordinate tap at the element's center; the badge
-overlay intercepts the coordinates and EXPANDS the LogBox instead. Tapping
-`Minimize` in a prior run is not enough — the collapsed badge persists and
-keeps swallowing taps (a truncated grep of the dump can hide it: the badge's
-content-desc is the full warning text, longer than typical head -20/60-char
-filters).
-
-Fix: loop until the dump is clean — if `Component Stack|Minimize` present tap
-`Dismiss` (removes the notification permanently for the app session); else if
-the warning text desc is present tap it to expand, then `Dismiss`. Verify with
-`grep -c LogBox` == 0 before driving tabs. Dismissal survives across appium
-sessions (same app process); it re-fires only on a fresh JS reload.
diff --git a/.kilo_workflow/learnings/mobile-e2e-android-page-source-tags-and-text-headers.md b/.kilo_workflow/learnings/mobile-e2e-android-page-source-tags-and-text-headers.md
deleted file mode 100644
index 68e04ccc5b6..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-android-page-source-tags-and-text-headers.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# mobile-e2e-android: Appium page source uses class-named tags, not <node>; TODAY headers are text-only
-
-Two parser traps that each produced hours of false "row missing" reads on
-Android (UiAutomator2):
-
-1. `driver.getPageSource()` returns tags named by widget class
-   (`<android.widget.FrameLayout>`, `<android.view.ViewGroup>`), NOT `<node>`.
-   `adb shell uiautomator dump` DOES use `<node>`. A regex shared between the
-   two (`/<node[^>]*>/g`) silently matches nothing in Appium sources — every
-   iteration then reports zero rows. Parse with
-   `/<[a-zA-Z][a-zA-Z0-9.]*[^>]*>/g` and pull attributes per tag.
-
-2. History section headers ("TODAY", "ACTIVE NOW") render as plain
-   `android.widget.TextView` nodes with a `text` attribute and NO
-   `content-desc`. Region-scoping that parses only `content-desc` finds no
-   tray-bottom anchor; the fallback anchor (+inf) then counts HISTORY rows as
-   TRAY rows on departure assertions — the exact failure mode
-   `mobile-e2e-tray-vs-history-region-scoped-assertions.md` warns about, one
-   level down. Parse BOTH attributes and anchor on the header's text.
-
-Bounds order reminder: `bounds="[x1,y1][x2,y2]"` — group 2 is x1, group 3 is
-y1. Reading group 2 as y ranks every row by its left edge.
diff --git a/.kilo_workflow/learnings/mobile-e2e-android-uiautomator-screenshot-crash-adb-fallback.md b/.kilo_workflow/learnings/mobile-e2e-android-uiautomator-screenshot-crash-adb-fallback.md
deleted file mode 100644
index 20fa74b11c9..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-android-uiautomator-screenshot-crash-adb-fallback.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# mobile e2e Android: UiAutomator2 instrumentation dies at takeScreenshot under parallel-emulator load — ADB screencap fallback
-
-Symptom: mid-flow `WebDriverError: 'GET /screenshot' cannot be proxied to
-UiAutomator2 server because the instrumentation process is not running
-(probably crashed)`. Seen twice in one round with three emulators + an iOS
-simulator running; hierarchy dumps and taps worked minutes before and after.
-
-Cause: the UiAutomator2 instrumentation process is killed/crashes under host
-load. The APP is unaffected — screen state, navigation, and the relay survive;
-a new appium session (next `appium.sh test`) respawns instrumentation.
-
-Fix: keep time-critical captures on `driver.takeScreenshot()` (tight timing
-after a transcript poll), but on a crash do NOT re-drive the flow blind —
-inspect with a fresh session, then fall back to
-`pnpm dev:mobile:android adb -s <serial> exec-out screencap -p > out.png` for
-static states (sheet open, post-dismiss). Same 1080x2424 pixel space as the
-uiautomator bounds, so geometry analysis stays valid across both sources.
diff --git a/.kilo_workflow/learnings/mobile-e2e-cli-relay-window-wedge.md b/.kilo_workflow/learnings/mobile-e2e-cli-relay-window-wedge.md
deleted file mode 100644
index c7269ce463f..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-cli-relay-window-wedge.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# mobile-e2e-cli-relay-window-wedge
-
-Symptom: the `relay` window of an orchestrator-prepared
-`kilo-e2e-cli-<worktree>` tmux session shows an idle shell (`pane_current_command`
-= zsh), echoes typed input, but never executes it (no output, no new prompt);
-sending C-c then collapses the window.
-
-Cause: the pane's shell was wedged (likely a stopped/zombie job state) after
-the original `kilo remote` relay process died; the tmux window only looked
-alive in `tmux ls`.
-
-Fix: do not keep probing the wedged pane. Let the window die (or kill it),
-recreate it with `tmux new-window -t <cli-session> -n relay`, probe with
-`echo OK`, then restart the relay with
-`apps/mobile/e2e/remote-cli.sh exec remote` (absolute path) and confirm
-`Remote connection enabled.`. The mobile Agents list only discovers the
-session while this relay is connected.
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
deleted file mode 100644
index 87fe1b52363..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-drag-cancel-race-instrument-timing.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# 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
-product defect and NOT (as an earlier version of this learning claimed) a drag that "lands
-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). 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).
-
-Decisive readout (use it again): temporary `console.log` in `invalidateSettle(source)` and
-around the scrollToIndex await in `pr-review-discussion-tab.tsx` (byte-restored after) —
-Metro captures `[D3R4] begin gen N` / `resolved gen N current M match <bool>` /
-`invalidateSettle from drag|retap at <epochMs>`. `match false` = cancel won;
-`invalidate` timestamp after `resolved` = instrument too slow.
-
-Working instruments:
-1. **Android only**: one `adb shell "input tap x y && input swipe 540 1400 540 1100 250"`
-   (~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, 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-fullstring-regex-selector-escaping.md b/.kilo_workflow/learnings/mobile-e2e-fullstring-regex-selector-escaping.md
deleted file mode 100644
index 260b309fd40..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-fullstring-regex-selector-escaping.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# mobile e2e: helper patterns are full-string REGEXES — escape parens/dots/plus in literal labels
-
-Symptom: a flow's `waitVisible('Discussion thread src/alpha.ts L10 (RIGHT)')` times out
-for 20s while the exact card is on screen; `scrollUntilVisible('Conversation comment at T+2')`
-overscrolls to the list bottom; an invariant that tolerates empty `findRects` results then
-passes VACUOUSLY.
-
-Cause: `e2e/wdio/helpers.js` `findAll` feeds the pattern to Android UiSelector
-`textMatches`/`descriptionMatches` (whole-string Java regex) or the iOS `MATCHES` predicate.
-Literal labels containing regex specials silently never match: `(RIGHT)` reads as a group
-(missing the literal parens), `.` matches anything, and `T+2` reads as "one or more T then 2".
-Worse, `(await findRects(bad))` returns `[]`, so "no X intersects Y" invariants pass with the
-target never located.
-
-Fix: in flow files, wrap every literal label in an escaper and assert presence before geometry:
-
-```js
-const rx = s => new RegExp('^' + s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '$');
-```
-
-A `^...$` anchor is harmless (the driver matches whole strings anyway). When a wait/scroll
-times out on something visibly on screen, suspect the pattern before suspecting the app.
diff --git a/.kilo_workflow/learnings/mobile-e2e-header-crop-sips-offset-broken-use-pil.md b/.kilo_workflow/learnings/mobile-e2e-header-crop-sips-offset-broken-use-pil.md
deleted file mode 100644
index 463da8a340b..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-header-crop-sips-offset-broken-use-pil.md
+++ /dev/null
@@ -1,12 +0,0 @@
-# mobile e2e evidence: sips --cropOffset is unreliable for header crops — use PIL
-
-Symptom: cropping the header strip out of a 1206x2622 simctl screenshot with
-`sips -c 340 1206 --cropOffset 0 0 in.png --out out.png` returns a center-crop
-(ignores the offset) or an all-black image (offset overshoots).
-
-Cause: sips `-c` crops centered; `--cropOffset` semantics are unclear/buggy on
-current macOS (observed July 2026).
-
-Fix: `python3 -c` with PIL (`import PIL` works on this machine's python3):
-`Image.open(p).crop((0,0,w,340)).save(out)`. Deterministic, exact pixel regions,
-and cheap downscales (`resize((w//2, h//2))`) keep evidence small for reports.
diff --git a/.kilo_workflow/learnings/mobile-e2e-headless-exec-run-not-tray-visible.md b/.kilo_workflow/learnings/mobile-e2e-headless-exec-run-not-tray-visible.md
deleted file mode 100644
index 53e6f085966..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-headless-exec-run-not-tray-visible.md
+++ /dev/null
@@ -1,37 +0,0 @@
-# mobile: headless `remote-cli.sh exec run` sessions never appear in Active now
-
-Symptom: a real CLI turn started with `apps/mobile/e2e/remote-cli.sh exec run ...` writes
-`cli_sessions_v2` rows (status busy→idle, live `total_cost_microdollars` and
-`last_activity_at` via session-ingest), but the session NEVER shows in the mobile tray —
-not while running, not via the relay.
-
-Cause: `/api/sessions/active` (session-ingest heartbeat view) only lists sessions with a live
-heartbeat/remote connection. A headless `exec run` process does not register one, and the
-separate `exec remote` relay process does not advertise other processes' sessions — so the
-router's Phase-1 heartbeat list never contains the run session, and the tray's WS/tRPC paths
-never see it. Verified on session-list-ux-19e2: three real `kilo/kilo-auto/efficient` runs
-(cost, activity, transcript all persisted; sessions searchable and in history after ending)
-with zero tray appearances, while `activeSessions.list` HTTP replays matched exactly.
-
-Fix: choose the probe per acceptance target:
-- Cost/activity persistence (items 7/17 server side): probe Postgres directly during the run
-  (read-only `docker exec dev-postgres-1 psql`); poll every 8-10s.
-- **Prompt shape matters as much as duration (r3 refinement):** mid-turn cost/activity
-  persists only happen when the turn produces MULTIPLE assistant-message upserts (tool
-  round-trips: shell/file tool calls spaced over time). A turn that is ONE giant assistant
-  message (even 40KB streamed for 3+ minutes, e.g. "list 100 foods") can deliver all ingest
-  events in a single flush at completion — cost and `last_activity_at` then move ONLY at
-  turn end and the "advances while the turn runs" criterion is unprovable on that turn.
-  r3 timings: single-message turn — zero mid-turn persists in ~3min; 8-sequential-shell-
-  command turn — cost 0→2380→5606 while busy (≈30s cost-window cadence), activity 4
-  advances at 15-18s gaps. Use a prompt that forces sequential tool calls
-  ("run these commands ONE AT A TIME ... after EACH write a sentence").
-  Also: `exec run` auto-rejects file writes OUTSIDE the worktree
-  (`permission requested: external_directory (/tmp/*); auto-rejecting`) — a /tmp poem task
-  dies in ~30s; keep the task read-only or accept a worktree-root file and delete it after.
-- Tray visibility / activity meta (item 17 client side): seed or drive a row the tray CAN
-  see (cloud-agent rows via the DB merge, or a relay/TUI session). Setting
-  `last_activity_at=now()` on a live tray row flips its meta to "just now" within one 30s
-  poll — a deterministic read-path proof that meta prefers `lastActivityAt`.
-- Watch out: `exec run` runs in the WORKTREE ROOT — the model may write files there
-  (r2: `sea-poem.txt`). Check `baseline.sh check` before reporting; delete the artifact.
diff --git a/.kilo_workflow/learnings/mobile-e2e-nextjs-suspend-protocol.md b/.kilo_workflow/learnings/mobile-e2e-nextjs-suspend-protocol.md
deleted file mode 100644
index 17d4c845fde..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-nextjs-suspend-protocol.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# mobile: kill -STOP nextjs to hold loading skeletons — only after the app is past splash
-
-Symptom: using the `kill -STOP <nextjs-pid>` suspend trick to freeze API responses (holding loading skeletons indefinitely for screenshots/assertions) hangs the app at the splash screen instead.
-
-Cause: a cold app start needs nextjs to answer its initial requests; suspending before the app is past splash blocks startup itself, not just the screen under test.
-
-Fix: launch and settle the app first, navigate to the screen under test, then `kill -STOP` the nextjs process; `kill -CONT` it as soon as the assertion is done. Treat the suspend window as strictly scoped to an already-running app.
diff --git a/.kilo_workflow/learnings/mobile-e2e-remote-cli-model-pin-relaunch.md b/.kilo_workflow/learnings/mobile-e2e-remote-cli-model-pin-relaunch.md
deleted file mode 100644
index 0ec0d737b1c..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-remote-cli-model-pin-relaunch.md
+++ /dev/null
@@ -1,28 +0,0 @@
-# mobile e2e: remote CLI TUI keeps a stale model — send-keys lands in the TUI, relaunch the tmux session with `-m`
-
-Symptom: `apps/mobile/e2e/remote-cli.sh start <email>` launches the kilo TUI with whatever model
-the CLI last used (e.g. "MoonshotAI: Kimi K3"), not the E2E-required `kilo/kilo-auto/efficient`.
-Trying to fix it by `tmux send-keys "/model kilo/kilo-auto/efficient" Enter` makes it worse: the
-keystrokes land **inside the TUI app**, the text is submitted as a user prompt, and a junk
-session (titled e.g. "Kilo model configuration review") appears in the account's session list —
-the mobile app's Agents tab will show it.
-
-Cause: `remote-cli.sh start` accepts only `<email> [--reinstall]` and launches plain `kilo`; it
-has no model flag. A TUI is not a shell — send-keys text goes to the app's input, not to a
-command line.
-
-Fix: don't patch the TUI in place. Delete the junk session, kill the tmux session, and relaunch
-it pinned:
-
-```bash
-apps/mobile/e2e/remote-cli.sh exec session delete <junkSessionID>
-tmux kill-session -t kilo-e2e-cli-<worktree-slug>
-tmux new-session -d -s kilo-e2e-cli-<worktree-slug> -c "<repo>/dev/.dev-logs/remote-cli/<worktree-slug>" -x 220 -y 50
-tmux send-keys -t kilo-e2e-cli-context...:0 "source '<...>/.cli-env' && clear && kilo -m kilo/kilo-auto/efficient" Enter
-# then recreate the relay window and confirm:
-tmux new-window -t kilo-e2e-cli-<worktree-slug> -n relay
-# in it: apps/mobile/e2e/remote-cli.sh exec remote  → "Remote connection enabled."
-```
-
-Verify the model in the TUI header (`Auto Efficient Kilo Gateway`) — `exec models` only lists
-available models and never shows the current selection.
diff --git a/.kilo_workflow/learnings/mobile-e2e-scrolluntilvisible-lands-but-throws.md b/.kilo_workflow/learnings/mobile-e2e-scrolluntilvisible-lands-but-throws.md
deleted file mode 100644
index d0cb6fd0e9a..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-scrolluntilvisible-lands-but-throws.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# mobile: scrollUntilVisible throws "scrolled N times without finding" but lands on the target
-
-Symptom: `scrollUntilVisible('<full label>')` throws after exhausting maxScrolls, yet a
-hierarchy dump taken immediately after shows the target fully visible and correctly
-positioned (observed twice on iOS PR-review Discussion tab, pr-review-ux-7f22).
-
-Cause: the helper checks visibility between flicks; the final flick moves the list
-past the last check point (momentum + FlashList re-layout), so the loop exhausts while
-the end state is fine. It is the same flick-overshoot family as
-`mobile-e2e-top-clip-positioning-flashlist-clamp` — not a new defect.
-
-Fix: after a failed scrollUntilVisible, dump the hierarchy before retrying or
-classifying — the target is often already on screen. For flows that must not throw,
-wrap in `.catch(() => {})` and follow with an explicit `assertVisible` probe.
diff --git a/.kilo_workflow/learnings/mobile-e2e-tapon-prefix-matches-static-section-label.md b/.kilo_workflow/learnings/mobile-e2e-tapon-prefix-matches-static-section-label.md
deleted file mode 100644
index 7c79793f7b9..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-tapon-prefix-matches-static-section-label.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# mobile e2e: tapOn prefix regex matches the static section label above the real button
-
-Symptom: `tapOn(/^Run on: /)` on the new-session screen silently taps nothing; the
-follow-up wait times out. No product defect.
-
-Cause: `tapOn` sorts matches topmost-first (y, then x) and taps index 0. The form's
-static section header Text (`Run on`, y=322) sorts ABOVE the interactive row button
-(`Run on: Cloud Agent`, y=347) and matches the same prefix pattern, so the tap lands
-on the non-interactive label.
-
-Fix: always match the control's FULL exact accessibility label
-(`tapOn(/^Run on: Cloud Agent$/)`), never a prefix that also fits a sibling heading.
-When a tap "does nothing", dump the hierarchy and compare every match's rect before
-blaming the app — the topmost match wins, not the most interactive one.
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
deleted file mode 100644
index 57992de3a75..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-top-clip-positioning-flashlist-clamp.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# mobile: positioning a thread at the top clip — FlashList max-offset clamp and sub-threshold swipes
-
-Symptom: E2E flows that need a collapsed resolved thread clipped ~5-20pt above the visible
-content top (PR-review flows 4 / 7a / 7b) cannot nudge the card high enough: swipes stop
-moving the list, always at the same card position.
-
-Cause: two independent constraints.
-1. The list is at FlashList's computed max scroll offset. The clamp releases only when the
-   content BELOW the target card exceeds one viewport height AND has been measured. With
-   freshly mounted data (collapsed cards + unmeasured conversation comments), a mid-list
-   card simply cannot reach the clip. In the pr-review-d957 fixture (iOS), gamma clamped at
-   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 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 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).
-- Android reminder: the a11y clamp edge (y=444 on pixel9 API35, 1080x2424) is NOT the
-  opaque-chrome bottom (~y536 pixels); verify clip geometry with a screenshot pixel scan,
-  not bounds alone.
diff --git a/.kilo_workflow/learnings/mobile-e2e-tray-vs-history-region-scoped-assertions.md b/.kilo_workflow/learnings/mobile-e2e-tray-vs-history-region-scoped-assertions.md
deleted file mode 100644
index 81a8325190d..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-tray-vs-history-region-scoped-assertions.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# mobile: tray-row assertions must be region-scoped — same session renders in tray AND history
-
-Symptom: an E2E departure assertion ("row leaves Active now") fails even though the row
-correctly departed the tray, or passes even though it never departed.
-
-Cause: the same session id renders in TWO places — the "Active now" tray while live and the
-history sections below it once departed — and both rows expose the SAME composite
-accessibility label (`<title>, <EYEBROW>, <meta>[, from <PLATFORM>]`). The Appium helpers
-match full-string regexes against labels anywhere in the hierarchy, so a title pattern
-matches whichever copy exists. A departure flow that waits for "not visible" can never win
-while the history copy renders; a flow that asserts "still visible" passes on the history
-copy even if the tray copy is stuck.
-
-Fix: scope by position, not text. In JS flows, `h.findAll(pattern)` + `driver.getElementRect`
-and compare y against a region anchor: tray rows sit ABOVE the expander
-(`/more active sessions|Show fewer active sessions/`) or, when there is no expander, above the
-first history section header (`/Today|TODAY|Yesterday/`). Example in this round's scratch
-(`case1d2.js`): row departs the tray when `rowY == null || rowY >= trayBottomY`, then the same
-title must still match somewhere below (history landing).
-
-Two adjacent gotchas from the same round:
-
-- Labels are COMPOSITE: always match with a trailing `.*`
-  (`/E2E iOS cloud one.*/`), never the bare title — the bare title full-string-matches nothing
-  and the flow times out while the row is plainly on screen.
-- "Renamed row lands in history": assert `rowY > historyHeaderY` AFTER the departure bound
-  (~50s), not just visibility — the lingering tray copy matches first.
diff --git a/.kilo_workflow/learnings/mobile-e2e-tui-remote-in-process-tray-visibility.md b/.kilo_workflow/learnings/mobile-e2e-tui-remote-in-process-tray-visibility.md
deleted file mode 100644
index aa0297d0623..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-tui-remote-in-process-tray-visibility.md
+++ /dev/null
@@ -1,24 +0,0 @@
-# mobile-e2e: TUI must enable /remote in-process for tray visibility
-
-Symptom: an interactive kilo TUI session with a busy turn never appears in the
-mobile tray or `/api/sessions/active`, even while a separate
-`remote-cli.sh exec remote` relay process shows `Remote connection enabled.`
-The session persists to Postgres (status/cost/activity all update) but the
-heartbeat view lists nothing.
-
-Cause: the heartbeat/active view lists sessions whose OWN process holds a CLI
-socket. The separate relay process advertises only its own (empty) session set
-— it never advertises the TUI's sessions (same finding as
-`mobile-e2e-headless-exec-run-not-tray-visible.md` for headless runs). A stock
-TUI posts ingest events over HTTP but opens no CLI socket.
-
-Fix: send `/remote` to the running TUI (one Enter to autocomplete, one to
-submit; status line shows `◆ Remote`). The TUI process then registers the CLI
-socket for its own session: `/api/sessions/active` lists it within ~12-15s and
-the tray row follows on the next poll. Toggling `/remote` off removes it.
-
-Also: `remote-cli.sh start <email>` re-prepares the per-worktree CLI home for a
-DIFFERENT account (re-mints the token, kills and recreates the tmux session).
-Check which user the prepared token belongs to before driving turns — the CLI
-home is per-worktree, not per-platform, so a sibling shard's prep can leave the
-TUI authenticated as the other platform's user.
diff --git a/.kilo_workflow/learnings/mobile-e2e-wedged-app-session-tray-refetch-stall.md b/.kilo_workflow/learnings/mobile-e2e-wedged-app-session-tray-refetch-stall.md
deleted file mode 100644
index 023366e6f3a..00000000000
--- a/.kilo_workflow/learnings/mobile-e2e-wedged-app-session-tray-refetch-stall.md
+++ /dev/null
@@ -1,26 +0,0 @@
-# mobile-e2e: multi-hour app session can stall tray refetch — force-stop + deep-link relaunch recovers
-
-Symptom: on an app session that had been foregrounded for ~1.5h through many
-Appium runs, newly seeded live cloud rows (visible in the
-`activeSessions.list` tRPC replay) never rendered in the tray for 7+ minutes
-of untouched watching. A tab bounce (Home -> Agents) rendered them instantly;
-the same behavior repeated on departure (terminalized rows lingered).
-
-Diagnosis: the app's 30s `refetchInterval` poll was running (nextjs logs show
-`activeSessions.list` 200s), but the results were not applied to the rendered
-tray until a navigation refetch. Never root-caused to product code — the SAME
-flows on a freshly relaunched app worked untouched (appearance 30.9s,
-departure ~40s, matching the iOS shard's 39.4s on identical code), so the
-stall is a property of the long-lived app process state, not the build.
-
-Fix: treat >1h-foreground app sessions as suspect. Recover with
-`am force-stop com.kilocode.kiloapp` + the preflight deep link (adb reverses
-first; see `mobile-android-dev-client-cold-start-deep-link.md`) — auth
-survives (no `pm clear`), the bundle reloads in ~40s, and the tray polls
-correctly again. Attribute findings to the product only after reproducing on a
-fresh app session.
-
-Related measurement tip: count the app's real poll traffic with
-`grep -c "activeSessions.list" dev/logs/nextjs.log` over 60s — sibling shards'
-apps poll the same nextjs, so measure once with your app force-stopped and
-subtract the floor.
diff --git a/.kilo_workflow/learnings/mobile-file-navigator-sheet-clipped-ios26.md b/.kilo_workflow/learnings/mobile-file-navigator-sheet-clipped-ios26.md
deleted file mode 100644
index da0458434a8..00000000000
--- a/.kilo_workflow/learnings/mobile-file-navigator-sheet-clipped-ios26.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# 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 (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 — 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-device-auth-consent-sheet.md b/.kilo_workflow/learnings/mobile-ios-device-auth-consent-sheet.md
deleted file mode 100644
index aec8de9c648..00000000000
--- a/.kilo_workflow/learnings/mobile-ios-device-auth-consent-sheet.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# mobile: iOS device-auth start() opens an ASWebAuthenticationSession consent over the pending branch
-
-Symptom: after tapping `More sign-in options` on the iOS login screen, a system alert
-`"Kilo" Wants to Use "<ip>" to Sign In` (Cancel/Continue) covers the app, and the
-pending-with-code branch is not visible for pixel probes.
-
-Cause: `use-device-auth.ts` `start()` calls `WebBrowser.openAuthSessionAsync(verificationUrl)` on
-iOS (ASWebAuthenticationSession); the consent alert precedes the auth sheet. e1/e2 never hit it
-because their starts all 500'd (error branch renders before the browser call).
-
-Fix: tap `Cancel` index 0 on the consent — `openAuthSessionAsync` resolves as cancelled, NO app
-state changes (the hook's own `cancel()` is not called), and the pending-with-code branch
-("Your sign-in code:", `Sign in code: X X X X - X X X X`, "Open sign-in page in browser",
-"Cancel sign in") stays rendered for probing. Then tap `Cancel sign in` to return to idle.
-Probe discriminators: dark-glyph fraction on the big code text (full alpha ~0.19-0.21 with the
-all-channels<100 threshold; parked ~50% alpha washes glyphs above 100 -> ~0.0) and on the
-Open-in-browser button text (~0.036 full alpha). The muted "Your sign-in code:" heading scores
-0.000 even when healthy (gray > 100/channel) — not a discriminator.
diff --git a/.kilo_workflow/learnings/mobile-ios-pr-link-open-button-clearx-shift.md b/.kilo_workflow/learnings/mobile-ios-pr-link-open-button-clearx-shift.md
deleted file mode 100644
index ef87e6d62bd..00000000000
--- a/.kilo_workflow/learnings/mobile-ios-pr-link-open-button-clearx-shift.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# mobile iOS: PR-link entry screen — Open button shifts +7pt when the field gains content (clear-X)
-
-Symptom: verifying "invalid link renders INLINE in the reserved slot, Open button bounds
-unchanged" by recording Open bounds on the empty entry screen, pasting `not-a-url`, and
-re-measuring FAILS: Open moves y 236→243 and grows h 39→40 even though the helper slot is
-documented as layout-stable.
-
-Cause: the in-field clear-X (`Clear pull request link`, h-13/w-13 ≈ 46pt) appears whenever the
-field has content; it is taller than the 39pt input, so the input ROW grows 39→46 and pushes the
-helper slot and Open button down ~7pt. This is field-CONTENT state, not helper-message state —
-the clear-X predates the pr-review-ux-7f22 changes (present at r1 head `dd659d4a9`).
-
-Fix (decisive experiment for the slot invariant): hold field state constant across the helper
-transition — paste `not-a-url` (helper visible, clear-X present), tap the clear-X: the shipped
-clear handler does NOT clear `helperMessage`, so the invalid helper stays mounted with an empty
-field, and Open returns EXACTLY to the initial rect ({x:21,y:236,w:360,h:39} on iPhone 17).
-That byte-identical comparison is the assertion the AC intends; the +7pt with a filled field is
-pre-existing approved behavior, not a regression.
diff --git a/.kilo_workflow/learnings/mobile-ios-simulator-e2e-limitations.md b/.kilo_workflow/learnings/mobile-ios-simulator-e2e-limitations.md
deleted file mode 100644
index ac30b60ce2a..00000000000
--- a/.kilo_workflow/learnings/mobile-ios-simulator-e2e-limitations.md
+++ /dev/null
@@ -1,12 +0,0 @@
-# mobile: iOS simulator capabilities E2E cannot exercise (keyboard, speech, banners, push)
-
-Symptom: an E2E flow stalls typing into a composer, waits forever for speech recognition, or cannot capture a notification banner — with no product defect involved.
-
-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 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.
-
-Fix: disable the hardware keyboard via PlistBuddy on the simulator's preferences plist (then reboot the sim) to restore the software keyboard. For the rest: report those criteria as environment-limited (a skip with rationale), never as product failures, and cover them with unit/integration tests or a manual pass instead.
diff --git a/.kilo_workflow/learnings/mobile-ios-xcuitest-a11y-tree-geometry-containment.md b/.kilo_workflow/learnings/mobile-ios-xcuitest-a11y-tree-geometry-containment.md
deleted file mode 100644
index 9a842b00164..00000000000
--- a/.kilo_workflow/learnings/mobile-ios-xcuitest-a11y-tree-geometry-containment.md
+++ /dev/null
@@ -1,29 +0,0 @@
-# mobile iOS: XCUI tree — a11y-labeled parent Views are leaves; assert by geometry, not XML ancestry
-
-Symptom: a flow parses `driver.getPageSource()` to assert "snippet inside thread card" via XML
-parent/child containment and finds the card node has ZERO descendants — while pills, snippets and
-comment texts all render on screen. Plain-text labels also appear exactly TWICE in the tree, and
-`visible="true"` matches nothing, so visibility filtering empties the probe.
-
-Cause (iOS 26.5 sim, RN 0.86, PR-review Discussion tab, verified 2026-07-30):
-- A RN View with `accessibilityLabel` (thread cards, header Pressables) becomes ONE accessibility
-  element; its children are NOT XML descendants — they appear as geometric SIBLINGS elsewhere in
-  the tree. Containment must be rect-in-rect on the page-source coordinates (`x/y/width/height`).
-- Plain RN Texts are mirrored across two windows at identical rects — dedupe by
-  (label,x,y,width,height) before counting, and never assert `count === 1` on a Text label
-  (transiently or consistently 2). Interactive elements (Pressables with labels) appear once.
-- Badge Texts using NativeWind `uppercase` expose the TRANSFORMED string (`RESOLVED`, `OUTDATED`,
-  `FILE`) — match the uppercase form.
-- Off-screen FlashList rows stay mounted in the tree; the `visible` attribute is useless (never
-  `true`). Before coordinate-tapping a node, require `0 <= y && y+h <= screenHeight`; swipe
-  (clamped, harmless) until the node is in the viewport.
-- Diff-line gutters (line numbers, +/- markers) are `accessibilityElementsHidden`; the code
-  container's `buildDiffLineAccessibilityLabel` (`Deleted line 8: ...`) is NOT what reaches the
-  tree — the inner selectable RNText's raw code string is. Assert snippet content via code texts
-  (`// stub change`, `return 1;`), and rely on screenshots for line-number evidence.
-- Emoji labels (`👍 reaction, 2 reactions`) match fine through the helpers' predicate path.
-
-Fix: parse page source into a rect tree (fast-xml-parser from the repo's `.pnpm` store requires
-fine from scratch flows), keep `flat()` (dedupe) + `insideRect()` + `inViewport()` helpers, and
-tap by node-rect centre via W3C actions instead of global `tapOn` when the same label exists in
-several cards (e.g. `Resolve thread`).
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
deleted file mode 100644
index aefa09a54eb..00000000000
--- a/.kilo_workflow/learnings/mobile-kilochat-attachments-capability-gate-blocks-e2e.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# mobile: kilo-chat attachment flows are untestable against a dev:seed fake instance (capability gate)
-
-Symptom: an E2E round that must attach a photo in kilo-chat (file-preview criterion 10,
-share-button regression) cannot start: the composer renders no `Attach file` button.
-
-Cause (r1): the button is gated on `botStatus?.capabilities?.includes('attachments')`
-(apps/mobile/src/components/kilo-chat/conversation-screen.tsx:72); a fake sandbox never
-advertises capabilities.
-
-Cause (r2, NEW — defeats the direct-POST workaround): even an orchestrator-level
-HMAC `POST /bot/v1/sandboxes/:id/bot-status` with `{online:true, capabilities:['attachments']}`
-does NOT survive the first conversation open. The mobile client polls
-`POST /v1/sandboxes/:id/request-bot-status` every ~15s while the conversation screen is
-mounted; kilo-chat fans out `deliverChatWebhook` to kiloclaw, which throws
-`Instance for <label> has no sandboxId` for every `ki_fake_*` sandbox (the fake-instance
-seed writes `sandbox_id` in Postgres but never populates the KILOCLAW_INSTANCE DO record
-that `deliverChatWebhook` reads via `stub.getStatus()`). `isDefiniteUnreachable` matches
-`has no sandboxId` → kilo-chat publishes `{online:false, at: Date.now()}`
-(services/kilo-chat/src/services/bot-status-request.ts), and the monotonic upsert in
-SandboxStatusDO (`setWhere: at < excluded.at`) accepts it and NULLs capabilities. Verified
-on device r2: seeded row (19:2x) overwritten at first open (21:26), `Bot is offline`
-banner, 0 `Attach file`, stable across a reopen; kilo-chat pane shows the offline publish
-on every poll tick. The overwrite is structural, not caused by a stack restart — DO state
-(`.wrangler/state`) persists across `dev:start`.
-
-Fix: none sanctioned today. The product needs a dev-only capability/status seed that also
-survives the request-bot-status escalation (e.g. seed the KILOCLAW_INSTANCE DO so
-`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.
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
deleted file mode 100644
index 44b2cad6c3e..00000000000
--- a/.kilo_workflow/learnings/mobile-rename-entry-points-and-field-clearing.md
+++ /dev/null
@@ -1,21 +0,0 @@
-# mobile: rename entry points — tray row has NO rename action; use history row or detail header
-
-Symptom: an E2E flow that long-presses the "Active now" tray row to rename gets an action sheet with
-only `Copy session ID` / `Cancel` — no `Rename` — and stalls waiting for it.
-
-Cause: by design `RemoteSessionRow` (tray) offers only copy-id; `canManage`/rename exists on the
-HISTORY row (`session-row.tsx`, sheet: Copy session ID / Rename / Delete session / Cancel) and on the
-session-detail header (pressable title, a11y label `Rename session: <title>`, opens RenameModal).
-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, 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-vitest-pure-tsx-include-globs.md b/.kilo_workflow/learnings/mobile-vitest-pure-tsx-include-globs.md
deleted file mode 100644
index 72517baf446..00000000000
--- a/.kilo_workflow/learnings/mobile-vitest-pure-tsx-include-globs.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# mobile: a `src/components/agents/*.test.tsx` matches no vitest project — coverage guard fails
-
-Symptom: after adding a component test named `*.test.tsx` under
-`apps/mobile/src/components/agents/` (or any `src/components/` subtree outside
-`pr-review/`/`kiloclaw/`), `pnpm test` fails in `src/lib/vitest-project-coverage.test.ts` with
-"Test files matched by no vitest project include — they never run", listing the new file.
-
-Cause: `apps/mobile/vitest.pure.config.ts` includes `src/components/**/*.test.ts` but
-`*.test.tsx` **only** under `src/components/pr-review/**` and `src/components/kiloclaw/**`;
-`apps/mobile/vitest.mounted.config.ts` includes only `src/**/*.mounted.test.tsx`. A plain
-`.test.tsx` elsewhere is an orphan, and the committed coverage guard (which evaluates both
-configs' real include arrays against every test-looking file under `src/`) fails the run
-loudly instead of letting the file sit idle.
-
-Fix: name the test `*.test.ts` and follow the `message-bubble.test.ts` direct-call convention
-(mock `react-native` with string host components, call the component as a function, walk the
-returned element tree — works for hook-free components), or name it `*.mounted.test.tsx` and
-use the `src/test/render-with-providers.tsx` harness. Only widen
-`vitest.pure.config.ts`'s include list when a whole new `.tsx` test directory is being
-introduced deliberately.
diff --git a/.kilo_workflow/learnings/pi-planner-trust-prompt-needs-approve-flag.md b/.kilo_workflow/learnings/pi-planner-trust-prompt-needs-approve-flag.md
deleted file mode 100644
index 288096f4307..00000000000
--- a/.kilo_workflow/learnings/pi-planner-trust-prompt-needs-approve-flag.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# pi planner wedges on "Trust project folder?" at launch
-
-**Symptom:** A pi-harness planner/orchestrator launched via `launch-interactive.sh` shows an interactive `Trust project folder?` dialog and never starts working.
-
-**Cause:** Fresh worktrees are untrusted; pi blocks on its trust prompt before loading project resources, and the tmux launch cannot answer it.
-
-**Fix:** Pass `--approve` in the pi command line (per-run trust; does not mutate pi settings):
-
-```bash
-.kilo_workflow/launch-interactive.sh <section>-planner <worktree> --log "$SCRATCH/planner.log" \
-  pi --approve --model kilocode/kilo-internal/kimi-k3 --thinking high "<planner role message>" "@$SCRATCH/brief.md"
-```
-
-Do not resolve it by pressing Enter on the persisted `Trust` option — that silently writes the worktree path into the user's pi settings.
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
deleted file mode 100644
index 1125cc5946e..00000000000
--- a/.kilo_workflow/learnings/pnpm-install-noop-leaves-virtual-store-drift.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# pnpm-install-noop-leaves-virtual-store-drift
-
-Symptom: `pnpm install` prints "Already up to date" in <1s and does NOT re-apply
-patches or recreate deleted `.pnpm` package dirs — even `pnpm install --force` and
-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 (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
-re-verifies virtual-store contents. Patch re-application only happens during a real
-(re)link pass.
-
-Fix: `rm -f node_modules/.pnpm-workspace-state-v1.json && pnpm install` forces the
-full relink (~1 min, re-applies patches, prunes stale peer-hash instances). Verify
-with `xxd`/`cat` on the patched files afterwards. The install does not disturb
-running dev services; restart Metro afterwards as cheap insurance.
diff --git a/.kilo_workflow/learnings/prettier-churn-cannot-be-undone-by-oxfmt.md b/.kilo_workflow/learnings/prettier-churn-cannot-be-undone-by-oxfmt.md
deleted file mode 100644
index 47772ea669b..00000000000
--- a/.kilo_workflow/learnings/prettier-churn-cannot-be-undone-by-oxfmt.md
+++ /dev/null
@@ -1,29 +0,0 @@
-# Prettier churn cannot be undone by running oxfmt afterwards
-
-**Symptom.** A role agent's diff on its owned files is far larger than the planned
-change (thousands of lines across untouched regions): single quotes flipped to double
-quotes, object literals rewrapped multi-line. The agent ran Prettier (defaults or its
-own config) on repo files.
-
-**Cause.** This repository's formatter is **oxfmt** (root `pnpm format`, config
-`.oxfmtrc.json`: `singleQuote`, `printWidth: 100`). Prettier with defaults
-(`printWidth: 80`, double quotes) reformats whole files. The trap: running oxfmt
-afterwards does NOT restore the original. Prettier expands object literals to one
-property per line, and oxfmt (like Prettier) preserves object literals that are
-already expanded in the source — so the double-quote churn reverts but the object
-expansion stays. Both states are formatter fixed points; the original single-line
-form is unrecoverable by formatting.
-
-**Fix.**
-
-- Recovery: `git checkout HEAD -- <files>` and re-apply the functional edits. Do not
-  attempt formatter-based repair.
-- Prevention (dispatchers): every implementer handoff that touches files pins —
-  never run `prettier`/`npx prettier`; the repo formatter is oxfmt
-  (`pnpm -w exec oxfmt <file>`); before finishing, run
-  `git diff HEAD --stat -- <owned paths>` and confirm the diff is limited to the
-  functional edits.
-- Detection (orchestrator): compare the emitted slice diff size against the planned
-  change size BEFORE dispatching the reviewer. A diff many times larger than the
-  plan's edit description is churn — revert and redo the round; do not send churn to
-  the reviewer and do not commit it.
diff --git a/.kilo_workflow/learnings/system/.gitignore b/.kilo_workflow/learnings/system/.gitignore
deleted file mode 100644
index bf27f3114d4..00000000000
--- a/.kilo_workflow/learnings/system/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-*
-!.gitignore
-!.gitkeep
diff --git a/.kilo_workflow/learnings/system/.gitkeep b/.kilo_workflow/learnings/system/.gitkeep
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/.kilo_workflow/learnings/web-jest-full-suite-local-workers-and-collisions.md b/.kilo_workflow/learnings/web-jest-full-suite-local-workers-and-collisions.md
deleted file mode 100644
index 45f2ab80bfe..00000000000
--- a/.kilo_workflow/learnings/web-jest-full-suite-local-workers-and-collisions.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# Running the full web jest suite locally: workers, timeouts, and run collisions
-
-**Symptom 1 — mass per-test 5s timeouts and 60s `beforeAll` hook timeouts across
-unrelated suites when running `pnpm --filter web test` locally.** The failures name
-`workerSetup.ts` `beforeAll` or `cleanupDbForTest` in `beforeEach`, in suites far from
-whatever you changed.
-
-**Cause.** `apps/web/jest.config.ts` defaults to `maxWorkers: '50%'`. Every worker's
-first suite cold-starts a per-worker database
-(`DROP DATABASE … WITH (FORCE)` + `CREATE DATABASE` + full drizzle migrate + partition
-provisioning, `apps/web/src/tests/setup/workerSetup.ts`). On a laptop docker postgres,
-N parallel cold starts exceed the hardcoded 60s hook timeout; the setup flag file is
-only written after success, so every subsequent suite re-runs the full setup and times
-out again — the whole run is poisoned from the start. Even after setup, 200-table
-`TRUNCATE` cleanup per test can exceed the 5s default test timeout under load.
-
-**Fix.** Run the full suite as `JEST_MAX_WORKERS=1 pnpm --filter web test` with nothing
-else DB-heavy on the machine, and expect it to take hours (~680 suites). Per-file
-(`pnpm --filter web test -- <file>`) runs are fine with default workers. If a full-run
-failure is in a suite your diff does not touch, re-run that suite alone before
-believing it.
-
-**Symptom 2 — a second concurrent DB-test run crashes with `ERR_UNHANDLED_ERROR` /
-`Connection terminated unexpectedly`, and both runs produce garbage results.**
-
-**Cause.** With `JEST_MAX_WORKERS=1` (or any equal worker count), both runs use the
-same `JEST_WORKER_ID`s and therefore the SAME `postgres-<workerId>` databases: each
-run's setup `DROP DATABASE … WITH (FORCE)` terminates the other run's connections
-mid-flight.
-
-**Fix.** Never run two web jest invocations (or anything else using the shared
-docker postgres test setup) concurrently on one worktree. One DB-test run at a time,
-machine-wide.
diff --git a/.kilo_workflow/pick-reviewers.sh b/.kilo_workflow/pick-reviewers.sh
deleted file mode 100755
index 811c6e77c6f..00000000000
--- a/.kilo_workflow/pick-reviewers.sh
+++ /dev/null
@@ -1,57 +0,0 @@
-#!/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); 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 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
-# 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
deleted file mode 100755
index d717ae3e408..00000000000
--- a/.kilo_workflow/pr-gate.sh
+++ /dev/null
@@ -1,120 +0,0 @@
-#!/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> [--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)
-#   --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
-#
-# 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 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
-
-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 ;;
-    --label) LABEL=${2:?}; shift 2 ;;
-    --wait) WAIT=${2:?}; shift 2 ;;
-    *) echo "pr-gate: unknown option $1" >&2; exit 1 ;;
-  esac
-done
-
-DEADLINE=$(( $(date +%s) + WAIT ))
-while :; do
-  DATA=$(gh pr view "$PR" --repo "$REPO" \
-    --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')
-  # 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&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")
-  [ -n "$BOTCOMMENTS" ] && break
-  [ "$(date +%s)" -ge "$DEADLINE" ] && break
-  sleep 30
-done
-
-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")
-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.
-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"
-
-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
-
-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"
-[ "$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
-  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
deleted file mode 100755
index 1d73545959a..00000000000
--- a/.kilo_workflow/pr-threads.sh
+++ /dev/null
@@ -1,125 +0,0 @@
-#!/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 and pagination mistakes.
-#
-#   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
-#
-# <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 ...}
-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!,$after:String){
-  repository(owner:$owner,name:$repo){pullRequest(number:$pr){
-    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() {
-  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"
-}
-
-# 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() {
-  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=$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")
-  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
-  gh api "repos/$REPO/pulls/$pr/comments/$comment/replies" -f body="$body" --jq '.html_url'
-}
-
-do_resolve() {
-  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 \
-    -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)
-    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 -}")
-    # 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/.kilo_workflow/slice-diff.sh b/.kilo_workflow/slice-diff.sh
deleted file mode 100755
index f088b07102f..00000000000
--- a/.kilo_workflow/slice-diff.sh
+++ /dev/null
@@ -1,73 +0,0 @@
-#!/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 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>
-#
-#   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.
-#
-# 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 [--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; --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 --binary -- "$@" > "$OUT"
-
-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
-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
-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/.kilo_workflow/steer.sh b/.kilo_workflow/steer.sh
deleted file mode 100755
index aab8d78824c..00000000000
--- a/.kilo_workflow/steer.sh
+++ /dev/null
@@ -1,90 +0,0 @@
-#!/usr/bin/env bash
-# Deliver a message to a running interactive kilo session (starter, planner,
-# orchestrator) and prove it landed.
-#
-#   steer.sh <tmux-target> <message>     # message text, or - to read stdin
-#
-# 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
-#      trailing Enter, so the text sits unsent in the input box forever. That is
-#      the "wedged" session agents keep reporting. Enter must arrive as its own
-#      keystroke, after the text.
-#   2. A delivered message only reaches the model at the next turn boundary. The
-#      footer shows `N queued` until then, which is delivery working, not a wedge.
-#
-# Exit 0 once the message is submitted; prints `queued` (waiting for the current
-# turn to end) or `running` (the session picked it up immediately). Exit 1 with
-# the pane tail if it could not be submitted — the message may be sitting in the
-# composer, so fix the target rather than sending a second copy.
-set -euo pipefail
-
-TARGET=${1:?tmux target — session, window or pane}
-MSG=${2:?message text, or - for stdin}
-[ "$MSG" = "-" ] && MSG=$(cat)
-[ -n "${MSG//[[:space:]]/}" ] || { echo "steer: empty message" >&2; exit 1; }
-
-CMD=$(tmux display-message -p -t "$TARGET" '#{pane_current_command}' 2>/dev/null || true)
-[ -n "$CMD" ] || { echo "steer: no such tmux target: $TARGET" >&2; exit 1; }
-# A mistargeted steer pasted into a shell pane RUNS as a shell command. Only
-# panes running the kilo CLI (node, or bun on a source checkout) are steerable.
-case $CMD in
-  node | bun | kilo) ;;
-  *)
-    echo "steer: $TARGET is running '$CMD', not a kilo CLI — refusing to paste into it" >&2
-    exit 1
-    ;;
-esac
-
-# -J joins wrapped lines, so a needle survives the pane's width.
-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. `--` 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 '^›'; }
-# 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`
-# wraps it in bracketed paste, which keeps a multi-line message as ONE prompt —
-# an unbracketed paste submits at every newline, so a three-line steer arrives
-# as three prompts and the first fragment gets acted on alone.
-tmux load-buffer -b "$BUF" - <<<"$MSG"
-tmux paste-buffer -d -p -b "$BUF" -t "$TARGET"
-
-# Separate keystroke, after the composer has settled — trap 1.
-for attempt in 1 2 3; do
-  # Re-press Enter only while the text is demonstrably still in the composer.
-  # Failing to *confirm* a submission is not evidence the Enter was lost, and a
-  # blind resend would submit whatever sits in the composer by then.
-  if [ "$attempt" -gt 1 ] && ! composed; then break; fi
-  sleep 1
-  tmux send-keys -t "$TARGET" Enter
-  for _ in 1 2 3 4; 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. 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
-
-echo "steer: submission unconfirmed — inspect $TARGET before resending" >&2
-pane | grep -vE '^ *$' | tail -15 >&2
-exit 1
diff --git a/.kilo_workflow/upload-pr-attachment.sh b/.kilo_workflow/upload-pr-attachment.sh
deleted file mode 100755
index 2c96cf6f9d3..00000000000
--- a/.kilo_workflow/upload-pr-attachment.sh
+++ /dev/null
@@ -1,63 +0,0 @@
-#!/usr/bin/env bash
-# Upload one screenshot with the security-reviewed gh-image v1.2.0 binary only
-# after verifying its release digest. See learnings/gh-image-unverified-release-binary.md.
-set -euo pipefail
-
-VERSION=v1.2.0
-[ "$#" -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 ;;
-  Darwin-x86_64) ASSET=darwin-amd64; EXPECTED=08353182ec9f1af8b445d192b538741fb7421a16e12e2645f2152ac859c0958a ;;
-  Linux-aarch64 | Linux-arm64) ASSET=linux-arm64; EXPECTED=f36fd26e1920e217eb2bd1d5f7e0378c00f64214f3b011f5697d883943f0d1ee ;;
-  Linux-x86_64) ASSET=linux-amd64; EXPECTED=0505f8c46d63bd603a445fdbfdd6be45e75a80778d97f1edf3580697fa6b7919 ;;
-  *) echo "unsupported platform: $(uname -s)-$(uname -m)" >&2; exit 1 ;;
-esac
-
-unset GH_SESSION_TOKEN
-
-KILO_CACHE_ROOT=${XDG_CACHE_HOME:-${HOME:?}/.cache}
-BINARY="$KILO_CACHE_ROOT/kilo-workflow/gh-image/$VERSION/$ASSET"
-checksum() {
-  if command -v sha256sum >/dev/null; then
-    sha256sum "$1" | cut -d' ' -f1
-  else
-    shasum -a 256 "$1" | cut -d' ' -f1
-  fi
-}
-if [ -f "$BINARY" ]; then
-  ACTUAL=$(checksum "$BINARY")
-else
-  KILO_IMAGE_TMP=$(mktemp -d "${TMPDIR:-/tmp}/kilo-gh-image.XXXXXX")
-  trap 'rm -rf "$KILO_IMAGE_TMP"' EXIT
-  gh release download "$VERSION" --repo drogers0/gh-image --pattern "$ASSET" --output "$KILO_IMAGE_TMP/$ASSET"
-  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.tmp.$$"
-  mv -f "$BINARY.tmp.$$" "$BINARY"
-fi
-
-[ "$ACTUAL" = "$EXPECTED" ] || { echo "cached gh-image checksum mismatch" >&2; rm -f "$BINARY"; exit 1; }
-exec "$BINARY" "$SCREENSHOT" --repo "$REPO"
diff --git a/apps/mobile/AGENTS.md b/apps/mobile/AGENTS.md
index 926d014e01a..149d6127029 100644
--- a/apps/mobile/AGENTS.md
+++ b/apps/mobile/AGENTS.md
@@ -5,7 +5,7 @@
 Expo Router app for iOS and Android only. Use dev builds, never Expo Go. No web-specific code.
 
 - 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.
+- Substantial mobile work 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 a3f1ab61559..29a3f7dd6e9 100644
--- a/apps/mobile/e2e/AGENTS.md
+++ b/apps/mobile/e2e/AGENTS.md
@@ -4,20 +4,11 @@ Interactive verification against a local backend. Run commands from the reposito
 
 ## E2E Bundle: Required First Step
 
-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
-.kilo_workflow/e2e-slot-status.sh    # live holders; stale slots and unaccounted resources
-```
-
-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. Taking
-is idempotent per session. Parallel iOS and Android verifiers share this bundle
-and never take another slot.
+E2E device/stack work is owned by one process per round. That owner starts every
+resource, records the platform scope and ready device identifiers, then stops
+everything it started before leaving. Default platform scope is **iOS-only**;
+run Android only when the change touches platform-specific paths or a prior
+platform-specific defect exists, and record that rationale.
 
 ## Fresh Worktree Quickstart
 
@@ -28,6 +19,8 @@ node --version   # must be v24; activate the root .nvmrc first if needed
 pnpm dev:worktree:prepare
 ```
 
+Missing local env values: the human bootstrap is `pnpm dev:setup-env`. Test users, credits, and API tokens: `pnpm dev:seed` (no args lists topics).
+
 Record pre-existing state so you later clean up only resources you own:
 
 ```bash
@@ -36,27 +29,35 @@ tmux ls
 xcrun simctl list devices booted
 ```
 
-Reuse an existing stack only when it belongs to the current live slot bundle.
-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.
+Reuse an existing stack only when it belongs to this worktree (same
+`kilo-dev-<slug>` session). An unaccounted stack whose slug matches this
+worktree's basename is yours: stop it with `pnpm dev:stop`, then 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:
+If this worktree has no stack, the bundle owner starts the complete mobile flow:
 
 ```bash
-.kilo_workflow/e2e-start-resource.sh stack mobile cloud-agent-next kiloclaw event-service
+pnpm dev:env -y cloudflare-session-ingest
+pnpm dev:start --no-attach --reuse-running mobile cloud-agent-next kiloclaw event-service
+pnpm drizzle migrate
 ```
 
-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.
+Confirm services are up with `pnpm dev:status --json`. Refresh the session-ingest
+Secrets Store binding before start when the worktree is fresh.
 
-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):
+iOS claim+build (idempotent per worktree):
 
 ```bash
-.kilo_workflow/e2e-start-resource.sh bundle <avd-name> [--gpu host]
+CLAIM=$(pnpm -s dev:mobile:simulator claim)
+UDID=$(printf '%s' "$CLAIM" | node -e 'process.stdout.write(JSON.parse(require("fs").readFileSync(0,"utf8")).device.id)')
+pnpm dev:mobile:ios build "$UDID"
 ```
 
+Android (only with a recorded dual-platform rationale): start, claim, build via
+`pnpm dev:mobile:android` (see Android section). Generated `apps/mobile/{ios,android}`
+trees are gitignored; prebuild runs when missing.
+
 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.
@@ -107,18 +108,22 @@ Pinned surface only: REST pull/repo/check-runs/statuses/`pulls/{n}/files` (pagin
 
 ## iOS Simulator
 
-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:
+The bundle owner claims and builds before dispatch. The start wrapper does both
+in one command; never share a simulator with another worktree. The claim command
+prefers an unclaimed shutdown iPhone and boots it:
 
 ```bash
-.kilo_workflow/e2e-start-resource.sh ios [udid]  # idempotent per worktree
-.kilo_workflow/e2e-stop-resource.sh ios          # this worktree's claims
+pnpm dev:mobile:simulator claim [udid]   # claim (+ boot); then build
+pnpm dev:mobile:ios build <udid>
+pnpm dev:mobile:simulator release-all    # this worktree's claims; powers off what it booted
 ```
 
 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:
+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:
 
 ```bash
 pnpm dev:mobile:ios build <udid>
@@ -201,15 +206,25 @@ Setup is automatic: the repository install provides Appium and the webdriverio c
 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/appium.sh <udid|emulator-5554> test -e KEY=VALUE <flow.js>
+apps/mobile/e2e/appium.sh <udid|emulator-5554> test -e KEY=VALUE <flow.js> [more-flows.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`.
+One `appium.sh <device> test` invocation accepts multiple flow files and runs them on **one** WebDriver session. Session startup is the dominant per-command cost, so a verifier plans its route and batches flows into as few invocations as possible. Batching applies to verifier-written flows; `login.sh` / `logout.sh` keep their per-call sessions. The Appium server per device already persists across invocations for the bundle's lifetime; stop it during bundle cleanup with `apps/mobile/e2e/appium.sh <udid> server stop`.
+
+### Video-first evidence
+
+Record each flow segment (not the whole route) with `record.sh`. Extract frames at the timestamps the flow hit — simctl videos are variable-frame-rate, so a static screen legitimately yields few frames. Android `screenrecord` caps at ~3 minutes (`--time-limit 170`); segment recordings, never one whole-route video. Keep screenshots for ad-hoc stills.
+
+```bash
+apps/mobile/e2e/record.sh <udid|serial> start <video-path>
+apps/mobile/e2e/record.sh <udid|serial> stop
+apps/mobile/e2e/record.sh frame <video-path> <hh:mm:ss> <out.png>
+xcrun simctl io <udid> screenshot <path>      # iOS still
+pnpm dev:mobile:android adb -s <serial> exec-out screencap -p > <path>  # Android still
+```
 
-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.
+`stop` is idempotent. The bundle owner runs `record.sh <device> stop` for every bundle device before `pnpm dev:mobile:simulator release-all` / `pnpm dev:mobile:android emulator-stop` (also reaps a recorder orphaned by a crashed verifier).
 
 ## Remote CLI Session Flows
 
@@ -251,44 +266,70 @@ Do not conclude Android is unavailable from `command -v adb` or the inherited `P
 pnpm dev:mobile:android doctor
 ```
 
-The bundle owner uses the wrappers for emulator lifecycle and the Expo/Gradle
-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.
+The bundle owner uses the repository Android wrappers for emulator lifecycle
+and the Expo/Gradle build before dispatch. `pnpm dev:mobile:android emulator-start`
+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
 
 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
-EMULATOR=$(.kilo_workflow/e2e-start-resource.sh android <avd-name> --gpu host)
+EMULATOR=$(pnpm -s dev:mobile:android emulator-start <avd-name> --gpu host --wait)
 SERIAL=$(jq -r .serial <<<"$EMULATOR")
 EMULATOR_PID=$(jq -r .pid <<<"$EMULATOR")
 EMULATOR_LOG=$(jq -r .log <<<"$EMULATOR")
+pnpm -s dev:mobile:android claim "$SERIAL" >/dev/null
+pnpm dev:mobile:android build "$SERIAL"
 ```
 
-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.
+On success, 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.
 
 ### 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.
+With `--wait`, JSON is printed only **after** boot succeeds. On failure the command throws and stdout is empty — `$EMULATOR` / `$EMULATOR_LOG` / `$EMULATOR_PID` are unset. Before any teardown, decide attempt 2's GPU from the **error text** (not from whether a process is still alive after stop):
+
+| Error text | Cause | Attempt 2 GPU |
+|---|---|---|
+| `… did not reach sys.boot_completed=1 within 8 minutes; see <log>` | process still live, boot envelope missed | `--gpu host` (retry Mac GPU) |
+| `… died while booting; see <log>` | recorded PID died mid-boot | `--gpu swiftshader_indirect` |
+| `… exited during launch; see <log>` | process died before console bind | `--gpu swiftshader_indirect` |
+| `… did not bind console port … within 30s; see <log>` | launch hung before bind | `--gpu swiftshader_indirect` |
+| `… does not own console port …` | foreign process on the port | `--gpu swiftshader_indirect` |
+| `… did not record its PID` | launch failed before pid file | `--gpu swiftshader_indirect` |
+| any other `emulator-start` failure | treat as died / unusable host GPU path | `--gpu swiftshader_indirect` |
+
+Only the boot-envelope timeout retries the Mac GPU. Every pre-boot launch failure and mid-boot death switches to software rendering.
+
+Log path for `tail -200` (not `$EMULATOR_LOG`):
+
+- `$TMPDIR/kilo-e2e-android-<worktree-slug>.log` (slug = basename with non `[A-Za-z0-9_-]` → `_`), or
+- the path after `see ` in the error text (when present).
+
+The session record at `$TMPDIR/kilo-mobile-android-emulators/<worktree-slug>.json` only exists after a successful launch bind. Pre-boot launch failures delete it before rethrowing, so there is nothing to read — `emulator-stop` still reaps a stray tmux session. Boot-wait failures leave the record in place; read it before stopping only if you need the recorded PID/session for the handoff. Then run `pnpm dev:mobile:android emulator-stop` and `pnpm dev:mobile:android release-all` — stop kills any remaining PID and deletes the session record, so it cannot be used to re-derive the GPU policy afterward. Relaunch once with the GPU chosen above. If the second attempt also fails, stop and return a test-environment blocker with the log tail; never a third launch.
 
 ### Build and login
 
-Claim the serial (idempotent), then build:
+After emulator-start + claim + build (above), run login next:
 
 ```bash
-pnpm dev:mobile:android claim <serial>
-pnpm dev:mobile:android build <serial>   # validated cached APK only
-apps/mobile/e2e/login.sh <serial>
+apps/mobile/e2e/login.sh "$SERIAL"
 ```
 
-`build` installs a validated cached APK when the Android native fingerprint and toolchain match. Never install an APK from another output path or invoke Gradle directly. Reinstall via `build <serial>` only when the native fingerprint changed, never to reset app state.
+`build` installs a validated cached APK when the Android native fingerprint and toolchain match. Never install an APK from another output path or invoke Gradle directly. Reinstall via `build <serial>` only when the native fingerprint changed, never to reset app state. For rebuilds only, the manual claim and build commands are:
+
+```bash
+pnpm dev:mobile:android claim <serial>   # idempotent
+pnpm dev:mobile:android build <serial>   # validated cached APK only
+```
 
-`build` reads the generated Android project, and `apps/mobile/android/` is git-ignored — a fresh worktree has none. Run `npx expo prebuild --platform android` in `apps/mobile` once before the first `build`; it is codegen only, needs no wrapper, and a missing project is the one failure `build` cannot fix itself.
+`apps/mobile/android/` is git-ignored and a fresh worktree has none. The
+wrapper runs `npx expo prebuild --platform android` when needed; that step is
+codegen only, needs no wrapper, and the generated tree is gitignored.
 
 `login.sh` and `logout.sh` accept an iOS simulator UDID or an Android ADB serial. On Android, `login.sh`'s shared preflight verifies the claim, applies both `adb reverse` mappings (the `nextjs` service's API port and the `mobile` service's Metro port, both from `pnpm dev:status --json` — there is no service named `metro`), and opens the dev-client deep link itself. On the primary path no manual reverse or `am start` is needed.
 
@@ -337,16 +378,19 @@ rm -f "$LOGIN_LOG"
 ```
 
 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:
+conditional resources first (skip any never started), then the stack. An
+iOS-only round has no Android resources to stop, so the Android stop line is
+skipped by the same skip-any-never-started rule:
 
 ```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   # refuses while any resource above is still live
+apps/mobile/e2e/record.sh <udid> stop                                              # every bundle device; idempotent
+apps/mobile/e2e/record.sh <serial> stop                                            # only if android was started
+pnpm dev:mobile:android emulator-stop || true                                      # only if android was started
+pnpm dev:mobile:android release-all || true                                        # only if android was started
+pnpm dev:mobile:simulator release-all
+pnpm dev:stop
 rm -f "$EMULATOR_LOG"
 ```
 
@@ -354,7 +398,7 @@ 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 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.
+Also stop 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/appium.sh b/apps/mobile/e2e/appium.sh
index 661e6b330d9..17dd3a0c8c5 100755
--- a/apps/mobile/e2e/appium.sh
+++ b/apps/mobile/e2e/appium.sh
@@ -4,7 +4,7 @@
 # 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> test [-e KEY=VALUE]... <flow.js> [more-flows.js]
 #   appium.sh <device> hierarchy
 #   appium.sh <device> server start|stop|status
 #   appium.sh <device> --exec <command...>
diff --git a/apps/mobile/e2e/record.sh b/apps/mobile/e2e/record.sh
new file mode 100755
index 00000000000..ef1efca511c
--- /dev/null
+++ b/apps/mobile/e2e/record.sh
@@ -0,0 +1,335 @@
+#!/usr/bin/env bash
+# Segment-scoped screen recorder for E2E evidence. Does NOT take the Appium
+# device lock — recording does not drive the device.
+#
+#   record.sh <udid|serial> start <video-path>
+#   record.sh <udid|serial> stop
+#   record.sh frame <video-path> <hh:mm:ss> <out.png>
+#
+# iOS uses simctl recordVideo (no duration cap). Android uses adb shell
+# screenrecord, which caps at ~3 minutes; record in segments, never one
+# whole-route video. Stop is idempotent so bundle cleanup can call it blindly.
+set -euo pipefail
+
+resolve_adb() {
+  local candidate found
+  found=$(command -v adb 2>/dev/null || true)
+  for candidate in "$found" "${ANDROID_HOME:-}/platform-tools/adb" "$HOME/Library/Android/sdk/platform-tools/adb"; do
+    if [ -n "$candidate" ] && [ -x "$candidate" ]; then
+      printf '%s' "$candidate"
+      return 0
+    fi
+  done
+  return 1
+}
+
+# State is KEY=VALUE lines. Values are base64-encoded so paths with spaces or
+# shell metacharacters round-trip without eval/source. Encode/decode failures
+# are fatal — never silently empty a pid (that would turn stop into a no-op
+# while the recorder keeps running).
+b64_encode() {
+  local out
+  out=$(printf '%s' "$1" | base64 | tr -d '\n') || {
+    echo "record.sh: base64 encode failed" >&2
+    return 1
+  }
+  [ -n "$out" ] || {
+    echo "record.sh: base64 encode produced empty output" >&2
+    return 1
+  }
+  printf '%s' "$out"
+}
+
+b64_decode() {
+  local out
+  out=$(printf '%s' "$1" | base64 -d 2>/dev/null) || {
+    echo "record.sh: base64 decode failed for state value" >&2
+    return 1
+  }
+  printf '%s' "$out"
+}
+
+read_state() {
+  platform='' pid='' path='' remote=''
+  [ -f "$STATE_FILE" ] || return 0
+  local line key value decoded
+  while IFS= read -r line || [ -n "$line" ]; do
+    [ -n "$line" ] || continue
+    key=${line%%=*}
+    value=${line#*=}
+    case "$key" in
+      platform | pid | path | remote)
+        decoded=$(b64_decode "$value") || return 1
+        case "$key" in
+          platform) platform=$decoded ;;
+          pid)
+            [ -n "$decoded" ] || {
+              echo "record.sh: empty pid in state file" >&2
+              return 1
+            }
+            pid=$decoded
+            ;;
+          path) path=$decoded ;;
+          remote) remote=$decoded ;;
+        esac
+        ;;
+    esac
+  done <"$STATE_FILE"
+}
+
+write_state() {
+  # usage: write_state key value ...
+  # Capture encode first so a failed b64_encode is fatal (command-sub status
+  # alone is not enough under set -e for the printf pipeline).
+  local encoded
+  : >"$STATE_FILE"
+  while [ $# -ge 2 ]; do
+    encoded=$(b64_encode "$2") || return 1
+    printf '%s=%s\n' "$1" "$encoded" >>"$STATE_FILE" || return 1
+    shift 2
+  done
+}
+
+clear_state() {
+  rm -rf "$STATE_DIR"
+}
+
+require_dir() {
+  local dir
+  dir=$(dirname "$1")
+  [ -d "$dir" ] || mkdir -p "$dir"
+}
+
+# True when $1 is live and its command line looks like our recorder (not a
+# recycled PID of an unrelated process). Use -ww so BSD ps does not truncate
+# the command column to the terminal width (no-tty default is ~79 cols).
+recorder_pid_live() {
+  local pid=$1 expect=$2 cmd
+  kill -0 "$pid" 2>/dev/null || return 1
+  cmd=$(ps -ww -p "$pid" -o command= 2>/dev/null || ps -p "$pid" -o args= 2>/dev/null || true)
+  [ -n "$cmd" ] || return 1
+  case "$cmd" in
+    *"$expect"*) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+stop_ios() {
+  local pid path waited was_live=0
+  pid=$1
+  path=$2
+  if recorder_pid_live "$pid" "recordVideo"; then
+    was_live=1
+    kill -INT "$pid" 2>/dev/null || true
+    waited=0
+    while [ "$waited" -lt 15 ] && kill -0 "$pid" 2>/dev/null; do
+      sleep 1
+      waited=$((waited + 1))
+    done
+    if kill -0 "$pid" 2>/dev/null; then
+      echo "record.sh: iOS recorder on $DEVICE did not exit after SIGINT" >&2
+      return 2
+    fi
+  fi
+  if [ ! -s "$path" ]; then
+    if [ "$was_live" -eq 1 ]; then
+      echo "record.sh: no finalized video at $path" >&2
+      return 1
+    fi
+    echo "record.sh: no active recording for $DEVICE" >&2
+    return 0
+  fi
+  local size
+  size=$(stat -f%z "$path" 2>/dev/null || stat -c%s "$path" 2>/dev/null || echo 0)
+  echo "$path $size"
+  return 0
+}
+
+stop_android() {
+  local pid path remote adb waited remaining was_live=0
+  pid=$1
+  path=$2
+  remote=${3:-}
+  adb=$(resolve_adb) || { echo "record.sh: adb not found" >&2; return 1; }
+  if recorder_pid_live "$pid" "screenrecord"; then
+    was_live=1
+  fi
+  remaining=$("$adb" -s "$DEVICE" shell pidof screenrecord 2>/dev/null | tr -d '[:space:]') || remaining=''
+  [ -n "$remaining" ] && was_live=1
+  "$adb" -s "$DEVICE" shell pkill -INT screenrecord >/dev/null 2>&1 || true
+  waited=0
+  while [ "$waited" -lt 15 ]; do
+    remaining=$("$adb" -s "$DEVICE" shell pidof screenrecord 2>/dev/null | tr -d '[:space:]') || remaining=''
+    [ -z "$remaining" ] && break
+    sleep 1
+    waited=$((waited + 1))
+  done
+  remaining=$("$adb" -s "$DEVICE" shell pidof screenrecord 2>/dev/null | tr -d '[:space:]') || remaining=''
+  if [ -n "$remaining" ]; then
+    echo "record.sh: Android screenrecord on $DEVICE still running after SIGINT" >&2
+    return 2
+  fi
+  if kill -0 "$pid" 2>/dev/null; then
+    waited=0
+    while [ "$waited" -lt 5 ] && kill -0 "$pid" 2>/dev/null; do
+      sleep 1
+      waited=$((waited + 1))
+    done
+  fi
+  if [ -n "$remote" ]; then
+    "$adb" -s "$DEVICE" pull "$remote" "$path" >/dev/null 2>&1 || true
+    # Drop the remote so a later failed segment cannot pull a prior video.
+    "$adb" -s "$DEVICE" shell rm -f "$remote" >/dev/null 2>&1 || true
+  fi
+  if [ ! -s "$path" ]; then
+    if [ "$was_live" -eq 1 ]; then
+      echo "record.sh: no finalized video at $path" >&2
+      return 1
+    fi
+    echo "record.sh: no active recording for $DEVICE" >&2
+    return 0
+  fi
+  local size
+  size=$(stat -f%z "$path" 2>/dev/null || stat -c%s "$path" 2>/dev/null || echo 0)
+  echo "$path $size"
+  return 0
+}
+
+usage() {
+  echo "usage: record.sh <udid|serial> start <video-path>" >&2
+  echo "       record.sh <udid|serial> stop" >&2
+  echo "       record.sh frame <video-path> <hh:mm:ss> <out.png>" >&2
+  exit 1
+}
+
+if [ "${1:-}" = "frame" ]; then
+  VIDEO="${2:?usage: record.sh frame <video-path> <hh:mm:ss> <out.png>}"
+  TS="${3:?usage: record.sh frame <video-path> <hh:mm:ss> <out.png>}"
+  OUT="${4:?usage: record.sh frame <video-path> <hh:mm:ss> <out.png>}"
+  command -v ffmpeg >/dev/null 2>&1 || { echo "record.sh: ffmpeg not found" >&2; exit 1; }
+  ffmpeg -i "$VIDEO" -ss "$TS" -frames:v 1 -y "$OUT" >/dev/null 2>&1
+  exit 0
+fi
+
+DEVICE="${1:?usage: record.sh <udid|serial> start|stop   or   record.sh frame <video> <ts> <out.png>}"
+shift
+
+STATE_DIR="${TMPDIR:-/tmp}/kilo-e2e-record/$DEVICE"
+STATE_FILE="$STATE_DIR/state"
+
+cmd="${1:-}"
+case "$cmd" in
+  start)
+    VIDEO="${2:?usage: record.sh <device> start <video-path>}"
+    # Corrupt/unreadable prior state must not permanently block the device:
+    # self-clear and start fresh (plan: stale state files self-clear on next start).
+    if ! read_state; then
+      echo "record.sh: clearing unreadable prior state for $DEVICE" >&2
+      clear_state
+    elif [ -n "${pid:-}" ] && kill -0 "$pid" 2>/dev/null; then
+      if recorder_pid_live "$pid" "recordVideo" || recorder_pid_live "$pid" "screenrecord"; then
+        echo "record.sh: already recording on $DEVICE (pid $pid)" >&2
+        exit 1
+      fi
+      # Stale pid recycled by an unrelated process — clear and start fresh.
+    fi
+    clear_state
+    mkdir -p "$STATE_DIR"
+    require_dir "$VIDEO"
+    # Subshell ignores SIGHUP then execs the recorder so $! is the real
+    # process (not a wrapper) and the recorder survives start's exit.
+    # stop SIGINTs that pid to finalize — never SIGKILL.
+    case "$DEVICE" in
+      emulator-*)
+        ADB=$(resolve_adb) || { echo "record.sh: adb not found" >&2; exit 1; }
+        REMOTE="/sdcard/kilo-e2e-record.mp4"
+        # Clear any prior segment so a failed new recording cannot pull stale video.
+        "$ADB" -s "$DEVICE" shell rm -f "$REMOTE" >/dev/null 2>&1 || true
+        (
+          trap '' HUP
+          exec "$ADB" -s "$DEVICE" shell screenrecord --time-limit 170 --size 1280x720 "$REMOTE"
+        ) >/dev/null 2>&1 &
+        write_state platform android pid "$!" path "$VIDEO" remote "$REMOTE"
+        expect=screenrecord
+        ;;
+      *)
+        command -v xcrun >/dev/null 2>&1 || { echo "record.sh: xcrun not found" >&2; exit 1; }
+        (
+          trap '' HUP
+          exec xcrun simctl io "$DEVICE" recordVideo --codec h264 --force "$VIDEO"
+        ) >/dev/null 2>&1 &
+        write_state platform ios pid "$!" path "$VIDEO"
+        expect=recordVideo
+        ;;
+    esac
+    # Give the recorder a beat to install signal handlers, then require liveness.
+    sleep 0.2
+    rec_pid=
+    read_state
+    rec_pid=${pid:-}
+    if [ -z "$rec_pid" ] || ! recorder_pid_live "$rec_pid" "$expect"; then
+      # If the probe is wrong but the pid is still live, SIGINT it before drop.
+      if [ -n "$rec_pid" ] && kill -0 "$rec_pid" 2>/dev/null; then
+        kill -INT "$rec_pid" 2>/dev/null || true
+      fi
+      clear_state
+      echo "record.sh: recorder failed to stay up on $DEVICE" >&2
+      exit 1
+    fi
+    echo "record.sh: started $DEVICE recorder -> $VIDEO" >&2
+    ;;
+
+  stop)
+    if ! read_state; then
+      # Blind cleanup must stay idempotent. Best-effort reap without a readable
+      # pid: android device-wide pkill; iOS match simctl recordVideo for this UDID.
+      echo "record.sh: clearing unreadable state for $DEVICE" >&2
+      case "$DEVICE" in
+        emulator-*)
+          if adb=$(resolve_adb 2>/dev/null); then
+            "$adb" -s "$DEVICE" shell pkill -INT screenrecord >/dev/null 2>&1 || true
+          fi
+          ;;
+        *)
+          # pgrep exits 1 when nothing matches; keep stop idempotent under set -e.
+          orphans=$(pgrep -f "simctl io $DEVICE recordVideo" 2>/dev/null || true)
+          if [ -n "$orphans" ]; then
+            printf '%s\n' "$orphans" | while read -r orphan; do
+              [ -n "$orphan" ] || continue
+              kill -INT "$orphan" 2>/dev/null || true
+            done
+          fi
+          ;;
+      esac
+      clear_state
+      exit 0
+    fi
+    if [ -z "${pid:-}" ]; then
+      echo "record.sh: no active recording for $DEVICE" >&2
+      clear_state
+      exit 0
+    fi
+    case "${platform:-}" in
+      ios)
+        if ! stop_ios "$pid" "${path:-}"; then
+          exit 1
+        fi
+        ;;
+      android)
+        if ! stop_android "$pid" "${path:-}" "${remote:-}"; then
+          exit 1
+        fi
+        ;;
+      *)
+        echo "record.sh: unknown platform '${platform:-}' in state file" >&2
+        clear_state
+        exit 1
+        ;;
+    esac
+    clear_state
+    ;;
+
+  *)
+    usage
+    ;;
+esac
diff --git a/apps/mobile/e2e/remote-cli.sh b/apps/mobile/e2e/remote-cli.sh
index bed528e1740..75aa6b8bbe5 100755
--- a/apps/mobile/e2e/remote-cli.sh
+++ b/apps/mobile/e2e/remote-cli.sh
@@ -69,7 +69,7 @@ prepare_env() {
 
   if [ -z "$nextjs_port" ] || [ -z "$ingest_port" ]; then
     echo "Required services are not up for $REPO_ROOT." >&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 "Start the stack: pnpm dev:start --no-attach 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
diff --git a/dev/local/appium-wrapper.test.ts b/dev/local/appium-wrapper.test.ts
index db6529a6733..0e0cc462b73 100644
--- a/dev/local/appium-wrapper.test.ts
+++ b/dev/local/appium-wrapper.test.ts
@@ -1,7 +1,17 @@
 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';
 
+const repoRoot = process.cwd();
+
+function executable(file: string, contents: string): void {
+  fs.writeFileSync(file, contents);
+  fs.chmodSync(file, 0o755);
+}
+
 const { portsFor, slugFor } = await import('../../apps/mobile/e2e/wdio/ports.js');
 
 test('appium port assignment is deterministic and block-shaped', () => {
@@ -37,3 +47,367 @@ test('appium wrapper rejects a missing device and unknown commands', () => {
   assert.notEqual(unknown.status, 0);
   assert.match(unknown.stderr, /usage: appium\.sh/);
 });
+
+test('record.sh passes bash -n syntax check', () => {
+  const result = spawnSync('bash', ['-n', path.join(repoRoot, 'apps/mobile/e2e/record.sh')], {
+    encoding: 'utf8',
+  });
+  assert.equal(result.status, 0, result.stderr);
+});
+
+function makeXcrunStub(bin: string, signalLog: string, videoData: string): void {
+  const escapedData = videoData.replace(/'/g, "\\'");
+  const script =
+    '#!/usr/bin/env node\n' +
+    "const fs = require('fs');\n" +
+    "const path = require('path');\n" +
+    'const args = process.argv.slice(2);\n' +
+    "const log = process.env.SIGNAL_LOG || '/dev/null';\n" +
+    "const videoData = process.env.VIDEO_DATA || '" +
+    escapedData +
+    "';\n" +
+    "if (args[0] === 'simctl' && args[1] === 'io' && args[3] === 'recordVideo') {\n" +
+    '  const videoPath = args[args.length - 1];\n' +
+    '  fs.mkdirSync(path.dirname(videoPath), { recursive: true });\n' +
+    "  process.on('SIGINT', () => { fs.appendFileSync(log, 'INT\\n'); fs.writeFileSync(videoPath, videoData); process.exit(0); });\n" +
+    "  process.on('SIGTERM', () => { fs.appendFileSync(log, 'TERM\\n'); process.exit(0); });\n" +
+    '  setInterval(() => {}, 1000);\n' +
+    '} else {\n' +
+    '  process.exit(0);\n' +
+    '}\n';
+  executable(path.join(bin, 'xcrun'), script);
+}
+
+function makeFfmpegStub(bin: string): void {
+  executable(
+    path.join(bin, 'ffmpeg'),
+    `#!/usr/bin/env node
+const fs = require('fs');
+const args = process.argv.slice(2);
+const i = args.indexOf('-i');
+const ss = args.indexOf('-ss');
+const y = args.indexOf('-y');
+const input = args[i + 1];
+const ts = args[ss + 1];
+const out = args[y + 1];
+fs.writeFileSync(out, 'frame:' + input + ':' + ts);
+process.exit(0);
+`
+  );
+}
+
+function makeAdbStub(bin: string, remoteDir: string): void {
+  const escapedDir = remoteDir.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+  const script =
+    '#!/usr/bin/env node\n' +
+    "const fs = require('fs');\n" +
+    "const path = require('path');\n" +
+    "const stateDir = process.env.RECORD_ADB_STATE || '" +
+    escapedDir +
+    "';\n" +
+    "const pidFile = path.join(stateDir, 'pid');\n" +
+    "const remoteFile = path.join(stateDir, 'remote.mp4');\n" +
+    "const signalLog = process.env.SIGNAL_LOG || '/dev/null';\n" +
+    "const videoData = process.env.VIDEO_DATA || 'androiddata';\n" +
+    'fs.mkdirSync(stateDir, { recursive: true });\n' +
+    'const args = process.argv.slice(2);\n' +
+    "const cmd = args.join(' ');\n" +
+    "if (cmd.includes('shell screenrecord')) {\n" +
+    '  fs.writeFileSync(pidFile, String(process.pid));\n' +
+    "  process.on('SIGINT', () => { fs.writeFileSync(remoteFile, videoData); fs.rmSync(pidFile, { force: true }); process.exit(0); });\n" +
+    '  setInterval(() => {}, 1000);\n' +
+    "} else if (cmd.includes('pkill -INT screenrecord')) {\n" +
+    '  if (fs.existsSync(pidFile)) {\n' +
+    "    try { process.kill(Number(fs.readFileSync(pidFile, 'utf8')), 'SIGINT'); fs.appendFileSync(signalLog, 'INT(device)\\n'); } catch {}\n" +
+    '  }\n' +
+    '  process.exit(0);\n' +
+    "} else if (cmd.includes('pidof screenrecord')) {\n" +
+    '  if (fs.existsSync(pidFile)) {\n' +
+    "    try { process.kill(Number(fs.readFileSync(pidFile, 'utf8')), 0); } catch { fs.rmSync(pidFile, { force: true }); }\n" +
+    '  }\n' +
+    "  if (fs.existsSync(pidFile)) console.log(fs.readFileSync(pidFile, 'utf8'));\n" +
+    '  process.exit(0);\n' +
+    "} else if (cmd.includes('pull')) {\n" +
+    '  const hostPath = args[args.length - 1];\n' +
+    '  if (fs.existsSync(remoteFile)) fs.copyFileSync(remoteFile, hostPath);\n' +
+    '  process.exit(0);\n' +
+    '} else {\n' +
+    '  process.exit(0);\n' +
+    '}\n';
+  executable(path.join(bin, 'adb'), script);
+}
+
+test('record.sh iOS start/stop finalizes a non-empty video and cleans state', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-record-ios-test-'));
+  const bin = path.join(root, 'bin');
+  const tmp = path.join(root, 'tmp');
+  const signalLog = path.join(root, 'signals.log');
+  fs.mkdirSync(bin);
+  fs.mkdirSync(tmp);
+  makeXcrunStub(bin, signalLog, 'h264data');
+  const video = path.join(tmp, 'video.mp4');
+  const minimalPath = `${bin}:${path.dirname(process.execPath)}:/usr/bin:/bin`;
+  const env = {
+    ...process.env,
+    PATH: minimalPath,
+    TMPDIR: tmp,
+    SIGNAL_LOG: signalLog,
+    VIDEO_DATA: 'h264data',
+  };
+  try {
+    const start = spawnSync(
+      path.join(repoRoot, 'apps/mobile/e2e/record.sh'),
+      ['UDID-123', 'start', video],
+      {
+        encoding: 'utf8',
+        env,
+      }
+    );
+    assert.equal(start.status, 0, start.stderr);
+    assert.ok(fs.existsSync(path.join(tmp, 'kilo-e2e-record', 'UDID-123', 'state')));
+    const second = spawnSync(
+      path.join(repoRoot, 'apps/mobile/e2e/record.sh'),
+      ['UDID-123', 'start', video],
+      {
+        encoding: 'utf8',
+        env,
+      }
+    );
+    assert.notEqual(second.status, 0);
+    assert.match(second.stderr, /already recording/);
+
+    const stop = spawnSync(path.join(repoRoot, 'apps/mobile/e2e/record.sh'), ['UDID-123', 'stop'], {
+      encoding: 'utf8',
+      env,
+    });
+    assert.equal(stop.status, 0, stop.stderr);
+    assert.equal(stop.stdout.trim(), `${video} 8`);
+    assert.equal(fs.readFileSync(video, 'utf8'), 'h264data');
+    assert.ok(!fs.existsSync(path.join(tmp, 'kilo-e2e-record', 'UDID-123')));
+    const signals = fs.readFileSync(signalLog, 'utf8');
+    assert.ok(signals.includes('INT'));
+    assert.ok(!signals.includes('TERM'));
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('record.sh Android start/stop finalizes a non-empty video and cleans state', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-record-android-test-'));
+  const bin = path.join(root, 'bin');
+  const tmp = path.join(root, 'tmp');
+  const adbState = path.join(root, 'adb-state');
+  const signalLog = path.join(root, 'signals.log');
+  fs.mkdirSync(bin);
+  fs.mkdirSync(tmp);
+  makeAdbStub(bin, adbState);
+  const video = path.join(tmp, 'video.mp4');
+  const minimalPath = `${bin}:${path.dirname(process.execPath)}:/usr/bin:/bin`;
+  const env = {
+    ...process.env,
+    PATH: minimalPath,
+    TMPDIR: tmp,
+    RECORD_ADB_STATE: adbState,
+    SIGNAL_LOG: signalLog,
+    VIDEO_DATA: 'androiddata',
+  };
+  try {
+    const start = spawnSync(
+      path.join(repoRoot, 'apps/mobile/e2e/record.sh'),
+      ['emulator-5554', 'start', video],
+      {
+        encoding: 'utf8',
+        env,
+      }
+    );
+    assert.equal(start.status, 0, start.stderr);
+    assert.ok(fs.existsSync(path.join(tmp, 'kilo-e2e-record', 'emulator-5554', 'state')));
+    const stop = spawnSync(
+      path.join(repoRoot, 'apps/mobile/e2e/record.sh'),
+      ['emulator-5554', 'stop'],
+      {
+        encoding: 'utf8',
+        env,
+      }
+    );
+    assert.equal(stop.status, 0, stop.stderr);
+    assert.equal(stop.stdout.trim(), `${video} 11`);
+    assert.equal(fs.readFileSync(video, 'utf8'), 'androiddata');
+    assert.ok(!fs.existsSync(path.join(tmp, 'kilo-e2e-record', 'emulator-5554')));
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('record.sh stop is a no-op when state is stale and video is missing', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-record-stale-stop-'));
+  const tmp = path.join(root, 'tmp');
+  fs.mkdirSync(path.join(tmp, 'kilo-e2e-record', 'UDID-STALE'), { recursive: true });
+  // Guaranteed-dead PID on Linux and macOS (pid 1 is init and kill -0 succeeds).
+  // State values are base64-encoded (see record.sh write_state).
+  const b64 = (s: string) => Buffer.from(s).toString('base64');
+  fs.writeFileSync(
+    path.join(tmp, 'kilo-e2e-record', 'UDID-STALE', 'state'),
+    `platform=${b64('ios')}\npid=${b64('999999')}\npath=${b64(path.join(tmp, 'missing.mp4'))}\n`
+  );
+  try {
+    const stop = spawnSync(
+      path.join(repoRoot, 'apps/mobile/e2e/record.sh'),
+      ['UDID-STALE', 'stop'],
+      {
+        encoding: 'utf8',
+        env: { ...process.env, TMPDIR: tmp },
+      }
+    );
+    assert.equal(stop.status, 0, stop.stderr);
+    assert.ok(!fs.existsSync(path.join(tmp, 'kilo-e2e-record', 'UDID-STALE')));
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('record.sh stop fails when a live recorder exits without a video', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-record-empty-live-'));
+  const bin = path.join(root, 'bin');
+  const tmp = path.join(root, 'tmp');
+  fs.mkdirSync(bin);
+  fs.mkdirSync(tmp);
+  // Stub exits on SIGINT without writing the video file.
+  makeXcrunStub(bin, path.join(root, 'signals.log'), '');
+  // Override to write empty / nothing: replace VIDEO_DATA with empty and
+  // patch behavior via env — use a custom stub that deletes any path on INT.
+  executable(
+    path.join(bin, 'xcrun'),
+    `#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const args = process.argv.slice(2);
+if (args[0] === 'simctl' && args[1] === 'io' && args[3] === 'recordVideo') {
+  const videoPath = args[args.length - 1];
+  fs.mkdirSync(path.dirname(videoPath), { recursive: true });
+  process.on('SIGINT', () => { try { fs.unlinkSync(videoPath); } catch {} process.exit(0); });
+  setInterval(() => {}, 1000);
+} else process.exit(0);
+`
+  );
+  const video = path.join(tmp, 'video.mp4');
+  const env = {
+    ...process.env,
+    PATH: `${bin}:${path.dirname(process.execPath)}:/usr/bin:/bin`,
+    TMPDIR: tmp,
+  };
+  try {
+    const start = spawnSync(
+      path.join(repoRoot, 'apps/mobile/e2e/record.sh'),
+      ['UDID-E', 'start', video],
+      {
+        encoding: 'utf8',
+        env,
+      }
+    );
+    assert.equal(start.status, 0, start.stderr);
+    const stop = spawnSync(path.join(repoRoot, 'apps/mobile/e2e/record.sh'), ['UDID-E', 'stop'], {
+      encoding: 'utf8',
+      env,
+    });
+    assert.notEqual(stop.status, 0);
+    assert.match(stop.stderr, /no finalized video/);
+    // State retained so a retry is possible.
+    assert.ok(fs.existsSync(path.join(tmp, 'kilo-e2e-record', 'UDID-E', 'state')));
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('record.sh start recovers from corrupt prior state', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-record-corrupt-start-'));
+  const bin = path.join(root, 'bin');
+  const tmp = path.join(root, 'tmp');
+  const signalLog = path.join(root, 'signals.log');
+  fs.mkdirSync(bin);
+  fs.mkdirSync(tmp);
+  makeXcrunStub(bin, signalLog, 'h264data');
+  fs.mkdirSync(path.join(tmp, 'kilo-e2e-record', 'UDID-C'), { recursive: true });
+  fs.writeFileSync(
+    path.join(tmp, 'kilo-e2e-record', 'UDID-C', 'state'),
+    'platform=not-valid-base64!!!\n'
+  );
+  const video = path.join(tmp, 'video.mp4');
+  const env = {
+    ...process.env,
+    PATH: `${bin}:${path.dirname(process.execPath)}:/usr/bin:/bin`,
+    TMPDIR: tmp,
+    SIGNAL_LOG: signalLog,
+    VIDEO_DATA: 'h264data',
+  };
+  try {
+    const start = spawnSync(
+      path.join(repoRoot, 'apps/mobile/e2e/record.sh'),
+      ['UDID-C', 'start', video],
+      {
+        encoding: 'utf8',
+        env,
+      }
+    );
+    assert.equal(start.status, 0, start.stderr);
+    const stop = spawnSync(path.join(repoRoot, 'apps/mobile/e2e/record.sh'), ['UDID-C', 'stop'], {
+      encoding: 'utf8',
+      env,
+    });
+    assert.equal(stop.status, 0, stop.stderr);
+    assert.equal(fs.readFileSync(video, 'utf8'), 'h264data');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('record.sh frame invokes ffmpeg input-first and extracts a frame', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-record-frame-test-'));
+  const bin = path.join(root, 'bin');
+  fs.mkdirSync(bin);
+  makeFfmpegStub(bin);
+  const video = path.join(root, 'video.mp4');
+  const out = path.join(root, 'frame.png');
+  fs.writeFileSync(video, 'dummy');
+  const minimalPath = `${bin}:${path.dirname(process.execPath)}:/usr/bin:/bin`;
+  const env = { ...process.env, PATH: minimalPath };
+  try {
+    const result = spawnSync(
+      path.join(repoRoot, 'apps/mobile/e2e/record.sh'),
+      ['frame', video, '00:01:23', out],
+      {
+        encoding: 'utf8',
+        env,
+      }
+    );
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(fs.readFileSync(out, 'utf8'), `frame:${video}:00:01:23`);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('record.sh frame fails loudly when ffmpeg is missing', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kilo-record-frame-missing-test-'));
+  const bin = path.join(root, 'bin');
+  fs.mkdirSync(bin);
+  const video = path.join(root, 'video.mp4');
+  const out = path.join(root, 'frame.png');
+  fs.writeFileSync(video, 'dummy');
+  const minimalPath = `${bin}:${path.dirname(process.execPath)}:/usr/bin:/bin`;
+  const env = { ...process.env, PATH: minimalPath };
+  try {
+    const result = spawnSync(
+      path.join(repoRoot, 'apps/mobile/e2e/record.sh'),
+      ['frame', video, '00:00:01', out],
+      {
+        encoding: 'utf8',
+        env,
+      }
+    );
+    assert.notEqual(result.status, 0);
+    assert.match(result.stderr, /ffmpeg not found/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
diff --git a/dev/local/mobile-simulator.ts b/dev/local/mobile-simulator.ts
index 3138eceaa48..a705e58abab 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-take-slot.sh), so no
+// machine-global slot semaphore (external multi-agent tooling), so no
 // heavier ownership protocol is needed here.
 type ClaimRecord = {
   deviceId?: string;
@@ -469,7 +469,7 @@ 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-stop-resource.sh ios`, which stops a resource without
+// external stop-resource wrappers, which stop 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.
diff --git a/dev/local/workflow-scripts.test.ts b/dev/local/workflow-scripts.test.ts
deleted file mode 100644
index 2f7bf285de9..00000000000
--- a/dev/local/workflow-scripts.test.ts
+++ /dev/null
@@ -1,729 +0,0 @@
-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);
-  // 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,
-    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', wt, 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');
-    // 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')
-      .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: %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 = {
-    ...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[] = [], cwd: string = repoRoot) =>
-      spawnSync(path.join(repoRoot, '.kilo_workflow', script), args, {
-        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);
-    // 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'),
-      `${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 });
-  }
-});
-
-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":[]}'
-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
-`
-  );
-  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 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');
-  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/scripts/worktree-prepare.sh b/scripts/worktree-prepare.sh
index 52a12147fa8..03283cb91c6 100755
--- a/scripts/worktree-prepare.sh
+++ b/scripts/worktree-prepare.sh
@@ -103,13 +103,6 @@ if [ "$MAIN_WORKTREE_REALPATH" != "$CURRENT_WORKTREE_REALPATH" ] &&
   cp "$MAIN_WORKTREE/apps/mobile/.env.local" ./apps/mobile/.env.local
 fi
 
-if [ "$MAIN_WORKTREE_REALPATH" != "$CURRENT_WORKTREE_REALPATH" ] &&
-  [ -d "$MAIN_WORKTREE/.kilo_workflow/learnings/system" ]; then
-  echo "==> Copying machine-local workflow learnings from main worktree…"
-  mkdir -p .kilo_workflow/learnings/system
-  cp -R "$MAIN_WORKTREE/.kilo_workflow/learnings/system/." .kilo_workflow/learnings/system/
-fi
-
 if command -v direnv >/dev/null 2>&1 && [ -f apps/mobile/.envrc ]; then
   echo "==> Authorizing this worktree's mobile direnv config…"
   direnv allow ./apps/mobile