docs(changelog): add android notification tap fix

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.dockerignore

@@ -0,0 +1,48 @@
+.git
+.worktrees
+.bun-cache
+.bun
+.tmp
+**/.tmp
+.DS_Store
+**/.DS_Store
+*.png
+*.jpg
+*.jpeg
+*.webp
+*.gif
+*.mp4
+*.mov
+*.wav
+*.mp3
+node_modules
+**/node_modules
+.pnpm-store
+**/.pnpm-store
+.turbo
+**/.turbo
+.cache
+**/.cache
+.next
+**/.next
+coverage
+**/coverage
+*.log
+tmp
+**/tmp
+
+# build artifacts
+dist
+**/dist
+apps/macos/.build
+apps/ios/build
+**/*.trace
+
+# large app trees not needed for CLI build
+apps/
+assets/
+Peekaboo/
+Swabble/
+Core/
+Users/
+vendor/

.github/workflows/ci.yml

@@ -5,12 +5,33 @@ on:
   pull_request:
 
 jobs:
-  build:
+  checks:
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
-        runtime: [node, bun]
+        include:
+          - runtime: node
+            task: lint
+            command: pnpm lint
+          - runtime: node
+            task: test
+            command: pnpm test
+          - runtime: node
+            task: build
+            command: pnpm build
+          - runtime: node
+            task: protocol
+            command: pnpm protocol:check
+          - runtime: bun
+            task: lint
+            command: bunx biome check src
+          - runtime: bun
+            task: test
+            command: bunx vitest run
+          - runtime: bun
+            task: build
+            command: bunx tsc -p tsconfig.json
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -77,37 +98,42 @@ jobs:
           pnpm -v
           pnpm install --ignore-scripts=false --config.engine-strict=false --config.enable-pre-post-scripts=true || pnpm install --ignore-scripts=false --config.engine-strict=false --config.enable-pre-post-scripts=true
 
-      - name: Lint (node)
-        if: matrix.runtime == 'node'
-        run: pnpm lint
-
-      - name: Test (node)
-        if: matrix.runtime == 'node'
-        run: pnpm test
-
-      - name: Build (node)
-        if: matrix.runtime == 'node'
-        run: pnpm build
-
-      - name: Protocol check (node)
-        if: matrix.runtime == 'node'
-        run: pnpm protocol:check
-
-      - name: Lint (bun)
-        if: matrix.runtime == 'bun'
-        run: bunx biome check src
-
-      - name: Test (bun)
-        if: matrix.runtime == 'bun'
-        run: bunx vitest run
-
-      - name: Build (bun)
-        if: matrix.runtime == 'bun'
-        run: bunx tsc -p tsconfig.json
+      - name: Run ${{ matrix.task }} (${{ matrix.runtime }})
+        run: ${{ matrix.command }}
 
   macos-app:
     if: github.event_name == 'pull_request'
     runs-on: macos-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - task: lint
+            command: |
+              swiftlint --config .swiftlint.yml
+              swiftformat --lint apps/macos/Sources --config .swiftformat
+          - task: build
+            command: |
+              set -euo pipefail
+              for attempt in 1 2 3; do
+                if swift build --package-path apps/macos --configuration release; then
+                  exit 0
+                fi
+                echo "swift build failed (attempt $attempt/3). Retrying…"
+                sleep $((attempt * 20))
+              done
+              exit 1
+          - task: test
+            command: |
+              set -euo pipefail
+              for attempt in 1 2 3; do
+                if swift test --package-path apps/macos --parallel --enable-code-coverage --show-codecov-path; then
+                  exit 0
+                fi
+                echo "swift test failed (attempt $attempt/3). Retrying…"
+                sleep $((attempt * 20))
+              done
+              exit 1
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -142,35 +168,8 @@ jobs:
           xcodebuild -version
           swift --version
 
-      - name: SwiftLint
-        run: swiftlint --config .swiftlint.yml
-
-      - name: SwiftFormat (lint mode)
-        run: swiftformat --lint apps/macos/Sources --config .swiftformat
-
-      - name: Swift build (release)
-        run: |
-          set -euo pipefail
-          for attempt in 1 2 3; do
-            if swift build --package-path apps/macos --configuration release; then
-              exit 0
-            fi
-            echo "swift build failed (attempt $attempt/3). Retrying…"
-            sleep $((attempt * 20))
-          done
-          exit 1
-
-      - name: Swift tests (coverage)
-        run: |
-          set -euo pipefail
-          for attempt in 1 2 3; do
-            if swift test --package-path apps/macos --parallel --enable-code-coverage --show-codecov-path; then
-              exit 0
-            fi
-            echo "swift test failed (attempt $attempt/3). Retrying…"
-            sleep $((attempt * 20))
-          done
-          exit 1
+      - name: Run ${{ matrix.task }}
+        run: ${{ matrix.command }}
   ios:
     if: false # ignore iOS in CI for now
     runs-on: macos-latest
@@ -346,6 +345,14 @@ jobs:
 
   android:
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - task: test
+            command: ./gradlew --no-daemon :app:testDebugUnitTest
+          - task: build
+            command: ./gradlew --no-daemon :app:assembleDebug
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -385,6 +392,6 @@ jobs:
             "platforms;android-36" \
             "build-tools;36.0.0"
 
-      - name: Android unit tests + debug build
+      - name: Run Android ${{ matrix.task }}
         working-directory: apps/android
-        run: ./gradlew --no-daemon :app:testDebugUnitTest :app:assembleDebug
+        run: ${{ matrix.command }}

.gitignore

@@ -9,17 +9,20 @@ coverage
 .DS_Store
 **/.DS_Store
 ui/src/ui/__screenshots__/
+ui/playwright-report/
+ui/test-results/
 
 # Bun build artifacts
 *.bun-build
 apps/macos/.build/
-apps/shared/ClawdisKit/.build/
+apps/shared/ClawdbotKit/.build/
+**/ModuleCache/
 bin/
-bin/clawdis-mac
+bin/clawdbot-mac
 bin/docs-list
 apps/macos/.build-local/
 apps/macos/.swiftpm/
-apps/shared/ClawdisKit/.swiftpm/
+apps/shared/ClawdbotKit/.swiftpm/
 Core/
 apps/ios/*.xcodeproj/
 apps/ios/*.xcworkspace/
@@ -28,6 +31,7 @@ vendor/
 
 # Vendor build artifacts
 vendor/a2ui/renderers/lit/dist/
+.bundle.hash
 
 # fastlane (iOS)
 apps/ios/fastlane/README.md
@@ -43,3 +47,4 @@ apps/ios/*.dSYM.zip
 
 # provisioning profiles (local)
 apps/ios/*.mobileprovision
+.env

.npmrc

@@ -1 +1 @@
-allow-build-scripts=@whiskeysockets/baileys,sharp,esbuild,protobufjs,fs-ext
+allow-build-scripts=@whiskeysockets/baileys,sharp,esbuild,protobufjs,fs-ext,node-pty

.swiftlint.yml

@@ -108,6 +108,10 @@ function_body_length:
   warning: 150
   error: 300
 
+function_parameter_count:
+  warning: 7
+  error: 10
+
 file_length:
   warning: 1500
   error: 2500

AGENTS.md

@@ -7,7 +7,7 @@
 
 ## Build, Test, and Development Commands
 - Install deps: `pnpm install`
-- Run CLI in dev: `pnpm clawdis ...` (tsx entry) or `pnpm dev` for `src/index.ts`.
+- Run CLI in dev: `pnpm clawdbot ...` (tsx entry) or `pnpm dev` for `src/index.ts`.
 - Type-check/build: `pnpm build` (tsc)
 - Lint/format: `pnpm lint` (biome check), `pnpm format` (biome format)
 - Tests: `pnpm test` (vitest); coverage: `pnpm test:coverage`
@@ -32,15 +32,16 @@
 - PRs should summarize scope, note testing performed, and mention any user-facing changes or new flags.
 
 ## Security & Configuration Tips
-- Web provider stores creds at `~/.clawdis/credentials/`; rerun `clawdis login` if logged out.
-- Pi sessions live under `~/.clawdis/sessions/` by default; the base directory is not configurable.
+- Web provider stores creds at `~/.clawdbot/credentials/`; rerun `clawdbot login` if logged out.
+- Pi sessions live under `~/.clawdbot/sessions/` by default; the base directory is not configurable.
 - Never commit or publish real phone numbers, videos, or live configuration values. Use obviously fake placeholders in docs, tests, and examples.
 
 ## Agent-Specific Notes
-- Gateway currently runs only as the menubar app (launchctl shows `application.com.steipete.clawdis.debug.*`), there is no separate LaunchAgent/helper label installed. Restart via the Clawdis Mac app or `scripts/restart-mac.sh`; to verify/kill use `launchctl print gui/$UID | grep clawdis` rather than expecting `com.steipete.clawdis`. **When debugging on macOS, start/stop the gateway via the app, not ad-hoc tmux sessions; kill any temporary tunnels before handoff.**
-- macOS logs: use `./scripts/clawlog.sh` (aka `vtlog`) to query unified logs for subsystem `com.steipete.clawdis`; it supports follow/tail/category filters and expects passwordless sudo for `/usr/bin/log`.
+- Gateway currently runs only as the menubar app (launchctl shows `application.com.steipete.clawdbot.debug.*`), there is no separate LaunchAgent/helper label installed. Restart via the Clawdbot Mac app or `scripts/restart-mac.sh`; to verify/kill use `launchctl print gui/$UID | grep clawdbot` rather than expecting `com.steipete.clawdbot`. **When debugging on macOS, start/stop the gateway via the app, not ad-hoc tmux sessions; kill any temporary tunnels before handoff.**
+- macOS logs: use `./scripts/clawlog.sh` (aka `vtlog`) to query unified logs for subsystem `com.steipete.clawdbot`; it supports follow/tail/category filters and expects passwordless sudo for `/usr/bin/log`.
 - Also read the shared guardrails at `~/Projects/oracle/AGENTS.md` and `~/Projects/agent-scripts/AGENTS.MD` before making changes; align with any cross-repo rules noted there.
 - SwiftUI state management (iOS/macOS): prefer the `Observation` framework (`@Observable`, `@Bindable`) over `ObservableObject`/`@StateObject`; don’t introduce new `ObservableObject` unless required for compatibility, and migrate existing usages when touching related code.
+- Connection providers: when adding a new connection, update every UI surface and docs (macOS app, web UI, mobile if applicable, onboarding/overview docs) and add matching status + configuration forms so provider lists and settings stay in sync.
 - **Restart apps:** “restart iOS/Android apps” means rebuild (recompile/install) and relaunch, not just kill/launch.
 - **Device checks:** before testing, verify connected real devices (iOS/Android) before reaching for simulators/emulators.
 - iOS Team ID lookup: `security find-identity -p codesigning -v` → use Apple Development (…) TEAMID. Fallback: `defaults read com.apple.dt.Xcode IDEProvisioningTeamIdentifiers`.
@@ -51,26 +52,27 @@
 - **Multi-agent safety:** do **not** create/remove/modify `git worktree` checkouts (or edit `.worktrees/*`) unless Peter explicitly asks.
 - **Multi-agent safety:** do **not** switch branches / check out a different branch unless Peter explicitly asks.
 - **Multi-agent safety:** running multiple agents is OK as long as each agent has its own session.
-- When asked to open a “session” file, open the Pi session logs under `~/.clawdis/sessions/*.jsonl` (newest unless a specific ID is given), not the default `sessions.json`. If logs are needed from Mac Studio, SSH via Tailscale and read the same path there.
-- Menubar dimming + restart flow mirrors Trimmy: use `scripts/restart-mac.sh` (kills all Clawdis variants, runs `swift build`, packages, relaunches). Icon dimming depends on MenuBarExtraAccess wiring in AppMain; keep `appearsDisabled` updates intact when touching the status item.
+- When asked to open a “session” file, open the Pi session logs under `~/.clawdbot/sessions/*.jsonl` (newest unless a specific ID is given), not the default `sessions.json`. If logs are needed from Mac Studio, SSH via Tailscale and read the same path there.
+- Menubar dimming + restart flow mirrors Trimmy: use `scripts/restart-mac.sh` (kills all Clawdbot variants, runs `swift build`, packages, relaunches). Icon dimming depends on MenuBarExtraAccess wiring in AppMain; keep `appearsDisabled` updates intact when touching the status item.
+- Do not rebuild the macOS app over SSH; rebuilds must be run directly on the Mac.
 - Never send streaming/partial replies to external messaging surfaces (WhatsApp, Telegram); only final replies should be delivered there. Streaming/tool events may still go to internal UIs/control channel.
 - Voice wake forwarding tips:
-  - Command template should stay `clawdis-mac agent --message "${text}" --thinking low`; `VoiceWakeForwarder` already shell-escapes `${text}`. Don’t add extra quotes.
-  - launchd PATH is minimal; ensure the app’s launch agent sets PATH to include `/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Users/steipete/Library/pnpm` so `pnpm`/`clawdis` binaries resolve when invoked via `clawdis-mac`.
-  - For manual `clawdis send` messages that include `!`, use the heredoc pattern noted below to avoid the Bash tool’s escaping.
+  - Command template should stay `clawdbot-mac agent --message "${text}" --thinking low`; `VoiceWakeForwarder` already shell-escapes `${text}`. Don’t add extra quotes.
+  - launchd PATH is minimal; ensure the app’s launch agent sets PATH to include `/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Users/steipete/Library/pnpm` so `pnpm`/`clawdbot` binaries resolve when invoked via `clawdbot-mac`.
+  - For manual `clawdbot send` messages that include `!`, use the heredoc pattern noted below to avoid the Bash tool’s escaping.
 
 ## Exclamation Mark Escaping Workaround
-The Claude Code Bash tool escapes `!` to `\\!` in command arguments. When using `clawdis send` with messages containing exclamation marks, use heredoc syntax:
+The Claude Code Bash tool escapes `!` to `\\!` in command arguments. When using `clawdbot send` with messages containing exclamation marks, use heredoc syntax:
 
 ```bash
 # WRONG - will send "Hello\\!" with backslash
-clawdis send --to "+1234" --message 'Hello!'
+clawdbot send --to "+1234" --message 'Hello!'
 
 # CORRECT - use heredoc to avoid escaping
-clawdis send --to "+1234" --message "$(cat <<'EOF'
+clawdbot send --to "+1234" --message "$(cat <<'EOF'
 Hello!
 EOF
 )"
 ```
 
-This is a Claude Code quirk, not a clawdis bug.
+This is a Claude Code quirk, not a clawdbot bug.

CHANGELOG.md

@@ -1,418 +1,110 @@
 # Changelog
 
-## 2.0.0-beta5 — Unreleased
+**Why this looks different:** the project was renamed from **Clawdis → Clawdbot**. To make the transition clear, releases now use **date-based versions** (`YYYY.M.D`) and the changelog is **compressed** into milestone summaries. Full detail still lives in git history and the docs.
 
-### Breaking
-- Skills config schema moved under `skills.*`:
-  - `skillsLoad.extraDirs` → `skills.load.extraDirs`
-  - `skillsInstall.*` → `skills.install.*`
-  - per-skill config map moved to `skills.entries` (e.g. `skills.peekaboo.enabled` → `skills.entries.peekaboo.enabled`)
-  - new optional bundled allowlist: `skills.allowBundled` (only affects bundled skills)
-
-### Features
-- Talk mode: continuous speech conversations (macOS/iOS/Android) with ElevenLabs TTS, reply directives, and optional interrupt-on-speech.
-- UI: add optional `ui.seamColor` accent to tint the Talk Mode side bubble (macOS/iOS/Android).
-- Nix mode: opt-in declarative config + read-only settings UI when `CLAWDIS_NIX_MODE=1` (thanks @joshp123 for the persistence — earned my trust; I'll merge these going forward).
-- Agent runtime: accept legacy `Z_AI_API_KEY` for Z.AI provider auth (maps to `ZAI_API_KEY`).
-- Tests: add a Z.AI live test gate for smoke validation when keys are present.
-- macOS Debug: add app log verbosity and rolling file log toggle for swift-log-backed app logs.
+## Unreleased
 
 ### Fixes
-- macOS codesign: skip hardened runtime for ad-hoc signing and avoid empty options args (#70) — thanks @petter-b
-- Docs/agent tools: clarify that browser `wait` should be avoided by default and used only in exceptional cases.
-- Browser tools: `upload` supports auto-click refs, direct `inputRef`/`element` file inputs, and emits input/change after `setFiles` so JS-heavy sites pick up attachments.
-- macOS: Voice Wake now fully tears down the Speech pipeline when disabled (cancel pending restarts, drop stale callbacks) to avoid high CPU in the background.
-- macOS menu: add a Talk Mode action alongside the Open Dashboard/Chat/Canvas entries.
-- macOS Debug: hide “Restart Gateway” when the app won’t start a local gateway (remote mode / attach-only).
-- macOS Talk Mode: orb overlay refresh, ElevenLabs request logging, API key status in settings, and auto-select first voice when none is configured.
-- macOS Talk Mode: add hard timeout around ElevenLabs TTS synthesis to avoid getting stuck “speaking” forever on hung requests.
-- macOS Talk Mode: avoid stuck playback when the audio player never starts (fail-fast + watchdog).
-- macOS Talk Mode: fix audio stop ordering so disabling Talk Mode always stops in-flight playback.
-- macOS Talk Mode: throttle audio-level updates (avoid per-buffer task creation) to reduce CPU/task churn.
-- macOS Talk Mode: increase overlay window size so wave rings don’t clip; close button is hover-only and closer to the orb.
-- Talk Mode: fall back to system TTS when ElevenLabs is unavailable, returns non-audio, or playback fails (macOS/iOS/Android).
-- Talk Mode: stream PCM on macOS/iOS for lower latency (incremental playback); Android continues MP3 streaming.
-- Talk Mode: validate ElevenLabs v3 stability and latency tier directives before sending requests.
-- iOS/Android Talk Mode: auto-select the first ElevenLabs voice when none is configured.
-- ElevenLabs: add retry/backoff for 429/5xx and include content-type in errors for debugging.
-- Talk Mode: align to the gateway’s main session key and fall back to history polling when chat events drop (prevents stuck “thinking” / missing messages).
-- Talk Mode: treat history timestamps as seconds or milliseconds to avoid stale assistant picks (macOS/iOS/Android).
-- Chat UI: clear streaming/tool bubbles when external runs finish, preventing duplicate assistant bubbles.
-- Chat UI: user bubbles use `ui.seamColor` (fallback to a calmer default blue).
-- Android Chat UI: use `onPrimary` for user bubble text to preserve contrast (thanks @Syhids).
-- Control UI: sync sidebar navigation with the URL for deep-linking, and auto-scroll chat to the latest message.
-- Control UI: disable Web Chat + Talk when no iOS/Android node is connected; refreshed Web Chat styling and keyboard send.
-- macOS Web Chat: fix composer layout so the connection pill and send button stay inside the input field.
-- macOS: bundle Control UI assets into the app relay so the packaged app can serve them (thanks @mbelinky).
-- Talk Mode: wait for chat history to surface the assistant reply before starting TTS (macOS/iOS/Android).
-- iOS Talk Mode: fix chat completion wait to time out even if no events arrive (prevents “Thinking…” hangs).
-- iOS Talk Mode: keep recognition running during playback to support interrupt-on-speech.
-- iOS Talk Mode: preserve directive voice/model overrides across config reloads and add ElevenLabs request timeouts.
-- iOS/Android Talk Mode: explicitly `chat.subscribe` when Talk Mode is active, so completion events arrive even if the Chat UI isn’t open.
-- Chat UI: refresh history when another client finishes a run in the same session, so Talk Mode + Voice Wake transcripts appear consistently.
-- Gateway: `voice.transcript` now also maps agent bus output to `chat` events, ensuring chat UIs refresh for voice-triggered runs.
-- iOS/Android: show a centered Talk Mode orb overlay while Talk Mode is enabled.
-- Gateway config: inject `talk.apiKey` from `ELEVENLABS_API_KEY`/shell profile so nodes can fetch it on demand.
-- Canvas A2UI: tag requests with `platform=android|ios|macos` and boost Android canvas background contrast.
-- iOS/Android nodes: enable scrolling for loaded web pages in the Canvas WebView (default scaffold stays touch-first).
-- macOS menu: device list now uses `node.list` (devices only; no agent/tool presence entries).
-- macOS menu: device list now shows connected nodes only.
-- macOS menu: device rows now pack platform/version on the first line, and command lists wrap in submenus.
-- macOS menu: split device platform/version across first and second rows for better fit.
-- iOS node: fix ReplayKit screen recording crash caused by queue isolation assertions during capture.
-- iOS Talk Mode: avoid audio tap queue assertions when starting recognition.
-- macOS: use $HOME/Library/pnpm for SSH PATH exports (thanks @mbelinky).
-- iOS/Android nodes: bridge auto-connect refreshes stale tokens and settings now show richer bridge/device details.
-- macOS: bundle device model resources to prevent Instances crashes (thanks @mbelinky).
-- iOS/Android nodes: status pill now surfaces camera activity instead of overlay toasts.
-- iOS/Android/macOS nodes: camera snaps recompress to keep base64 payloads under 5 MB.
-- iOS/Android nodes: status pill now surfaces pairing, screen recording, voice wake, and foreground-required states.
-- iOS/Android nodes: avoid duplicating “Gateway reconnecting…” when the bridge is already connecting.
-- iOS/Android nodes: Talk Mode now lives on a side bubble (with an iOS toggle to hide it), and Android settings no longer show the Talk Mode switch.
-- macOS menu: top status line now shows pending node pairing approvals (incl. repairs).
-- CLI: avoid spurious gateway close errors after successful request/response cycles.
-- Agent runtime: clamp tool-result images to the 5MB Anthropic limit to avoid hard request rejections.
-- Tests: add Swift Testing coverage for camera errors and Kotest coverage for Android bridge endpoints.
+- Android: tapping the foreground service notification brings the app to the front. (#179) — thanks @Syhids
+- Cron tool passes `id` to the gateway for update/remove/run/runs (keeps `jobId` input). (#180) — thanks @adamgall
 
-## 2.0.0-beta4 — 2025-12-27
 
-### Fixes
-- Package contents: include Discord/hooks build outputs in the npm tarball to avoid missing module errors.
-- Heartbeat replies now drop any output containing `HEARTBEAT_OK`, preventing stray emoji/text from being delivered.
-- macOS menu now refreshes the control channel after the gateway starts and shows “Connecting to gateway…” while the gateway is coming up.
-- macOS local mode now waits for the gateway to be ready before configuring the control channel, avoiding false “no connection” flashes.
-- WhatsApp watchdog now forces a reconnect even if the socket close event stalls (force-close to unblock reconnect loop).
-- Gateway presence now reports macOS product version (via `sw_vers`) instead of Darwin kernel version.
-
-## 2.0.0-beta3 — 2025-12-27
+## 2026.1.4
 
 ### Highlights
-- First-class Clawdis tools (browser, canvas, nodes, cron) replace the old `clawdis-*` skills; tool schemas are now injected directly into the agent runtime.
-- Per-session model selection + custom model providers: `models.providers` merges into `~/.clawdis/agent/models.json` (merge/replace modes) for LiteLLM, local OpenAI-compatible servers, Anthropic proxies, etc.
-- Group chat activation modes: per-group `/activation mention|always` command with status visibility.
-- Discord bot transport for DMs and guild text channels, with allowlists + mention gating.
-- Gateway webhooks: external `wake` and isolated `agent` hooks with dedicated token auth.
-- Hook mappings + Gmail Pub/Sub helper (`clawdis hooks gmail setup/run`) with auto-renew + Tailscale Funnel support.
-- Command queue modes + per-session overrides (`/queue ...`) and new `agent.maxConcurrent` cap for safe parallelism across sessions.
-- Background bash tasks: `bash` auto-yields after 20s (or on demand) with a `process` tool to list/poll/log/write/kill sessions.
-- Gateway in-process restart: `clawdis_gateway` tool action triggers a SIGUSR1 restart without needing a supervisor.
+- Rename completion: all CLIs, paths, bundle IDs, env vars, and docs standardized on **Clawdbot**.
+- Agent-to-agent relay: `sessions_send` ping‑pong with `REPLY_SKIP` plus announce step with `ANNOUNCE_SKIP`.
+- Gateway quality-of-life: config hot reload, port config support, and Control UI base paths.
+- Sandbox additions: per-session Docker sandbox with hardened limits + optional sandboxed Chromium.
+- New node capability: `location.get` across macOS/iOS/Android (CLI + tools).
+- Models CLI: scan OpenRouter free models (tools/images), manage aliases/fallbacks, and show last-used model in status.
 
 ### Breaking
-- Config refactor: `inbound.*` removed; use top-level `routing` (allowlists + group rules + transcription), `messages` (prefixes/timestamps), and `session` (scoping/store/mainKey). No legacy keys read.
-- Heartbeat config moved to `agent.heartbeat`: set `every: "30m"` (duration string) and optional `model`. `agent.heartbeatMinutes` is removed, and heartbeats are disabled unless `agent.heartbeat.every` is set.
-- Heartbeats now run via the gateway runner (main session) and deliver to the last used channel by default. WhatsApp reply-heartbeat behavior is removed; use `agent.heartbeat.target`/`to` (or `target: "none"`) to control delivery.
-- Browser `act` no longer accepts CSS `selector`; use `snapshot` refs (default `ai`) or `evaluate` as an escape hatch.
+- Tool names drop the `clawdbot_` prefix (`browser`, `canvas`, `nodes`, `cron`, `gateway`).
+- Bash tool removes node-pty `stdinMode: "pty"` support (use tmux for real TTYs).
+- Primary session key is fixed to `main` (or `global` for global scope).
 
 ### Fixes
-- Heartbeat replies now strip repeated `HEARTBEAT_OK` tails to avoid accidental “OK OK” spam.
-- Heartbeat delivery now uses the last non-empty payload, preventing tool preambles from swallowing the final reply.
-- Heartbeats now skip WhatsApp delivery when the web provider is inactive or unlinked (instead of logging “no active gateway listener”).
-- Heartbeat failure logs now include the error reason instead of `[object Object]`.
-- Duration strings now accept `h` (hours) where durations are parsed (e.g., heartbeat intervals).
-- WhatsApp inbound now normalizes more wrapper types so quoted reply bodies are extracted reliably.
-- WhatsApp send now preserves existing JIDs (including group `@g.us`) instead of coercing to `@s.whatsapp.net`. (Thanks @arun-8687.)
-- Telegram/WhatsApp: reply context stays in `Body`/`ReplyTo*`, but outbound replies no longer thread to the original message. (Thanks @joshp123 for the PR and follow-up question.)
-- Suppressed libsignal session cleanup spam from console logs unless verbose mode is enabled.
-- WhatsApp web creds persistence hardened; credentials are restored before auth checks and QR login auto-restarts if it stalls.
-- Group chats now honor `routing.groupChat.requireMention=false` as the default activation when no per-group override exists.
-- Gateway auth no longer supports PAM/system mode; use token or shared password.
-- Tailscale Funnel now requires password auth (no token-only public exposure).
-- Group `/new` resets now work with @mentions so activation guidance appears on fresh sessions.
-- Group chat activation context is now injected into the system prompt at session start (and after activation changes), including /new greetings.
-- Typing indicators now start only once a reply payload is produced (no "thinking" typing for silent runs).
-- WhatsApp group typing now starts immediately only when the bot is mentioned; otherwise it waits until real output exists.
-- Streamed `<think>` segments are stripped before partial replies are emitted.
-- System prompt now tags allowlisted owner numbers as the user identity to avoid mistaken “friend” assumptions.
-- LM Studio/Ollama replies now require <final> tags; streaming ignores content until <final> begins.
-- LM Studio responses API: tools payloads no longer include `strict: null`, and LM Studio no longer gets forced `<think>/<final>` tags.
-- Identity emoji no longer auto-prefixes replies (set `messages.responsePrefix` explicitly if desired).
-- Model switches now enqueue a system event so the next run knows the active model.
-- `/model status` now lists available models (same as `/model`).
-- `process log` pagination is now line-based (omit `offset` to grab the last N lines).
-- macOS WebChat: assistant bubbles now update correctly when toggling light/dark mode.
-- macOS: avoid spawning a duplicate gateway process when an external listener already exists.
-- Node bridge: when binding to a non-loopback host (e.g. Tailnet IP), also listens on `127.0.0.1` for local connections (without creating duplicate loopback listeners for `0.0.0.0`/`127.0.0.1` binds).
-- UI perf: pause repeat animations when scenes are inactive (typing dots, onboarding glow, iOS status pulse), throttle voice overlay level updates, and reduce overlay focus churn.
-- Canvas defaults/A2UI auto-nav aligned; debug status overlay centered; redundant await removed in `CanvasManager`.
-- Gateway launchd loop fixed by removing redundant `kickstart -k`.
-- CLI now hints when Peekaboo is unauthorized.
-- WhatsApp web inbox listeners now clean up on close to avoid duplicate handlers.
-- Gateway startup now brings up browser control before external providers; WhatsApp/Telegram/Discord auto-start can be disabled with `web.enabled`, `telegram.enabled`, or `discord.enabled`.
-
-### Providers & Routing
-- New Discord provider for DMs + guild text channels with allowlists and mention-gated replies by default.
-- `routing.queue` now controls queue vs interrupt behavior globally + per surface (defaults: WhatsApp/Telegram interrupt, Discord/WebChat queue).
-- `/queue <mode>` supports one-shot or per-session overrides; `/queue reset|default` clears overrides.
-- `agent.maxConcurrent` caps global parallel runs while keeping per-session serialization.
-
-### macOS app
-- Update-ready state surfaced in the menu; menu sections regrouped with session submenus.
-- Menu bar now shows a dedicated Nodes section under Context with inline rows, overflow submenu, and iconized actions.
-- Nodes now expose consistent inline details with per-node submenus for quick copy of key fields.
-- Node rows now show compact app versions (build numbers moved to submenus) and offer SSH launch from Bonjour when available.
-- Menu actions are grouped below toggles; Open Canvas hides when disabled and Voice Wake now anchors the mic picker.
-- Connections now include Discord provider status + configuration UI.
-- Menu bar gains an Allow Camera toggle alongside Canvas.
-- Session list polish: sleeping/disconnected/error states, usage bar restored, padding + bar sizing tuned, syncing menu removed, header hidden when disconnected.
-- Chat UI polish: tool call cards + merged tool results, glass background, tighter composer spacing, visual effect host tweaks.
-- OAuth storage moved; legacy session syncing metadata removed.
-- Remote SSH tunnels now get health checks; Debug → Ports highlights unhealthy tunnels and offers Reset SSH tunnel.
-- Menu bar session/node sections no longer reflow while open, keeping hover highlights aligned.
-- Menu hover highlights now span the full width (including submenu arrows).
-- Menu session rows now refresh while open without width changes (no more stuck “Loading sessions…”).
-- Menu width no longer grows on hover when moving the mouse across rows.
-- Context usage bars now have higher contrast in light mode.
-- macOS node timeouts now share a single async timeout helper for consistent behavior.
-- WebChat window defaults tightened (narrower width, edge-to-edge layout) and the SwiftUI tag removed from the title.
-
-### Nodes & Canvas
-- Debug status overlay gated and toggleable on macOS/iOS/Android nodes.
-- Gateway now derives the canvas host URL via a shared helper for bridge + WS handshakes (avoids loopback pitfalls).
-- `canvas a2ui push` validates JSONL with line errors, rejects v0.9 payloads, and supports `--text` quick renders.
-- `nodes rename` lets you override paired node display names without editing JSON.
-- Android scaffold asset cleanup; iOS canvas/voice wake adjustments.
-
-### Logging & Observability
-- New subsystem console formatter with color modes, shortened prefixes, and TTY detection; browser/gateway logs route through the subsystem logger.
-- WhatsApp console output streamlined; chalk/tslog typing fixes.
-
-### Web UI
-- Chat is now the dashboard landing view; health status simplified; initial scroll animation removed.
-
-### Build, Dev, Docs
-- Notarization flow added for macOS release artifacts; packaging scripts updated.
-- macOS signing auto-selects Developer ID → Apple Distribution → Apple Development; no ad-hoc fallback.
-- Added type-aware oxlint; docs list resolves from cwd; formatting/lint cleanup and dependency bumps (Peekaboo).
-- Docs refreshed for tools, custom model providers, Discord, queue/routing, group activation commands, logging, restart semantics, release notes, GitHub pages CTAs, and npm pitfalls.
-- `pnpm build` now skips A2UI bundling for faster builds (run `pnpm canvas:a2ui:bundle` when needed).
-
-### Tests
-- Coverage added for models config merging, WhatsApp reply context, QR login flows, auto-reply behavior, and gateway SIGTERM timeouts.
-- Added gateway webhook coverage (auth, validation, and summary posting).
-- Vitest now isolates HOME/XDG config roots so tests never touch a real `~/.clawdis` install.
-
-## 2.0.0-beta2 — 2025-12-21
-
-Second beta focused on bundled gateway packaging, skills management, onboarding polish, and provider reliability.
-
-### Highlights
-- Bundled gateway packaging: bun-compiled embedded gateway, new `gateway-daemon` command, launchd support, DMG packaging (zip+DMG).
-- Skills platform: managed/bundled skills, install metadata + installers (uv), skill search + website, media/transcription helpers.
-- macOS app: new Connections settings w/ provider status + QR login, skills settings redesign w/ install targets, models list loaded from the Gateway, clearer local/remote gateway choices.
-- Web/agent UX: tool summary streaming + runtime toggle, WhatsApp QR login tool, agent steering queue, voice wake routes to main session, workspace bootstrap ritual.
-
-### Gateway & providers
-- Gateway: `models.list`, provider status events + RPC coverage, tailscale auth + PAM, bind-mode config, enriched agent WS logs, safer upgrade socket handling, fixed handshake auth crash.
-- WhatsApp Web: QR login flow improvements (logged-out clearing, wait flow), self-chat mode handling, removed batching delay, web inbox made non-blocking.
-- Telegram: normalized chat IDs with clearer error reporting.
-
-### Canvas & browser control
-- Canvas host served on Gateway port; removed standalone canvasHost port config; restored action bridge; refreshed A2UI bundle + message context; bridge canvas host for nodes.
-- A2UI full-screen gutters + status clearance after successful load to avoid overlay collisions.
-- Browser control API simplified; added MCP tool dispatch + native actions; control server can start without Playwright; hook timeouts extended.
-
-### macOS UI polish
-- Onboarding chat UI: kickoff flow, bubble tails, spacing + bottom bar refinements, window sizing tweaks, show Dock icon during onboarding.
-- Skills UI: stabilized action column, fixed install target access, refined list layout and sizing, always show CLI installer.
-- Remote/local gateway: auto-enable local gateway, clearer labels, re-ensure remote tunnel, hide local bridge discovery in remote mode.
-
-### Build, CI, deps
-- Bundled playwright-core + chromium-bidi/long; bun gateway bytecode builds; swiftformat/biome CI fixes; iOS lint script updates; Android icon/compiler updates; ignored new ClawdisKit `.swiftpm` path.
+- Doctor migrates legacy Clawdis config/service installs and normalizes sandbox Docker names.
+- Doctor checks sandbox image availability and offers to build or fall back to legacy images.
+- Presence beacons keep node lists fresh; Instances view stays accurate.
+- Block streaming/chunking reliability (Telegram/Discord ordering, fewer duplicates).
+- WhatsApp GIF playback for MP4-based GIFs.
+- Onboarding + Control UI basePath handling fixes and UI polish.
+- Clearer tool summaries, reduced log noise, and safer watchdog/queue behavior.
+- Canvas host watcher resilience; build and packaging edge cases cleaned up.
 
 ### Docs
-- README architecture refresh + npm header image fix; onboarding/bootstrap steps; skills install guidance + new skills; browser/canvas control docs; bundled gateway + DMG packaging notes.
+- Sandbox setup, hot reload, port config, and session announce step coverage.
+- Skills and onboarding clarifications + additional examples.
 
-## 2.0.0-beta1 — 2025-12-19
-
-First Clawdis release post rebrand. This is a semver-major because we dropped legacy providers/agents and moved defaults to new paths while adding a full macOS companion app, a WebSocket Gateway, and an iOS node.
-
-### Bug Fixes
-- macOS: Voice Wake / push-to-talk no longer initialize `AVAudioEngine` at app launch, preventing Bluetooth headphones from switching into headset profile when voice features are unused. (Thanks @Nachx639)
+## 2026.1.3 (beta 5)
 
 ### Breaking
-- Renamed to **Clawdis**: defaults now live under `~/.clawdis` (sessions in `~/.clawdis/sessions/`, IPC at `~/.clawdis/clawdis.sock`, logs in `/tmp/clawdis`). Launchd labels and config filenames follow the new name; legacy stores are copied forward on first run.
-- Pi only: only the embedded Pi runtime remains, and the agent CLI/CLI flags for Claude/Codex/Gemini were removed. The Pi CLI runs in RPC mode with a persistent worker.
-- WhatsApp Web is the only transport; Twilio support and related CLI flags/tests were removed.
-- Direct chats now collapse into a single `main` session by default (no config needed); groups stay isolated as `group:<jid>`.
-- Gateway is now a loopback-only WebSocket daemon (`ws://127.0.0.1:18789`) that owns all providers/state; clients (CLI, WebChat, macOS app, nodes) connect to it. Start it explicitly (`clawdis gateway …`) or via Clawdis.app; helper subcommands no longer auto-spawn a gateway.
+- Skills config moved under `skills.*` (new `skills.entries`, `skills.allowBundled`).
+- Group session keys now `surface:group:<id>` / `surface:channel:<id>`; legacy `group:*` removed.
+- Discord config refactor; `discord.allowFrom` + `discord.requireMention` removed.
+- Discord/Telegram require `enabled: true` in config when using env tokens.
+- Routing `allowFrom`/mention settings moved to per-surface group settings.
 
-### Gateway, nodes, and automation
-- New typed Gateway WS protocol (JSON schema validated) with `clawdis gateway {health,status,send,agent,call}` helpers and structured presence/instance updates for all clients.
-- Optional LAN-facing bridge (`tcp://0.0.0.0:18790`) keeps the Gateway loopback-only while enabling direct Bonjour-discovered connections for paired nodes.
-- Node pairing + management via `clawdis nodes {pending,approve,reject,invoke}` (used by the iOS node and future remote nodes).
-- Cron jobs are Gateway-owned (`clawdis cron …`) with run history stored as JSONL and support for “isolated summary” posting into the main session.
+### Highlights
+- Talk Mode (continuous voice) with ElevenLabs TTS on macOS/iOS/Android.
+- Discord: expanded tool actions, richer routing, and threaded reply tags.
+- Auto-reply queue modes + session model overrides; TUI upgrades.
+- Nix mode (declarative config) and Docker setup flow.
+- Onboarding wizard + configure/doctor/update flows.
+- Signal + iMessage providers; new skills (Trello, Things, Notes/Reminders, tmux coding).
+- Browser tooling upgrades (remote CDP, no-sandbox, profiles).
 
-### macOS companion app
-- **Clawdis.app menu bar companion**: packaged, signed bundle with gateway start/stop, launchd toggle, project-root and pnpm/node auto-resolution, live log shortcut, restart button, and status/recipient table plus badges/dimming for attention and paused states.
-- **On-device Voice Wake**: Apple speech recognizer with wake-word table, language picker, live mic meter, “hold until silence,” animated ears/legs, and main-session routing that replies on the **last used surface** (WhatsApp/Telegram/WebChat). Delivery failures are logged, and the run remains visible via WebChat/session logs.
-- **WebChat & Debugging**: bundled WebChat UI, Debug tab with heartbeat sliders, session-store picker, log opener (`clawlog`), gateway restart, health probes, and scrollable settings panes.
-- **Browser control**: manage clawd’s dedicated Chrome/Chromium with tab listing/open/focus/close, screenshots, DOM query/dump, and “AI snapshots” (aria/domSnapshot/ai) via `clawdis browser …` and UI controls.
-- **Remote gateway control**: Bonjour discovery for local masters plus SSH-tunnel fallback for remote control when multicast is unavailable.
+### Fixes
+- macOS codesign/TCC hardening and menu/UI stability improvements.
+- Streaming/typing fixes; per-provider chunk limit tuning.
+- Remote gateway auth + token handling tightened.
+- Camera capture reliability and media sizing fixes.
 
-### iOS node
-- New iOS companion app that pairs to the Gateway bridge, reports presence as a node, and exposes a WKWebView “Canvas” for agent-driven UI.
-- `clawdis nodes invoke` supports `canvas.eval` and `canvas.snapshot` to drive and verify the iOS Canvas (fails fast when the iOS node is backgrounded).
-- Voice wake words are configurable in-app; the iOS node reconnects to the last bridge when credentials are still present in Keychain.
+## 2025.12.27 (betas 3–4)
 
-### WhatsApp & agent experience
-- Group chats fully supported: mention-gated triggers (including media-only captions), sender attribution, session primer with subject/member roster, allowlist bypass when you’re @‑mentioned, and safer handling of view-once/ephemeral media.
-- Thinking/verbosity directives: `/think` and `/verbose` acknowledge and persist per session while allowing inline overrides; verbose mode streams tool metadata with emoji/args/previews and coalesces bursts to reduce WhatsApp noise.
-- Heartbeats: configurable cadence with CLI/GUI toggles; directive acks suppressed during heartbeats; array/multi-payload replies normalized for Baileys.
-- Reply quality: smarter chunking on words/newlines, fallback warnings when media fails to send, self-number mention detection, and primed group sessions send the roster on first turn.
-- In-chat `/status`: prints agent readiness, session context usage %, current thinking/verbose options, and when the WhatsApp web creds were refreshed (helps decide when to re-scan QR); still available via `clawdis status` CLI for web session health.
+### Highlights
+- First-class tools replace `clawdbot-*` skills (browser, canvas, nodes, cron).
+- Per-session model selection and custom model providers.
+- Group activation commands; Discord provider for DMs/guilds.
+- Gateway webhooks + Gmail Pub/Sub hooks.
+- Command queue modes + `agent.maxConcurrent` cap.
+- Background bash tasks with `process` tool; gateway in-process restart.
 
-### CLI, RPC, and health
-- New `clawdis agent` command plus a persistent Pi RPC worker (auto-started) enables direct agent chats; `clawdis status` renders a colored session/recipient table.
-- `clawdis health` probes WhatsApp link status, connect latency, heartbeat interval, session-store recency, and IPC socket presence (JSON mode for monitors).
-- Added `--help`/`--version` flags; login/logout accept `--provider` (WhatsApp default). Console output is mirrored into pino logs under `/tmp/clawdis`.
-- RPC stability: stdin/stdout loop for Pi, auto-restart worker, raw error surfacing, and deliver-via-RPC when JSON agent output is returned.
+### Fixes
+- Packaging fixes, heartbeat cleanup, WhatsApp reconnect reliability.
+- macOS menu/Chat UI polish and presence reporting fixes.
 
-### Security & hardening
-- Media server blocks symlink/path traversal, clears temporary downloads, and rotates logs daily (24h retention).
-- Session store purged on logout; IPC socket directory permissions tightened (0700/0600).
-- Launchd PATH and helper lookup hardened for packaged macOS builds; health probes surface missing binaries quickly.
+## 2025.12.21 (beta 2)
 
-### Docs
-- Added `docs/telegram.md` outlining the Telegram Bot API provider (grammY) and how it shares the `main` session. Default grammY throttler keeps Bot API calls under rate limits.
-- Gateway can run WhatsApp + Telegram together when configured; `clawdis send --provider telegram …` sends via the Telegram bot (webhook/proxy options documented).
+### Highlights
+- Bundled gateway packaging + DMG distribution pipeline.
+- Skills platform (bundled/managed/workspace) with install gating + UI.
+- Onboarding polish and agent UX improvements.
+- Canvas host served from Gateway; browser control simplification.
 
-## 1.5.0 — 2025-12-05
+## 2025.12.19 (beta 1)
+
+### Highlights
+- First Clawdbot release: Gateway WS control plane + optional Bridge.
+- macOS menu bar companion app with Voice Wake + WebChat.
+- iOS node pairing with Canvas surface.
+- WhatsApp groups, thinking/verbose directives, health/status tooling.
 
 ### Breaking
-- Dropped all non-Pi agents (Claude, Codex, Gemini, Opencode); only the embedded Pi runtime remains and related CLI helpers have been removed.
-- Removed Twilio support and all related commands/options (webhook/up/provider flags/wait-poll); CLAWDIS is Baileys Web-only.
+- Switched to Pi-only agent runtime; legacy providers removed.
+- Gateway became the single source of truth (no ad-hoc direct sends).
 
-### Changes
-- Default agent handling now favors Pi RPC while falling back to plain command execution for non-Pi invocations, keeping heartbeat/session plumbing intact.
-- Documentation updated to reflect Pi-only support and to mark legacy Claude paths as historical.
-- Status command reports web session health + session recipients; config paths are locked to `~/.clawdis` with session metadata stored under `~/.clawdis/sessions/`.
-- Simplified send/agent/gateway/heartbeat to web-only delivery; removed Twilio mocks/tests and dead code.
-- Pi RPC timeout is now inactivity-based (5m without events) and error messages show seconds only.
-- Pi sessions now write to `~/.clawdis/sessions/` by default (legacy session logs from older installs are copied over when present).
-- Directive triggers (`/think`, `/verbose`, `/stop` et al.) now reply immediately using normalized bodies (timestamps/group prefixes stripped) without waiting for the agent.
-- Directive/system acks carry a `⚙️` prefix and verbose parsing rejects typoed `/ver*` strings so unrelated text doesn’t flip verbosity.
-- Batched history blocks no longer trip directive parsing; `/think` in prior messages won't emit stray acknowledgements.
-- RPC fallbacks no longer echo the user's prompt (e.g., pasting a link) when the agent returns no assistant text.
-- Heartbeat prompts with `/think` no longer send directive acks; heartbeat replies stay silent on settings.
-- `clawdis sessions` now renders a colored table (a la oracle) with context usage shown in k tokens and percent of the context window.
-
-## 1.4.1 — 2025-12-04
-
-### Changes
-- Added `clawdis agent` CLI command to talk directly to the configured agent using existing session handling (no WhatsApp send), with JSON output and delivery option.
-- `/new` reset trigger now works even when inbound messages have timestamp prefixes (e.g., `[Dec 4 17:35]`).
-- WhatsApp mention parsing accepts nullable arrays and flattens safely to avoid missed mentions.
-
-## 1.4.0 — 2025-12-03
+## 2025.12.05–2025.12.03 (pre-Clawdbot)
 
 ### Highlights
-- **Thinking directives & state:** `/t|/think|/thinking <level>` (aliases off|minimal|low|medium|high|max/highest). Inline applies to that message; directive-only message pins the level for the session; `/think:off` clears. Resolution: inline > session override > `agent.thinkingDefault` > off. Pi gets `--thinking <level>` (except off); other agents append cue words (`think` → `think hard` → `think harder` → `ultrathink`). Heartbeat probe uses `HEARTBEAT /think:high`.
-- **Group chats (web provider):** Clawdis now fully supports WhatsApp groups: mention-gated triggers (including image-only @ mentions), recent group history injection, per-group sessions, sender attribution, and a first-turn primer with group subject/member roster; heartbeats are skipped for groups.
-- **Group session primer:** The first turn of a group session now tells the agent it is in a WhatsApp group and lists known members/subject so it can address the right speaker.
-- **Media failures are surfaced:** When a web auto-reply media fetch/send fails (e.g., HTTP 404), we now append a warning to the fallback text so you know the attachment was skipped.
-- **Verbose directives + session hints:** `/v|/verbose on|full|off` mirrors thinking: inline > session > config default. Directive-only replies with an acknowledgement; invalid levels return a hint. When enabled, tool results from JSON-emitting agents (Pi, etc.) are forwarded as metadata-only `[🛠️ <tool-name> <arg>]` messages (now streamed as they happen), and new sessions surface a `🧭 New session: <id>` hint.
-- **Verbose tool coalescing:** successive tool results of the same tool within ~1s are batched into one `[🛠️ tool] arg1, arg2` message to reduce WhatsApp noise.
-- **Directive confirmations:** Directive-only messages now reply with an acknowledgement (`Thinking level set to high.` / `Thinking disabled.`) and reject unknown levels with a helpful hint (state is unchanged).
-- **Pi stability:** RPC replies buffered until the assistant turn finishes; parsers return consistent `texts[]`; web auto-replies keep a warm Pi RPC process to avoid cold starts.
-- **Claude prompt flow:** One-time `sessionIntro` with per-message `/think:high` bodyPrefix; system prompt always sent on first turn even with `sendSystemOnce`.
-- **Heartbeat UX:** Backpressure skips reply heartbeats while other commands run; skips don’t refresh session `updatedAt`; web heartbeats normalize array payloads and optional `heartbeatCommand`.
-- **Control via WhatsApp:** Send `/restart` to restart the launchd service (`com.steipete.clawdis`) from your allowed numbers.
-- **Pi completion signal:** RPC now resolves on Pi’s `agent_end` (or process exit) so late assistant messages aren’t truncated; 5-minute hard cap only as a failsafe.
+- Pi-only agent path and web-only gateway workflow.
+- Thinking/verbose directives, group chat support, and heartbeat controls.
+- `clawdbot agent` CLI added; session tables and health reporting.
 
-### Reliability & UX
-- Outbound chunking prefers newlines/word boundaries and enforces caps (~4000 chars for web/WhatsApp).
-- Web auto-replies fall back to caption-only if media send fails; hosted media MIME-sniffed and cleaned up immediately.
-- IPC gateway send shows typing indicator; batched inbound messages keep timestamps; watchdog restarts WhatsApp after long inactivity.
-- Early `allowFrom` filtering prevents decryption errors; same-phone mode supported with echo suppression.
-- All console output is now mirrored into pino logs (still printed to stdout/stderr), so verbose runs keep full traces.
-- `--verbose` now forces log level `trace` (was `debug`) to capture every event.
-- Verbose tool messages now include emoji + args + a short result preview for bash/read/edit/write/attach (derived from RPC tool start/end events).
+## 2025.11.28–2025.11.25 (early web-only)
 
-### Security / Hardening
-- IPC socket hardened (0700 dir / 0600 socket, no symlinks/foreign owners); `clawdis logout` also prunes session store.
-- Media server blocks symlinks and enforces path containment; logging rotates daily and prunes >24h.
-
-### Bug Fixes
-- Web group chats now bypass the second `allowFrom` check (we still enforce it on the group participant at inbox ingest), so mentioned group messages reply even when the group JID isn’t in your allowlist.
-- `logVerbose` also writes to the configured Pino logger at debug level (without breaking stdout).
-- Group auto-replies now append the triggering sender (`[from: Name (+E164)]`) to the batch body so agents can address the right person in group chats.
-- Media-only pings now pick up mentions inside captions (image/video/etc.), so @-mentions on media-only messages trigger replies.
-- MIME sniffing and redirect handling for downloads/hosted media.
-- Response prefix applied to heartbeat alerts; heartbeat array payloads handled for both providers.
-- Pi RPC typing exposes `signal`/`killed`; NDJSON parsers normalized across agents.
-- Pi session resumes now append `--continue`, so existing history/think level are reloaded instead of starting empty.
-
-### Testing
-- Fixtures isolate session stores; added coverage for thinking directives, stateful levels, heartbeat backpressure, and agent parsing.
-
-## 1.3.0 — 2025-12-02
-
-### Highlights
-- **Pluggable agents (Claude, Pi, Codex, Opencode):** agent selection via config/CLI plus per-agent argv builders and NDJSON parsers enable swapping without template changes.
-- **Safety stop words:** `stop|esc|abort|wait|exit` immediately reply “Agent was aborted.” and mark the session so the next prompt is prefixed with an abort reminder.
-- **Agent session reliability:** Only Claude returns a stable `session_id`; others may reset between runs.
-
-### Bug Fixes
-- Empty `result` fields no longer leak raw JSON to users.
-- Heartbeat alerts now honor `responsePrefix`.
-- Command failures return user-friendly messages.
-- Test session isolation to avoid touching real `sessions.json`.
-- (Removed in 2.0.0) IPC reuse for `clawdis send/heartbeat` prevents Signal/WhatsApp session corruption.
-- Web send respects media kind (image/audio/video/document) with correct limits.
-
-### Changes
-- (Removed in 2.0.0) IPC gateway socket at `~/.clawdis/ipc/gateway.sock` with automatic CLI fallback.
-- Batched inbound messages with timestamps; typing indicator after sends.
-- Watchdog restarts WhatsApp after long inactivity; heartbeat logging includes minutes since last message.
-- Early `allowFrom` filtering before decryption.
-- Same-phone mode with echo detection and optional message prefix marker.
-
-## 1.2.2 — 2025-11-28
-
-### Changes
-- Manual heartbeat sends: `clawdis heartbeat --message/--body` (web provider only); `--dry-run` previews payloads.
-
-## 1.2.1 — 2025-11-28
-
-### Changes
-- Media MIME-first handling; hosted media extensions derived from detected MIME with tests.
-
-### Planned / in progress (from prior notes)
-- Heartbeat targeting quality: clearer recipient resolution and verbose logs.
-- Heartbeat delivery preview (Claude path) dry-run.
-- Simulated inbound hook for local testing.
-
-## 1.2.0 — 2025-11-27
-
-### Changes
-- Heartbeat interval default 10m for command mode; prompt `HEARTBEAT /think:high`; skips don’t refresh session; session `heartbeatIdleMinutes` support.
-- Heartbeat tooling: `--session-id`, `--heartbeat-now` (inline flag on `gateway`) for immediate startup probes.
-- Prompt structure: `sessionIntro` plus per-message `/think:high`; session idle up to 7 days.
-- Thinking directives: `/think:<level>`; Pi uses `--thinking`; others append cue; `/think:off` no-op.
-- Robustness: Baileys/WebSocket guards; global unhandled error handlers; WhatsApp LID mapping; hosted media MIME-sniffing and cleanup.
-- Docs: README Clawd setup; `docs/claude-config.md` for live config.
-
-## 1.1.0 — 2025-11-26
-
-### Changes
-- Web auto-replies resize/recompress media and honor `agent.mediaMaxMb`.
-- Detect media kind, enforce provider caps (images ≤6MB, audio/video ≤16MB, docs ≤100MB).
-- `session.sendSystemOnce` and optional `sessionIntro`.
-- Typing indicator refresh during commands; configurable via `agent.typingIntervalSeconds`.
-- Optional audio transcription via external CLI.
-- Command replies return structured payload/meta; respect `mediaMaxMb`; log Claude metadata; include `cwd` in timeout messages.
-- Web provider refactor; logout command; web-only gateway start helper.
-- Structured reconnect/heartbeat logging; bounded backoff with CLI/config knobs; troubleshooting guide.
-- Relay help prints effective heartbeat/backoff when in web mode.
-
-## 1.0.4 — 2025-11-25
-
-### Changes
-- Timeout fallbacks send partial stdout (≤800 chars) to the user instead of silence; tests added.
-- Web gateway auto-reconnects after Baileys/WebSocket drops; close propagation tests.
-
-## 0.1.3 — 2025-11-25
-
-### Changes
-- Auto-replies send a WhatsApp fallback message on command/Claude timeout with truncated stdout.
-- Added tests for timeout fallback and partial-output truncation.
+- Heartbeat CLI + interval handling.
+- Media MIME sniffing, size caps, and timeout fallbacks.
+- Web provider reconnects and early stability fixes.

CONTRIBUTING.md

@@ -0,0 +1,42 @@
+# Contributing to Clawdbot
+
+Welcome to the lobster tank! 🦞
+
+## Quick Links
+- **GitHub:** https://github.com/clawdbot/clawdbot
+- **Discord:** https://discord.gg/qkhbAGHRBT
+- **X/Twitter:** [@steipete](https://x.com/steipete) / [@clawdbot](https://x.com/clawdbot)
+
+## Maintainers
+
+- **Peter Steinberger** - Benevolent Dictator
+  - GitHub: [@steipete](https://github.com/steipete) · X: [@steipete](https://x.com/steipete)
+
+- **Shadow** - Discord + Slack subsystem
+  - GitHub: [@4shadowed](https://github.com/4shadowed) · X: [@4shad0wed](https://x.com/4shad0wed)
+
+- **Jos** - Telegram, API, Nix mode
+  - GitHub: [@joshp123](https://github.com/joshp123) · X: [@jjpcodes](https://x.com/jjpcodes)
+
+## How to Contribute
+1. **Bugs & small fixes** → Open a PR!
+2. **New features / architecture** → Start a [GitHub Discussion](https://github.com/clawdbot/clawdbot/discussions) or ask in Discord first
+3. **Questions** → Discord #setup-help
+
+## Before You PR
+- Test locally with your Clawdbot instance
+- Run linter: `npm run lint`
+- Keep PRs focused (one thing per PR)
+- Describe what & why
+
+## AI/Vibe-Coded PRs Welcome! 🤖
+
+Built with Codex, Claude, or other AI tools? **Awesome - just mark it!**
+
+Please include in your PR:
+- [ ] Mark as AI-assisted in the PR title or description
+- [ ] Note the degree of testing (untested / lightly tested / fully tested)
+- [ ] Include prompts or session logs if possible (super helpful!)
+- [ ] Confirm you understand what the code does
+
+AI PRs are first-class citizens here. We just want transparency so reviewers know what to look for.

Dockerfile

@@ -0,0 +1,16 @@
+FROM node:22-bookworm
+
+RUN corepack enable
+
+WORKDIR /app
+
+COPY . .
+
+RUN pnpm install --frozen-lockfile
+RUN pnpm build
+RUN pnpm ui:install
+RUN pnpm ui:build
+
+ENV NODE_ENV=production
+
+CMD ["node", "dist/index.js"]

Dockerfile.sandbox

@@ -0,0 +1,16 @@
+FROM debian:bookworm-slim
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update \
+  && apt-get install -y --no-install-recommends \
+    bash \
+    ca-certificates \
+    curl \
+    git \
+    jq \
+    python3 \
+    ripgrep \
+  && rm -rf /var/lib/apt/lists/*
+
+CMD ["sleep", "infinity"]

Dockerfile.sandbox-browser

@@ -0,0 +1,27 @@
+FROM debian:bookworm-slim
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update \
+  && apt-get install -y --no-install-recommends \
+    bash \
+    ca-certificates \
+    chromium \
+    curl \
+    fonts-liberation \
+    fonts-noto-color-emoji \
+    git \
+    jq \
+    novnc \
+    python3 \
+    websockify \
+    x11vnc \
+    xvfb \
+  && rm -rf /var/lib/apt/lists/*
+
+COPY scripts/sandbox-browser-entrypoint.sh /usr/local/bin/clawdbot-sandbox-browser
+RUN chmod +x /usr/local/bin/clawdbot-sandbox-browser
+
+EXPOSE 9222 5900 6080
+
+CMD ["clawdbot-sandbox-browser"]

README.md

@@ -1,7 +1,7 @@
-# 🦞 CLAWDIS — Personal AI Assistant
+# 🦞 CLAWDBOT — Personal AI Assistant
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/steipete/clawdis/main/docs/whatsapp-clawd.jpg" alt="CLAWDIS" width="400">
+  <img src="https://raw.githubusercontent.com/clawdbot/clawdbot/main/docs/whatsapp-clawd.jpg" alt="CLAWDBOT" width="400">
 </p>
 
 <p align="center">
@@ -9,18 +9,92 @@
 </p>
 
 <p align="center">
-  <a href="https://github.com/steipete/clawdis/actions/workflows/ci.yml?branch=main"><img src="https://img.shields.io/github/actions/workflow/status/steipete/clawdis/ci.yml?branch=main&style=for-the-badge" alt="CI status"></a>
-  <a href="https://github.com/steipete/clawdis/releases"><img src="https://img.shields.io/github/v/release/steipete/clawdis?include_prereleases&style=for-the-badge" alt="GitHub release"></a>
+  <a href="https://github.com/clawdbot/clawdbot/actions/workflows/ci.yml?branch=main"><img src="https://img.shields.io/github/actions/workflow/status/clawdbot/clawdbot/ci.yml?branch=main&style=for-the-badge" alt="CI status"></a>
+  <a href="https://github.com/clawdbot/clawdbot/releases"><img src="https://img.shields.io/github/v/release/clawdbot/clawdbot?include_prereleases&style=for-the-badge" alt="GitHub release"></a>
+  <a href="https://discord.gg/clawd"><img src="https://img.shields.io/discord/1456350064065904867?label=Discord&logo=discord&logoColor=white&color=5865F2&style=for-the-badge" alt="Discord"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge" alt="MIT License"></a>
 </p>
 
-**Clawdis** is a *personal AI assistant* you run on your own devices.
-It answers you on the surfaces you already use (WhatsApp, Telegram, Discord, WebChat), can speak and listen on macOS/iOS, and can render a live Canvas you control. The Gateway is just the control plane — the product is the assistant.
+**Clawdbot** is a *personal AI assistant* you run on your own devices.
+It answers you on the surfaces you already use (WhatsApp, Telegram, Discord, iMessage, WebChat), can speak and listen on macOS/iOS, and can render a live Canvas you control. The Gateway is just the control plane — the product is the assistant.
 
-If you want a private, single-user assistant that feels local, fast, and always-on, this is it.
+If you want a personal, single-user assistant that feels local, fast, and always-on, this is it.
+
+Website: https://clawd.me · Docs: [`docs/index.md`](docs/index.md) · FAQ: [`docs/faq.md`](docs/faq.md) · Wizard: [`docs/wizard.md`](docs/wizard.md) · Docker (optional): [`docs/docker.md`](docs/docker.md) · Discord: https://discord.gg/clawd
+
+Preferred setup: run the onboarding wizard (`clawdbot onboard`). It walks through gateway, workspace, providers, and skills. The CLI wizard is the recommended path and works on **macOS, Windows, and Linux**.
 
 Using Claude Pro/Max subscription? See `docs/onboarding.md` for the Anthropic OAuth setup.
 
+## Highlights
+
+- **Local-first Gateway** — single control plane for sessions, providers, tools, and events.
+- **Multi-surface inbox** — WhatsApp, Telegram, Discord, iMessage, WebChat, macOS, iOS/Android.
+- **Voice Wake + Talk Mode** — always-on speech for macOS/iOS/Android with ElevenLabs.
+- **Live Canvas** — agent-driven visual workspace with A2UI.
+- **First-class tools** — browser, canvas, nodes, cron, sessions, and Discord actions.
+- **Companion apps** — macOS menu bar app + iOS/Android nodes.
+- **Onboarding + skills** — wizard-driven setup with bundled/managed/workspace skills.
+
+## Everything we built so far
+
+### Core platform
+- Gateway WS control plane with sessions, presence, config, cron, webhooks, control UI, and Canvas host.
+- CLI surface: gateway, agent, send, wizard, doctor/update, and TUI.
+- Pi agent runtime in RPC mode with tool streaming and block streaming.
+- Session model: `main` for direct chats, group isolation, activation modes, queue modes, reply-back.
+- Media pipeline: images/audio/video, transcription hooks, size caps, temp file lifecycle.
+
+### Surfaces + providers
+- WhatsApp (Baileys), Telegram (grammY), Discord (discord.js), Signal (signal-cli), iMessage (imsg), WebChat.
+- Group mention gating, reply tags, per-surface chunking and routing.
+
+### Apps + nodes
+- macOS app: menu bar control plane, Voice Wake/PTT, Talk Mode overlay, WebChat, Debug tools, SSH remote gateway control.
+- iOS node: Canvas, Voice Wake, Talk Mode, camera, screen recording, Bonjour pairing.
+- Android node: Canvas, Talk Mode, camera, screen recording, optional SMS.
+- macOS node mode: system.run/notify + canvas/camera exposure.
+
+### Tools + automation
+- Browser control: dedicated clawd Chrome/Chromium, snapshots, actions, uploads, profiles.
+- Canvas: A2UI push/reset, eval, snapshot.
+- Nodes: camera snap/clip, screen record, location.get, notifications.
+- Cron + wakeups; webhooks; Gmail Pub/Sub triggers.
+- Skills platform: bundled, managed, and workspace skills with install gating + UI.
+
+### Ops + packaging
+- Control UI + WebChat served directly from the Gateway.
+- Tailscale Serve/Funnel or SSH tunnels with token/password auth.
+- Nix mode for declarative config; Docker-based installs.
+- Health, doctor migrations, structured logging, release tooling.
+
+## Changes since 2.0.0-beta5 (2026-01-03)
+
+### Highlights
+- Project rename completed: CLIs, paths, bundle IDs, env vars, and docs unified on Clawdbot.
+- Agent-to-agent relay: `sessions_send` ping‑pong with `REPLY_SKIP` plus announce step with `ANNOUNCE_SKIP`.
+- Gateway config hot reload, configurable port, and Control UI base-path support.
+- Sandbox options: per-session Docker sandbox with hardened limits + optional sandboxed Chromium.
+- New node capability: `location.get` across macOS/iOS/Android (CLI + tools).
+
+### Fixes
+- Presence beacons keep node lists fresh; Instances view stays accurate.
+- Block streaming + chunking reliability (Telegram/Discord ordering, fewer duplicates).
+- WhatsApp GIF playback for MP4-based GIFs.
+- Onboarding/Control UI basePath handling fixes + UI polish.
+- Cleaner logging + clearer tool summaries.
+
+### Breaking
+- Tool names drop the `clawdbot_` prefix (`browser`, `canvas`, `nodes`, `cron`, `gateway`).
+- Bash tool removed `stdinMode: "pty"` support (use tmux for real TTYs).
+- Primary session key is fixed to `main` (or `global` for global scope).
+
+## Project rename + changelog format
+
+Clawdis → Clawdbot. The rename touched every surface, path, and bundle ID. To make that transition explicit, releases now use **date-based versions** (`YYYY.M.D`), and the changelog is compressed into milestone summaries instead of long semver trains. Full detail still lives in git history and the docs.
+
+## How it works (short)
+
 ```
 Your surfaces
    │
@@ -31,30 +105,12 @@ Your surfaces
 └──────────────┬────────────────┘
                │
                ├─ Pi agent (RPC)
-               ├─ CLI (clawdis …)
+               ├─ CLI (clawdbot …)
                ├─ WebChat (browser)
-               ├─ macOS app (Clawdis.app)
+               ├─ macOS app (Clawdbot.app)
                └─ iOS node (Canvas + voice)
 ```
 
-## What Clawdis does
-
-- **Personal assistant** — one user, one identity, one memory surface.
-- **Multi-surface inbox** — WhatsApp, Telegram, Discord, WebChat, macOS, iOS.
-- **Voice wake + push-to-talk** — local speech recognition on macOS/iOS.
-- **Canvas** — a live visual workspace you can drive from the agent.
-- **Automation-ready** — browser control, media handling, and tool streaming.
-- **Local-first control plane** — the Gateway owns state, everything else connects.
-- **Group chats** — mention-based by default, `/activation always|mention` per group (owner-only).
-- **Nix mode** — opt-in declarative config + read-only UI when `CLAWDIS_NIX_MODE=1`.
-
-## How it works (short)
-
-- **Gateway** is the single source of truth for sessions/providers.
-- **Loopback-first**: `ws://127.0.0.1:18789` by default.
-- **Bridge** (optional) exposes a paired-node port for iOS/Android.
-- **Agent runtime** is **Pi** in RPC mode.
-
 ## Quick start (from source)
 
 Runtime: **Node ≥22** + **pnpm**.
@@ -64,23 +120,26 @@ pnpm install
 pnpm build
 pnpm ui:build
 
-# Link WhatsApp (stores creds in ~/.clawdis/credentials)
-pnpm clawdis login
+# Recommended: run the onboarding wizard
+pnpm clawdbot onboard
+
+# Link WhatsApp (stores creds in ~/.clawdbot/credentials)
+pnpm clawdbot login
 
 # Start the gateway
-pnpm clawdis gateway --port 18789 --verbose
+pnpm clawdbot gateway --port 18789 --verbose
 
 # Dev loop (auto-reload on TS changes)
 pnpm gateway:watch
 
 # Send a message
-pnpm clawdis send --to +1234567890 --message "Hello from Clawdis"
+pnpm clawdbot send --to +1234567890 --message "Hello from Clawdbot"
 
 # Talk to the assistant (optionally deliver back to WhatsApp/Telegram/Discord)
-pnpm clawdis agent --message "Ship checklist" --thinking high
+pnpm clawdbot agent --message "Ship checklist" --thinking high
 ```
 
-If you run from source, prefer `pnpm clawdis …` (not global `clawdis`).
+If you run from source, prefer `pnpm clawdbot …` (not global `clawdbot`).
 
 ## Chat commands
 
@@ -101,20 +160,20 @@ Send these in WhatsApp/Telegram/WebChat (group commands are owner-only):
 - **Events + snapshot**: handshake returns a snapshot (presence/health) and declares event types; runtime events include `agent`, `chat`, `presence`, `tick`, `health`, `heartbeat`, `cron`, `node.pair.*`, `voicewake.changed`, `shutdown`.
 - **Idempotency & safety**: `send`/`agent`/`chat.send` require idempotency keys with a TTL cache (5 min, cap 1000) to avoid double‑sends on reconnects; payload sizes are capped per connection.
 - **Bridge for nodes**: optional TCP bridge (`src/infra/bridge/server.ts`) is newline‑delimited JSON frames (`hello`, pairing, RPC, `invoke`); node connect/disconnect is surfaced into presence.
-- **Control UI + Canvas Host**: HTTP serves `/ui` assets (if built) and can host a live‑reload Canvas host for nodes (`src/canvas-host/server.ts`), injecting the A2UI postMessage bridge.
+- **Control UI + Canvas Host**: HTTP serves Control UI assets (default `/`, optional base path) and can host a live‑reload Canvas host for nodes (`src/canvas-host/server.ts`), injecting the A2UI postMessage bridge.
 
 ### iOS app (apps/ios)
 - **Discovery + pairing**: Bonjour discovery via `BridgeDiscoveryModel` (NWBrowser). `BridgeConnectionController` auto‑connects using Keychain token or allows manual host/port.
 - **Node runtime**: `BridgeSession` (actor) maintains the `NWConnection`, hello handshake, ping/pong, RPC requests, and `invoke` callbacks.
 - **Capabilities + commands**: advertises `canvas`, `screen`, `camera`, `voiceWake` (settings‑driven) and executes `canvas.*`, `canvas.a2ui.*`, `camera.*`, `screen.record` (`NodeAppModel.handleInvoke`).
-- **Canvas**: `WKWebView` with bundled Canvas scaffold + A2UI, JS eval, snapshot capture, and `clawdis://` deep‑link interception (`ScreenController`).
-- **Voice + deep links**: voice wake sends `voice.transcript` events; `clawdis://agent` links emit `agent.request`. Voice wake triggers sync via `voicewake.get` + `voicewake.changed`.
+- **Canvas**: `WKWebView` with bundled Canvas scaffold + A2UI, JS eval, snapshot capture, and `clawdbot://` deep‑link interception (`ScreenController`).
+- **Voice + deep links**: voice wake sends `voice.transcript` events; `clawdbot://agent` links emit `agent.request`. Voice wake triggers sync via `voicewake.get` + `voicewake.changed`.
 
 ## Companion apps
 
 The **macOS app is critical**: it runs the menu‑bar control plane, owns local permissions (TCC), hosts Voice Wake, exposes WebChat/debug tools, and coordinates local/remote gateway mode. Most “assistant” UX lives here.
 
-### macOS (Clawdis.app)
+### macOS (Clawdbot.app)
 
 - Menu bar control for the Gateway and health.
 - Voice Wake + push-to-talk overlay.
@@ -127,7 +186,7 @@ Build/run: `./scripts/restart-mac.sh` (packages + launches).
 
 - Pairs as a node via the Bridge.
 - Voice trigger forwarding + Canvas surface.
-- Controlled via `clawdis nodes …`.
+- Controlled via `clawdbot nodes …`.
 
 Runbook: `docs/ios/connect.md`.
 
@@ -145,11 +204,11 @@ Runbook: `docs/ios/connect.md`.
 
 ## Configuration
 
-Minimal `~/.clawdis/clawdis.json`:
+Minimal `~/.clawdbot/clawdbot.json`:
 
 ```json5
 {
-  routing: {
+  whatsapp: {
     allowFrom: ["+1234567890"]
   }
 }
@@ -157,13 +216,13 @@ Minimal `~/.clawdis/clawdis.json`:
 
 ### WhatsApp
 
-- Link the device: `pnpm clawdis login` (stores creds in `~/.clawdis/credentials`).
-- Allowlist who can talk to the assistant via `routing.allowFrom`.
+- Link the device: `pnpm clawdbot login` (stores creds in `~/.clawdbot/credentials`).
+- Allowlist who can talk to the assistant via `whatsapp.allowFrom`.
 
 ### Telegram
 
 - Set `TELEGRAM_BOT_TOKEN` or `telegram.botToken` (env wins).
-- Optional: set `telegram.requireMention`, `telegram.allowFrom`, or `telegram.webhookUrl` as needed.
+- Optional: set `telegram.groups` (with `telegram.groups."*".requireMention`), `telegram.allowFrom`, or `telegram.webhookUrl` as needed.
 
 ```json5
 {
@@ -176,7 +235,7 @@ Minimal `~/.clawdis/clawdis.json`:
 ### Discord
 
 - Set `DISCORD_BOT_TOKEN` or `discord.token` (env wins).
-- Optional: set `discord.requireMention`, `discord.allowFrom`, or `discord.mediaMaxMb` as needed.
+- Optional: set `discord.slashCommand`, `discord.dm.allowFrom`, `discord.guilds`, or `discord.mediaMaxMb` as needed.
 
 ```json5
 {
@@ -208,23 +267,30 @@ Browser control (optional):
 - [`docs/discovery.md`](docs/discovery.md)
 - [`docs/agent.md`](docs/agent.md)
 - [`docs/discord.md`](docs/discord.md)
+- [`docs/wizard.md`](docs/wizard.md)
 - Webhooks + external triggers: [`docs/webhook.md`](docs/webhook.md)
 - Gmail hooks (email → wake): [`docs/gmail-pubsub.md`](docs/gmail-pubsub.md)
 
 ## Email hooks (Gmail)
 
 ```bash
-clawdis hooks gmail setup --account you@gmail.com
-clawdis hooks gmail run
+clawdbot hooks gmail setup --account you@gmail.com
+clawdbot hooks gmail run
 ```
 - [`docs/security.md`](docs/security.md)
 - [`docs/troubleshooting.md`](docs/troubleshooting.md)
 - [`docs/ios/connect.md`](docs/ios/connect.md)
-- [`docs/clawdis-mac.md`](docs/clawdis-mac.md)
+- [`docs/clawdbot-mac.md`](docs/clawdbot-mac.md)
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines, maintainers, and how to submit PRs.
+
+AI/vibe-coded PRs welcome! 🤖
 
 ## Clawd
 
-Clawdis was built for **Clawd**, a space lobster AI assistant.
+Clawdbot was built for **Clawd**, a space lobster AI assistant.
 
 - https://clawd.me
 - https://soul.md

Swabble/Package.resolved

@@ -1,6 +1,15 @@
 {
-  "originHash" : "2012d083159d375d07febbc184c592c569d7ab48247045e35a762e3269d4cadc",
+  "originHash" : "5d29ee82825e0764775562242cfa1ff4dc79584797dd638f76c9876545454748",
   "pins" : [
+    {
+      "identity" : "elevenlabskit",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/steipete/ElevenLabsKit",
+      "state" : {
+        "revision" : "c8679fbd37416a8780fe43be88a497ff16209e2d",
+        "version" : "0.1.0"
+      }
+    },
     {
       "identity" : "swift-syntax",
       "kind" : "remoteSourceControl",

appcast.xml

@@ -1,31 +1,212 @@
 <?xml version="1.0" standalone="yes"?>
 <rss xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle" version="2.0">
     <channel>
-        <title>Clawdis</title>
+        <title>Clawdbot</title>
         <item>
-            <title>2.0.0-beta3</title>
-            <pubDate>Sat, 27 Dec 2025 19:02:02 +0100</pubDate>
-            <link>https://raw.githubusercontent.com/steipete/clawdis/main/appcast.xml</link>
-            <sparkle:version>2.0.0-beta3</sparkle:version>
-            <sparkle:shortVersionString>2.0.0-beta3</sparkle:shortVersionString>
+            <title>2.0.0-beta5</title>
+            <pubDate>Sat, 03 Jan 2026 07:15:16 +0100</pubDate>
+            <link>https://raw.githubusercontent.com/clawdbot/clawdbot/main/appcast.xml</link>
+            <sparkle:version>2765</sparkle:version>
+            <sparkle:shortVersionString>2.0.0-beta5</sparkle:shortVersionString>
             <sparkle:minimumSystemVersion>15.0</sparkle:minimumSystemVersion>
-            <enclosure url="https://github.com/steipete/clawdis/releases/download/v2.0.0-beta3/Clawdis-2.0.0-beta3.zip" length="70407960" type="application/octet-stream" sparkle:edSignature="A8ySMmbLRrpIkqkrmc9QrC+6om8Iyqray/6x/YNiJxDoJeXjp2T5t8XT0CKJeNBUlDkzIj/fwiK53v0qQ59cDQ=="/>
-        </item>
-        <item>
-            <title>2.0.0-beta4</title>
-            <pubDate>Sat, 27 Dec 2025 19:43:22 +0100</pubDate>
-            <link>https://raw.githubusercontent.com/steipete/clawdis/main/appcast.xml</link>
-            <sparkle:version>2.0.0-beta4</sparkle:version>
-            <sparkle:shortVersionString>2.0.0-beta4</sparkle:shortVersionString>
-            <sparkle:minimumSystemVersion>15.0</sparkle:minimumSystemVersion>
-            <description><![CDATA[<h2>Clawdis 2.0.0-beta4</h2>
+            <description><![CDATA[<h2>Clawdbot 2.0.0-beta5</h2>
+<h3>Fixed</h3>
+<ul>
+<li>Media: preserve GIF animation when uploading to Discord/other providers (skip JPEG optimization for image/gif).</li>
+<li>Agent runtime: update pi-mono dependencies to 0.31.1 (agent-core split).</li>
+<li>Dependencies: bump to latest compatible versions (TypeBox, grammY, Zod, Rolldown, oxlint-tsgolint).</li>
+<li>Tests: cover read tool image metadata + text output.</li>
+<li>Tests: add queue mode coverage (collect/followup + directive parsing).</li>
+</ul>
+<h3>Breaking</h3>
+<ul>
+<li>Skills config schema moved under <code>skills.*</code>:</li>
+</ul>
+  - <code>skillsLoad.extraDirs</code> → <code>skills.load.extraDirs</code>
+  - <code>skillsInstall.*</code> → <code>skills.install.*</code>
+  - per-skill config map moved to <code>skills.entries</code> (e.g. <code>skills.peekaboo.enabled</code> → <code>skills.entries.peekaboo.enabled</code>)
+  - new optional bundled allowlist: <code>skills.allowBundled</code> (only affects bundled skills)
+<ul>
+<li>Sessions: group keys now use <code>surface:group:<id></code> / <code>surface:channel:<id></code>; legacy <code>group:*</code> keys migrate on next message; <code>groupdm</code> keys are no longer recognized.</li>
+<li>Discord: remove legacy <code>discord.allowFrom</code>, <code>discord.guildAllowFrom</code>, and <code>discord.requireMention</code>; use <code>discord.dm</code> + <code>discord.guilds</code>.</li>
+<li>Providers: Discord/Telegram no longer auto-start from env tokens alone; add <code>discord: { enabled: true }</code> / <code>telegram: { enabled: true }</code> to your config when using <code>DISCORD_BOT_TOKEN</code> / <code>TELEGRAM_BOT_TOKEN</code>.</li>
+<li>Config: remove <code>routing.allowFrom</code>; use <code>whatsapp.allowFrom</code> instead (run <code>clawdbot doctor</code> to migrate).</li>
+<li>Config: remove <code>routing.groupChat.requireMention</code> + <code>telegram.requireMention</code>; use <code>whatsapp.groups</code>, <code>imessage.groups</code>, and <code>telegram.groups</code> defaults instead (run <code>clawdbot doctor</code> to migrate).</li>
+</ul>
+<h3>Features</h3>
+<ul>
+<li>Discord: expand <code>discord</code> tool actions (reactions, stickers, polls, threads, search, moderation gates) (#115) — thanks @thewilloftheshadow.</li>
+<li>Discord/Telegram: add reply tags (<code>[[reply_to_current]]</code>, <code>[[reply_to:<id>]]</code>) with per-provider <code>replyToMode</code> (off|first|all) for native threaded replies.</li>
+<li>Talk mode: continuous speech conversations (macOS/iOS/Android) with ElevenLabs TTS, reply directives, and optional interrupt-on-speech.</li>
+<li>Auto-reply: expand queue modes (steer/followup/collect/steer-backlog) with debounce/cap/drop options and followup backlog handling.</li>
+<li>UI: add optional <code>ui.seamColor</code> accent to tint the Talk Mode side bubble (macOS/iOS/Android).</li>
+<li>Nix mode: opt-in declarative config + read-only settings UI when <code>CLAWDBOT_NIX_MODE=1</code> (thanks @joshp123 for the persistence — earned my trust; I'll merge these going forward).</li>
+<li>CLI: add Google Antigravity OAuth auth option for Claude Opus 4.5/Gemini 3 (#88) — thanks @mukhtharcm.</li>
+<li>Agent runtime: accept legacy <code>Z_AI_API_KEY</code> for Z.AI provider auth (maps to <code>ZAI_API_KEY</code>).</li>
+<li>Groups: add per-group mention gating defaults/overrides for Telegram/WhatsApp/iMessage via <code>*.groups</code> with <code>"*"</code> defaults; Discord now supports <code>discord.guilds."*"</code> as a default.</li>
+<li>Discord: add user-installed slash command handling with per-user sessions and auto-registration (#94) — thanks @thewilloftheshadow.</li>
+<li>Discord: add DM enable/allowlist plus guild channel/user/guild allowlists with id/name matching.</li>
+<li>Signal: add <code>signal-cli</code> JSON-RPC support for send/receive via the Signal provider.</li>
+<li>iMessage: add imsg JSON-RPC integration (stdio), chat_id routing, and group chat support.</li>
+<li>Chat UI: add recent-session dropdown switcher (main first) in macOS/iOS/Android + Control UI.</li>
+<li>UI: add Discord/Signal/iMessage connection panels in macOS + Control UI (thanks @thewilloftheshadow).</li>
+<li>Discord: allow agent-triggered reactions via <code>clawdbot_discord</code> when enabled, and surface message ids in context.</li>
+<li>Discord: revamp guild routing config with per-guild/channel rules and slugged display names; add optional group DM support (default off).</li>
+<li>Discord: remove legacy guild/channel ignore lists in favor of per-guild allowlists (and proposed per-guild ignore lists).</li>
+<li>Skills: add Trello skill for board/list/card management (thanks @clawd).</li>
+<li>Docker: add containerized gateway/CLI setup via Dockerfile, compose, and setup script (thanks @dan-dr).</li>
+<li>Tests: add a Z.AI live test gate for smoke validation when keys are present.</li>
+<li>macOS Debug: add app log verbosity and rolling file log toggle for swift-log-backed app logs.</li>
+<li>CLI: add onboarding wizard (gateway + workspace + skills) with daemon installers and Anthropic/Minimax setup paths.</li>
+<li>CLI: add ASCII banner header to wizard entry points.</li>
+<li>CLI: add <code>configure</code>, <code>doctor</code>, and <code>update</code> wizards for ongoing setup, health checks, and modernization.</li>
+<li>CLI: add Signal CLI auto-install from GitHub releases in the wizard and persist wizard run metadata in config.</li>
+<li>CLI: add remote gateway client config (gateway.remote.*) with Bonjour-assisted discovery.</li>
+<li>CLI: enhance <code>clawdbot tui</code> with model/session pickers, tool cards, and slash commands (local or remote).</li>
+<li>Gateway: allow <code>sessions.patch</code> to set per-session model overrides (used by the TUI <code>/model</code> flow).</li>
+<li>Skills: allow <code>bun</code> as a node manager for skill installs.</li>
+<li>Skills: add <code>things-mac</code> (Things 3 CLI) for read/search plus add/update via URL scheme.</li>
+<li>Skills: add Apple Notes + Reminders skills via memo CLI (thanks @tylerwince).</li>
+<li>Tests: add a Docker-based onboarding E2E harness.</li>
+<li>Tests: harden wizard E2E flows for reset, providers, skills, and remote non-interactive runs.</li>
+<li>Browser tools: add remote CDP URL support, Linux launcher options (<code>executablePath</code>, <code>noSandbox</code>), and surface <code>cdpUrl</code> in status.</li>
+<li>Skills: add tmux-first coding-agent skill + <code>requires.anyBins</code> gate for multi-CLI setup (thanks @sreekaransrinath).</li>
+</ul>
 <h3>Fixes</h3>
 <ul>
-<li>Package contents: include Discord/hooks build outputs in the npm tarball to avoid missing module errors.</li>
+<li>Gog calendar: format date ranges as RFC 3339 with timezone to satisfy Google Calendar API (thanks @jayhickey).</li>
+<li>macOS onboarding: add scrollable page gutter for overflowing content (#105) — thanks @thewilloftheshadow.</li>
+<li>Chat UI: keep the chat scrolled to the latest message after switching sessions.</li>
+<li>Chat UI: show rich session display names in Web Chat + SwiftUI + Android.</li>
+<li>Auto-reply: stream completed reply blocks as soon as they finish (configurable default + break); skip empty tool-only blocks unless verbose.</li>
+<li>Discord: avoid duplicate sends when block streaming is enabled (race with typing hook).</li>
+<li>Providers: make outbound text chunk limits configurable via <code>*.textChunkLimit</code> (defaults remain 4000/Discord 2000).</li>
+<li>CLI onboarding: persist gateway token in config so local CLI auth works; recommend auth Off unless you need multi-machine access.</li>
+<li>Control UI: accept a <code>?token=</code> URL param to auto-fill Gateway auth; onboarding now opens the dashboard with token auth when configured.</li>
+<li>Agent prompt: remove hardcoded user name in system prompt example.</li>
+<li>Chat UI: add extra top padding before the first message bubble in Web Chat (macOS/iOS/Android).</li>
+<li>Control UI: refine Web Chat session selector styling (chevron spacing + background).</li>
+<li>WebChat: stream live updates for sessions even when runs start outside the chat UI.</li>
+<li>Gateway CLI: read <code>CLAWDBOT_GATEWAY_PASSWORD</code> from environment in <code>callGateway()</code> — allows <code>doctor</code>/<code>health</code> commands to auth without explicit <code>--password</code> flag.</li>
+<li>Gateway: add password auth support for remote gateway connections (thanks @jeffersonwarrior).</li>
+<li>Auto-reply: strip stray leading/trailing <code>HEARTBEAT_OK</code> from normal replies; drop short (≤ 30 chars) heartbeat acks.</li>
+<li>WhatsApp auto-reply: default to self-only when no config is present.</li>
+<li>Logging: trim provider prefix duplication in Discord/Signal/Telegram runtime log lines.</li>
+<li>Logging/Signal: treat signal-cli "Failed …" lines as errors in gateway logs.</li>
+<li>Discord: include recent guild context when replying to mentions and add <code>discord.historyLimit</code> to tune how many messages are captured.</li>
+<li>Discord: include author tag + id in group context <code>[from:]</code> lines for ping-ready replies (thanks @thewilloftheshadow).</li>
+<li>Discord: include replied-to message context when a Discord message references another message (thanks @thewilloftheshadow).</li>
+<li>Discord: preserve newlines when stripping reply tags from agent output.</li>
+<li>Gateway: fix TypeScript build by aligning hook mapping <code>channel</code> types and removing a dead Group DM branch in Discord monitor.</li>
+<li>Skills: switch imsg installer to brew tap formula.</li>
+<li>Skills: gate macOS-only skills by OS and surface block reasons in the Skills UI.</li>
+<li>Onboarding: show skill descriptions in the macOS setup flow and surface clearer Gateway/skills error messages.</li>
+<li>Onboarding: auto-verify Claude OAuth tokens, show “verified” when detected working, and avoid re-auth prompts unless verification fails.</li>
+<li>CLI onboarding: include exit code + a useful one-line summary when skill dependency installs fail.</li>
+<li>CLI onboarding: explain Tailscale exposure options (Off/Serve/Funnel) and colorize provider status (linked/configured/needs setup).</li>
+<li>CLI onboarding: add provider primers (WhatsApp/Telegram/Discord/Signal) incl. Discord bot token setup steps.</li>
+<li>CLI onboarding: allow skipping the “install missing skill dependencies” selection without canceling the wizard.</li>
+<li>CLI onboarding: always prompt for WhatsApp <code>whatsapp.allowFrom</code> and print (optionally open) the Control UI URL when done.</li>
+<li>CLI onboarding: detect gateway reachability and annotate Local/Remote choices (helps pick the right mode).</li>
+<li>macOS settings: colorize provider status subtitles to distinguish healthy vs degraded states.</li>
+<li>macOS: keep config writes on the main actor to satisfy Swift concurrency rules.</li>
+<li>macOS menu: show multi-line gateway error details, add an always-visible gateway row, avoid duplicate gateway status rows, suppress transient <code>cancelled</code> device refresh errors, and auto-recover the control channel on disconnect.</li>
+<li>macOS menu: show session last-used timestamps in the list and add recent-message previews in session submenus.</li>
+<li>macOS menu: tighten session row padding and time out session preview loading with cached fallback.</li>
+<li>macOS: log health refresh failures and recovery to make gateway issues easier to diagnose.</li>
+<li>macOS codesign: skip hardened runtime for ad-hoc signing and avoid empty options args (#70) — thanks @petter-b</li>
+<li>macOS codesign: include camera entitlement so permission prompts work in the menu bar app.</li>
+<li>Agent tools: bash tool supports real TTY via <code>stdinMode: "pty"</code> with node-pty, warning + fallback on load/start failure.</li>
+<li>Agent tools: map <code>camera.snap</code> JPEG payloads to <code>image/jpeg</code> to avoid MIME mismatch errors.</li>
+<li>Tests: cover <code>camera.snap</code> MIME mapping to prevent image/png vs image/jpeg mismatches.</li>
+<li>macOS camera: wait for exposure/white balance to settle before capturing a snap to avoid dark images.</li>
+<li>Camera snap: add <code>delayMs</code> parameter (default 2000ms on macOS) to improve exposure reliability.</li>
+<li>Camera: add <code>camera.list</code> and optional <code>deviceId</code> selection for snaps/clips.</li>
+<li>Tests: cover camera device selection params in CLI + agent tools.</li>
+<li>macOS packaging: move rpath config into swift build for reliability (#69) — thanks @petter-b</li>
+<li>macOS: prioritize main bundle for device resources to prevent crash (#73) — thanks @petter-b</li>
+<li>macOS remote: route settings through gateway config and avoid local config reads in remote mode.</li>
+<li>Telegram: align token resolution for cron/agent/CLI sends (env/config/tokenFile) to prevent isolated delivery failures (#76).</li>
+<li>Telegram: honor per-group mention gating defaults/overrides via <code>telegram.groups</code> and <code>"*"</code> defaults (thanks @joshp123).</li>
+<li>Chat UI: clear composer input immediately and allow clear while editing to prevent duplicate sends (#72) — thanks @hrdwdmrbl</li>
+<li>Restart: use systemd on Linux (and report actual restart method) instead of always launchctl.</li>
+<li>Gateway relay: detect Bun binaries via execPath to resolve packaged assets on macOS.</li>
+<li>Cron: prevent <code>every</code> schedules without an anchor from firing in a tight loop (thanks @jamesgroat).</li>
+<li>Docs: add manual OAuth setup for remote/headless deployments (#67) — thanks @wstock</li>
+<li>Docs/agent tools: clarify that browser <code>wait</code> should be avoided by default and used only in exceptional cases.</li>
+<li>Docs: clarify self-chat mode and group mention gating config (#111) — thanks @rafaelreis-r.</li>
+<li>Browser tools: <code>upload</code> supports auto-click refs, direct <code>inputRef</code>/<code>element</code> file inputs, and emits input/change after <code>setFiles</code> so JS-heavy sites pick up attachments.</li>
+<li>Browser tools: harden CDP readiness (HTTP + WS), retry CDP connects, and auto-restart the clawd browser when the socket handshake stalls.</li>
+<li>Browser CLI: add <code>clawdbot browser reset-profile</code> to move the clawd profile to Trash when it gets wedged.</li>
+<li>Signal: fix daemon startup race (wait for <code>/api/v1/check</code>) and normalize JSON-RPC <code>version</code> probe parsing.</li>
+<li>Docs/Signal: clarify bot-number vs personal-account setup (self-chat loop protection) and add a quickstart config snippet.</li>
+<li>Docs: refresh the CLI wizard guide and highlight onboarding in the README.</li>
+<li>CLI: tighten onboarding prompt typing to keep bun builds green.</li>
+<li>macOS: Voice Wake now fully tears down the Speech pipeline when disabled (cancel pending restarts, drop stale callbacks) to avoid high CPU in the background.</li>
+<li>macOS menu: add a Talk Mode action alongside the Open Dashboard/Chat/Canvas entries.</li>
+<li>macOS Debug: hide “Restart Gateway” when the app won’t start a local gateway (remote mode / attach-only).</li>
+<li>macOS Debug: add an icon for the App Logging submenu.</li>
+<li>macOS Talk Mode: orb overlay refresh, ElevenLabs request logging, API key status in settings, and auto-select first voice when none is configured.</li>
+<li>macOS Talk Mode: add hard timeout around ElevenLabs TTS synthesis to avoid getting stuck “speaking” forever on hung requests.</li>
+<li>macOS Talk Mode: avoid stuck playback when the audio player never starts (fail-fast + watchdog).</li>
+<li>macOS Talk Mode: fix audio stop ordering so disabling Talk Mode always stops in-flight playback.</li>
+<li>macOS Talk Mode: throttle audio-level updates (avoid per-buffer task creation) to reduce CPU/task churn.</li>
+<li>macOS Talk Mode: increase overlay window size so wave rings don’t clip; close button is hover-only and closer to the orb.</li>
+<li>WebChat: preserve chat run ordering per session so concurrent runs don’t strand the typing indicator.</li>
+<li>Talk Mode: fall back to system TTS when ElevenLabs is unavailable, returns non-audio, or playback fails (macOS/iOS/Android).</li>
+<li>Talk Mode: stream PCM on macOS/iOS for lower latency (incremental playback); Android continues MP3 streaming.</li>
+<li>Talk Mode: validate ElevenLabs v3 stability and latency tier directives before sending requests.</li>
+<li>iOS/Android Talk Mode: auto-select the first ElevenLabs voice when none is configured.</li>
+<li>ElevenLabs: add retry/backoff for 429/5xx and include content-type in errors for debugging.</li>
+<li>Talk Mode: align to the gateway’s main session key and fall back to history polling when chat events drop (prevents stuck “thinking” / missing messages).</li>
+<li>Talk Mode: treat history timestamps as seconds or milliseconds to avoid stale assistant picks (macOS/iOS/Android).</li>
+<li>Chat UI: clear streaming/tool bubbles when external runs finish, preventing duplicate assistant bubbles.</li>
+<li>Chat UI: user bubbles use <code>ui.seamColor</code> (fallback to a calmer default blue).</li>
+<li>Android Chat UI: use <code>onPrimary</code> for user bubble text to preserve contrast (thanks @Syhids).</li>
+<li>Control UI: sync sidebar navigation with the URL for deep-linking, and auto-scroll chat to the latest message.</li>
+<li>Control UI: disable Web Chat + Talk when no iOS/Android node is connected; refreshed Web Chat styling and keyboard send.</li>
+<li>Control UI: keep chat pinned to the latest message while typing/sending and restore drafts on send failures.</li>
+<li>Control UI: soften chat bubble text opacity for calmer readability.</li>
+<li>macOS Web Chat: improve empty/error states, focus message field on open, keep pill/send inside the input field, and make the composer pill edge-to-edge with square top corners.</li>
+<li>macOS: bundle Control UI assets into the app relay so the packaged app can serve them (thanks @mbelinky).</li>
+<li>Talk Mode: wait for chat history to surface the assistant reply before starting TTS (macOS/iOS/Android).</li>
+<li>iOS Talk Mode: fix chat completion wait to time out even if no events arrive (prevents “Thinking…” hangs).</li>
+<li>iOS Talk Mode: keep recognition running during playback to support interrupt-on-speech.</li>
+<li>iOS Talk Mode: preserve directive voice/model overrides across config reloads and add ElevenLabs request timeouts.</li>
+<li>iOS/Android Talk Mode: explicitly <code>chat.subscribe</code> when Talk Mode is active, so completion events arrive even if the Chat UI isn’t open.</li>
+<li>Chat UI: refresh history when another client finishes a run in the same session, so Talk Mode + Voice Wake transcripts appear consistently.</li>
+<li>Gateway: <code>voice.transcript</code> now also maps agent bus output to <code>chat</code> events, ensuring chat UIs refresh for voice-triggered runs.</li>
+<li>Gateway: auto-migrate legacy config on startup (non-Nix); Nix mode hard-fails with a clear error when legacy keys are present.</li>
+<li>iOS/Android: show a centered Talk Mode orb overlay while Talk Mode is enabled.</li>
+<li>Gateway config: inject <code>talk.apiKey</code> from <code>ELEVENLABS_API_KEY</code>/shell profile so nodes can fetch it on demand.</li>
+<li>Canvas A2UI: tag requests with <code>platform=android|ios|macos</code> and boost Android canvas background contrast.</li>
+<li>iOS/Android nodes: enable scrolling for loaded web pages in the Canvas WebView (default scaffold stays touch-first).</li>
+<li>macOS menu: device list now uses <code>node.list</code> (devices only; no agent/tool presence entries).</li>
+<li>macOS menu: device list now shows connected nodes only.</li>
+<li>macOS menu: device rows now pack platform/version on the first line, and command lists wrap in submenus.</li>
+<li>macOS menu: split device platform/version across first and second rows for better fit.</li>
+<li>macOS Canvas: show remote control status in the debug overlay and log A2UI auto-nav decisions.</li>
+<li>Canvas A2UI: polish the debug status HUD styling.</li>
+<li>iOS node: fix ReplayKit screen recording crash caused by queue isolation assertions during capture.</li>
+<li>iOS Talk Mode: avoid audio tap queue assertions when starting recognition.</li>
+<li>macOS: use $HOME/Library/pnpm for SSH PATH exports (thanks @mbelinky).</li>
+<li>macOS remote: harden SSH tunnel recovery/logging, honor <code>gateway.remote.url</code> port when forwarding, clarify gateway disconnect status, and add Debug menu tunnel reset.</li>
+<li>iOS/Android nodes: bridge auto-connect refreshes stale tokens and settings now show richer bridge/device details.</li>
+<li>macOS: bundle device model resources to prevent Instances crashes (thanks @mbelinky).</li>
+<li>iOS/Android nodes: status pill now surfaces camera activity instead of overlay toasts.</li>
+<li>iOS/Android/macOS nodes: camera snaps recompress to keep base64 payloads under 5 MB.</li>
+<li>iOS/Android nodes: status pill now surfaces pairing, screen recording, voice wake, and foreground-required states.</li>
+<li>iOS/Android nodes: avoid duplicating “Gateway reconnecting…” when the bridge is already connecting.</li>
+<li>iOS/Android nodes: Talk Mode now lives on a side bubble (with an iOS toggle to hide it), and Android settings no longer show the Talk Mode switch.</li>
+<li>macOS menu: top status line now shows pending node pairing approvals (incl. repairs).</li>
+<li>CLI: avoid spurious gateway close errors after successful request/response cycles.</li>
+<li>Agent runtime: clamp tool-result images to the 5MB Anthropic limit to avoid hard request rejections.</li>
+<li>Agent runtime: write v2 session headers so Pi session branching stays in the Clawdbot sessions dir.</li>
+<li>Tests: add Swift Testing coverage for camera errors and Kotest coverage for Android bridge endpoints.</li>
 </ul>
-<p><a href="https://github.com/steipete/clawdis/blob/main/CHANGELOG.md">View full changelog</a></p>
+<p><a href="https://github.com/clawdbot/clawdbot/blob/main/CHANGELOG.md">View full changelog</a></p>
 ]]></description>
-            <enclosure url="https://github.com/steipete/clawdis/releases/download/v2.0.0-beta4/Clawdis-2.0.0-beta4.zip" length="70407894" type="application/octet-stream" sparkle:edSignature="HmuiC7TnUn80ZApnKfb6w+JGSrjc3uUOndMrtbTp42bkBSVifbttNVazqvJueGBo4MgoJV8CP+zQNzVmtVihAQ=="/>
+            <enclosure url="https://github.com/clawdbot/clawdbot/releases/download/v2.0.0-beta5/Clawdbot-2.0.0-beta5.zip" length="145432870" type="application/octet-stream" sparkle:edSignature="qKPcmSx2pAaIYz9NqFp0TY63KrcDlpctUHnNpRs6Q60qQqBWtQycLIhhvhxmGnHupaiEXJfspb/Ad9RgODIzAw=="/>
         </item>
     </channel>
-</rss>
+</rss>

apps/android/README.md

@@ -1,6 +1,6 @@
-## Clawdis Node (Android) (internal)
+## Clawdbot Node (Android) (internal)
 
-Modern Android node app: connects to the **Gateway-owned bridge** (`_clawdis-bridge._tcp`) over TCP and exposes **Canvas + Chat + Camera**.
+Modern Android node app: connects to the **Gateway-owned bridge** (`_clawdbot-bridge._tcp`) over TCP and exposes **Canvas + Chat + Camera**.
 
 Notes:
 - The node keeps the connection alive via a **foreground service** (persistent notification with a Disconnect action).
@@ -25,7 +25,7 @@ cd apps/android
 
 1) Start the gateway (on your “master” machine):
 ```bash
-pnpm clawdis gateway --port 18789 --verbose
+pnpm clawdbot gateway --port 18789 --verbose
 ```
 
 2) In the Android app:
@@ -34,8 +34,8 @@ pnpm clawdis gateway --port 18789 --verbose
 
 3) Approve pairing (on the gateway machine):
 ```bash
-clawdis nodes pending
-clawdis nodes approve <requestId>
+clawdbot nodes pending
+clawdbot nodes approve <requestId>
 ```
 
 More details: `docs/android/connect.md`.

apps/android/app/build.gradle.kts

@@ -6,17 +6,17 @@ plugins {
 }
 
 android {
-  namespace = "com.steipete.clawdis.node"
+  namespace = "com.clawdbot.android"
   compileSdk = 36
 
   sourceSets {
     getByName("main") {
-      assets.srcDir(file("../../shared/ClawdisKit/Sources/ClawdisKit/Resources"))
+      assets.srcDir(file("../../shared/ClawdbotKit/Sources/ClawdbotKit/Resources"))
     }
   }
 
   defaultConfig {
-    applicationId = "com.steipete.clawdis.node"
+    applicationId = "com.clawdbot.android"
     minSdk = 31
     targetSdk = 36
     versionCode = 1
@@ -48,6 +48,10 @@ android {
   lint {
     disable += setOf("IconLauncherShape")
   }
+
+  testOptions {
+    unitTests.isIncludeAndroidResources = true
+  }
 }
 
 kotlin {
@@ -96,6 +100,7 @@ dependencies {
   testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.10.2")
   testImplementation("io.kotest:kotest-runner-junit5-jvm:6.0.7")
   testImplementation("io.kotest:kotest-assertions-core-jvm:6.0.7")
+  testImplementation("org.robolectric:robolectric:4.16")
   testRuntimeOnly("org.junit.vintage:junit-vintage-engine:5.13.3")
 }
 

apps/android/app/src/main/AndroidManifest.xml

@@ -9,17 +9,18 @@
     <uses-permission
         android:name="android.permission.NEARBY_WIFI_DEVICES"
         android:usesPermissionFlags="neverForLocation" />
-    <uses-permission
-        android:name="android.permission.ACCESS_FINE_LOCATION"
-        android:maxSdkVersion="32" />
-    <uses-permission
-        android:name="android.permission.ACCESS_COARSE_LOCATION"
-        android:maxSdkVersion="32" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
     <uses-permission android:name="android.permission.CAMERA" />
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.SEND_SMS" />
     <uses-feature
         android:name="android.hardware.camera"
         android:required="false" />
+    <uses-feature
+        android:name="android.hardware.telephony"
+        android:required="false" />
 
     <application
         android:name=".NodeApp"
@@ -31,7 +32,7 @@
         android:label="@string/app_name"
         android:supportsRtl="true"
         android:networkSecurityConfig="@xml/network_security_config"
-        android:theme="@style/Theme.ClawdisNode">
+        android:theme="@style/Theme.ClawdbotNode">
         <service
             android:name=".NodeForegroundService"
             android:exported="false"

apps/android/app/src/main/assets/tool-display.json

@@ -0,0 +1,197 @@
+{
+  "version": 1,
+  "fallback": {
+    "emoji": "🧩",
+    "detailKeys": [
+      "command",
+      "path",
+      "url",
+      "targetUrl",
+      "targetId",
+      "ref",
+      "element",
+      "node",
+      "nodeId",
+      "jobId",
+      "requestId",
+      "to",
+      "channelId",
+      "guildId",
+      "userId",
+      "name",
+      "query",
+      "pattern",
+      "messageId"
+    ]
+  },
+  "tools": {
+    "bash": {
+      "emoji": "🛠️",
+      "title": "Bash",
+      "detailKeys": ["command"]
+    },
+    "process": {
+      "emoji": "🧰",
+      "title": "Process",
+      "detailKeys": ["sessionId"]
+    },
+    "read": {
+      "emoji": "📖",
+      "title": "Read",
+      "detailKeys": ["path"]
+    },
+    "write": {
+      "emoji": "✍️",
+      "title": "Write",
+      "detailKeys": ["path"]
+    },
+    "edit": {
+      "emoji": "📝",
+      "title": "Edit",
+      "detailKeys": ["path"]
+    },
+    "attach": {
+      "emoji": "📎",
+      "title": "Attach",
+      "detailKeys": ["path", "url", "fileName"]
+    },
+    "browser": {
+      "emoji": "🌐",
+      "title": "Browser",
+      "actions": {
+        "status": { "label": "status" },
+        "start": { "label": "start" },
+        "stop": { "label": "stop" },
+        "tabs": { "label": "tabs" },
+        "open": { "label": "open", "detailKeys": ["targetUrl"] },
+        "focus": { "label": "focus", "detailKeys": ["targetId"] },
+        "close": { "label": "close", "detailKeys": ["targetId"] },
+        "snapshot": {
+          "label": "snapshot",
+          "detailKeys": ["targetUrl", "targetId", "ref", "element", "format"]
+        },
+        "screenshot": {
+          "label": "screenshot",
+          "detailKeys": ["targetUrl", "targetId", "ref", "element"]
+        },
+        "navigate": {
+          "label": "navigate",
+          "detailKeys": ["targetUrl", "targetId"]
+        },
+        "console": { "label": "console", "detailKeys": ["level", "targetId"] },
+        "pdf": { "label": "pdf", "detailKeys": ["targetId"] },
+        "upload": {
+          "label": "upload",
+          "detailKeys": ["paths", "ref", "inputRef", "element", "targetId"]
+        },
+        "dialog": {
+          "label": "dialog",
+          "detailKeys": ["accept", "promptText", "targetId"]
+        },
+        "act": {
+          "label": "act",
+          "detailKeys": ["request.kind", "request.ref", "request.selector", "request.text", "request.value"]
+        }
+      }
+    },
+    "canvas": {
+      "emoji": "🖼️",
+      "title": "Canvas",
+      "actions": {
+        "present": { "label": "present", "detailKeys": ["target", "node", "nodeId"] },
+        "hide": { "label": "hide", "detailKeys": ["node", "nodeId"] },
+        "navigate": { "label": "navigate", "detailKeys": ["url", "node", "nodeId"] },
+        "eval": { "label": "eval", "detailKeys": ["javaScript", "node", "nodeId"] },
+        "snapshot": { "label": "snapshot", "detailKeys": ["format", "node", "nodeId"] },
+        "a2ui_push": { "label": "A2UI push", "detailKeys": ["jsonlPath", "node", "nodeId"] },
+        "a2ui_reset": { "label": "A2UI reset", "detailKeys": ["node", "nodeId"] }
+      }
+    },
+    "nodes": {
+      "emoji": "📱",
+      "title": "Nodes",
+      "actions": {
+        "status": { "label": "status" },
+        "describe": { "label": "describe", "detailKeys": ["node", "nodeId"] },
+        "pending": { "label": "pending" },
+        "approve": { "label": "approve", "detailKeys": ["requestId"] },
+        "reject": { "label": "reject", "detailKeys": ["requestId"] },
+        "notify": { "label": "notify", "detailKeys": ["node", "nodeId", "title", "body"] },
+        "camera_snap": { "label": "camera snap", "detailKeys": ["node", "nodeId", "facing", "deviceId"] },
+        "camera_list": { "label": "camera list", "detailKeys": ["node", "nodeId"] },
+        "camera_clip": { "label": "camera clip", "detailKeys": ["node", "nodeId", "facing", "duration", "durationMs"] },
+        "screen_record": {
+          "label": "screen record",
+          "detailKeys": ["node", "nodeId", "duration", "durationMs", "fps", "screenIndex"]
+        }
+      }
+    },
+    "cron": {
+      "emoji": "⏰",
+      "title": "Cron",
+      "actions": {
+        "status": { "label": "status" },
+        "list": { "label": "list" },
+        "add": {
+          "label": "add",
+          "detailKeys": ["job.name", "job.id", "job.schedule", "job.cron"]
+        },
+        "update": { "label": "update", "detailKeys": ["jobId"] },
+        "remove": { "label": "remove", "detailKeys": ["jobId"] },
+        "run": { "label": "run", "detailKeys": ["jobId"] },
+        "runs": { "label": "runs", "detailKeys": ["jobId"] },
+        "wake": { "label": "wake", "detailKeys": ["text", "mode"] }
+      }
+    },
+    "gateway": {
+      "emoji": "🔌",
+      "title": "Gateway",
+      "actions": {
+        "restart": { "label": "restart", "detailKeys": ["reason", "delayMs"] }
+      }
+    },
+    "whatsapp_login": {
+      "emoji": "🟢",
+      "title": "WhatsApp Login",
+      "actions": {
+        "start": { "label": "start" },
+        "wait": { "label": "wait" }
+      }
+    },
+    "discord": {
+      "emoji": "💬",
+      "title": "Discord",
+      "actions": {
+        "react": { "label": "react", "detailKeys": ["channelId", "messageId", "emoji"] },
+        "reactions": { "label": "reactions", "detailKeys": ["channelId", "messageId"] },
+        "sticker": { "label": "sticker", "detailKeys": ["to", "stickerIds"] },
+        "poll": { "label": "poll", "detailKeys": ["question", "to"] },
+        "permissions": { "label": "permissions", "detailKeys": ["channelId"] },
+        "readMessages": { "label": "read messages", "detailKeys": ["channelId", "limit"] },
+        "sendMessage": { "label": "send", "detailKeys": ["to", "content"] },
+        "editMessage": { "label": "edit", "detailKeys": ["channelId", "messageId"] },
+        "deleteMessage": { "label": "delete", "detailKeys": ["channelId", "messageId"] },
+        "threadCreate": { "label": "thread create", "detailKeys": ["channelId", "name"] },
+        "threadList": { "label": "thread list", "detailKeys": ["guildId", "channelId"] },
+        "threadReply": { "label": "thread reply", "detailKeys": ["channelId", "content"] },
+        "pinMessage": { "label": "pin", "detailKeys": ["channelId", "messageId"] },
+        "unpinMessage": { "label": "unpin", "detailKeys": ["channelId", "messageId"] },
+        "listPins": { "label": "list pins", "detailKeys": ["channelId"] },
+        "searchMessages": { "label": "search", "detailKeys": ["guildId", "content"] },
+        "memberInfo": { "label": "member", "detailKeys": ["guildId", "userId"] },
+        "roleInfo": { "label": "roles", "detailKeys": ["guildId"] },
+        "emojiList": { "label": "emoji list", "detailKeys": ["guildId"] },
+        "roleAdd": { "label": "role add", "detailKeys": ["guildId", "userId", "roleId"] },
+        "roleRemove": { "label": "role remove", "detailKeys": ["guildId", "userId", "roleId"] },
+        "channelInfo": { "label": "channel", "detailKeys": ["channelId"] },
+        "channelList": { "label": "channels", "detailKeys": ["guildId"] },
+        "voiceStatus": { "label": "voice", "detailKeys": ["guildId", "userId"] },
+        "eventList": { "label": "events", "detailKeys": ["guildId"] },
+        "eventCreate": { "label": "event create", "detailKeys": ["guildId", "name"] },
+        "timeout": { "label": "timeout", "detailKeys": ["guildId", "userId"] },
+        "kick": { "label": "kick", "detailKeys": ["guildId", "userId"] },
+        "ban": { "label": "ban", "detailKeys": ["guildId", "userId"] }
+      }
+    }
+  }
+}

apps/android/app/src/main/java/com/clawdbot/android/CameraHudState.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node
+package com.clawdbot.android
 
 enum class CameraHudKind {
   Photo,

apps/android/app/src/main/java/com/clawdbot/android/DeviceNames.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node
+package com.clawdbot.android
 
 import android.content.Context
 import android.os.Build

apps/android/app/src/main/java/com/clawdbot/android/LocationMode.kt

@@ -0,0 +1,15 @@
+package com.clawdbot.android
+
+enum class LocationMode(val rawValue: String) {
+  Off("off"),
+  WhileUsing("whileUsing"),
+  Always("always"),
+  ;
+
+  companion object {
+    fun fromRawValue(raw: String?): LocationMode {
+      val normalized = raw?.trim()?.lowercase()
+      return entries.firstOrNull { it.rawValue.lowercase() == normalized } ?: Off
+    }
+  }
+}

apps/android/app/src/main/java/com/clawdbot/android/MainActivity.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node
+package com.clawdbot.android
 
 import android.Manifest
 import android.content.pm.ApplicationInfo
@@ -18,8 +18,8 @@ import androidx.core.view.WindowInsetsControllerCompat
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.repeatOnLifecycle
-import com.steipete.clawdis.node.ui.RootScreen
-import com.steipete.clawdis.node.ui.ClawdisTheme
+import com.clawdbot.android.ui.RootScreen
+import com.clawdbot.android.ui.ClawdbotTheme
 import kotlinx.coroutines.launch
 
 class MainActivity : ComponentActivity() {
@@ -39,6 +39,7 @@ class MainActivity : ComponentActivity() {
     screenCaptureRequester = ScreenCaptureRequester(this)
     viewModel.camera.attachLifecycleOwner(this)
     viewModel.camera.attachPermissionRequester(permissionRequester)
+    viewModel.sms.attachPermissionRequester(permissionRequester)
     viewModel.screenRecorder.attachScreenCaptureRequester(screenCaptureRequester)
     viewModel.screenRecorder.attachPermissionRequester(permissionRequester)
 
@@ -55,7 +56,7 @@ class MainActivity : ComponentActivity() {
     }
 
     setContent {
-      ClawdisTheme {
+      ClawdbotTheme {
         Surface(modifier = Modifier) {
           RootScreen(viewModel = viewModel)
         }

apps/android/app/src/main/java/com/clawdbot/android/MainViewModel.kt

@@ -1,12 +1,13 @@
-package com.steipete.clawdis.node
+package com.clawdbot.android
 
 import android.app.Application
 import androidx.lifecycle.AndroidViewModel
-import com.steipete.clawdis.node.bridge.BridgeEndpoint
-import com.steipete.clawdis.node.chat.OutgoingAttachment
-import com.steipete.clawdis.node.node.CameraCaptureManager
-import com.steipete.clawdis.node.node.CanvasController
-import com.steipete.clawdis.node.node.ScreenRecordManager
+import com.clawdbot.android.bridge.BridgeEndpoint
+import com.clawdbot.android.chat.OutgoingAttachment
+import com.clawdbot.android.node.CameraCaptureManager
+import com.clawdbot.android.node.CanvasController
+import com.clawdbot.android.node.ScreenRecordManager
+import com.clawdbot.android.node.SmsManager
 import kotlinx.coroutines.flow.StateFlow
 
 class MainViewModel(app: Application) : AndroidViewModel(app) {
@@ -15,6 +16,7 @@ class MainViewModel(app: Application) : AndroidViewModel(app) {
   val canvas: CanvasController = runtime.canvas
   val camera: CameraCaptureManager = runtime.camera
   val screenRecorder: ScreenRecordManager = runtime.screenRecorder
+  val sms: SmsManager = runtime.sms
 
   val bridges: StateFlow<List<BridgeEndpoint>> = runtime.bridges
   val discoveryStatusText: StateFlow<String> = runtime.discoveryStatusText
@@ -33,6 +35,8 @@ class MainViewModel(app: Application) : AndroidViewModel(app) {
   val instanceId: StateFlow<String> = runtime.instanceId
   val displayName: StateFlow<String> = runtime.displayName
   val cameraEnabled: StateFlow<Boolean> = runtime.cameraEnabled
+  val locationMode: StateFlow<LocationMode> = runtime.locationMode
+  val locationPreciseEnabled: StateFlow<Boolean> = runtime.locationPreciseEnabled
   val preventSleep: StateFlow<Boolean> = runtime.preventSleep
   val wakeWords: StateFlow<List<String>> = runtime.wakeWords
   val voiceWakeMode: StateFlow<VoiceWakeMode> = runtime.voiceWakeMode
@@ -70,6 +74,14 @@ class MainViewModel(app: Application) : AndroidViewModel(app) {
     runtime.setCameraEnabled(value)
   }
 
+  fun setLocationMode(mode: LocationMode) {
+    runtime.setLocationMode(mode)
+  }
+
+  fun setLocationPreciseEnabled(value: Boolean) {
+    runtime.setLocationPreciseEnabled(value)
+  }
+
   fun setPreventSleep(value: Boolean) {
     runtime.setPreventSleep(value)
   }
@@ -106,6 +118,10 @@ class MainViewModel(app: Application) : AndroidViewModel(app) {
     runtime.setTalkEnabled(enabled)
   }
 
+  fun refreshBridgeHello() {
+    runtime.refreshBridgeHello()
+  }
+
   fun connect(endpoint: BridgeEndpoint) {
     runtime.connect(endpoint)
   }

apps/android/app/src/main/java/com/clawdbot/android/NodeApp.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node
+package com.clawdbot.android
 
 import android.app.Application
 

apps/android/app/src/main/java/com/clawdbot/android/NodeForegroundService.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node
+package com.clawdbot.android
 
 import android.app.Notification
 import android.app.NotificationChannel
@@ -29,7 +29,7 @@ class NodeForegroundService : Service() {
   override fun onCreate() {
     super.onCreate()
     ensureChannel()
-    val initial = buildNotification(title = "Clawdis Node", text = "Starting…")
+    val initial = buildNotification(title = "Clawdbot Node", text = "Starting…")
     startForegroundWithTypes(notification = initial, requiresMic = false)
 
     val runtime = (application as NodeApp).runtime
@@ -44,7 +44,7 @@ class NodeForegroundService : Service() {
         ) { status, server, connected, voiceMode, voiceListening ->
           Quint(status, server, connected, voiceMode, voiceListening)
         }.collect { (status, server, connected, voiceMode, voiceListening) ->
-          val title = if (connected) "Clawdis Node · Connected" else "Clawdis Node"
+          val title = if (connected) "Clawdbot Node · Connected" else "Clawdbot Node"
           val voiceSuffix =
             if (voiceMode == VoiceWakeMode.Always) {
               if (voiceListening) " · Voice Wake: Listening" else " · Voice Wake: Paused"
@@ -91,21 +91,38 @@ class NodeForegroundService : Service() {
         "Connection",
         NotificationManager.IMPORTANCE_LOW,
       ).apply {
-        description = "Clawdis node connection status"
+        description = "Clawdbot node connection status"
         setShowBadge(false)
       }
     mgr.createNotificationChannel(channel)
   }
 
   private fun buildNotification(title: String, text: String): Notification {
+    val launchIntent = Intent(this, MainActivity::class.java).apply {
+      flags = Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP
+    }
+    val launchPending =
+      PendingIntent.getActivity(
+        this,
+        1,
+        launchIntent,
+        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+      )
+
     val stopIntent = Intent(this, NodeForegroundService::class.java).setAction(ACTION_STOP)
-    val flags = PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-    val stopPending = PendingIntent.getService(this, 2, stopIntent, flags)
+    val stopPending =
+      PendingIntent.getService(
+        this,
+        2,
+        stopIntent,
+        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+      )
 
     return NotificationCompat.Builder(this, CHANNEL_ID)
       .setSmallIcon(R.mipmap.ic_launcher)
       .setContentTitle(title)
       .setContentText(text)
+      .setContentIntent(launchPending)
       .setOngoing(true)
       .setOnlyAlertOnce(true)
       .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
@@ -146,7 +163,7 @@ class NodeForegroundService : Service() {
     private const val CHANNEL_ID = "connection"
     private const val NOTIFICATION_ID = 1
 
-    private const val ACTION_STOP = "com.steipete.clawdis.node.action.STOP"
+    private const val ACTION_STOP = "com.clawdbot.android.action.STOP"
 
     fun start(context: Context) {
       val intent = Intent(context, NodeForegroundService::class.java)

apps/android/app/src/main/java/com/clawdbot/android/NodeRuntime.kt

@@ -1,36 +1,42 @@
-package com.steipete.clawdis.node
+package com.clawdbot.android
 
 import android.Manifest
 import android.content.Context
 import android.content.pm.PackageManager
+import android.location.LocationManager
 import android.os.Build
 import android.os.SystemClock
 import androidx.core.content.ContextCompat
-import com.steipete.clawdis.node.chat.ChatController
-import com.steipete.clawdis.node.chat.ChatMessage
-import com.steipete.clawdis.node.chat.ChatPendingToolCall
-import com.steipete.clawdis.node.chat.ChatSessionEntry
-import com.steipete.clawdis.node.chat.OutgoingAttachment
-import com.steipete.clawdis.node.bridge.BridgeDiscovery
-import com.steipete.clawdis.node.bridge.BridgeEndpoint
-import com.steipete.clawdis.node.bridge.BridgePairingClient
-import com.steipete.clawdis.node.bridge.BridgeSession
-import com.steipete.clawdis.node.node.CameraCaptureManager
-import com.steipete.clawdis.node.BuildConfig
-import com.steipete.clawdis.node.node.CanvasController
-import com.steipete.clawdis.node.node.ScreenRecordManager
-import com.steipete.clawdis.node.protocol.ClawdisCapability
-import com.steipete.clawdis.node.protocol.ClawdisCameraCommand
-import com.steipete.clawdis.node.protocol.ClawdisCanvasA2UIAction
-import com.steipete.clawdis.node.protocol.ClawdisCanvasA2UICommand
-import com.steipete.clawdis.node.protocol.ClawdisCanvasCommand
-import com.steipete.clawdis.node.protocol.ClawdisScreenCommand
-import com.steipete.clawdis.node.voice.TalkModeManager
-import com.steipete.clawdis.node.voice.VoiceWakeManager
+import com.clawdbot.android.chat.ChatController
+import com.clawdbot.android.chat.ChatMessage
+import com.clawdbot.android.chat.ChatPendingToolCall
+import com.clawdbot.android.chat.ChatSessionEntry
+import com.clawdbot.android.chat.OutgoingAttachment
+import com.clawdbot.android.bridge.BridgeDiscovery
+import com.clawdbot.android.bridge.BridgeEndpoint
+import com.clawdbot.android.bridge.BridgePairingClient
+import com.clawdbot.android.bridge.BridgeSession
+import com.clawdbot.android.node.CameraCaptureManager
+import com.clawdbot.android.node.LocationCaptureManager
+import com.clawdbot.android.BuildConfig
+import com.clawdbot.android.node.CanvasController
+import com.clawdbot.android.node.ScreenRecordManager
+import com.clawdbot.android.node.SmsManager
+import com.clawdbot.android.protocol.ClawdbotCapability
+import com.clawdbot.android.protocol.ClawdbotCameraCommand
+import com.clawdbot.android.protocol.ClawdbotCanvasA2UIAction
+import com.clawdbot.android.protocol.ClawdbotCanvasA2UICommand
+import com.clawdbot.android.protocol.ClawdbotCanvasCommand
+import com.clawdbot.android.protocol.ClawdbotScreenCommand
+import com.clawdbot.android.protocol.ClawdbotLocationCommand
+import com.clawdbot.android.protocol.ClawdbotSmsCommand
+import com.clawdbot.android.voice.TalkModeManager
+import com.clawdbot.android.voice.VoiceWakeManager
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.TimeoutCancellationException
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -55,7 +61,9 @@ class NodeRuntime(context: Context) {
   val prefs = SecurePrefs(appContext)
   val canvas = CanvasController()
   val camera = CameraCaptureManager(appContext)
+  val location = LocationCaptureManager(appContext)
   val screenRecorder = ScreenRecordManager(appContext)
+  val sms = SmsManager(appContext)
   private val json = Json { ignoreUnknownKeys = true }
 
   private val externalAudioCaptureActive = MutableStateFlow(false)
@@ -186,6 +194,8 @@ class NodeRuntime(context: Context) {
   val instanceId: StateFlow<String> = prefs.instanceId
   val displayName: StateFlow<String> = prefs.displayName
   val cameraEnabled: StateFlow<Boolean> = prefs.cameraEnabled
+  val locationMode: StateFlow<LocationMode> = prefs.locationMode
+  val locationPreciseEnabled: StateFlow<Boolean> = prefs.locationPreciseEnabled
   val preventSleep: StateFlow<Boolean> = prefs.preventSleep
   val wakeWords: StateFlow<List<String>> = prefs.wakeWords
   val voiceWakeMode: StateFlow<VoiceWakeMode> = prefs.voiceWakeMode
@@ -312,6 +322,14 @@ class NodeRuntime(context: Context) {
     prefs.setCameraEnabled(value)
   }
 
+  fun setLocationMode(mode: LocationMode) {
+    prefs.setLocationMode(mode)
+  }
+
+  fun setLocationPreciseEnabled(value: Boolean) {
+    prefs.setLocationPreciseEnabled(value)
+  }
+
   fun setPreventSleep(value: Boolean) {
     prefs.setPreventSleep(value)
   }
@@ -349,104 +367,128 @@ class NodeRuntime(context: Context) {
     prefs.setTalkEnabled(value)
   }
 
+  private fun buildInvokeCommands(): List<String> =
+    buildList {
+      add(ClawdbotCanvasCommand.Present.rawValue)
+      add(ClawdbotCanvasCommand.Hide.rawValue)
+      add(ClawdbotCanvasCommand.Navigate.rawValue)
+      add(ClawdbotCanvasCommand.Eval.rawValue)
+      add(ClawdbotCanvasCommand.Snapshot.rawValue)
+      add(ClawdbotCanvasA2UICommand.Push.rawValue)
+      add(ClawdbotCanvasA2UICommand.PushJSONL.rawValue)
+      add(ClawdbotCanvasA2UICommand.Reset.rawValue)
+      add(ClawdbotScreenCommand.Record.rawValue)
+      if (cameraEnabled.value) {
+        add(ClawdbotCameraCommand.Snap.rawValue)
+        add(ClawdbotCameraCommand.Clip.rawValue)
+      }
+      if (locationMode.value != LocationMode.Off) {
+        add(ClawdbotLocationCommand.Get.rawValue)
+      }
+      if (sms.canSendSms()) {
+        add(ClawdbotSmsCommand.Send.rawValue)
+      }
+    }
+
+  private fun buildCapabilities(): List<String> =
+    buildList {
+      add(ClawdbotCapability.Canvas.rawValue)
+      add(ClawdbotCapability.Screen.rawValue)
+      if (cameraEnabled.value) add(ClawdbotCapability.Camera.rawValue)
+      if (sms.canSendSms()) add(ClawdbotCapability.Sms.rawValue)
+      if (voiceWakeMode.value != VoiceWakeMode.Off && hasRecordAudioPermission()) {
+        add(ClawdbotCapability.VoiceWake.rawValue)
+      }
+      if (locationMode.value != LocationMode.Off) {
+        add(ClawdbotCapability.Location.rawValue)
+      }
+    }
+
+  private fun buildPairingHello(token: String?): BridgePairingClient.Hello {
+    val modelIdentifier = listOfNotNull(Build.MANUFACTURER, Build.MODEL)
+      .joinToString(" ")
+      .trim()
+      .ifEmpty { null }
+    val versionName = BuildConfig.VERSION_NAME.trim().ifEmpty { "dev" }
+    val advertisedVersion =
+      if (BuildConfig.DEBUG && !versionName.contains("dev", ignoreCase = true)) {
+        "$versionName-dev"
+      } else {
+        versionName
+      }
+    return BridgePairingClient.Hello(
+      nodeId = instanceId.value,
+      displayName = displayName.value,
+      token = token,
+      platform = "Android",
+      version = advertisedVersion,
+      deviceFamily = "Android",
+      modelIdentifier = modelIdentifier,
+      caps = buildCapabilities(),
+      commands = buildInvokeCommands(),
+    )
+  }
+
+  private fun buildSessionHello(token: String?): BridgeSession.Hello {
+    val modelIdentifier = listOfNotNull(Build.MANUFACTURER, Build.MODEL)
+      .joinToString(" ")
+      .trim()
+      .ifEmpty { null }
+    val versionName = BuildConfig.VERSION_NAME.trim().ifEmpty { "dev" }
+    val advertisedVersion =
+      if (BuildConfig.DEBUG && !versionName.contains("dev", ignoreCase = true)) {
+        "$versionName-dev"
+      } else {
+        versionName
+      }
+    return BridgeSession.Hello(
+      nodeId = instanceId.value,
+      displayName = displayName.value,
+      token = token,
+      platform = "Android",
+      version = advertisedVersion,
+      deviceFamily = "Android",
+      modelIdentifier = modelIdentifier,
+      caps = buildCapabilities(),
+      commands = buildInvokeCommands(),
+    )
+  }
+
+  fun refreshBridgeHello() {
+    scope.launch {
+      if (!_isConnected.value) return@launch
+      val token = prefs.loadBridgeToken()
+      if (token.isNullOrBlank()) return@launch
+      session.updateHello(buildSessionHello(token))
+    }
+  }
+
   fun connect(endpoint: BridgeEndpoint) {
     scope.launch {
       _statusText.value = "Connecting…"
       val storedToken = prefs.loadBridgeToken()
-      val modelIdentifier = listOfNotNull(Build.MANUFACTURER, Build.MODEL)
-        .joinToString(" ")
-        .trim()
-        .ifEmpty { null }
-
-      val invokeCommands =
-        buildList {
-          add(ClawdisCanvasCommand.Present.rawValue)
-          add(ClawdisCanvasCommand.Hide.rawValue)
-          add(ClawdisCanvasCommand.Navigate.rawValue)
-          add(ClawdisCanvasCommand.Eval.rawValue)
-          add(ClawdisCanvasCommand.Snapshot.rawValue)
-          add(ClawdisCanvasA2UICommand.Push.rawValue)
-          add(ClawdisCanvasA2UICommand.PushJSONL.rawValue)
-          add(ClawdisCanvasA2UICommand.Reset.rawValue)
-          add(ClawdisScreenCommand.Record.rawValue)
-          if (cameraEnabled.value) {
-            add(ClawdisCameraCommand.Snap.rawValue)
-            add(ClawdisCameraCommand.Clip.rawValue)
-          }
-        }
       val resolved =
         if (storedToken.isNullOrBlank()) {
           _statusText.value = "Pairing…"
-          val caps = buildList {
-            add(ClawdisCapability.Canvas.rawValue)
-            add(ClawdisCapability.Screen.rawValue)
-            if (cameraEnabled.value) add(ClawdisCapability.Camera.rawValue)
-            if (voiceWakeMode.value != VoiceWakeMode.Off && hasRecordAudioPermission()) {
-              add(ClawdisCapability.VoiceWake.rawValue)
-            }
-          }
-          val versionName = BuildConfig.VERSION_NAME.trim().ifEmpty { "dev" }
-          val advertisedVersion =
-            if (BuildConfig.DEBUG && !versionName.contains("dev", ignoreCase = true)) {
-              "$versionName-dev"
-            } else {
-              versionName
-            }
           BridgePairingClient().pairAndHello(
             endpoint = endpoint,
-            hello =
-              BridgePairingClient.Hello(
-                nodeId = instanceId.value,
-                displayName = displayName.value,
-                token = null,
-                platform = "Android",
-                version = advertisedVersion,
-                deviceFamily = "Android",
-                modelIdentifier = modelIdentifier,
-                caps = caps,
-                commands = invokeCommands,
-              ),
+            hello = buildPairingHello(token = null),
           )
         } else {
           BridgePairingClient.PairResult(ok = true, token = storedToken.trim())
         }
 
       if (!resolved.ok || resolved.token.isNullOrBlank()) {
-        _statusText.value = "Failed: pairing required"
+        val errorMessage = resolved.error?.trim().orEmpty().ifEmpty { "pairing required" }
+        _statusText.value = "Failed: $errorMessage"
         return@launch
       }
 
       val authToken = requireNotNull(resolved.token).trim()
       prefs.saveBridgeToken(authToken)
-      val versionName = BuildConfig.VERSION_NAME.trim().ifEmpty { "dev" }
-      val advertisedVersion =
-        if (BuildConfig.DEBUG && !versionName.contains("dev", ignoreCase = true)) {
-          "$versionName-dev"
-        } else {
-          versionName
-        }
       session.connect(
         endpoint = endpoint,
-        hello =
-          BridgeSession.Hello(
-            nodeId = instanceId.value,
-            displayName = displayName.value,
-            token = authToken,
-            platform = "Android",
-            version = advertisedVersion,
-            deviceFamily = "Android",
-            modelIdentifier = modelIdentifier,
-            caps =
-              buildList {
-                add(ClawdisCapability.Canvas.rawValue)
-                add(ClawdisCapability.Screen.rawValue)
-                if (cameraEnabled.value) add(ClawdisCapability.Camera.rawValue)
-                if (voiceWakeMode.value != VoiceWakeMode.Off && hasRecordAudioPermission()) {
-                  add(ClawdisCapability.VoiceWake.rawValue)
-                }
-              },
-            commands = invokeCommands,
-          ),
+        hello = buildSessionHello(token = authToken),
       )
     }
   }
@@ -458,6 +500,28 @@ class NodeRuntime(context: Context) {
       )
   }
 
+  private fun hasFineLocationPermission(): Boolean {
+    return (
+      ContextCompat.checkSelfPermission(appContext, Manifest.permission.ACCESS_FINE_LOCATION) ==
+        PackageManager.PERMISSION_GRANTED
+      )
+  }
+
+  private fun hasCoarseLocationPermission(): Boolean {
+    return (
+      ContextCompat.checkSelfPermission(appContext, Manifest.permission.ACCESS_COARSE_LOCATION) ==
+        PackageManager.PERMISSION_GRANTED
+      )
+  }
+
+  private fun hasBackgroundLocationPermission(): Boolean {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return true
+    return (
+      ContextCompat.checkSelfPermission(appContext, Manifest.permission.ACCESS_BACKGROUND_LOCATION) ==
+        PackageManager.PERMISSION_GRANTED
+      )
+  }
+
   fun connectManual() {
     val host = manualHost.value.trim()
     val port = manualPort.value
@@ -488,7 +552,7 @@ class NodeRuntime(context: Context) {
       val actionId = (userActionObj["id"] as? JsonPrimitive)?.content?.trim().orEmpty().ifEmpty {
         java.util.UUID.randomUUID().toString()
       }
-      val name = ClawdisCanvasA2UIAction.extractActionName(userActionObj) ?: return@launch
+      val name = ClawdbotCanvasA2UIAction.extractActionName(userActionObj) ?: return@launch
 
       val surfaceId =
         (userActionObj["surfaceId"] as? JsonPrimitive)?.content?.trim().orEmpty().ifEmpty { "main" }
@@ -498,7 +562,7 @@ class NodeRuntime(context: Context) {
 
       val sessionKey = "main"
       val message =
-        ClawdisCanvasA2UIAction.formatAgentMessage(
+        ClawdbotCanvasA2UIAction.formatAgentMessage(
           actionName = name,
           sessionKey = sessionKey,
           surfaceId = surfaceId,
@@ -532,7 +596,7 @@ class NodeRuntime(context: Context) {
 
       try {
         canvas.eval(
-          ClawdisCanvasA2UIAction.jsDispatchA2UIActionStatus(
+          ClawdbotCanvasA2UIAction.jsDispatchA2UIActionStatus(
             actionId = actionId,
             ok = connected && error == null,
             error = error,
@@ -649,10 +713,10 @@ class NodeRuntime(context: Context) {
 
   private suspend fun handleInvoke(command: String, paramsJson: String?): BridgeSession.InvokeResult {
     if (
-      command.startsWith(ClawdisCanvasCommand.NamespacePrefix) ||
-        command.startsWith(ClawdisCanvasA2UICommand.NamespacePrefix) ||
-        command.startsWith(ClawdisCameraCommand.NamespacePrefix) ||
-        command.startsWith(ClawdisScreenCommand.NamespacePrefix)
+      command.startsWith(ClawdbotCanvasCommand.NamespacePrefix) ||
+        command.startsWith(ClawdbotCanvasA2UICommand.NamespacePrefix) ||
+        command.startsWith(ClawdbotCameraCommand.NamespacePrefix) ||
+        command.startsWith(ClawdbotScreenCommand.NamespacePrefix)
       ) {
       if (!isForeground.value) {
         return BridgeSession.InvokeResult.error(
@@ -661,26 +725,34 @@ class NodeRuntime(context: Context) {
         )
       }
     }
-    if (command.startsWith(ClawdisCameraCommand.NamespacePrefix) && !cameraEnabled.value) {
+    if (command.startsWith(ClawdbotCameraCommand.NamespacePrefix) && !cameraEnabled.value) {
       return BridgeSession.InvokeResult.error(
         code = "CAMERA_DISABLED",
         message = "CAMERA_DISABLED: enable Camera in Settings",
       )
     }
+    if (command.startsWith(ClawdbotLocationCommand.NamespacePrefix) &&
+      locationMode.value == LocationMode.Off
+    ) {
+      return BridgeSession.InvokeResult.error(
+        code = "LOCATION_DISABLED",
+        message = "LOCATION_DISABLED: enable Location in Settings",
+      )
+    }
 
     return when (command) {
-      ClawdisCanvasCommand.Present.rawValue -> {
+      ClawdbotCanvasCommand.Present.rawValue -> {
         val url = CanvasController.parseNavigateUrl(paramsJson)
         canvas.navigate(url)
         BridgeSession.InvokeResult.ok(null)
       }
-      ClawdisCanvasCommand.Hide.rawValue -> BridgeSession.InvokeResult.ok(null)
-      ClawdisCanvasCommand.Navigate.rawValue -> {
+      ClawdbotCanvasCommand.Hide.rawValue -> BridgeSession.InvokeResult.ok(null)
+      ClawdbotCanvasCommand.Navigate.rawValue -> {
         val url = CanvasController.parseNavigateUrl(paramsJson)
         canvas.navigate(url)
         BridgeSession.InvokeResult.ok(null)
       }
-      ClawdisCanvasCommand.Eval.rawValue -> {
+      ClawdbotCanvasCommand.Eval.rawValue -> {
         val js =
           CanvasController.parseEvalJs(paramsJson)
             ?: return BridgeSession.InvokeResult.error(
@@ -698,7 +770,7 @@ class NodeRuntime(context: Context) {
           }
         BridgeSession.InvokeResult.ok("""{"result":${result.toJsonString()}}""")
       }
-      ClawdisCanvasCommand.Snapshot.rawValue -> {
+      ClawdbotCanvasCommand.Snapshot.rawValue -> {
         val snapshotParams = CanvasController.parseSnapshotParams(paramsJson)
         val base64 =
           try {
@@ -715,7 +787,7 @@ class NodeRuntime(context: Context) {
           }
         BridgeSession.InvokeResult.ok("""{"format":"${snapshotParams.format.rawValue}","base64":"$base64"}""")
       }
-      ClawdisCanvasA2UICommand.Reset.rawValue -> {
+      ClawdbotCanvasA2UICommand.Reset.rawValue -> {
         val a2uiUrl = resolveA2uiHostUrl()
           ?: return BridgeSession.InvokeResult.error(
             code = "A2UI_HOST_NOT_CONFIGURED",
@@ -731,7 +803,7 @@ class NodeRuntime(context: Context) {
         val res = canvas.eval(a2uiResetJS)
         BridgeSession.InvokeResult.ok(res)
       }
-      ClawdisCanvasA2UICommand.Push.rawValue, ClawdisCanvasA2UICommand.PushJSONL.rawValue -> {
+      ClawdbotCanvasA2UICommand.Push.rawValue, ClawdbotCanvasA2UICommand.PushJSONL.rawValue -> {
         val messages =
           try {
             decodeA2uiMessages(command, paramsJson)
@@ -754,7 +826,7 @@ class NodeRuntime(context: Context) {
         val res = canvas.eval(js)
         BridgeSession.InvokeResult.ok(res)
       }
-      ClawdisCameraCommand.Snap.rawValue -> {
+      ClawdbotCameraCommand.Snap.rawValue -> {
         showCameraHud(message = "Taking photo…", kind = CameraHudKind.Photo)
         triggerCameraFlash()
         val res =
@@ -768,7 +840,7 @@ class NodeRuntime(context: Context) {
         showCameraHud(message = "Photo captured", kind = CameraHudKind.Success, autoHideMs = 1600)
         BridgeSession.InvokeResult.ok(res.payloadJson)
       }
-      ClawdisCameraCommand.Clip.rawValue -> {
+      ClawdbotCameraCommand.Clip.rawValue -> {
         val includeAudio = paramsJson?.contains("\"includeAudio\":true") != false
         if (includeAudio) externalAudioCaptureActive.value = true
         try {
@@ -787,7 +859,60 @@ class NodeRuntime(context: Context) {
           if (includeAudio) externalAudioCaptureActive.value = false
         }
       }
-      ClawdisScreenCommand.Record.rawValue -> {
+      ClawdbotLocationCommand.Get.rawValue -> {
+        val mode = locationMode.value
+        if (!isForeground.value && mode != LocationMode.Always) {
+          return BridgeSession.InvokeResult.error(
+            code = "LOCATION_BACKGROUND_UNAVAILABLE",
+            message = "LOCATION_BACKGROUND_UNAVAILABLE: background location requires Always",
+          )
+        }
+        if (!hasFineLocationPermission() && !hasCoarseLocationPermission()) {
+          return BridgeSession.InvokeResult.error(
+            code = "LOCATION_PERMISSION_REQUIRED",
+            message = "LOCATION_PERMISSION_REQUIRED: grant Location permission",
+          )
+        }
+        if (!isForeground.value && mode == LocationMode.Always && !hasBackgroundLocationPermission()) {
+          return BridgeSession.InvokeResult.error(
+            code = "LOCATION_PERMISSION_REQUIRED",
+            message = "LOCATION_PERMISSION_REQUIRED: enable Always in system Settings",
+          )
+        }
+        val (maxAgeMs, timeoutMs, desiredAccuracy) = parseLocationParams(paramsJson)
+        val preciseEnabled = locationPreciseEnabled.value
+        val accuracy =
+          when (desiredAccuracy) {
+            "precise" -> if (preciseEnabled && hasFineLocationPermission()) "precise" else "balanced"
+            "coarse" -> "coarse"
+            else -> if (preciseEnabled && hasFineLocationPermission()) "precise" else "balanced"
+          }
+        val providers =
+          when (accuracy) {
+            "precise" -> listOf(LocationManager.GPS_PROVIDER, LocationManager.NETWORK_PROVIDER)
+            "coarse" -> listOf(LocationManager.NETWORK_PROVIDER, LocationManager.GPS_PROVIDER)
+            else -> listOf(LocationManager.NETWORK_PROVIDER, LocationManager.GPS_PROVIDER)
+          }
+        try {
+          val payload =
+            location.getLocation(
+              desiredProviders = providers,
+              maxAgeMs = maxAgeMs,
+              timeoutMs = timeoutMs,
+              isPrecise = accuracy == "precise",
+            )
+          BridgeSession.InvokeResult.ok(payload.payloadJson)
+        } catch (err: TimeoutCancellationException) {
+          BridgeSession.InvokeResult.error(
+            code = "LOCATION_TIMEOUT",
+            message = "LOCATION_TIMEOUT: no fix in time",
+          )
+        } catch (err: Throwable) {
+          val message = err.message ?: "LOCATION_UNAVAILABLE: no fix"
+          BridgeSession.InvokeResult.error(code = "LOCATION_UNAVAILABLE", message = message)
+        }
+      }
+      ClawdbotScreenCommand.Record.rawValue -> {
         // Status pill mirrors screen recording state so it stays visible without overlay stacking.
         _screenRecordActive.value = true
         try {
@@ -803,6 +928,17 @@ class NodeRuntime(context: Context) {
           _screenRecordActive.value = false
         }
       }
+      ClawdbotSmsCommand.Send.rawValue -> {
+        val res = sms.send(paramsJson)
+        if (res.ok) {
+          BridgeSession.InvokeResult.ok(res.payloadJson)
+        } else {
+          val error = res.error ?: "SMS_SEND_FAILED"
+          val idx = error.indexOf(':')
+          val code = if (idx > 0) error.substring(0, idx).trim() else "SMS_SEND_FAILED"
+          BridgeSession.InvokeResult.error(code = code, message = error)
+        }
+      }
       else ->
         BridgeSession.InvokeResult.error(
           code = "INVALID_REQUEST",
@@ -840,11 +976,30 @@ class NodeRuntime(context: Context) {
     return code to "$code: $message"
   }
 
+  private fun parseLocationParams(paramsJson: String?): Triple<Long?, Long, String?> {
+    if (paramsJson.isNullOrBlank()) {
+      return Triple(null, 10_000L, null)
+    }
+    val root =
+      try {
+        json.parseToJsonElement(paramsJson).asObjectOrNull()
+      } catch (_: Throwable) {
+        null
+      }
+    val maxAgeMs = (root?.get("maxAgeMs") as? JsonPrimitive)?.content?.toLongOrNull()
+    val timeoutMs =
+      (root?.get("timeoutMs") as? JsonPrimitive)?.content?.toLongOrNull()?.coerceIn(1_000L, 60_000L)
+        ?: 10_000L
+    val desiredAccuracy =
+      (root?.get("desiredAccuracy") as? JsonPrimitive)?.content?.trim()?.lowercase()
+    return Triple(maxAgeMs, timeoutMs, desiredAccuracy)
+  }
+
   private fun resolveA2uiHostUrl(): String? {
     val raw = session.currentCanvasHostUrl()?.trim().orEmpty()
     if (raw.isBlank()) return null
     val base = raw.trimEnd('/')
-    return "${base}/__clawdis__/a2ui/?platform=android"
+    return "${base}/__clawdbot__/a2ui/?platform=android"
   }
 
   private suspend fun ensureA2uiReady(a2uiUrl: String): Boolean {
@@ -879,7 +1034,7 @@ class NodeRuntime(context: Context) {
     val jsonlField = (obj["jsonl"] as? JsonPrimitive)?.content?.trim().orEmpty()
     val hasMessagesArray = obj["messages"] is JsonArray
 
-    if (command == ClawdisCanvasA2UICommand.PushJSONL.rawValue || (!hasMessagesArray && jsonlField.isNotBlank())) {
+    if (command == ClawdbotCanvasA2UICommand.PushJSONL.rawValue || (!hasMessagesArray && jsonlField.isNotBlank())) {
       val jsonl = jsonlField
       if (jsonl.isBlank()) throw IllegalArgumentException("INVALID_REQUEST: jsonl required")
       val messages =
@@ -936,7 +1091,7 @@ private const val a2uiReadyCheckJS: String =
   """
   (() => {
     try {
-      return !!globalThis.clawdisA2UI && typeof globalThis.clawdisA2UI.applyMessages === 'function';
+      return !!globalThis.clawdbotA2UI && typeof globalThis.clawdbotA2UI.applyMessages === 'function';
     } catch (_) {
       return false;
     }
@@ -947,8 +1102,8 @@ private const val a2uiResetJS: String =
   """
   (() => {
     try {
-      if (!globalThis.clawdisA2UI) return { ok: false, error: "missing clawdisA2UI" };
-      return globalThis.clawdisA2UI.reset();
+      if (!globalThis.clawdbotA2UI) return { ok: false, error: "missing clawdbotA2UI" };
+      return globalThis.clawdbotA2UI.reset();
     } catch (e) {
       return { ok: false, error: String(e?.message ?? e) };
     }
@@ -959,9 +1114,9 @@ private fun a2uiApplyMessagesJS(messagesJson: String): String {
   return """
     (() => {
       try {
-        if (!globalThis.clawdisA2UI) return { ok: false, error: "missing clawdisA2UI" };
+        if (!globalThis.clawdbotA2UI) return { ok: false, error: "missing clawdbotA2UI" };
         const messages = $messagesJson;
-        return globalThis.clawdisA2UI.applyMessages(messages);
+        return globalThis.clawdbotA2UI.applyMessages(messages);
       } catch (e) {
         return { ok: false, error: String(e?.message ?? e) };
       }

apps/android/app/src/main/java/com/clawdbot/android/PermissionRequester.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node
+package com.clawdbot.android
 
 import android.content.pm.PackageManager
 import android.content.Intent
@@ -115,7 +115,7 @@ class PermissionRequester(private val activity: ComponentActivity) {
 
   private fun buildRationaleMessage(permissions: List<String>): String {
     val labels = permissions.map { permissionLabel(it) }
-    return "Clawdis needs ${labels.joinToString(", ")} to capture camera media."
+    return "Clawdbot needs ${labels.joinToString(", ")} permissions to continue."
   }
 
   private fun buildSettingsMessage(permissions: List<String>): String {
@@ -127,6 +127,7 @@ class PermissionRequester(private val activity: ComponentActivity) {
     when (permission) {
       Manifest.permission.CAMERA -> "Camera"
       Manifest.permission.RECORD_AUDIO -> "Microphone"
+      Manifest.permission.SEND_SMS -> "SMS"
       else -> permission
     }
 }

apps/android/app/src/main/java/com/clawdbot/android/ScreenCaptureRequester.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node
+package com.clawdbot.android
 
 import android.app.Activity
 import android.content.Context
@@ -55,7 +55,7 @@ class ScreenCaptureRequester(private val activity: ComponentActivity) {
       suspendCancellableCoroutine { cont ->
         AlertDialog.Builder(activity)
           .setTitle("Screen recording required")
-          .setMessage("Clawdis needs to record the screen for this command.")
+          .setMessage("Clawdbot needs to record the screen for this command.")
           .setPositiveButton("Continue") { _, _ -> cont.resume(true) }
           .setNegativeButton("Not now") { _, _ -> cont.resume(false) }
           .setOnCancelListener { cont.resume(false) }

apps/android/app/src/main/java/com/clawdbot/android/SecurePrefs.kt

@@ -1,6 +1,6 @@
 @file:Suppress("DEPRECATION")
 
-package com.steipete.clawdis.node
+package com.clawdbot.android
 
 import android.content.Context
 import androidx.core.content.edit
@@ -31,7 +31,7 @@ class SecurePrefs(context: Context) {
   private val prefs =
     EncryptedSharedPreferences.create(
       context,
-      "clawdis.node.secure",
+      "clawdbot.node.secure",
       masterKey,
       EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
       EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM,
@@ -47,6 +47,14 @@ class SecurePrefs(context: Context) {
   private val _cameraEnabled = MutableStateFlow(prefs.getBoolean("camera.enabled", true))
   val cameraEnabled: StateFlow<Boolean> = _cameraEnabled
 
+  private val _locationMode =
+    MutableStateFlow(LocationMode.fromRawValue(prefs.getString("location.enabledMode", "off")))
+  val locationMode: StateFlow<LocationMode> = _locationMode
+
+  private val _locationPreciseEnabled =
+    MutableStateFlow(prefs.getBoolean("location.preciseEnabled", true))
+  val locationPreciseEnabled: StateFlow<Boolean> = _locationPreciseEnabled
+
   private val _preventSleep = MutableStateFlow(prefs.getBoolean("screen.preventSleep", true))
   val preventSleep: StateFlow<Boolean> = _preventSleep
 
@@ -93,6 +101,16 @@ class SecurePrefs(context: Context) {
     _cameraEnabled.value = value
   }
 
+  fun setLocationMode(mode: LocationMode) {
+    prefs.edit { putString("location.enabledMode", mode.rawValue) }
+    _locationMode.value = mode
+  }
+
+  fun setLocationPreciseEnabled(value: Boolean) {
+    prefs.edit { putBoolean("location.preciseEnabled", value) }
+    _locationPreciseEnabled.value = value
+  }
+
   fun setPreventSleep(value: Boolean) {
     prefs.edit { putBoolean("screen.preventSleep", value) }
     _preventSleep.value = value

apps/android/app/src/main/java/com/clawdbot/android/VoiceWakeMode.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node
+package com.clawdbot.android
 
 enum class VoiceWakeMode(val rawValue: String) {
   Off("off"),

apps/android/app/src/main/java/com/clawdbot/android/WakeWords.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node
+package com.clawdbot.android
 
 object WakeWords {
   const val maxWords: Int = 32

apps/android/app/src/main/java/com/clawdbot/android/bridge/BonjourEscapes.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.bridge
+package com.clawdbot.android.bridge
 
 object BonjourEscapes {
   fun decode(input: String): String {

apps/android/app/src/main/java/com/clawdbot/android/bridge/BridgeDiscovery.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.bridge
+package com.clawdbot.android.bridge
 
 import android.content.Context
 import android.net.ConnectivityManager
@@ -51,9 +51,9 @@ class BridgeDiscovery(
   private val nsd = context.getSystemService(NsdManager::class.java)
   private val connectivity = context.getSystemService(ConnectivityManager::class.java)
   private val dns = DnsResolver.getInstance()
-  private val serviceType = "_clawdis-bridge._tcp."
-  private val wideAreaDomain = "clawdis.internal."
-  private val logTag = "Clawdis/BridgeDiscovery"
+  private val serviceType = "_clawdbot-bridge._tcp."
+  private val wideAreaDomain = "clawdbot.internal."
+  private val logTag = "Clawdbot/BridgeDiscovery"
 
   private val localById = ConcurrentHashMap<String, BridgeEndpoint>()
   private val unicastById = ConcurrentHashMap<String, BridgeEndpoint>()

apps/android/app/src/main/java/com/clawdbot/android/bridge/BridgeEndpoint.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.bridge
+package com.clawdbot.android.bridge
 
 data class BridgeEndpoint(
   val stableId: String,

apps/android/app/src/main/java/com/clawdbot/android/bridge/BridgePairingClient.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.bridge
+package com.clawdbot.android.bridge
 
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
@@ -37,21 +37,21 @@ class BridgePairingClient {
     withContext(Dispatchers.IO) {
       val socket = Socket()
       socket.tcpNoDelay = true
-      socket.connect(InetSocketAddress(endpoint.host, endpoint.port), 8_000)
-      socket.soTimeout = 60_000
-
-      val reader = BufferedReader(InputStreamReader(socket.getInputStream(), Charsets.UTF_8))
-      val writer = BufferedWriter(OutputStreamWriter(socket.getOutputStream(), Charsets.UTF_8))
-
-      fun send(line: String) {
-        writer.write(line)
-        writer.write("\n")
-        writer.flush()
-      }
-
-      fun sendJson(obj: JsonObject) = send(obj.toString())
-
       try {
+        socket.connect(InetSocketAddress(endpoint.host, endpoint.port), 8_000)
+        socket.soTimeout = 60_000
+
+        val reader = BufferedReader(InputStreamReader(socket.getInputStream(), Charsets.UTF_8))
+        val writer = BufferedWriter(OutputStreamWriter(socket.getOutputStream(), Charsets.UTF_8))
+
+        fun send(line: String) {
+          writer.write(line)
+          writer.write("\n")
+          writer.flush()
+        }
+
+        fun sendJson(obj: JsonObject) = send(obj.toString())
+
         sendJson(
           buildJsonObject {
             put("type", JsonPrimitive("hello"))
@@ -111,6 +111,9 @@ class BridgePairingClient {
           }
           else -> PairResult(ok = false, token = null, error = "unexpected bridge response")
         }
+      } catch (e: Exception) {
+        val message = e.message?.trim().orEmpty().ifEmpty { "gateway unreachable" }
+        PairResult(ok = false, token = null, error = message)
       } finally {
         try {
           socket.close()

apps/android/app/src/main/java/com/clawdbot/android/bridge/BridgeSession.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.bridge
+package com.clawdbot.android.bridge
 
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineScope
@@ -11,7 +11,7 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
-import com.steipete.clawdis.node.BuildConfig
+import com.clawdbot.android.BuildConfig
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.JsonObject
@@ -75,6 +75,13 @@ class BridgeSession(
     }
   }
 
+  suspend fun updateHello(hello: Hello) {
+    val target = desired ?: return
+    desired = target.first to hello
+    val conn = currentConnection ?: return
+    conn.sendJson(buildHelloJson(hello))
+  }
+
   fun disconnect() {
     desired = null
     // Unblock connectOnce() read loop. Coroutine cancellation alone won't interrupt BufferedReader.readLine().
@@ -196,20 +203,7 @@ class BridgeSession(
       currentConnection = conn
 
       try {
-        conn.sendJson(
-          buildJsonObject {
-            put("type", JsonPrimitive("hello"))
-            put("nodeId", JsonPrimitive(hello.nodeId))
-            hello.displayName?.let { put("displayName", JsonPrimitive(it)) }
-            hello.token?.let { put("token", JsonPrimitive(it)) }
-            hello.platform?.let { put("platform", JsonPrimitive(it)) }
-            hello.version?.let { put("version", JsonPrimitive(it)) }
-            hello.deviceFamily?.let { put("deviceFamily", JsonPrimitive(it)) }
-            hello.modelIdentifier?.let { put("modelIdentifier", JsonPrimitive(it)) }
-            hello.caps?.let { put("caps", JsonArray(it.map(::JsonPrimitive))) }
-            hello.commands?.let { put("commands", JsonArray(it.map(::JsonPrimitive))) }
-          },
-        )
+        conn.sendJson(buildHelloJson(hello))
 
         val firstLine = reader.readLine() ?: throw IllegalStateException("bridge closed connection")
         val first = json.parseToJsonElement(firstLine).asObjectOrNull()
@@ -223,7 +217,7 @@ class BridgeSession(
               // Local JVM unit tests use android.jar stubs; Log.d can throw "not mocked".
               runCatching {
                 android.util.Log.d(
-                  "ClawdisBridge",
+                  "ClawdbotBridge",
                   "canvasHostUrl resolved=${canvasHostUrl ?: "none"} (raw=${rawCanvasUrl ?: "none"})",
                 )
               }
@@ -307,6 +301,20 @@ class BridgeSession(
       }
     }
 
+  private fun buildHelloJson(hello: Hello): JsonObject =
+    buildJsonObject {
+      put("type", JsonPrimitive("hello"))
+      put("nodeId", JsonPrimitive(hello.nodeId))
+      hello.displayName?.let { put("displayName", JsonPrimitive(it)) }
+      hello.token?.let { put("token", JsonPrimitive(it)) }
+      hello.platform?.let { put("platform", JsonPrimitive(it)) }
+      hello.version?.let { put("version", JsonPrimitive(it)) }
+      hello.deviceFamily?.let { put("deviceFamily", JsonPrimitive(it)) }
+      hello.modelIdentifier?.let { put("modelIdentifier", JsonPrimitive(it)) }
+      hello.caps?.let { put("caps", JsonArray(it.map(::JsonPrimitive))) }
+      hello.commands?.let { put("commands", JsonArray(it.map(::JsonPrimitive))) }
+    }
+
   private fun normalizeCanvasHostUrl(raw: String?, endpoint: BridgeEndpoint): String? {
     val trimmed = raw?.trim().orEmpty()
     val parsed = trimmed.takeIf { it.isNotBlank() }?.let { runCatching { URI(it) }.getOrNull() }

apps/android/app/src/main/java/com/clawdbot/android/chat/ChatController.kt

@@ -1,6 +1,6 @@
-package com.steipete.clawdis.node.chat
+package com.clawdbot.android.chat
 
-import com.steipete.clawdis.node.bridge.BridgeSession
+import com.clawdbot.android.bridge.BridgeSession
 import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
 import kotlinx.coroutines.CoroutineScope
@@ -361,10 +361,12 @@ class ChatController(
 
         val ts = payload["ts"].asLongOrNull() ?: System.currentTimeMillis()
         if (phase == "start") {
+          val args = data?.get("args").asObjectOrNull()
           pendingToolCallsById[toolCallId] =
             ChatPendingToolCall(
               toolCallId = toolCallId,
               name = name,
+              args = args,
               startedAtMs = ts,
               isError = null,
             )
@@ -469,7 +471,8 @@ class ChatController(
       val key = obj["key"].asStringOrNull()?.trim().orEmpty()
       if (key.isEmpty()) return@mapNotNull null
       val updatedAt = obj["updatedAt"].asLongOrNull()
-      ChatSessionEntry(key = key, updatedAtMs = updatedAt)
+      val displayName = obj["displayName"].asStringOrNull()?.trim()
+      ChatSessionEntry(key = key, updatedAtMs = updatedAt, displayName = displayName)
     }
   }
 

apps/android/app/src/main/java/com/clawdbot/android/chat/ChatModels.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.chat
+package com.clawdbot.android.chat
 
 data class ChatMessage(
   val id: String,
@@ -18,6 +18,7 @@ data class ChatMessageContent(
 data class ChatPendingToolCall(
   val toolCallId: String,
   val name: String,
+  val args: kotlinx.serialization.json.JsonObject? = null,
   val startedAtMs: Long,
   val isError: Boolean? = null,
 )
@@ -25,6 +26,7 @@ data class ChatPendingToolCall(
 data class ChatSessionEntry(
   val key: String,
   val updatedAtMs: Long?,
+  val displayName: String? = null,
 )
 
 data class ChatHistory(

apps/android/app/src/main/java/com/clawdbot/android/node/CameraCaptureManager.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.node
+package com.clawdbot.android.node
 
 import android.Manifest
 import android.content.Context
@@ -20,7 +20,7 @@ import androidx.camera.video.VideoRecordEvent
 import androidx.core.content.ContextCompat
 import androidx.core.content.ContextCompat.checkSelfPermission
 import androidx.core.graphics.scale
-import com.steipete.clawdis.node.PermissionRequester
+import com.clawdbot.android.PermissionRequester
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.withTimeout
@@ -152,7 +152,7 @@ class CameraCaptureManager(private val context: Context) {
       provider.unbindAll()
       provider.bindToLifecycle(owner, selector, videoCapture)
 
-      val file = File.createTempFile("clawdis-clip-", ".mp4")
+      val file = File.createTempFile("clawdbot-clip-", ".mp4")
       val outputOptions = FileOutputOptions.Builder(file).build()
 
       val finalized = kotlinx.coroutines.CompletableDeferred<VideoRecordEvent.Finalize>()
@@ -256,7 +256,7 @@ private suspend fun Context.cameraProvider(): ProcessCameraProvider =
 
 private suspend fun ImageCapture.takeJpegBytes(executor: Executor): ByteArray =
   suspendCancellableCoroutine { cont ->
-    val file = File.createTempFile("clawdis-snap-", ".jpg")
+    val file = File.createTempFile("clawdbot-snap-", ".jpg")
     val options = ImageCapture.OutputFileOptions.Builder(file).build()
     takePicture(
       options,

apps/android/app/src/main/java/com/clawdbot/android/node/CanvasController.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.node
+package com.clawdbot.android.node
 
 import android.graphics.Bitmap
 import android.graphics.Canvas
@@ -17,7 +17,7 @@ import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.JsonPrimitive
-import com.steipete.clawdis.node.BuildConfig
+import com.clawdbot.android.BuildConfig
 import kotlin.coroutines.resume
 
 class CanvasController {
@@ -84,12 +84,12 @@ class CanvasController {
     withWebViewOnMain { wv ->
       if (currentUrl == null) {
         if (BuildConfig.DEBUG) {
-          Log.d("ClawdisCanvas", "load scaffold: $scaffoldAssetUrl")
+          Log.d("ClawdbotCanvas", "load scaffold: $scaffoldAssetUrl")
         }
         wv.loadUrl(scaffoldAssetUrl)
       } else {
         if (BuildConfig.DEBUG) {
-          Log.d("ClawdisCanvas", "load url: $currentUrl")
+          Log.d("ClawdbotCanvas", "load url: $currentUrl")
         }
         wv.loadUrl(currentUrl)
       }
@@ -106,7 +106,7 @@ class CanvasController {
       val js = """
         (() => {
           try {
-            const api = globalThis.__clawdis;
+            const api = globalThis.__clawdbot;
             if (!api) return;
             if (typeof api.setDebugStatusEnabled === 'function') {
               api.setDebugStatusEnabled(${if (enabled) "true" else "false"});

apps/android/app/src/main/java/com/clawdbot/android/node/JpegSizeLimiter.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.node
+package com.clawdbot.android.node
 
 import kotlin.math.max
 import kotlin.math.min

apps/android/app/src/main/java/com/clawdbot/android/node/LocationCaptureManager.kt

@@ -0,0 +1,98 @@
+package com.clawdbot.android.node
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.location.Location
+import android.location.LocationManager
+import android.os.CancellationSignal
+import java.time.Instant
+import java.time.format.DateTimeFormatter
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeout
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlinx.coroutines.suspendCancellableCoroutine
+
+class LocationCaptureManager(private val context: Context) {
+  data class Payload(val payloadJson: String)
+
+  suspend fun getLocation(
+    desiredProviders: List<String>,
+    maxAgeMs: Long?,
+    timeoutMs: Long,
+    isPrecise: Boolean,
+  ): Payload =
+    withContext(Dispatchers.Main) {
+      val manager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
+      if (!manager.isProviderEnabled(LocationManager.GPS_PROVIDER) &&
+        !manager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)
+      ) {
+        throw IllegalStateException("LOCATION_UNAVAILABLE: no location providers enabled")
+      }
+
+      val cached = bestLastKnown(manager, desiredProviders, maxAgeMs)
+      val location =
+        cached ?: requestCurrent(manager, desiredProviders, timeoutMs)
+
+      val timestamp = DateTimeFormatter.ISO_INSTANT.format(Instant.ofEpochMilli(location.time))
+      val source = location.provider
+      val altitudeMeters = if (location.hasAltitude()) location.altitude else null
+      val speedMps = if (location.hasSpeed()) location.speed.toDouble() else null
+      val headingDeg = if (location.hasBearing()) location.bearing.toDouble() else null
+      Payload(
+        buildString {
+          append("{\"lat\":")
+          append(location.latitude)
+          append(",\"lon\":")
+          append(location.longitude)
+          append(",\"accuracyMeters\":")
+          append(location.accuracy.toDouble())
+          if (altitudeMeters != null) append(",\"altitudeMeters\":").append(altitudeMeters)
+          if (speedMps != null) append(",\"speedMps\":").append(speedMps)
+          if (headingDeg != null) append(",\"headingDeg\":").append(headingDeg)
+          append(",\"timestamp\":\"").append(timestamp).append('"')
+          append(",\"isPrecise\":").append(isPrecise)
+          append(",\"source\":\"").append(source).append('"')
+          append('}')
+        },
+      )
+    }
+
+  private fun bestLastKnown(
+    manager: LocationManager,
+    providers: List<String>,
+    maxAgeMs: Long?,
+  ): Location? {
+    val now = System.currentTimeMillis()
+    val candidates =
+      providers.mapNotNull { provider -> manager.getLastKnownLocation(provider) }
+    val freshest = candidates.maxByOrNull { it.time } ?: return null
+    if (maxAgeMs != null && now - freshest.time > maxAgeMs) return null
+    return freshest
+  }
+
+  @SuppressLint("MissingPermission")
+  private suspend fun requestCurrent(
+    manager: LocationManager,
+    providers: List<String>,
+    timeoutMs: Long,
+  ): Location {
+    val resolved =
+      providers.firstOrNull { manager.isProviderEnabled(it) }
+        ?: throw IllegalStateException("LOCATION_UNAVAILABLE: no providers available")
+    return withTimeout(timeoutMs.coerceAtLeast(1)) {
+      suspendCancellableCoroutine { cont ->
+        val signal = CancellationSignal()
+        cont.invokeOnCancellation { signal.cancel() }
+        manager.getCurrentLocation(resolved, signal, context.mainExecutor) { location ->
+          if (location != null) {
+            cont.resume(location)
+          } else {
+            cont.resumeWithException(IllegalStateException("LOCATION_UNAVAILABLE: no fix"))
+          }
+        }
+      }
+    }
+  }
+}

apps/android/app/src/main/java/com/clawdbot/android/node/ScreenRecordManager.kt

@@ -1,11 +1,11 @@
-package com.steipete.clawdis.node.node
+package com.clawdbot.android.node
 
 import android.content.Context
 import android.hardware.display.DisplayManager
 import android.media.MediaRecorder
 import android.media.projection.MediaProjectionManager
 import android.util.Base64
-import com.steipete.clawdis.node.ScreenCaptureRequester
+import com.clawdbot.android.ScreenCaptureRequester
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.withContext
@@ -16,13 +16,13 @@ class ScreenRecordManager(private val context: Context) {
   data class Payload(val payloadJson: String)
 
   @Volatile private var screenCaptureRequester: ScreenCaptureRequester? = null
-  @Volatile private var permissionRequester: com.steipete.clawdis.node.PermissionRequester? = null
+  @Volatile private var permissionRequester: com.clawdbot.android.PermissionRequester? = null
 
   fun attachScreenCaptureRequester(requester: ScreenCaptureRequester) {
     screenCaptureRequester = requester
   }
 
-  fun attachPermissionRequester(requester: com.steipete.clawdis.node.PermissionRequester) {
+  fun attachPermissionRequester(requester: com.clawdbot.android.PermissionRequester) {
     permissionRequester = requester
   }
 
@@ -62,7 +62,7 @@ class ScreenRecordManager(private val context: Context) {
       val height = metrics.heightPixels
       val densityDpi = metrics.densityDpi
 
-      val file = File.createTempFile("clawdis-screen-", ".mp4")
+      val file = File.createTempFile("clawdbot-screen-", ".mp4")
       if (includeAudio) ensureMicPermission()
 
       val recorder = MediaRecorder()
@@ -89,7 +89,7 @@ class ScreenRecordManager(private val context: Context) {
         val surface = recorder.surface
         virtualDisplay =
           projection.createVirtualDisplay(
-            "clawdis-screen",
+            "clawdbot-screen",
             width,
             height,
             densityDpi,

apps/android/app/src/main/java/com/clawdbot/android/node/SmsManager.kt

@@ -0,0 +1,230 @@
+package com.clawdbot.android.node
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.telephony.SmsManager as AndroidSmsManager
+import androidx.core.content.ContextCompat
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.encodeToString
+import com.clawdbot.android.PermissionRequester
+
+/**
+ * Sends SMS messages via the Android SMS API.
+ * Requires SEND_SMS permission to be granted.
+ */
+class SmsManager(private val context: Context) {
+
+    private val json = JsonConfig
+    @Volatile private var permissionRequester: PermissionRequester? = null
+
+    data class SendResult(
+        val ok: Boolean,
+        val to: String,
+        val message: String?,
+        val error: String? = null,
+        val payloadJson: String,
+    )
+
+    internal data class ParsedParams(
+        val to: String,
+        val message: String,
+    )
+
+    internal sealed class ParseResult {
+        data class Ok(val params: ParsedParams) : ParseResult()
+        data class Error(
+            val error: String,
+            val to: String = "",
+            val message: String? = null,
+        ) : ParseResult()
+    }
+
+    internal data class SendPlan(
+        val parts: List<String>,
+        val useMultipart: Boolean,
+    )
+
+    companion object {
+        internal val JsonConfig = Json { ignoreUnknownKeys = true }
+
+        internal fun parseParams(paramsJson: String?, json: Json = JsonConfig): ParseResult {
+            val params = paramsJson?.trim().orEmpty()
+            if (params.isEmpty()) {
+                return ParseResult.Error(error = "INVALID_REQUEST: paramsJSON required")
+            }
+
+            val obj = try {
+                json.parseToJsonElement(params).jsonObject
+            } catch (_: Throwable) {
+                null
+            }
+
+            if (obj == null) {
+                return ParseResult.Error(error = "INVALID_REQUEST: expected JSON object")
+            }
+
+            val to = (obj["to"] as? JsonPrimitive)?.content?.trim().orEmpty()
+            val message = (obj["message"] as? JsonPrimitive)?.content.orEmpty()
+
+            if (to.isEmpty()) {
+                return ParseResult.Error(
+                    error = "INVALID_REQUEST: 'to' phone number required",
+                    message = message,
+                )
+            }
+
+            if (message.isEmpty()) {
+                return ParseResult.Error(
+                    error = "INVALID_REQUEST: 'message' text required",
+                    to = to,
+                )
+            }
+
+            return ParseResult.Ok(ParsedParams(to = to, message = message))
+        }
+
+        internal fun buildSendPlan(
+            message: String,
+            divider: (String) -> List<String>,
+        ): SendPlan {
+            val parts = divider(message).ifEmpty { listOf(message) }
+            return SendPlan(parts = parts, useMultipart = parts.size > 1)
+        }
+
+        internal fun buildPayloadJson(
+            json: Json = JsonConfig,
+            ok: Boolean,
+            to: String,
+            error: String?,
+        ): String {
+            val payload =
+                mutableMapOf<String, JsonElement>(
+                    "ok" to JsonPrimitive(ok),
+                    "to" to JsonPrimitive(to),
+                )
+            if (!ok) {
+                payload["error"] = JsonPrimitive(error ?: "SMS_SEND_FAILED")
+            }
+            return json.encodeToString(JsonObject.serializer(), JsonObject(payload))
+        }
+    }
+
+    fun hasSmsPermission(): Boolean {
+        return ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.SEND_SMS
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+
+    fun canSendSms(): Boolean {
+        return hasSmsPermission() && hasTelephonyFeature()
+    }
+
+    fun hasTelephonyFeature(): Boolean {
+        return context.packageManager?.hasSystemFeature(PackageManager.FEATURE_TELEPHONY) == true
+    }
+
+    fun attachPermissionRequester(requester: PermissionRequester) {
+        permissionRequester = requester
+    }
+
+    /**
+     * Send an SMS message.
+     * 
+     * @param paramsJson JSON with "to" (phone number) and "message" (text) fields
+     * @return SendResult indicating success or failure
+     */
+    suspend fun send(paramsJson: String?): SendResult {
+        if (!hasTelephonyFeature()) {
+            return errorResult(
+                error = "SMS_UNAVAILABLE: telephony not available",
+            )
+        }
+
+        if (!ensureSmsPermission()) {
+            return errorResult(
+                error = "SMS_PERMISSION_REQUIRED: grant SMS permission",
+            )
+        }
+
+        val parseResult = parseParams(paramsJson, json)
+        if (parseResult is ParseResult.Error) {
+            return errorResult(
+                error = parseResult.error,
+                to = parseResult.to,
+                message = parseResult.message,
+            )
+        }
+        val params = (parseResult as ParseResult.Ok).params
+
+        return try {
+            val smsManager = context.getSystemService(AndroidSmsManager::class.java)
+                ?: throw IllegalStateException("SMS_UNAVAILABLE: SmsManager not available")
+
+            val plan = buildSendPlan(params.message) { smsManager.divideMessage(it) }
+            if (plan.useMultipart) {
+                smsManager.sendMultipartTextMessage(
+                    params.to,     // destination
+                    null,          // service center (null = default)
+                    ArrayList(plan.parts),    // message parts
+                    null,          // sent intents
+                    null,          // delivery intents
+                )
+            } else {
+                smsManager.sendTextMessage(
+                    params.to,     // destination
+                    null,          // service center (null = default)
+                    params.message,// message
+                    null,          // sent intent
+                    null,          // delivery intent
+                )
+            }
+
+            okResult(to = params.to, message = params.message)
+        } catch (e: SecurityException) {
+            errorResult(
+                error = "SMS_PERMISSION_REQUIRED: ${e.message}",
+                to = params.to,
+                message = params.message,
+            )
+        } catch (e: Throwable) {
+            errorResult(
+                error = "SMS_SEND_FAILED: ${e.message ?: "unknown error"}",
+                to = params.to,
+                message = params.message,
+            )
+        }
+    }
+
+    private suspend fun ensureSmsPermission(): Boolean {
+        if (hasSmsPermission()) return true
+        val requester = permissionRequester ?: return false
+        val results = requester.requestIfMissing(listOf(Manifest.permission.SEND_SMS))
+        return results[Manifest.permission.SEND_SMS] == true
+    }
+
+    private fun okResult(to: String, message: String): SendResult {
+        return SendResult(
+            ok = true,
+            to = to,
+            message = message,
+            error = null,
+            payloadJson = buildPayloadJson(json = json, ok = true, to = to, error = null),
+        )
+    }
+
+    private fun errorResult(error: String, to: String = "", message: String? = null): SendResult {
+        return SendResult(
+            ok = false,
+            to = to,
+            message = message,
+            error = error,
+            payloadJson = buildPayloadJson(json = json, ok = false, to = to, error = error),
+        )
+    }
+}

apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotCanvasA2UIAction.kt

@@ -1,9 +1,9 @@
-package com.steipete.clawdis.node.protocol
+package com.clawdbot.android.protocol
 
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.JsonPrimitive
 
-object ClawdisCanvasA2UIAction {
+object ClawdbotCanvasA2UIAction {
   fun extractActionName(userAction: JsonObject): String? {
     val name =
       (userAction["name"] as? JsonPrimitive)
@@ -61,6 +61,6 @@ object ClawdisCanvasA2UIAction {
     val err = (error ?: "").replace("\\", "\\\\").replace("\"", "\\\"")
     val okLiteral = if (ok) "true" else "false"
     val idEscaped = actionId.replace("\\", "\\\\").replace("\"", "\\\"")
-    return "window.dispatchEvent(new CustomEvent('clawdis:a2ui-action-status', { detail: { id: \"${idEscaped}\", ok: ${okLiteral}, error: \"${err}\" } }));"
+    return "window.dispatchEvent(new CustomEvent('clawdbot:a2ui-action-status', { detail: { id: \"${idEscaped}\", ok: ${okLiteral}, error: \"${err}\" } }));"
   }
 }

apps/android/app/src/main/java/com/clawdbot/android/protocol/ClawdbotProtocolConstants.kt

@@ -1,13 +1,15 @@
-package com.steipete.clawdis.node.protocol
+package com.clawdbot.android.protocol
 
-enum class ClawdisCapability(val rawValue: String) {
+enum class ClawdbotCapability(val rawValue: String) {
   Canvas("canvas"),
   Camera("camera"),
   Screen("screen"),
+  Sms("sms"),
   VoiceWake("voiceWake"),
+  Location("location"),
 }
 
-enum class ClawdisCanvasCommand(val rawValue: String) {
+enum class ClawdbotCanvasCommand(val rawValue: String) {
   Present("canvas.present"),
   Hide("canvas.hide"),
   Navigate("canvas.navigate"),
@@ -20,7 +22,7 @@ enum class ClawdisCanvasCommand(val rawValue: String) {
   }
 }
 
-enum class ClawdisCanvasA2UICommand(val rawValue: String) {
+enum class ClawdbotCanvasA2UICommand(val rawValue: String) {
   Push("canvas.a2ui.push"),
   PushJSONL("canvas.a2ui.pushJSONL"),
   Reset("canvas.a2ui.reset"),
@@ -31,7 +33,7 @@ enum class ClawdisCanvasA2UICommand(val rawValue: String) {
   }
 }
 
-enum class ClawdisCameraCommand(val rawValue: String) {
+enum class ClawdbotCameraCommand(val rawValue: String) {
   Snap("camera.snap"),
   Clip("camera.clip"),
   ;
@@ -41,7 +43,7 @@ enum class ClawdisCameraCommand(val rawValue: String) {
   }
 }
 
-enum class ClawdisScreenCommand(val rawValue: String) {
+enum class ClawdbotScreenCommand(val rawValue: String) {
   Record("screen.record"),
   ;
 
@@ -49,3 +51,21 @@ enum class ClawdisScreenCommand(val rawValue: String) {
     const val NamespacePrefix: String = "screen."
   }
 }
+
+enum class ClawdbotSmsCommand(val rawValue: String) {
+  Send("sms.send"),
+  ;
+
+  companion object {
+    const val NamespacePrefix: String = "sms."
+  }
+}
+
+enum class ClawdbotLocationCommand(val rawValue: String) {
+  Get("location.get"),
+  ;
+
+  companion object {
+    const val NamespacePrefix: String = "location."
+  }
+}

apps/android/app/src/main/java/com/clawdbot/android/tools/ToolDisplay.kt

@@ -0,0 +1,222 @@
+package com.clawdbot.android.tools
+
+import android.content.Context
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.contentOrNull
+
+@Serializable
+private data class ToolDisplayActionSpec(
+  val label: String? = null,
+  val detailKeys: List<String>? = null,
+)
+
+@Serializable
+private data class ToolDisplaySpec(
+  val emoji: String? = null,
+  val title: String? = null,
+  val label: String? = null,
+  val detailKeys: List<String>? = null,
+  val actions: Map<String, ToolDisplayActionSpec>? = null,
+)
+
+@Serializable
+private data class ToolDisplayConfig(
+  val version: Int? = null,
+  val fallback: ToolDisplaySpec? = null,
+  val tools: Map<String, ToolDisplaySpec>? = null,
+)
+
+data class ToolDisplaySummary(
+  val name: String,
+  val emoji: String,
+  val title: String,
+  val label: String,
+  val verb: String?,
+  val detail: String?,
+) {
+  val detailLine: String?
+    get() {
+      val parts = mutableListOf<String>()
+      if (!verb.isNullOrBlank()) parts.add(verb)
+      if (!detail.isNullOrBlank()) parts.add(detail)
+      return if (parts.isEmpty()) null else parts.joinToString(" · ")
+    }
+
+  val summaryLine: String
+    get() = if (detailLine != null) "${emoji} ${label}: ${detailLine}" else "${emoji} ${label}"
+}
+
+object ToolDisplayRegistry {
+  private const val CONFIG_ASSET = "tool-display.json"
+
+  private val json = Json { ignoreUnknownKeys = true }
+  @Volatile private var cachedConfig: ToolDisplayConfig? = null
+
+  fun resolve(
+    context: Context,
+    name: String?,
+    args: JsonObject?,
+    meta: String? = null,
+  ): ToolDisplaySummary {
+    val trimmedName = name?.trim().orEmpty().ifEmpty { "tool" }
+    val key = trimmedName.lowercase()
+    val config = loadConfig(context)
+    val spec = config.tools?.get(key)
+    val fallback = config.fallback
+
+    val emoji = spec?.emoji ?: fallback?.emoji ?: "🧩"
+    val title = spec?.title ?: titleFromName(trimmedName)
+    val label = spec?.label ?: trimmedName
+
+    val actionRaw = args?.get("action")?.asStringOrNull()?.trim()
+    val action = actionRaw?.takeIf { it.isNotEmpty() }
+    val actionSpec = action?.let { spec?.actions?.get(it) }
+    val verb = normalizeVerb(actionSpec?.label ?: action)
+
+    var detail: String? = null
+    if (key == "read") {
+      detail = readDetail(args)
+    } else if (key == "write" || key == "edit" || key == "attach") {
+      detail = pathDetail(args)
+    }
+
+    val detailKeys = actionSpec?.detailKeys ?: spec?.detailKeys ?: fallback?.detailKeys ?: emptyList()
+    if (detail == null) {
+      detail = firstValue(args, detailKeys)
+    }
+
+    if (detail == null) {
+      detail = meta
+    }
+
+    if (detail != null) {
+      detail = shortenHomeInString(detail)
+    }
+
+    return ToolDisplaySummary(
+      name = trimmedName,
+      emoji = emoji,
+      title = title,
+      label = label,
+      verb = verb,
+      detail = detail,
+    )
+  }
+
+  private fun loadConfig(context: Context): ToolDisplayConfig {
+    val existing = cachedConfig
+    if (existing != null) return existing
+    return try {
+      val jsonString = context.assets.open(CONFIG_ASSET).bufferedReader().use { it.readText() }
+      val decoded = json.decodeFromString(ToolDisplayConfig.serializer(), jsonString)
+      cachedConfig = decoded
+      decoded
+    } catch (_: Throwable) {
+      val fallback = ToolDisplayConfig()
+      cachedConfig = fallback
+      fallback
+    }
+  }
+
+  private fun titleFromName(name: String): String {
+    val cleaned = name.replace("_", " ").trim()
+    if (cleaned.isEmpty()) return "Tool"
+    return cleaned
+      .split(Regex("\\s+"))
+      .joinToString(" ") { part ->
+        val upper = part.uppercase()
+        if (part.length <= 2 && part == upper) part
+        else upper.firstOrNull()?.toString().orEmpty() + part.lowercase().drop(1)
+      }
+  }
+
+  private fun normalizeVerb(value: String?): String? {
+    val trimmed = value?.trim().orEmpty()
+    if (trimmed.isEmpty()) return null
+    return trimmed.replace("_", " ")
+  }
+
+  private fun readDetail(args: JsonObject?): String? {
+    val path = args?.get("path")?.asStringOrNull() ?: return null
+    val offset = args["offset"].asNumberOrNull()
+    val limit = args["limit"].asNumberOrNull()
+    return if (offset != null && limit != null) {
+      val end = offset + limit
+      "${path}:${offset.toInt()}-${end.toInt()}"
+    } else {
+      path
+    }
+  }
+
+  private fun pathDetail(args: JsonObject?): String? {
+    return args?.get("path")?.asStringOrNull()
+  }
+
+  private fun firstValue(args: JsonObject?, keys: List<String>): String? {
+    for (key in keys) {
+      val value = valueForPath(args, key)
+      val rendered = renderValue(value)
+      if (!rendered.isNullOrBlank()) return rendered
+    }
+    return null
+  }
+
+  private fun valueForPath(args: JsonObject?, path: String): JsonElement? {
+    var current: JsonElement? = args
+    for (segment in path.split(".")) {
+      if (segment.isBlank()) return null
+      val obj = current as? JsonObject ?: return null
+      current = obj[segment]
+    }
+    return current
+  }
+
+  private fun renderValue(value: JsonElement?): String? {
+    if (value == null) return null
+    if (value is JsonPrimitive) {
+      if (value.isString) {
+        val trimmed = value.contentOrNull?.trim().orEmpty()
+        if (trimmed.isEmpty()) return null
+        val firstLine = trimmed.lineSequence().firstOrNull()?.trim().orEmpty()
+        if (firstLine.isEmpty()) return null
+        return if (firstLine.length > 160) "${firstLine.take(157)}…" else firstLine
+      }
+      val raw = value.contentOrNull?.trim().orEmpty()
+      raw.toBooleanStrictOrNull()?.let { return it.toString() }
+      raw.toLongOrNull()?.let { return it.toString() }
+      raw.toDoubleOrNull()?.let { return it.toString() }
+    }
+    if (value is JsonArray) {
+      val items = value.mapNotNull { renderValue(it) }
+      if (items.isEmpty()) return null
+      val preview = items.take(3).joinToString(", ")
+      return if (items.size > 3) "${preview}…" else preview
+    }
+    return null
+  }
+
+  private fun shortenHomeInString(value: String): String {
+    val home = System.getProperty("user.home")?.takeIf { it.isNotBlank() }
+      ?: System.getenv("HOME")?.takeIf { it.isNotBlank() }
+    if (home.isNullOrEmpty()) return value
+    return value.replace(home, "~")
+      .replace(Regex("/Users/[^/]+"), "~")
+      .replace(Regex("/home/[^/]+"), "~")
+  }
+
+  private fun JsonElement?.asStringOrNull(): String? {
+    val primitive = this as? JsonPrimitive ?: return null
+    return if (primitive.isString) primitive.contentOrNull else primitive.toString()
+  }
+
+  private fun JsonElement?.asNumberOrNull(): Double? {
+    val primitive = this as? JsonPrimitive ?: return null
+    val raw = primitive.contentOrNull ?: return null
+    return raw.toDoubleOrNull()
+  }
+}

apps/android/app/src/main/java/com/clawdbot/android/ui/CameraHudOverlay.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.ui
+package com.clawdbot.android.ui
 
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Box

apps/android/app/src/main/java/com/clawdbot/android/ui/ChatSheet.kt

@@ -1,8 +1,8 @@
-package com.steipete.clawdis.node.ui
+package com.clawdbot.android.ui
 
 import androidx.compose.runtime.Composable
-import com.steipete.clawdis.node.MainViewModel
-import com.steipete.clawdis.node.ui.chat.ChatSheetContent
+import com.clawdbot.android.MainViewModel
+import com.clawdbot.android.ui.chat.ChatSheetContent
 
 @Composable
 fun ChatSheet(viewModel: MainViewModel) {

apps/android/app/src/main/java/com/clawdbot/android/ui/ClawdbotTheme.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.ui
+package com.clawdbot.android.ui
 
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.material3.MaterialTheme
@@ -9,7 +9,7 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalContext
 
 @Composable
-fun ClawdisTheme(content: @Composable () -> Unit) {
+fun ClawdbotTheme(content: @Composable () -> Unit) {
   val context = LocalContext.current
   val isDark = isSystemInDarkTheme()
   val colorScheme = if (isDark) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)

apps/android/app/src/main/java/com/clawdbot/android/ui/RootScreen.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.ui
+package com.clawdbot.android.ui
 
 import android.annotation.SuppressLint
 import android.Manifest
@@ -65,8 +65,8 @@ import androidx.compose.ui.viewinterop.AndroidView
 import androidx.compose.ui.window.Popup
 import androidx.compose.ui.window.PopupProperties
 import androidx.core.content.ContextCompat
-import com.steipete.clawdis.node.CameraHudKind
-import com.steipete.clawdis.node.MainViewModel
+import com.clawdbot.android.CameraHudKind
+import com.clawdbot.android.MainViewModel
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -334,7 +334,7 @@ private fun CanvasView(viewModel: MainViewModel, modifier: Modifier = Modifier)
           WebSettingsCompat.setAlgorithmicDarkeningAllowed(settings, false)
         }
         if (isDebuggable) {
-          Log.d("ClawdisWebView", "userAgent: ${settings.userAgentString}")
+          Log.d("ClawdbotWebView", "userAgent: ${settings.userAgentString}")
         }
         isScrollContainer = true
         overScrollMode = View.OVER_SCROLL_IF_CONTENT_SCROLLS
@@ -349,7 +349,7 @@ private fun CanvasView(viewModel: MainViewModel, modifier: Modifier = Modifier)
             ) {
               if (!isDebuggable) return
               if (!request.isForMainFrame) return
-              Log.e("ClawdisWebView", "onReceivedError: ${error.errorCode} ${error.description} ${request.url}")
+              Log.e("ClawdbotWebView", "onReceivedError: ${error.errorCode} ${error.description} ${request.url}")
             }
 
             override fun onReceivedHttpError(
@@ -360,14 +360,14 @@ private fun CanvasView(viewModel: MainViewModel, modifier: Modifier = Modifier)
               if (!isDebuggable) return
               if (!request.isForMainFrame) return
               Log.e(
-                "ClawdisWebView",
+                "ClawdbotWebView",
                 "onReceivedHttpError: ${errorResponse.statusCode} ${errorResponse.reasonPhrase} ${request.url}",
               )
             }
 
             override fun onPageFinished(view: WebView, url: String?) {
               if (isDebuggable) {
-                Log.d("ClawdisWebView", "onPageFinished: $url")
+                Log.d("ClawdbotWebView", "onPageFinished: $url")
               }
               viewModel.canvas.onPageFinished()
             }
@@ -378,7 +378,7 @@ private fun CanvasView(viewModel: MainViewModel, modifier: Modifier = Modifier)
             ): Boolean {
               if (isDebuggable) {
                 Log.e(
-                  "ClawdisWebView",
+                  "ClawdbotWebView",
                   "onRenderProcessGone didCrash=${detail.didCrash()} priorityAtExit=${detail.rendererPriorityAtExit()}",
                 )
               }
@@ -391,7 +391,7 @@ private fun CanvasView(viewModel: MainViewModel, modifier: Modifier = Modifier)
               if (!isDebuggable) return false
               val msg = consoleMessage ?: return false
               Log.d(
-                "ClawdisWebView",
+                "ClawdbotWebView",
                 "console ${msg.messageLevel()} @ ${msg.sourceId()}:${msg.lineNumber()} ${msg.message()}",
               )
               return false
@@ -423,7 +423,7 @@ private class CanvasA2UIActionBridge(private val onMessage: (String) -> Unit) {
   }
 
   companion object {
-    const val interfaceName: String = "clawdisCanvasA2UIAction"
+    const val interfaceName: String = "clawdbotCanvasA2UIAction"
   }
 }
 

apps/android/app/src/main/java/com/clawdbot/android/ui/SettingsSheet.kt

@@ -1,8 +1,12 @@
-package com.steipete.clawdis.node.ui
+package com.clawdbot.android.ui
 
 import android.Manifest
+import android.content.Context
+import android.content.Intent
 import android.content.pm.PackageManager
+import android.net.Uri
 import android.os.Build
+import android.provider.Settings
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.animation.AnimatedVisibility
@@ -42,15 +46,17 @@ import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.core.content.ContextCompat
-import com.steipete.clawdis.node.BuildConfig
-import com.steipete.clawdis.node.MainViewModel
-import com.steipete.clawdis.node.NodeForegroundService
-import com.steipete.clawdis.node.VoiceWakeMode
+import com.clawdbot.android.BuildConfig
+import com.clawdbot.android.LocationMode
+import com.clawdbot.android.MainViewModel
+import com.clawdbot.android.NodeForegroundService
+import com.clawdbot.android.VoiceWakeMode
 
 @Composable
 fun SettingsSheet(viewModel: MainViewModel) {
@@ -58,6 +64,8 @@ fun SettingsSheet(viewModel: MainViewModel) {
   val instanceId by viewModel.instanceId.collectAsState()
   val displayName by viewModel.displayName.collectAsState()
   val cameraEnabled by viewModel.cameraEnabled.collectAsState()
+  val locationMode by viewModel.locationMode.collectAsState()
+  val locationPreciseEnabled by viewModel.locationPreciseEnabled.collectAsState()
   val preventSleep by viewModel.preventSleep.collectAsState()
   val wakeWords by viewModel.wakeWords.collectAsState()
   val voiceWakeMode by viewModel.voiceWakeMode.collectAsState()
@@ -101,11 +109,63 @@ fun SettingsSheet(viewModel: MainViewModel) {
       viewModel.setCameraEnabled(cameraOk)
     }
 
+  var pendingLocationMode by remember { mutableStateOf<LocationMode?>(null) }
+  var pendingPreciseToggle by remember { mutableStateOf(false) }
+
+  val locationPermissionLauncher =
+    rememberLauncherForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { perms ->
+      val fineOk = perms[Manifest.permission.ACCESS_FINE_LOCATION] == true
+      val coarseOk = perms[Manifest.permission.ACCESS_COARSE_LOCATION] == true
+      val granted = fineOk || coarseOk
+      val requestedMode = pendingLocationMode
+      pendingLocationMode = null
+
+      if (pendingPreciseToggle) {
+        pendingPreciseToggle = false
+        viewModel.setLocationPreciseEnabled(fineOk)
+        return@rememberLauncherForActivityResult
+      }
+
+      if (!granted) {
+        viewModel.setLocationMode(LocationMode.Off)
+        return@rememberLauncherForActivityResult
+      }
+
+      if (requestedMode != null) {
+        viewModel.setLocationMode(requestedMode)
+        if (requestedMode == LocationMode.Always && Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+          val backgroundOk =
+            ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_BACKGROUND_LOCATION) ==
+              PackageManager.PERMISSION_GRANTED
+          if (!backgroundOk) {
+            openAppSettings(context)
+          }
+        }
+      }
+    }
+
   val audioPermissionLauncher =
     rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { _ ->
       // Status text is handled by NodeRuntime.
     }
 
+  val smsPermissionAvailable =
+    remember {
+      context.packageManager?.hasSystemFeature(PackageManager.FEATURE_TELEPHONY) == true
+    }
+  var smsPermissionGranted by
+    remember {
+      mutableStateOf(
+        ContextCompat.checkSelfPermission(context, Manifest.permission.SEND_SMS) ==
+          PackageManager.PERMISSION_GRANTED,
+      )
+    }
+  val smsPermissionLauncher =
+    rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
+      smsPermissionGranted = granted
+      viewModel.refreshBridgeHello()
+    }
+
   fun setCameraEnabledChecked(checked: Boolean) {
     if (!checked) {
       viewModel.setCameraEnabled(false)
@@ -122,6 +182,47 @@ fun SettingsSheet(viewModel: MainViewModel) {
     }
   }
 
+  fun requestLocationPermissions(targetMode: LocationMode) {
+    val fineOk =
+      ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) ==
+        PackageManager.PERMISSION_GRANTED
+    val coarseOk =
+      ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) ==
+        PackageManager.PERMISSION_GRANTED
+    if (fineOk || coarseOk) {
+      viewModel.setLocationMode(targetMode)
+      if (targetMode == LocationMode.Always && Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+        val backgroundOk =
+          ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_BACKGROUND_LOCATION) ==
+            PackageManager.PERMISSION_GRANTED
+        if (!backgroundOk) {
+          openAppSettings(context)
+        }
+      }
+    } else {
+      pendingLocationMode = targetMode
+      locationPermissionLauncher.launch(
+        arrayOf(Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION),
+      )
+    }
+  }
+
+  fun setPreciseLocationChecked(checked: Boolean) {
+    if (!checked) {
+      viewModel.setLocationPreciseEnabled(false)
+      return
+    }
+    val fineOk =
+      ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) ==
+        PackageManager.PERMISSION_GRANTED
+    if (fineOk) {
+      viewModel.setLocationPreciseEnabled(true)
+    } else {
+      pendingPreciseToggle = true
+      locationPermissionLauncher.launch(arrayOf(Manifest.permission.ACCESS_FINE_LOCATION))
+    }
+  }
+
   val visibleBridges =
     if (isConnected && remoteAddress != null) {
       bridges.filterNot { "${it.host}:${it.port}" == remoteAddress }
@@ -149,7 +250,7 @@ fun SettingsSheet(viewModel: MainViewModel) {
     contentPadding = PaddingValues(16.dp),
     verticalArrangement = Arrangement.spacedBy(6.dp),
   ) {
-    // Order parity: Node → Bridge → Voice → Camera → Screen.
+    // Order parity: Node → Bridge → Voice → Camera → Messaging → Location → Screen.
     item { Text("Node", style = MaterialTheme.typography.titleSmall) }
     item {
       OutlinedTextField(
@@ -335,7 +436,7 @@ fun SettingsSheet(viewModel: MainViewModel) {
         Column(verticalArrangement = Arrangement.spacedBy(6.dp), modifier = Modifier.fillMaxWidth()) {
           ListItem(
             headlineContent = { Text("Foreground Only") },
-            supportingContent = { Text("Listens only while Clawdis is open.") },
+            supportingContent = { Text("Listens only while Clawdbot is open.") },
             trailingContent = {
               RadioButton(
                 selected = voiceWakeMode == VoiceWakeMode.Foreground,
@@ -381,7 +482,7 @@ fun SettingsSheet(viewModel: MainViewModel) {
       Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
         Button(
           onClick = {
-            val parsed = com.steipete.clawdis.node.WakeWords.parseCommaSeparated(wakeWordsText)
+            val parsed = com.clawdbot.android.WakeWords.parseCommaSeparated(wakeWordsText)
             viewModel.setWakeWords(parsed)
           },
           enabled = isConnected,
@@ -423,12 +524,110 @@ fun SettingsSheet(viewModel: MainViewModel) {
 
     item { HorizontalDivider() }
 
+    // Messaging
+    item { Text("Messaging", style = MaterialTheme.typography.titleSmall) }
+    item {
+      val buttonLabel =
+        when {
+          !smsPermissionAvailable -> "Unavailable"
+          smsPermissionGranted -> "Manage"
+          else -> "Grant"
+        }
+      ListItem(
+        headlineContent = { Text("SMS Permission") },
+        supportingContent = {
+          Text(
+            if (smsPermissionAvailable) {
+              "Allow the bridge to send SMS from this device."
+            } else {
+              "SMS requires a device with telephony hardware."
+            },
+          )
+        },
+        trailingContent = {
+          Button(
+            onClick = {
+              if (!smsPermissionAvailable) return@Button
+              if (smsPermissionGranted) {
+                openAppSettings(context)
+              } else {
+                smsPermissionLauncher.launch(Manifest.permission.SEND_SMS)
+              }
+            },
+            enabled = smsPermissionAvailable,
+          ) {
+            Text(buttonLabel)
+          }
+        },
+      )
+    }
+
+    item { HorizontalDivider() }
+
+    // Location
+    item { Text("Location", style = MaterialTheme.typography.titleSmall) }
+    item {
+      Column(verticalArrangement = Arrangement.spacedBy(6.dp), modifier = Modifier.fillMaxWidth()) {
+        ListItem(
+          headlineContent = { Text("Off") },
+          supportingContent = { Text("Disable location sharing.") },
+          trailingContent = {
+            RadioButton(
+              selected = locationMode == LocationMode.Off,
+              onClick = { viewModel.setLocationMode(LocationMode.Off) },
+            )
+          },
+        )
+        ListItem(
+          headlineContent = { Text("While Using") },
+          supportingContent = { Text("Only while Clawdbot is open.") },
+          trailingContent = {
+            RadioButton(
+              selected = locationMode == LocationMode.WhileUsing,
+              onClick = { requestLocationPermissions(LocationMode.WhileUsing) },
+            )
+          },
+        )
+        ListItem(
+          headlineContent = { Text("Always") },
+          supportingContent = { Text("Allow background location (requires system permission).") },
+          trailingContent = {
+            RadioButton(
+              selected = locationMode == LocationMode.Always,
+              onClick = { requestLocationPermissions(LocationMode.Always) },
+            )
+          },
+        )
+      }
+    }
+    item {
+      ListItem(
+        headlineContent = { Text("Precise Location") },
+        supportingContent = { Text("Use precise GPS when available.") },
+        trailingContent = {
+          Switch(
+            checked = locationPreciseEnabled,
+            onCheckedChange = ::setPreciseLocationChecked,
+            enabled = locationMode != LocationMode.Off,
+          )
+        },
+      )
+    }
+    item {
+      Text(
+        "Always may require Android Settings to allow background location.",
+        color = MaterialTheme.colorScheme.onSurfaceVariant,
+      )
+    }
+
+    item { HorizontalDivider() }
+
     // Screen
     item { Text("Screen", style = MaterialTheme.typography.titleSmall) }
     item {
       ListItem(
         headlineContent = { Text("Prevent Sleep") },
-        supportingContent = { Text("Keeps the screen awake while Clawdis is open.") },
+        supportingContent = { Text("Keeps the screen awake while Clawdbot is open.") },
         trailingContent = { Switch(checked = preventSleep, onCheckedChange = viewModel::setPreventSleep) },
       )
     }
@@ -453,3 +652,12 @@ fun SettingsSheet(viewModel: MainViewModel) {
     item { Spacer(modifier = Modifier.height(20.dp)) }
   }
 }
+
+private fun openAppSettings(context: Context) {
+  val intent =
+    Intent(
+      Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
+      Uri.fromParts("package", context.packageName, null),
+    )
+  context.startActivity(intent)
+}

apps/android/app/src/main/java/com/clawdbot/android/ui/StatusPill.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.ui
+package com.clawdbot.android.ui
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Row

apps/android/app/src/main/java/com/clawdbot/android/ui/TalkOrbOverlay.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.ui
+package com.clawdbot.android.ui
 
 import androidx.compose.animation.core.LinearEasing
 import androidx.compose.animation.core.RepeatMode

apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatComposer.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.ui.chat
+package com.clawdbot.android.ui.chat
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -15,7 +15,6 @@ import androidx.compose.foundation.horizontalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.ArrowUpward
 import androidx.compose.material.icons.filled.AttachFile
-import androidx.compose.material.icons.filled.FolderOpen
 import androidx.compose.material.icons.filled.Refresh
 import androidx.compose.material.icons.filled.Stop
 import androidx.compose.material3.ButtonDefaults
@@ -39,10 +38,12 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.dp
+import com.clawdbot.android.chat.ChatSessionEntry
 
 @Composable
 fun ChatComposer(
   sessionKey: String,
+  sessions: List<ChatSessionEntry>,
   healthOk: Boolean,
   thinkingLevel: String,
   pendingRunCount: Int,
@@ -51,13 +52,18 @@ fun ChatComposer(
   onPickImages: () -> Unit,
   onRemoveAttachment: (id: String) -> Unit,
   onSetThinkingLevel: (level: String) -> Unit,
-  onShowSessions: () -> Unit,
+  onSelectSession: (sessionKey: String) -> Unit,
   onRefresh: () -> Unit,
   onAbort: () -> Unit,
   onSend: (text: String) -> Unit,
 ) {
   var input by rememberSaveable { mutableStateOf("") }
   var showThinkingMenu by remember { mutableStateOf(false) }
+  var showSessionMenu by remember { mutableStateOf(false) }
+
+  val sessionOptions = resolveSessionChoices(sessionKey, sessions)
+  val currentSessionLabel =
+    sessionOptions.firstOrNull { it.key == sessionKey }?.displayName ?: sessionKey
 
   val canSend = pendingRunCount == 0 && (input.trim().isNotEmpty() || attachments.isNotEmpty()) && healthOk
 
@@ -73,6 +79,34 @@ fun ChatComposer(
         horizontalArrangement = Arrangement.spacedBy(8.dp),
         verticalAlignment = Alignment.CenterVertically,
       ) {
+        Box {
+          FilledTonalButton(
+            onClick = { showSessionMenu = true },
+            contentPadding = ButtonDefaults.ContentPadding,
+          ) {
+            Text("Session: $currentSessionLabel")
+          }
+
+          DropdownMenu(expanded = showSessionMenu, onDismissRequest = { showSessionMenu = false }) {
+            for (entry in sessionOptions) {
+              DropdownMenuItem(
+                text = { Text(entry.displayName ?: entry.key) },
+                onClick = {
+                  onSelectSession(entry.key)
+                  showSessionMenu = false
+                },
+                trailingIcon = {
+                  if (entry.key == sessionKey) {
+                    Text("✓")
+                  } else {
+                    Spacer(modifier = Modifier.width(10.dp))
+                  }
+                },
+              )
+            }
+          }
+        }
+
         Box {
           FilledTonalButton(
             onClick = { showThinkingMenu = true },
@@ -91,10 +125,6 @@ fun ChatComposer(
 
         Spacer(modifier = Modifier.weight(1f))
 
-        FilledTonalIconButton(onClick = onShowSessions, modifier = Modifier.size(42.dp)) {
-          Icon(Icons.Default.FolderOpen, contentDescription = "Sessions")
-        }
-
         FilledTonalIconButton(onClick = onRefresh, modifier = Modifier.size(42.dp)) {
           Icon(Icons.Default.Refresh, contentDescription = "Refresh")
         }
@@ -118,7 +148,7 @@ fun ChatComposer(
       )
 
       Row(modifier = Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
-        ConnectionPill(sessionKey = sessionKey, healthOk = healthOk)
+        ConnectionPill(sessionLabel = currentSessionLabel, healthOk = healthOk)
         Spacer(modifier = Modifier.weight(1f))
 
         if (pendingRunCount > 0) {
@@ -156,7 +186,7 @@ fun ChatComposer(
 }
 
 @Composable
-private fun ConnectionPill(sessionKey: String, healthOk: Boolean) {
+private fun ConnectionPill(sessionLabel: String, healthOk: Boolean) {
   Surface(
     shape = RoundedCornerShape(999.dp),
     color = MaterialTheme.colorScheme.surfaceContainerHighest,
@@ -171,7 +201,7 @@ private fun ConnectionPill(sessionKey: String, healthOk: Boolean) {
         shape = androidx.compose.foundation.shape.CircleShape,
         color = if (healthOk) Color(0xFF2ECC71) else Color(0xFFF39C12),
       ) {}
-      Text(sessionKey, style = MaterialTheme.typography.labelSmall)
+      Text(sessionLabel, style = MaterialTheme.typography.labelSmall)
       Text(
         if (healthOk) "Connected" else "Connecting…",
         style = MaterialTheme.typography.labelSmall,

apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatMarkdown.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.ui.chat
+package com.clawdbot.android.ui.chat
 
 import android.graphics.BitmapFactory
 import android.util.Base64

apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatMessageListCard.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.ui.chat
+package com.clawdbot.android.ui.chat
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -20,8 +20,8 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.unit.dp
-import com.steipete.clawdis.node.chat.ChatMessage
-import com.steipete.clawdis.node.chat.ChatPendingToolCall
+import com.clawdbot.android.chat.ChatMessage
+import com.clawdbot.android.chat.ChatPendingToolCall
 
 @Composable
 fun ChatMessageListCard(

apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatMessageViews.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.ui.chat
+package com.clawdbot.android.ui.chat
 
 import android.graphics.BitmapFactory
 import android.util.Base64
@@ -31,11 +31,13 @@ import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.unit.dp
 import androidx.compose.foundation.Image
-import com.steipete.clawdis.node.chat.ChatMessage
-import com.steipete.clawdis.node.chat.ChatMessageContent
-import com.steipete.clawdis.node.chat.ChatPendingToolCall
+import com.clawdbot.android.chat.ChatMessage
+import com.clawdbot.android.chat.ChatMessageContent
+import com.clawdbot.android.chat.ChatPendingToolCall
+import com.clawdbot.android.tools.ToolDisplayRegistry
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import androidx.compose.ui.platform.LocalContext
 
 @Composable
 fun ChatMessageBubble(message: ChatMessage) {
@@ -104,18 +106,42 @@ fun ChatTypingIndicatorBubble() {
 
 @Composable
 fun ChatPendingToolsBubble(toolCalls: List<ChatPendingToolCall>) {
+  val context = LocalContext.current
+  val displays =
+    remember(toolCalls, context) {
+      toolCalls.map { ToolDisplayRegistry.resolve(context, it.name, it.args) }
+    }
   Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.Start) {
     Surface(
       shape = RoundedCornerShape(16.dp),
       color = MaterialTheme.colorScheme.surfaceContainer,
     ) {
       Column(modifier = Modifier.padding(horizontal = 12.dp, vertical = 10.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) {
-        Text("Tools", style = MaterialTheme.typography.labelLarge, color = MaterialTheme.colorScheme.onSurface)
-        for (t in toolCalls.take(6)) {
-          Text("· ${t.name}", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
+        Text("Running tools…", style = MaterialTheme.typography.labelLarge, color = MaterialTheme.colorScheme.onSurface)
+        for (display in displays.take(6)) {
+          Column(verticalArrangement = Arrangement.spacedBy(2.dp)) {
+            Text(
+              "${display.emoji} ${display.label}",
+              style = MaterialTheme.typography.bodyMedium,
+              color = MaterialTheme.colorScheme.onSurfaceVariant,
+              fontFamily = FontFamily.Monospace,
+            )
+            display.detailLine?.let { detail ->
+              Text(
+                detail,
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                fontFamily = FontFamily.Monospace,
+              )
+            }
+          }
         }
         if (toolCalls.size > 6) {
-          Text("… +${toolCalls.size - 6} more", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
+          Text(
+            "… +${toolCalls.size - 6} more",
+            style = MaterialTheme.typography.bodySmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+          )
         }
       }
     }

apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatSessionsDialog.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.ui.chat
+package com.clawdbot.android.ui.chat
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
@@ -20,7 +20,7 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
-import com.steipete.clawdis.node.chat.ChatSessionEntry
+import com.clawdbot.android.chat.ChatSessionEntry
 
 @Composable
 fun ChatSessionsDialog(
@@ -82,7 +82,7 @@ private fun SessionRow(
       verticalAlignment = Alignment.CenterVertically,
       horizontalArrangement = Arrangement.spacedBy(10.dp),
     ) {
-      Text(entry.key, style = MaterialTheme.typography.bodyMedium)
+      Text(entry.displayName ?: entry.key, style = MaterialTheme.typography.bodyMedium)
       Spacer(modifier = Modifier.weight(1f))
       if (isCurrent) {
         Text("Current", style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
@@ -90,4 +90,3 @@ private fun SessionRow(
     }
   }
 }
-

apps/android/app/src/main/java/com/clawdbot/android/ui/chat/ChatSheetContent.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.ui.chat
+package com.clawdbot.android.ui.chat
 
 import android.content.ContentResolver
 import android.net.Uri
@@ -14,15 +14,13 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateListOf
-import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.unit.dp
-import com.steipete.clawdis.node.MainViewModel
-import com.steipete.clawdis.node.chat.OutgoingAttachment
+import com.clawdbot.android.MainViewModel
+import com.clawdbot.android.chat.OutgoingAttachment
 import java.io.ByteArrayOutputStream
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -40,10 +38,9 @@ fun ChatSheetContent(viewModel: MainViewModel) {
   val pendingToolCalls by viewModel.chatPendingToolCalls.collectAsState()
   val sessions by viewModel.chatSessions.collectAsState()
 
-  var showSessions by remember { mutableStateOf(false) }
-
   LaunchedEffect(Unit) {
     viewModel.loadChat("main")
+    viewModel.refreshChatSessions(limit = 200)
   }
 
   val context = LocalContext.current
@@ -87,6 +84,7 @@ fun ChatSheetContent(viewModel: MainViewModel) {
 
     ChatComposer(
       sessionKey = sessionKey,
+      sessions = sessions,
       healthOk = healthOk,
       thinkingLevel = thinkingLevel,
       pendingRunCount = pendingRunCount,
@@ -95,8 +93,11 @@ fun ChatSheetContent(viewModel: MainViewModel) {
       onPickImages = { pickImages.launch("image/*") },
       onRemoveAttachment = { id -> attachments.removeAll { it.id == id } },
       onSetThinkingLevel = { level -> viewModel.setChatThinkingLevel(level) },
-      onShowSessions = { showSessions = true },
-      onRefresh = { viewModel.refreshChat() },
+      onSelectSession = { key -> viewModel.switchChatSession(key) },
+      onRefresh = {
+        viewModel.refreshChat()
+        viewModel.refreshChatSessions(limit = 200)
+      },
       onAbort = { viewModel.abortChat() },
       onSend = { text ->
         val outgoing =
@@ -113,19 +114,6 @@ fun ChatSheetContent(viewModel: MainViewModel) {
       },
     )
   }
-
-  if (showSessions) {
-    ChatSessionsDialog(
-      currentSessionKey = sessionKey,
-      sessions = sessions,
-      onDismiss = { showSessions = false },
-      onRefresh = { viewModel.refreshChatSessions(limit = 50) },
-      onSelect = { key ->
-        viewModel.switchChatSession(key)
-        showSessions = false
-      },
-    )
-  }
 }
 
 data class PendingImageAttachment(

apps/android/app/src/main/java/com/clawdbot/android/ui/chat/SessionFilters.kt

@@ -0,0 +1,46 @@
+package com.clawdbot.android.ui.chat
+
+import com.clawdbot.android.chat.ChatSessionEntry
+
+private const val MAIN_SESSION_KEY = "main"
+private const val RECENT_WINDOW_MS = 24 * 60 * 60 * 1000L
+
+fun resolveSessionChoices(
+  currentSessionKey: String,
+  sessions: List<ChatSessionEntry>,
+  nowMs: Long = System.currentTimeMillis(),
+): List<ChatSessionEntry> {
+  val current = currentSessionKey.trim()
+  val cutoff = nowMs - RECENT_WINDOW_MS
+  val sorted = sessions.sortedByDescending { it.updatedAtMs ?: 0L }
+  val recent = mutableListOf<ChatSessionEntry>()
+  val seen = mutableSetOf<String>()
+  for (entry in sorted) {
+    if (!seen.add(entry.key)) continue
+    if ((entry.updatedAtMs ?: 0L) < cutoff) continue
+    recent.add(entry)
+  }
+
+  val result = mutableListOf<ChatSessionEntry>()
+  val included = mutableSetOf<String>()
+  val mainEntry = sorted.firstOrNull { it.key == MAIN_SESSION_KEY }
+  if (mainEntry != null) {
+    result.add(mainEntry)
+    included.add(MAIN_SESSION_KEY)
+  } else if (current == MAIN_SESSION_KEY) {
+    result.add(ChatSessionEntry(key = MAIN_SESSION_KEY, updatedAtMs = null))
+    included.add(MAIN_SESSION_KEY)
+  }
+
+  for (entry in recent) {
+    if (included.add(entry.key)) {
+      result.add(entry)
+    }
+  }
+
+  if (current.isNotEmpty() && !included.contains(current)) {
+    result.add(ChatSessionEntry(key = current, updatedAtMs = null))
+  }
+
+  return result
+}

apps/android/app/src/main/java/com/clawdbot/android/voice/StreamingMediaDataSource.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.voice
+package com.clawdbot.android.voice
 
 import android.media.MediaDataSource
 import kotlin.math.min

apps/android/app/src/main/java/com/clawdbot/android/voice/TalkDirectiveParser.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.voice
+package com.clawdbot.android.voice
 
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonElement

apps/android/app/src/main/java/com/clawdbot/android/voice/TalkModeManager.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.voice
+package com.clawdbot.android.voice
 
 import android.Manifest
 import android.content.Context
@@ -20,7 +20,7 @@ import android.speech.tts.TextToSpeech
 import android.speech.tts.UtteranceProgressListener
 import android.util.Log
 import androidx.core.content.ContextCompat
-import com.steipete.clawdis.node.bridge.BridgeSession
+import com.clawdbot.android.bridge.BridgeSession
 import java.net.HttpURLConnection
 import java.net.URL
 import java.util.UUID

apps/android/app/src/main/java/com/clawdbot/android/voice/VoiceWakeCommandExtractor.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.voice
+package com.clawdbot.android.voice
 
 object VoiceWakeCommandExtractor {
   fun extractCommand(text: String, triggerWords: List<String>): String? {

apps/android/app/src/main/java/com/clawdbot/android/voice/VoiceWakeManager.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.voice
+package com.clawdbot.android.voice
 
 import android.content.Context
 import android.content.Intent

apps/android/app/src/main/res/values/strings.xml

@@ -1,4 +1,4 @@
 <resources>
-    <string name="app_name">Clawdis Node</string>
+    <string name="app_name">Clawdbot Node</string>
 </resources>
 

apps/android/app/src/main/res/values/themes.xml

@@ -1,5 +1,5 @@
 <resources>
-    <style name="Theme.ClawdisNode" parent="Theme.Material3.DayNight.NoActionBar">
+    <style name="Theme.ClawdbotNode" parent="Theme.Material3.DayNight.NoActionBar">
         <item name="android:statusBarColor">@android:color/transparent</item>
         <item name="android:navigationBarColor">@android:color/transparent</item>
         <item name="android:windowLightStatusBar">false</item>

apps/android/app/src/main/res/xml/network_security_config.xml

@@ -4,7 +4,7 @@
   <base-config cleartextTrafficPermitted="true" tools:ignore="InsecureBaseConfiguration" />
   <!-- Allow HTTP for tailnet/local dev endpoints (e.g. canvas/background web). -->
   <domain-config cleartextTrafficPermitted="true">
-    <domain includeSubdomains="true">clawdis.internal</domain>
+    <domain includeSubdomains="true">clawdbot.internal</domain>
   </domain-config>
   <domain-config cleartextTrafficPermitted="true">
     <domain includeSubdomains="true">ts.net</domain>

apps/android/app/src/test/java/com/clawdbot/android/NodeForegroundServiceTest.kt

@@ -0,0 +1,43 @@
+package com.clawdbot.android
+
+import android.app.Notification
+import android.content.Intent
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class NodeForegroundServiceTest {
+  @Test
+  fun buildNotificationSetsLaunchIntent() {
+    val service = Robolectric.buildService(NodeForegroundService::class.java).get()
+    val notification = buildNotification(service)
+
+    val pendingIntent = notification.contentIntent
+    assertNotNull(pendingIntent)
+
+    val savedIntent = Shadows.shadowOf(pendingIntent).savedIntent
+    assertNotNull(savedIntent)
+    assertEquals(MainActivity::class.java.name, savedIntent.component?.className)
+
+    val expectedFlags = Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP
+    assertEquals(expectedFlags, savedIntent.flags and expectedFlags)
+  }
+
+  private fun buildNotification(service: NodeForegroundService): Notification {
+    val method =
+      NodeForegroundService::class.java.getDeclaredMethod(
+        "buildNotification",
+        String::class.java,
+        String::class.java,
+      )
+    method.isAccessible = true
+    return method.invoke(service, "Title", "Text") as Notification
+  }
+}

apps/android/app/src/test/java/com/clawdbot/android/WakeWordsTest.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node
+package com.clawdbot.android
 
 import org.junit.Assert.assertEquals
 import org.junit.Test

apps/android/app/src/test/java/com/clawdbot/android/bridge/BonjourEscapesTest.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.bridge
+package com.clawdbot.android.bridge
 
 import org.junit.Assert.assertEquals
 import org.junit.Test
@@ -12,7 +12,7 @@ class BonjourEscapesTest {
 
   @Test
   fun decodeDecodesDecimalEscapes() {
-    assertEquals("Clawdis Gateway", BonjourEscapes.decode("Clawdis\\032Gateway"))
+    assertEquals("Clawdbot Gateway", BonjourEscapes.decode("Clawdbot\\032Gateway"))
     assertEquals("A B", BonjourEscapes.decode("A\\032B"))
     assertEquals("Peter\u2019s Mac", BonjourEscapes.decode("Peter\\226\\128\\153s Mac"))
   }

apps/android/app/src/test/java/com/clawdbot/android/bridge/BridgeEndpointKotestTest.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.bridge
+package com.clawdbot.android.bridge
 
 import io.kotest.core.spec.style.StringSpec
 import io.kotest.matchers.shouldBe

apps/android/app/src/test/java/com/clawdbot/android/bridge/BridgePairingClientTest.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.bridge
+package com.clawdbot.android.bridge
 
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async

apps/android/app/src/test/java/com/clawdbot/android/bridge/BridgeSessionTest.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.bridge
+package com.clawdbot.android.bridge
 
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineScope

apps/android/app/src/test/java/com/clawdbot/android/node/CanvasControllerSnapshotParamsTest.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.node
+package com.clawdbot.android.node
 
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull

apps/android/app/src/test/java/com/clawdbot/android/node/JpegSizeLimiterTest.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.node
+package com.clawdbot.android.node
 
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue

apps/android/app/src/test/java/com/clawdbot/android/node/SmsManagerTest.kt

@@ -0,0 +1,91 @@
+package com.clawdbot.android.node
+
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class SmsManagerTest {
+  private val json = SmsManager.JsonConfig
+
+  @Test
+  fun parseParamsRejectsEmptyPayload() {
+    val result = SmsManager.parseParams("", json)
+    assertTrue(result is SmsManager.ParseResult.Error)
+    val error = result as SmsManager.ParseResult.Error
+    assertEquals("INVALID_REQUEST: paramsJSON required", error.error)
+  }
+
+  @Test
+  fun parseParamsRejectsInvalidJson() {
+    val result = SmsManager.parseParams("not-json", json)
+    assertTrue(result is SmsManager.ParseResult.Error)
+    val error = result as SmsManager.ParseResult.Error
+    assertEquals("INVALID_REQUEST: expected JSON object", error.error)
+  }
+
+  @Test
+  fun parseParamsRejectsNonObjectJson() {
+    val result = SmsManager.parseParams("[]", json)
+    assertTrue(result is SmsManager.ParseResult.Error)
+    val error = result as SmsManager.ParseResult.Error
+    assertEquals("INVALID_REQUEST: expected JSON object", error.error)
+  }
+
+  @Test
+  fun parseParamsRejectsMissingTo() {
+    val result = SmsManager.parseParams("{\"message\":\"Hi\"}", json)
+    assertTrue(result is SmsManager.ParseResult.Error)
+    val error = result as SmsManager.ParseResult.Error
+    assertEquals("INVALID_REQUEST: 'to' phone number required", error.error)
+    assertEquals("Hi", error.message)
+  }
+
+  @Test
+  fun parseParamsRejectsMissingMessage() {
+    val result = SmsManager.parseParams("{\"to\":\"+1234\"}", json)
+    assertTrue(result is SmsManager.ParseResult.Error)
+    val error = result as SmsManager.ParseResult.Error
+    assertEquals("INVALID_REQUEST: 'message' text required", error.error)
+    assertEquals("+1234", error.to)
+  }
+
+  @Test
+  fun parseParamsTrimsToField() {
+    val result = SmsManager.parseParams("{\"to\":\"  +1555  \",\"message\":\"Hello\"}", json)
+    assertTrue(result is SmsManager.ParseResult.Ok)
+    val ok = result as SmsManager.ParseResult.Ok
+    assertEquals("+1555", ok.params.to)
+    assertEquals("Hello", ok.params.message)
+  }
+
+  @Test
+  fun buildPayloadJsonEscapesFields() {
+    val payload = SmsManager.buildPayloadJson(
+      json = json,
+      ok = false,
+      to = "+1\"23",
+      error = "SMS_SEND_FAILED: \"nope\"",
+    )
+    val parsed = json.parseToJsonElement(payload).jsonObject
+    assertEquals("false", parsed["ok"]?.jsonPrimitive?.content)
+    assertEquals("+1\"23", parsed["to"]?.jsonPrimitive?.content)
+    assertEquals("SMS_SEND_FAILED: \"nope\"", parsed["error"]?.jsonPrimitive?.content)
+  }
+
+  @Test
+  fun buildSendPlanUsesMultipartWhenMultipleParts() {
+    val plan = SmsManager.buildSendPlan("hello") { listOf("a", "b") }
+    assertTrue(plan.useMultipart)
+    assertEquals(listOf("a", "b"), plan.parts)
+  }
+
+  @Test
+  fun buildSendPlanFallsBackToSinglePartWhenDividerEmpty() {
+    val plan = SmsManager.buildSendPlan("hello") { emptyList() }
+    assertFalse(plan.useMultipart)
+    assertEquals(listOf("hello"), plan.parts)
+  }
+}

apps/android/app/src/test/java/com/clawdbot/android/protocol/ClawdbotCanvasA2UIActionTest.kt

@@ -1,28 +1,28 @@
-package com.steipete.clawdis.node.protocol
+package com.clawdbot.android.protocol
 
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.jsonObject
 import org.junit.Assert.assertEquals
 import org.junit.Test
 
-class ClawdisCanvasA2UIActionTest {
+class ClawdbotCanvasA2UIActionTest {
   @Test
   fun extractActionNameAcceptsNameOrAction() {
     val nameObj = Json.parseToJsonElement("{\"name\":\"Hello\"}").jsonObject
-    assertEquals("Hello", ClawdisCanvasA2UIAction.extractActionName(nameObj))
+    assertEquals("Hello", ClawdbotCanvasA2UIAction.extractActionName(nameObj))
 
     val actionObj = Json.parseToJsonElement("{\"action\":\"Wave\"}").jsonObject
-    assertEquals("Wave", ClawdisCanvasA2UIAction.extractActionName(actionObj))
+    assertEquals("Wave", ClawdbotCanvasA2UIAction.extractActionName(actionObj))
 
     val fallbackObj =
       Json.parseToJsonElement("{\"name\":\"  \",\"action\":\"Fallback\"}").jsonObject
-    assertEquals("Fallback", ClawdisCanvasA2UIAction.extractActionName(fallbackObj))
+    assertEquals("Fallback", ClawdbotCanvasA2UIAction.extractActionName(fallbackObj))
   }
 
   @Test
   fun formatAgentMessageMatchesSharedSpec() {
     val msg =
-      ClawdisCanvasA2UIAction.formatAgentMessage(
+      ClawdbotCanvasA2UIAction.formatAgentMessage(
         actionName = "Get Weather",
         sessionKey = "main",
         surfaceId = "main",
@@ -40,9 +40,9 @@ class ClawdisCanvasA2UIActionTest {
 
   @Test
   fun jsDispatchA2uiStatusIsStable() {
-    val js = ClawdisCanvasA2UIAction.jsDispatchA2UIActionStatus(actionId = "a1", ok = true, error = null)
+    val js = ClawdbotCanvasA2UIAction.jsDispatchA2UIActionStatus(actionId = "a1", ok = true, error = null)
     assertEquals(
-      "window.dispatchEvent(new CustomEvent('clawdis:a2ui-action-status', { detail: { id: \"a1\", ok: true, error: \"\" } }));",
+      "window.dispatchEvent(new CustomEvent('clawdbot:a2ui-action-status', { detail: { id: \"a1\", ok: true, error: \"\" } }));",
       js,
     )
   }

apps/android/app/src/test/java/com/clawdbot/android/protocol/ClawdbotProtocolConstantsTest.kt

@@ -0,0 +1,35 @@
+package com.clawdbot.android.protocol
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class ClawdbotProtocolConstantsTest {
+  @Test
+  fun canvasCommandsUseStableStrings() {
+    assertEquals("canvas.present", ClawdbotCanvasCommand.Present.rawValue)
+    assertEquals("canvas.hide", ClawdbotCanvasCommand.Hide.rawValue)
+    assertEquals("canvas.navigate", ClawdbotCanvasCommand.Navigate.rawValue)
+    assertEquals("canvas.eval", ClawdbotCanvasCommand.Eval.rawValue)
+    assertEquals("canvas.snapshot", ClawdbotCanvasCommand.Snapshot.rawValue)
+  }
+
+  @Test
+  fun a2uiCommandsUseStableStrings() {
+    assertEquals("canvas.a2ui.push", ClawdbotCanvasA2UICommand.Push.rawValue)
+    assertEquals("canvas.a2ui.pushJSONL", ClawdbotCanvasA2UICommand.PushJSONL.rawValue)
+    assertEquals("canvas.a2ui.reset", ClawdbotCanvasA2UICommand.Reset.rawValue)
+  }
+
+  @Test
+  fun capabilitiesUseStableStrings() {
+    assertEquals("canvas", ClawdbotCapability.Canvas.rawValue)
+    assertEquals("camera", ClawdbotCapability.Camera.rawValue)
+    assertEquals("screen", ClawdbotCapability.Screen.rawValue)
+    assertEquals("voiceWake", ClawdbotCapability.VoiceWake.rawValue)
+  }
+
+  @Test
+  fun screenCommandsUseStableStrings() {
+    assertEquals("screen.record", ClawdbotScreenCommand.Record.rawValue)
+  }
+}

apps/android/app/src/test/java/com/clawdbot/android/ui/chat/SessionFiltersTest.kt

@@ -0,0 +1,35 @@
+package com.clawdbot.android.ui.chat
+
+import com.clawdbot.android.chat.ChatSessionEntry
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class SessionFiltersTest {
+  @Test
+  fun sessionChoicesPreferMainAndRecent() {
+    val now = 1_700_000_000_000L
+    val recent1 = now - 2 * 60 * 60 * 1000L
+    val recent2 = now - 5 * 60 * 60 * 1000L
+    val stale = now - 26 * 60 * 60 * 1000L
+    val sessions =
+      listOf(
+        ChatSessionEntry(key = "recent-1", updatedAtMs = recent1),
+        ChatSessionEntry(key = "main", updatedAtMs = stale),
+        ChatSessionEntry(key = "old-1", updatedAtMs = stale),
+        ChatSessionEntry(key = "recent-2", updatedAtMs = recent2),
+      )
+
+    val result = resolveSessionChoices("main", sessions, nowMs = now).map { it.key }
+    assertEquals(listOf("main", "recent-1", "recent-2"), result)
+  }
+
+  @Test
+  fun sessionChoicesIncludeCurrentWhenMissing() {
+    val now = 1_700_000_000_000L
+    val recent = now - 10 * 60 * 1000L
+    val sessions = listOf(ChatSessionEntry(key = "main", updatedAtMs = recent))
+
+    val result = resolveSessionChoices("custom", sessions, nowMs = now).map { it.key }
+    assertEquals(listOf("main", "custom"), result)
+  }
+}

apps/android/app/src/test/java/com/clawdbot/android/voice/TalkDirectiveParserTest.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.voice
+package com.clawdbot.android.voice
 
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull

apps/android/app/src/test/java/com/clawdbot/android/voice/VoiceWakeCommandExtractorTest.kt

@@ -1,4 +1,4 @@
-package com.steipete.clawdis.node.voice
+package com.clawdbot.android.voice
 
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull

apps/android/app/src/test/java/com/steipete/clawdis/node/protocol/ClawdisProtocolConstantsTest.kt

@@ -1,35 +0,0 @@
-package com.steipete.clawdis.node.protocol
-
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-class ClawdisProtocolConstantsTest {
-  @Test
-  fun canvasCommandsUseStableStrings() {
-    assertEquals("canvas.present", ClawdisCanvasCommand.Present.rawValue)
-    assertEquals("canvas.hide", ClawdisCanvasCommand.Hide.rawValue)
-    assertEquals("canvas.navigate", ClawdisCanvasCommand.Navigate.rawValue)
-    assertEquals("canvas.eval", ClawdisCanvasCommand.Eval.rawValue)
-    assertEquals("canvas.snapshot", ClawdisCanvasCommand.Snapshot.rawValue)
-  }
-
-  @Test
-  fun a2uiCommandsUseStableStrings() {
-    assertEquals("canvas.a2ui.push", ClawdisCanvasA2UICommand.Push.rawValue)
-    assertEquals("canvas.a2ui.pushJSONL", ClawdisCanvasA2UICommand.PushJSONL.rawValue)
-    assertEquals("canvas.a2ui.reset", ClawdisCanvasA2UICommand.Reset.rawValue)
-  }
-
-  @Test
-  fun capabilitiesUseStableStrings() {
-    assertEquals("canvas", ClawdisCapability.Canvas.rawValue)
-    assertEquals("camera", ClawdisCapability.Camera.rawValue)
-    assertEquals("screen", ClawdisCapability.Screen.rawValue)
-    assertEquals("voiceWake", ClawdisCapability.VoiceWake.rawValue)
-  }
-
-  @Test
-  fun screenCommandsUseStableStrings() {
-    assertEquals("screen.record", ClawdisScreenCommand.Record.rawValue)
-  }
-}

apps/android/settings.gradle.kts

@@ -14,6 +14,6 @@ dependencyResolutionManagement {
   }
 }
 
-rootProject.name = "ClawdisNodeAndroid"
+rootProject.name = "ClawdbotNodeAndroid"
 include(":app")
 

apps/ios/README.md

@@ -1,4 +1,4 @@
-# Clawdis (iOS)
+# Clawdbot (iOS)
 
 Internal-only SwiftUI app scaffold.
 
@@ -11,11 +11,11 @@ brew install swiftformat swiftlint
 ```bash
 cd apps/ios
 xcodegen generate
-open Clawdis.xcodeproj
+open Clawdbot.xcodeproj
 ```
 
 ## Shared packages
-- `../shared/ClawdisKit` — shared types/constants used by iOS (and later macOS bridge + gateway routing).
+- `../shared/ClawdbotKit` — shared types/constants used by iOS (and later macOS bridge + gateway routing).
 
 ## fastlane
 ```bash

apps/ios/Sources/Bridge/BridgeClient.swift

@@ -1,4 +1,4 @@
-import ClawdisKit
+import ClawdbotKit
 import Foundation
 import Network
 
@@ -14,7 +14,7 @@ actor BridgeClient {
     {
         self.lineBuffer = Data()
         let connection = NWConnection(to: endpoint, using: .tcp)
-        let queue = DispatchQueue(label: "com.steipete.clawdis.ios.bridge-client")
+        let queue = DispatchQueue(label: "com.clawdbot.ios.bridge-client")
         defer { connection.cancel() }
         try await self.withTimeout(seconds: 8, purpose: "connect") {
             try await self.startAndWaitForReady(connection, queue: queue)

apps/ios/Sources/Bridge/BridgeConnectionController.swift

@@ -1,4 +1,4 @@
-import ClawdisKit
+import ClawdbotKit
 import Darwin
 import Foundation
 import Network
@@ -99,7 +99,7 @@ final class BridgeConnectionController {
         guard !instanceId.isEmpty else { return }
 
         let token = KeychainStore.loadString(
-            service: "com.steipete.clawdis.bridge",
+            service: "com.clawdbot.bridge",
             account: self.keychainAccount(instanceId: instanceId))?
             .trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
         guard !token.isEmpty else { return }
@@ -189,7 +189,7 @@ final class BridgeConnectionController {
                 if !refreshed.isEmpty, refreshed != token {
                     _ = KeychainStore.saveString(
                         refreshed,
-                        service: "com.steipete.clawdis.bridge",
+                        service: "com.clawdbot.bridge",
                         account: self.keychainAccount(instanceId: instanceId))
                 }
                 appModel.connectToBridge(endpoint: endpoint, hello: self.makeHello(token: resolvedToken))
@@ -217,38 +217,46 @@ final class BridgeConnectionController {
     }
 
     private func currentCaps() -> [String] {
-        var caps = [ClawdisCapability.canvas.rawValue, ClawdisCapability.screen.rawValue]
+        var caps = [ClawdbotCapability.canvas.rawValue, ClawdbotCapability.screen.rawValue]
 
         // Default-on: if the key doesn't exist yet, treat it as enabled.
         let cameraEnabled =
             UserDefaults.standard.object(forKey: "camera.enabled") == nil
                 ? true
                 : UserDefaults.standard.bool(forKey: "camera.enabled")
-        if cameraEnabled { caps.append(ClawdisCapability.camera.rawValue) }
+        if cameraEnabled { caps.append(ClawdbotCapability.camera.rawValue) }
 
         let voiceWakeEnabled = UserDefaults.standard.bool(forKey: VoiceWakePreferences.enabledKey)
-        if voiceWakeEnabled { caps.append(ClawdisCapability.voiceWake.rawValue) }
+        if voiceWakeEnabled { caps.append(ClawdbotCapability.voiceWake.rawValue) }
+
+        let locationModeRaw = UserDefaults.standard.string(forKey: "location.enabledMode") ?? "off"
+        let locationMode = ClawdbotLocationMode(rawValue: locationModeRaw) ?? .off
+        if locationMode != .off { caps.append(ClawdbotCapability.location.rawValue) }
 
         return caps
     }
 
     private func currentCommands() -> [String] {
         var commands: [String] = [
-            ClawdisCanvasCommand.present.rawValue,
-            ClawdisCanvasCommand.hide.rawValue,
-            ClawdisCanvasCommand.navigate.rawValue,
-            ClawdisCanvasCommand.evalJS.rawValue,
-            ClawdisCanvasCommand.snapshot.rawValue,
-            ClawdisCanvasA2UICommand.push.rawValue,
-            ClawdisCanvasA2UICommand.pushJSONL.rawValue,
-            ClawdisCanvasA2UICommand.reset.rawValue,
-            ClawdisScreenCommand.record.rawValue,
+            ClawdbotCanvasCommand.present.rawValue,
+            ClawdbotCanvasCommand.hide.rawValue,
+            ClawdbotCanvasCommand.navigate.rawValue,
+            ClawdbotCanvasCommand.evalJS.rawValue,
+            ClawdbotCanvasCommand.snapshot.rawValue,
+            ClawdbotCanvasA2UICommand.push.rawValue,
+            ClawdbotCanvasA2UICommand.pushJSONL.rawValue,
+            ClawdbotCanvasA2UICommand.reset.rawValue,
+            ClawdbotScreenCommand.record.rawValue,
         ]
 
         let caps = Set(self.currentCaps())
-        if caps.contains(ClawdisCapability.camera.rawValue) {
-            commands.append(ClawdisCameraCommand.snap.rawValue)
-            commands.append(ClawdisCameraCommand.clip.rawValue)
+        if caps.contains(ClawdbotCapability.camera.rawValue) {
+            commands.append(ClawdbotCameraCommand.list.rawValue)
+            commands.append(ClawdbotCameraCommand.snap.rawValue)
+            commands.append(ClawdbotCameraCommand.clip.rawValue)
+        }
+        if caps.contains(ClawdbotCapability.location.rawValue) {
+            commands.append(ClawdbotLocationCommand.get.rawValue)
         }
 
         return commands

apps/ios/Sources/Bridge/BridgeDiscoveryModel.swift

@@ -1,4 +1,4 @@
-import ClawdisKit
+import ClawdbotKit
 import Foundation
 import Network
 import Observation
@@ -51,11 +51,11 @@ final class BridgeDiscoveryModel {
         if !self.browsers.isEmpty { return }
         self.appendDebugLog("start()")
 
-        for domain in ClawdisBonjour.bridgeServiceDomains {
+        for domain in ClawdbotBonjour.bridgeServiceDomains {
             let params = NWParameters.tcp
             params.includePeerToPeer = true
             let browser = NWBrowser(
-                for: .bonjour(type: ClawdisBonjour.bridgeServiceType, domain: domain),
+                for: .bonjour(type: ClawdbotBonjour.bridgeServiceType, domain: domain),
                 using: params)
 
             browser.stateUpdateHandler = { [weak self] state in
@@ -102,7 +102,7 @@ final class BridgeDiscoveryModel {
             }
 
             self.browsers[domain] = browser
-            browser.start(queue: DispatchQueue(label: "com.steipete.clawdis.ios.bridge-discovery.\(domain)"))
+            browser.start(queue: DispatchQueue(label: "com.clawdbot.ios.bridge-discovery.\(domain)"))
         }
     }
 
@@ -200,7 +200,7 @@ final class BridgeDiscoveryModel {
 
     private static func prettifyInstanceName(_ decodedName: String) -> String {
         let normalized = decodedName.split(whereSeparator: \.isWhitespace).joined(separator: " ")
-        let stripped = normalized.replacingOccurrences(of: " (Clawdis)", with: "")
+        let stripped = normalized.replacingOccurrences(of: " (Clawdbot)", with: "")
             .replacingOccurrences(of: #"\s+\(\d+\)$"#, with: "", options: .regularExpression)
         return stripped.trimmingCharacters(in: .whitespacesAndNewlines)
     }

apps/ios/Sources/Bridge/BridgeEndpointID.swift

@@ -1,4 +1,4 @@
-import ClawdisKit
+import ClawdbotKit
 import Foundation
 import Network
 

apps/ios/Sources/Bridge/BridgeSession.swift

@@ -1,4 +1,4 @@
-import ClawdisKit
+import ClawdbotKit
 import Foundation
 import Network
 
@@ -78,7 +78,7 @@ actor BridgeSession {
         let params = NWParameters.tcp
         params.includePeerToPeer = true
         let connection = NWConnection(to: endpoint, using: params)
-        let queue = DispatchQueue(label: "com.steipete.clawdis.ios.bridge-session")
+        let queue = DispatchQueue(label: "com.clawdbot.ios.bridge-session")
         self.connection = connection
         self.queue = queue
 

apps/ios/Sources/Bridge/BridgeSettingsStore.swift

@@ -1,8 +1,8 @@
 import Foundation
 
 enum BridgeSettingsStore {
-    private static let bridgeService = "com.steipete.clawdis.bridge"
-    private static let nodeService = "com.steipete.clawdis.node"
+    private static let bridgeService = "com.clawdbot.bridge"
+    private static let nodeService = "com.clawdbot.node"
 
     private static let instanceIdDefaultsKey = "node.instanceId"
     private static let preferredBridgeStableIDDefaultsKey = "bridge.preferredStableID"

apps/ios/Sources/Camera/CameraController.swift

@@ -1,8 +1,15 @@
 import AVFoundation
-import ClawdisKit
+import ClawdbotKit
 import Foundation
 
 actor CameraController {
+    struct CameraDeviceInfo: Codable, Sendable {
+        var id: String
+        var name: String
+        var position: String
+        var deviceType: String
+    }
+
     enum CameraError: LocalizedError, Sendable {
         case cameraUnavailable
         case microphoneUnavailable
@@ -29,7 +36,7 @@ actor CameraController {
         }
     }
 
-    func snap(params: ClawdisCameraSnapParams) async throws -> (
+    func snap(params: ClawdbotCameraSnapParams) async throws -> (
         format: String,
         base64: String,
         width: Int,
@@ -41,13 +48,14 @@ actor CameraController {
         // If you need the full-res photo, explicitly request a larger maxWidth.
         let maxWidth = params.maxWidth.flatMap { $0 > 0 ? $0 : nil } ?? 1600
         let quality = Self.clampQuality(params.quality)
+        let delayMs = max(0, params.delayMs ?? 0)
 
         try await self.ensureAccess(for: .video)
 
         let session = AVCaptureSession()
         session.sessionPreset = .photo
 
-        guard let device = Self.pickCamera(facing: facing) else {
+        guard let device = Self.pickCamera(facing: facing, deviceId: params.deviceId) else {
             throw CameraError.cameraUnavailable
         }
 
@@ -67,6 +75,7 @@ actor CameraController {
         session.startRunning()
         defer { session.stopRunning() }
         await Self.warmUpCaptureSession()
+        await Self.sleepDelayMs(delayMs)
 
         let settings: AVCapturePhotoSettings = {
             if output.availablePhotoCodecTypes.contains(.jpeg) {
@@ -100,7 +109,7 @@ actor CameraController {
             height: res.heightPx)
     }
 
-    func clip(params: ClawdisCameraClipParams) async throws -> (
+    func clip(params: ClawdbotCameraClipParams) async throws -> (
         format: String,
         base64: String,
         durationMs: Int,
@@ -119,7 +128,7 @@ actor CameraController {
         let session = AVCaptureSession()
         session.sessionPreset = .high
 
-        guard let camera = Self.pickCamera(facing: facing) else {
+        guard let camera = Self.pickCamera(facing: facing, deviceId: params.deviceId) else {
             throw CameraError.cameraUnavailable
         }
         let cameraInput = try AVCaptureDeviceInput(device: camera)
@@ -152,9 +161,9 @@ actor CameraController {
         await Self.warmUpCaptureSession()
 
         let movURL = FileManager.default.temporaryDirectory
-            .appendingPathComponent("clawdis-camera-\(UUID().uuidString).mov")
+            .appendingPathComponent("clawdbot-camera-\(UUID().uuidString).mov")
         let mp4URL = FileManager.default.temporaryDirectory
-            .appendingPathComponent("clawdis-camera-\(UUID().uuidString).mp4")
+            .appendingPathComponent("clawdbot-camera-\(UUID().uuidString).mp4")
 
         defer {
             try? FileManager.default.removeItem(at: movURL)
@@ -180,6 +189,23 @@ actor CameraController {
             hasAudio: includeAudio)
     }
 
+    func listDevices() -> [CameraDeviceInfo] {
+        let types: [AVCaptureDevice.DeviceType] = [
+            .builtInWideAngleCamera,
+        ]
+        let session = AVCaptureDevice.DiscoverySession(
+            deviceTypes: types,
+            mediaType: .video,
+            position: .unspecified)
+        return session.devices.map { device in
+            CameraDeviceInfo(
+                id: device.uniqueID,
+                name: device.localizedName,
+                position: Self.positionLabel(device.position),
+                deviceType: device.deviceType.rawValue)
+        }
+    }
+
     private func ensureAccess(for mediaType: AVMediaType) async throws {
         let status = AVCaptureDevice.authorizationStatus(for: mediaType)
         switch status {
@@ -201,7 +227,15 @@ actor CameraController {
         }
     }
 
-    private nonisolated static func pickCamera(facing: ClawdisCameraFacing) -> AVCaptureDevice? {
+    private nonisolated static func pickCamera(
+        facing: ClawdbotCameraFacing,
+        deviceId: String?) -> AVCaptureDevice?
+    {
+        if let deviceId, !deviceId.isEmpty {
+            if let match = AVCaptureDevice.devices(for: .video).first(where: { $0.uniqueID == deviceId }) {
+                return match
+            }
+        }
         let position: AVCaptureDevice.Position = (facing == .front) ? .front : .back
         if let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: position) {
             return device
@@ -210,6 +244,14 @@ actor CameraController {
         return AVCaptureDevice.default(for: .video)
     }
 
+    private nonisolated static func positionLabel(_ position: AVCaptureDevice.Position) -> String {
+        switch position {
+        case .front: "front"
+        case .back: "back"
+        default: "unspecified"
+        }
+    }
+
     nonisolated static func clampQuality(_ quality: Double?) -> Double {
         let q = quality ?? 0.9
         return min(1.0, max(0.05, q))
@@ -262,6 +304,13 @@ actor CameraController {
         // A short delay after `startRunning()` significantly reduces "blank first frame" captures on some devices.
         try? await Task.sleep(nanoseconds: 150_000_000) // 150ms
     }
+
+    private nonisolated static func sleepDelayMs(_ delayMs: Int) async {
+        guard delayMs > 0 else { return }
+        let maxDelayMs = 10 * 1000
+        let ns = UInt64(min(delayMs, maxDelayMs)) * UInt64(NSEC_PER_MSEC)
+        try? await Task.sleep(nanoseconds: ns)
+    }
 }
 
 private final class PhotoCaptureDelegate: NSObject, AVCapturePhotoCaptureDelegate {

apps/ios/Sources/Chat/ChatSheet.swift

@@ -1,15 +1,15 @@
-import ClawdisChatUI
+import ClawdbotChatUI
 import SwiftUI
 
 struct ChatSheet: View {
     @Environment(\.dismiss) private var dismiss
-    @State private var viewModel: ClawdisChatViewModel
+    @State private var viewModel: ClawdbotChatViewModel
     private let userAccent: Color?
 
     init(bridge: BridgeSession, sessionKey: String = "main", userAccent: Color? = nil) {
         let transport = IOSBridgeChatTransport(bridge: bridge)
         self._viewModel = State(
-            initialValue: ClawdisChatViewModel(
+            initialValue: ClawdbotChatViewModel(
                 sessionKey: sessionKey,
                 transport: transport))
         self.userAccent = userAccent
@@ -17,7 +17,10 @@ struct ChatSheet: View {
 
     var body: some View {
         NavigationStack {
-            ClawdisChatView(viewModel: self.viewModel, userAccent: self.userAccent)
+            ClawdbotChatView(
+                viewModel: self.viewModel,
+                showsSessionSwitcher: true,
+                userAccent: self.userAccent)
                 .navigationTitle("Chat")
                 .navigationBarTitleDisplayMode(.inline)
                 .toolbar {

apps/ios/Sources/Chat/IOSBridgeChatTransport.swift

@@ -1,8 +1,8 @@
-import ClawdisChatUI
-import ClawdisKit
+import ClawdbotChatUI
+import ClawdbotKit
 import Foundation
 
-struct IOSBridgeChatTransport: ClawdisChatTransport, Sendable {
+struct IOSBridgeChatTransport: ClawdbotChatTransport, Sendable {
     private let bridge: BridgeSession
 
     init(bridge: BridgeSession) {
@@ -19,7 +19,7 @@ struct IOSBridgeChatTransport: ClawdisChatTransport, Sendable {
         _ = try await self.bridge.request(method: "chat.abort", paramsJSON: json, timeoutSeconds: 10)
     }
 
-    func listSessions(limit: Int?) async throws -> ClawdisChatSessionsListResponse {
+    func listSessions(limit: Int?) async throws -> ClawdbotChatSessionsListResponse {
         struct Params: Codable {
             var includeGlobal: Bool
             var includeUnknown: Bool
@@ -28,7 +28,7 @@ struct IOSBridgeChatTransport: ClawdisChatTransport, Sendable {
         let data = try JSONEncoder().encode(Params(includeGlobal: true, includeUnknown: false, limit: limit))
         let json = String(data: data, encoding: .utf8)
         let res = try await self.bridge.request(method: "sessions.list", paramsJSON: json, timeoutSeconds: 15)
-        return try JSONDecoder().decode(ClawdisChatSessionsListResponse.self, from: res)
+        return try JSONDecoder().decode(ClawdbotChatSessionsListResponse.self, from: res)
     }
 
     func setActiveSessionKey(_ sessionKey: String) async throws {
@@ -38,12 +38,12 @@ struct IOSBridgeChatTransport: ClawdisChatTransport, Sendable {
         try await self.bridge.sendEvent(event: "chat.subscribe", payloadJSON: json)
     }
 
-    func requestHistory(sessionKey: String) async throws -> ClawdisChatHistoryPayload {
+    func requestHistory(sessionKey: String) async throws -> ClawdbotChatHistoryPayload {
         struct Params: Codable { var sessionKey: String }
         let data = try JSONEncoder().encode(Params(sessionKey: sessionKey))
         let json = String(data: data, encoding: .utf8)
         let res = try await self.bridge.request(method: "chat.history", paramsJSON: json, timeoutSeconds: 15)
-        return try JSONDecoder().decode(ClawdisChatHistoryPayload.self, from: res)
+        return try JSONDecoder().decode(ClawdbotChatHistoryPayload.self, from: res)
     }
 
     func sendMessage(
@@ -51,13 +51,13 @@ struct IOSBridgeChatTransport: ClawdisChatTransport, Sendable {
         message: String,
         thinking: String,
         idempotencyKey: String,
-        attachments: [ClawdisChatAttachmentPayload]) async throws -> ClawdisChatSendResponse
+        attachments: [ClawdbotChatAttachmentPayload]) async throws -> ClawdbotChatSendResponse
     {
         struct Params: Codable {
             var sessionKey: String
             var message: String
             var thinking: String
-            var attachments: [ClawdisChatAttachmentPayload]?
+            var attachments: [ClawdbotChatAttachmentPayload]?
             var timeoutMs: Int
             var idempotencyKey: String
         }
@@ -72,16 +72,16 @@ struct IOSBridgeChatTransport: ClawdisChatTransport, Sendable {
         let data = try JSONEncoder().encode(params)
         let json = String(data: data, encoding: .utf8)
         let res = try await self.bridge.request(method: "chat.send", paramsJSON: json, timeoutSeconds: 35)
-        return try JSONDecoder().decode(ClawdisChatSendResponse.self, from: res)
+        return try JSONDecoder().decode(ClawdbotChatSendResponse.self, from: res)
     }
 
     func requestHealth(timeoutMs: Int) async throws -> Bool {
         let seconds = max(1, Int(ceil(Double(timeoutMs) / 1000.0)))
         let res = try await self.bridge.request(method: "health", paramsJSON: nil, timeoutSeconds: seconds)
-        return (try? JSONDecoder().decode(ClawdisGatewayHealthOK.self, from: res))?.ok ?? true
+        return (try? JSONDecoder().decode(ClawdbotGatewayHealthOK.self, from: res))?.ok ?? true
     }
 
-    func events() -> AsyncStream<ClawdisChatTransportEvent> {
+    func events() -> AsyncStream<ClawdbotChatTransportEvent> {
         AsyncStream { continuation in
             let task = Task {
                 let stream = await self.bridge.subscribeServerEvents()
@@ -94,16 +94,16 @@ struct IOSBridgeChatTransport: ClawdisChatTransport, Sendable {
                         continuation.yield(.seqGap)
                     case "health":
                         guard let json = evt.payloadJSON, let data = json.data(using: .utf8) else { break }
-                        let ok = (try? JSONDecoder().decode(ClawdisGatewayHealthOK.self, from: data))?.ok ?? true
+                        let ok = (try? JSONDecoder().decode(ClawdbotGatewayHealthOK.self, from: data))?.ok ?? true
                         continuation.yield(.health(ok: ok))
                     case "chat":
                         guard let json = evt.payloadJSON, let data = json.data(using: .utf8) else { break }
-                        if let payload = try? JSONDecoder().decode(ClawdisChatEventPayload.self, from: data) {
+                        if let payload = try? JSONDecoder().decode(ClawdbotChatEventPayload.self, from: data) {
                             continuation.yield(.chat(payload))
                         }
                     case "agent":
                         guard let json = evt.payloadJSON, let data = json.data(using: .utf8) else { break }
-                        if let payload = try? JSONDecoder().decode(ClawdisAgentEventPayload.self, from: data) {
+                        if let payload = try? JSONDecoder().decode(ClawdbotAgentEventPayload.self, from: data) {
                             continuation.yield(.agent(payload))
                         }
                     default:

apps/ios/Sources/ClawdbotApp.swift

@@ -1,7 +1,7 @@
 import SwiftUI
 
 @main
-struct ClawdisApp: App {
+struct ClawdbotApp: App {
     @State private var appModel: NodeAppModel
     @State private var bridgeController: BridgeConnectionController
     @Environment(\.scenePhase) private var scenePhase

apps/ios/Sources/Info.plist

@@ -5,7 +5,7 @@
 	<key>CFBundleDevelopmentRegion</key>
 	<string>$(DEVELOPMENT_LANGUAGE)</string>
 	<key>CFBundleDisplayName</key>
-	<string>Clawdis</string>
+	<string>Clawdbot</string>
 	<key>CFBundleExecutable</key>
 	<string>$(EXECUTABLE_NAME)</string>
 	<key>CFBundleIconName</key>
@@ -29,16 +29,20 @@
 	</dict>
 	<key>NSBonjourServices</key>
 	<array>
-		<string>_clawdis-bridge._tcp</string>
+		<string>_clawdbot-bridge._tcp</string>
 	</array>
 	<key>NSCameraUsageDescription</key>
-	<string>Clawdis can capture photos or short video clips when requested via the bridge.</string>
+	<string>Clawdbot can capture photos or short video clips when requested via the bridge.</string>
 	<key>NSLocalNetworkUsageDescription</key>
-	<string>Clawdis discovers and connects to your Clawdis bridge on the local network.</string>
+	<string>Clawdbot discovers and connects to your Clawdbot bridge on the local network.</string>
+	<key>NSLocationWhenInUseUsageDescription</key>
+	<string>Clawdbot uses your location when you allow location sharing.</string>
+	<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
+	<string>Clawdbot can share your location in the background when you enable Always.</string>
 	<key>NSMicrophoneUsageDescription</key>
-	<string>Clawdis needs microphone access for voice wake.</string>
+	<string>Clawdbot needs microphone access for voice wake.</string>
 	<key>NSSpeechRecognitionUsageDescription</key>
-	<string>Clawdis uses on-device speech recognition for voice wake.</string>
+	<string>Clawdbot uses on-device speech recognition for voice wake.</string>
 	<key>UIApplicationSceneManifest</key>
 	<dict>
 		<key>UIApplicationSupportsMultipleScenes</key>

apps/ios/Sources/Location/LocationService.swift

@@ -0,0 +1,142 @@
+import ClawdbotKit
+import CoreLocation
+import Foundation
+
+@MainActor
+final class LocationService: NSObject, CLLocationManagerDelegate {
+    enum Error: Swift.Error {
+        case timeout
+        case unavailable
+    }
+
+    private let manager = CLLocationManager()
+    private var authContinuation: CheckedContinuation<CLAuthorizationStatus, Never>?
+    private var locationContinuation: CheckedContinuation<CLLocation, Swift.Error>?
+
+    override init() {
+        super.init()
+        self.manager.delegate = self
+        self.manager.desiredAccuracy = kCLLocationAccuracyBest
+    }
+
+    func authorizationStatus() -> CLAuthorizationStatus {
+        self.manager.authorizationStatus
+    }
+
+    func accuracyAuthorization() -> CLAccuracyAuthorization {
+        if #available(iOS 14.0, *) {
+            return self.manager.accuracyAuthorization
+        }
+        return .fullAccuracy
+    }
+
+    func ensureAuthorization(mode: ClawdbotLocationMode) async -> CLAuthorizationStatus {
+        guard CLLocationManager.locationServicesEnabled() else { return .denied }
+
+        let status = self.manager.authorizationStatus
+        if status == .notDetermined {
+            self.manager.requestWhenInUseAuthorization()
+            let updated = await self.awaitAuthorizationChange()
+            if mode != .always { return updated }
+        }
+
+        if mode == .always {
+            let current = self.manager.authorizationStatus
+            if current == .authorizedWhenInUse {
+                self.manager.requestAlwaysAuthorization()
+                return await self.awaitAuthorizationChange()
+            }
+            return current
+        }
+
+        return self.manager.authorizationStatus
+    }
+
+    func currentLocation(
+        params: ClawdbotLocationGetParams,
+        desiredAccuracy: ClawdbotLocationAccuracy,
+        maxAgeMs: Int?,
+        timeoutMs: Int?) async throws -> CLLocation
+    {
+        let now = Date()
+        if let maxAgeMs,
+           let cached = self.manager.location,
+           now.timeIntervalSince(cached.timestamp) * 1000 <= Double(maxAgeMs)
+        {
+            return cached
+        }
+
+        self.manager.desiredAccuracy = Self.accuracyValue(desiredAccuracy)
+        let timeout = max(0, timeoutMs ?? 10000)
+        return try await self.withTimeout(timeoutMs: timeout) {
+            try await self.requestLocation()
+        }
+    }
+
+    private func requestLocation() async throws -> CLLocation {
+        try await withCheckedThrowingContinuation { cont in
+            self.locationContinuation = cont
+            self.manager.requestLocation()
+        }
+    }
+
+    private func awaitAuthorizationChange() async -> CLAuthorizationStatus {
+        await withCheckedContinuation { cont in
+            self.authContinuation = cont
+        }
+    }
+
+    private func withTimeout<T>(
+        timeoutMs: Int,
+        operation: @escaping () async throws -> T) async throws -> T
+    {
+        if timeoutMs == 0 {
+            return try await operation()
+        }
+
+        return try await withThrowingTaskGroup(of: T.self) { group in
+            group.addTask { try await operation() }
+            group.addTask {
+                try await Task.sleep(nanoseconds: UInt64(timeoutMs) * 1_000_000)
+                throw Error.timeout
+            }
+            let result = try await group.next()!
+            group.cancelAll()
+            return result
+        }
+    }
+
+    private static func accuracyValue(_ accuracy: ClawdbotLocationAccuracy) -> CLLocationAccuracy {
+        switch accuracy {
+        case .coarse:
+            kCLLocationAccuracyKilometer
+        case .balanced:
+            kCLLocationAccuracyHundredMeters
+        case .precise:
+            kCLLocationAccuracyBest
+        }
+    }
+
+    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        if let cont = self.authContinuation {
+            self.authContinuation = nil
+            cont.resume(returning: manager.authorizationStatus)
+        }
+    }
+
+    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        guard let cont = self.locationContinuation else { return }
+        self.locationContinuation = nil
+        if let latest = locations.last {
+            cont.resume(returning: latest)
+        } else {
+            cont.resume(throwing: Error.unavailable)
+        }
+    }
+
+    func locationManager(_ manager: CLLocationManager, didFailWithError error: Swift.Error) {
+        guard let cont = self.locationContinuation else { return }
+        self.locationContinuation = nil
+        cont.resume(throwing: error)
+    }
+}

apps/ios/Sources/Model/NodeAppModel.swift

@@ -1,4 +1,4 @@
-import ClawdisKit
+import ClawdbotKit
 import Network
 import Observation
 import SwiftUI
@@ -31,6 +31,7 @@ final class NodeAppModel {
     @ObservationIgnored private var cameraHUDDismissTask: Task<Void, Never>?
     let voiceWake = VoiceWakeManager()
     let talkMode = TalkModeManager()
+    private let locationService = LocationService()
     private var lastAutoA2uiURL: String?
 
     var bridgeSession: BridgeSession { self.bridge }
@@ -88,7 +89,7 @@ final class NodeAppModel {
         }()
         guard !userAction.isEmpty else { return }
 
-        guard let name = ClawdisCanvasA2UIAction.extractActionName(userAction) else { return }
+        guard let name = ClawdbotCanvasA2UIAction.extractActionName(userAction) else { return }
         let actionId: String = {
             let id = (userAction["id"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
             return id.isEmpty ? UUID().uuidString : id
@@ -107,15 +108,15 @@ final class NodeAppModel {
 
         let host = UserDefaults.standard.string(forKey: "node.displayName") ?? UIDevice.current.name
         let instanceId = (UserDefaults.standard.string(forKey: "node.instanceId") ?? "ios-node").lowercased()
-        let contextJSON = ClawdisCanvasA2UIAction.compactJSON(userAction["context"])
+        let contextJSON = ClawdbotCanvasA2UIAction.compactJSON(userAction["context"])
         let sessionKey = "main"
 
-        let messageContext = ClawdisCanvasA2UIAction.AgentMessageContext(
+        let messageContext = ClawdbotCanvasA2UIAction.AgentMessageContext(
             actionName: name,
             session: .init(key: sessionKey, surfaceId: surfaceId),
             component: .init(id: sourceComponentId, host: host, instanceId: instanceId),
             contextJSON: contextJSON)
-        let message = ClawdisCanvasA2UIAction.formatAgentMessage(messageContext)
+        let message = ClawdbotCanvasA2UIAction.formatAgentMessage(messageContext)
 
         let ok: Bool
         var errorText: String?
@@ -140,7 +141,7 @@ final class NodeAppModel {
             }
         }
 
-        let js = ClawdisCanvasA2UIAction.jsDispatchA2UIActionStatus(actionId: actionId, ok: ok, error: errorText)
+        let js = ClawdbotCanvasA2UIAction.jsDispatchA2UIActionStatus(actionId: actionId, ok: ok, error: errorText)
         do {
             _ = try await self.screen.eval(javaScript: js)
         } catch {
@@ -152,7 +153,7 @@ final class NodeAppModel {
         guard let raw = await self.bridge.currentCanvasHostUrl() else { return nil }
         let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
         guard !trimmed.isEmpty, let base = URL(string: trimmed) else { return nil }
-        return base.appendingPathComponent("__clawdis__/a2ui/").absoluteString + "?platform=ios"
+        return base.appendingPathComponent("__clawdbot__/a2ui/").absoluteString + "?platform=ios"
     }
 
     private func showA2UIOnConnectIfNeeded() async {
@@ -188,6 +189,19 @@ final class NodeAppModel {
         self.talkMode.setEnabled(enabled)
     }
 
+    func requestLocationPermissions(mode: ClawdbotLocationMode) async -> Bool {
+        guard mode != .off else { return true }
+        let status = await self.locationService.ensureAuthorization(mode: mode)
+        switch status {
+        case .authorizedAlways:
+            return true
+        case .authorizedWhenInUse:
+            return mode != .always
+        default:
+            return false
+        }
+    }
+
     func connectToBridge(
         endpoint: NWEndpoint,
         hello: BridgeHello)
@@ -236,7 +250,9 @@ final class NodeAppModel {
                                 return BridgeInvokeResponse(
                                     id: req.id,
                                     ok: false,
-                                    error: ClawdisNodeError(code: .unavailable, message: "UNAVAILABLE: node not ready"))
+                                    error: ClawdbotNodeError(
+                                        code: .unavailable,
+                                        message: "UNAVAILABLE: node not ready"))
                             }
                             return await self.handleInvoke(req)
                         })
@@ -425,7 +441,7 @@ final class NodeAppModel {
         }
 
         // iOS bridge forwards to the gateway; no local auth prompts here.
-        // (Key-based unattended auth is handled on macOS for clawdis:// links.)
+        // (Key-based unattended auth is handled on macOS for clawdbot:// links.)
         let data = try JSONEncoder().encode(link)
         guard let json = String(bytes: data, encoding: .utf8) else {
             throw NSError(domain: "NodeAppModel", code: 2, userInfo: [
@@ -440,17 +456,14 @@ final class NodeAppModel {
         return false
     }
 
-    // swiftlint:disable:next function_body_length cyclomatic_complexity
     private func handleInvoke(_ req: BridgeInvokeRequest) async -> BridgeInvokeResponse {
         let command = req.command
 
-        if command.hasPrefix("canvas.") || command.hasPrefix("camera.") || command.hasPrefix("screen."),
-           self.isBackgrounded
-        {
+        if self.isBackgrounded, self.isBackgroundRestricted(command) {
             return BridgeInvokeResponse(
                 id: req.id,
                 ok: false,
-                error: ClawdisNodeError(
+                error: ClawdbotNodeError(
                     code: .backgroundUnavailable,
                     message: "NODE_BACKGROUND_UNAVAILABLE: canvas/camera/screen commands require foreground"))
         }
@@ -459,222 +472,36 @@ final class NodeAppModel {
             return BridgeInvokeResponse(
                 id: req.id,
                 ok: false,
-                error: ClawdisNodeError(
+                error: ClawdbotNodeError(
                     code: .unavailable,
                     message: "CAMERA_DISABLED: enable Camera in iOS Settings → Camera → Allow Camera"))
         }
 
         do {
             switch command {
-            case ClawdisCanvasCommand.present.rawValue:
-                let params = (try? Self.decodeParams(ClawdisCanvasPresentParams.self, from: req.paramsJSON)) ??
-                    ClawdisCanvasPresentParams()
-                let url = params.url?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
-                if url.isEmpty {
-                    self.screen.showDefaultCanvas()
-                } else {
-                    self.screen.navigate(to: url)
-                }
-                return BridgeInvokeResponse(id: req.id, ok: true)
-
-            case ClawdisCanvasCommand.hide.rawValue:
-                return BridgeInvokeResponse(id: req.id, ok: true)
-
-            case ClawdisCanvasCommand.navigate.rawValue:
-                let params = try Self.decodeParams(ClawdisCanvasNavigateParams.self, from: req.paramsJSON)
-                self.screen.navigate(to: params.url)
-                return BridgeInvokeResponse(id: req.id, ok: true)
-
-            case ClawdisCanvasCommand.evalJS.rawValue:
-                let params = try Self.decodeParams(ClawdisCanvasEvalParams.self, from: req.paramsJSON)
-                let result = try await self.screen.eval(javaScript: params.javaScript)
-                let payload = try Self.encodePayload(["result": result])
-                return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: payload)
-
-            case ClawdisCanvasCommand.snapshot.rawValue:
-                let params = try? Self.decodeParams(ClawdisCanvasSnapshotParams.self, from: req.paramsJSON)
-                let format = params?.format ?? .jpeg
-                let maxWidth: CGFloat? = {
-                    if let raw = params?.maxWidth, raw > 0 { return CGFloat(raw) }
-                    // Keep default snapshots comfortably below the gateway client's maxPayload.
-                    // For full-res, clients should explicitly request a larger maxWidth.
-                    return switch format {
-                    case .png: 900
-                    case .jpeg: 1600
-                    }
-                }()
-                let base64 = try await self.screen.snapshotBase64(
-                    maxWidth: maxWidth,
-                    format: format,
-                    quality: params?.quality)
-                let payload = try Self.encodePayload([
-                    "format": format == .jpeg ? "jpeg" : "png",
-                    "base64": base64,
-                ])
-                return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: payload)
-
-            case ClawdisCanvasA2UICommand.reset.rawValue:
-                guard let a2uiUrl = await self.resolveA2UIHostURL() else {
-                    return BridgeInvokeResponse(
-                        id: req.id,
-                        ok: false,
-                        error: ClawdisNodeError(
-                            code: .unavailable,
-                            message: "A2UI_HOST_NOT_CONFIGURED: gateway did not advertise canvas host"))
-                }
-                self.screen.navigate(to: a2uiUrl)
-                if await !self.screen.waitForA2UIReady(timeoutMs: 5000) {
-                    return BridgeInvokeResponse(
-                        id: req.id,
-                        ok: false,
-                        error: ClawdisNodeError(
-                            code: .unavailable,
-                            message: "A2UI_HOST_UNAVAILABLE: A2UI host not reachable"))
-                }
-
-                let json = try await self.screen.eval(javaScript: """
-                (() => {
-                  if (!globalThis.clawdisA2UI) return JSON.stringify({ ok: false, error: "missing clawdisA2UI" });
-                  return JSON.stringify(globalThis.clawdisA2UI.reset());
-                })()
-                """)
-                return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: json)
-
-            case ClawdisCanvasA2UICommand.push.rawValue, ClawdisCanvasA2UICommand.pushJSONL.rawValue:
-                let messages: [AnyCodable]
-                if command == ClawdisCanvasA2UICommand.pushJSONL.rawValue {
-                    let params = try Self.decodeParams(ClawdisCanvasA2UIPushJSONLParams.self, from: req.paramsJSON)
-                    messages = try ClawdisCanvasA2UIJSONL.decodeMessagesFromJSONL(params.jsonl)
-                } else {
-                    do {
-                        let params = try Self.decodeParams(ClawdisCanvasA2UIPushParams.self, from: req.paramsJSON)
-                        messages = params.messages
-                    } catch {
-                        // Be forgiving: some clients still send JSONL payloads to `canvas.a2ui.push`.
-                        let params = try Self.decodeParams(ClawdisCanvasA2UIPushJSONLParams.self, from: req.paramsJSON)
-                        messages = try ClawdisCanvasA2UIJSONL.decodeMessagesFromJSONL(params.jsonl)
-                    }
-                }
-
-                guard let a2uiUrl = await self.resolveA2UIHostURL() else {
-                    return BridgeInvokeResponse(
-                        id: req.id,
-                        ok: false,
-                        error: ClawdisNodeError(
-                            code: .unavailable,
-                            message: "A2UI_HOST_NOT_CONFIGURED: gateway did not advertise canvas host"))
-                }
-                self.screen.navigate(to: a2uiUrl)
-                if await !self.screen.waitForA2UIReady(timeoutMs: 5000) {
-                    return BridgeInvokeResponse(
-                        id: req.id,
-                        ok: false,
-                        error: ClawdisNodeError(
-                            code: .unavailable,
-                            message: "A2UI_HOST_UNAVAILABLE: A2UI host not reachable"))
-                }
-
-                let messagesJSON = try ClawdisCanvasA2UIJSONL.encodeMessagesJSONArray(messages)
-                let js = """
-                (() => {
-                  try {
-                    if (!globalThis.clawdisA2UI) return JSON.stringify({ ok: false, error: "missing clawdisA2UI" });
-                    const messages = \(messagesJSON);
-                    return JSON.stringify(globalThis.clawdisA2UI.applyMessages(messages));
-                  } catch (e) {
-                    return JSON.stringify({ ok: false, error: String(e?.message ?? e) });
-                  }
-                })()
-                """
-                let resultJSON = try await self.screen.eval(javaScript: js)
-                return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: resultJSON)
-
-            case ClawdisCameraCommand.snap.rawValue:
-                self.showCameraHUD(text: "Taking photo…", kind: .photo)
-                self.triggerCameraFlash()
-                let params = (try? Self.decodeParams(ClawdisCameraSnapParams.self, from: req.paramsJSON)) ??
-                    ClawdisCameraSnapParams()
-                let res = try await self.camera.snap(params: params)
-
-                struct Payload: Codable {
-                    var format: String
-                    var base64: String
-                    var width: Int
-                    var height: Int
-                }
-                let payload = try Self.encodePayload(Payload(
-                    format: res.format,
-                    base64: res.base64,
-                    width: res.width,
-                    height: res.height))
-                self.showCameraHUD(text: "Photo captured", kind: .success, autoHideSeconds: 1.6)
-                return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: payload)
-
-            case ClawdisCameraCommand.clip.rawValue:
-                let params = (try? Self.decodeParams(ClawdisCameraClipParams.self, from: req.paramsJSON)) ??
-                    ClawdisCameraClipParams()
-
-                let suspended = (params.includeAudio ?? true) ? self.voiceWake.suspendForExternalAudioCapture() : false
-                defer { self.voiceWake.resumeAfterExternalAudioCapture(wasSuspended: suspended) }
-
-                self.showCameraHUD(text: "Recording…", kind: .recording)
-                let res = try await self.camera.clip(params: params)
-
-                struct Payload: Codable {
-                    var format: String
-                    var base64: String
-                    var durationMs: Int
-                    var hasAudio: Bool
-                }
-                let payload = try Self.encodePayload(Payload(
-                    format: res.format,
-                    base64: res.base64,
-                    durationMs: res.durationMs,
-                    hasAudio: res.hasAudio))
-                self.showCameraHUD(text: "Clip captured", kind: .success, autoHideSeconds: 1.8)
-                return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: payload)
-
-            case ClawdisScreenCommand.record.rawValue:
-                let params = (try? Self.decodeParams(ClawdisScreenRecordParams.self, from: req.paramsJSON)) ??
-                    ClawdisScreenRecordParams()
-                if let format = params.format, format.lowercased() != "mp4" {
-                    throw NSError(domain: "Screen", code: 30, userInfo: [
-                        NSLocalizedDescriptionKey: "INVALID_REQUEST: screen format must be mp4",
-                    ])
-                }
-                // Status pill mirrors screen recording state so it stays visible without overlay stacking.
-                self.screenRecordActive = true
-                defer { self.screenRecordActive = false }
-                let path = try await self.screenRecorder.record(
-                    screenIndex: params.screenIndex,
-                    durationMs: params.durationMs,
-                    fps: params.fps,
-                    includeAudio: params.includeAudio,
-                    outPath: nil)
-                defer { try? FileManager.default.removeItem(atPath: path) }
-                let data = try Data(contentsOf: URL(fileURLWithPath: path))
-                struct Payload: Codable {
-                    var format: String
-                    var base64: String
-                    var durationMs: Int?
-                    var fps: Double?
-                    var screenIndex: Int?
-                    var hasAudio: Bool
-                }
-                let payload = try Self.encodePayload(Payload(
-                    format: "mp4",
-                    base64: data.base64EncodedString(),
-                    durationMs: params.durationMs,
-                    fps: params.fps,
-                    screenIndex: params.screenIndex,
-                    hasAudio: params.includeAudio ?? true))
-                return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: payload)
-
+            case ClawdbotLocationCommand.get.rawValue:
+                return try await self.handleLocationInvoke(req)
+            case ClawdbotCanvasCommand.present.rawValue,
+                 ClawdbotCanvasCommand.hide.rawValue,
+                 ClawdbotCanvasCommand.navigate.rawValue,
+                 ClawdbotCanvasCommand.evalJS.rawValue,
+                 ClawdbotCanvasCommand.snapshot.rawValue:
+                return try await self.handleCanvasInvoke(req)
+            case ClawdbotCanvasA2UICommand.reset.rawValue,
+                 ClawdbotCanvasA2UICommand.push.rawValue,
+                 ClawdbotCanvasA2UICommand.pushJSONL.rawValue:
+                return try await self.handleCanvasA2UIInvoke(req)
+            case ClawdbotCameraCommand.list.rawValue,
+                 ClawdbotCameraCommand.snap.rawValue,
+                 ClawdbotCameraCommand.clip.rawValue:
+                return try await self.handleCameraInvoke(req)
+            case ClawdbotScreenCommand.record.rawValue:
+                return try await self.handleScreenRecordInvoke(req)
             default:
                 return BridgeInvokeResponse(
                     id: req.id,
                     ok: false,
-                    error: ClawdisNodeError(code: .invalidRequest, message: "INVALID_REQUEST: unknown command"))
+                    error: ClawdbotNodeError(code: .invalidRequest, message: "INVALID_REQUEST: unknown command"))
             }
         } catch {
             if command.hasPrefix("camera.") {
@@ -684,10 +511,317 @@ final class NodeAppModel {
             return BridgeInvokeResponse(
                 id: req.id,
                 ok: false,
-                error: ClawdisNodeError(code: .unavailable, message: error.localizedDescription))
+                error: ClawdbotNodeError(code: .unavailable, message: error.localizedDescription))
         }
     }
 
+    private func isBackgroundRestricted(_ command: String) -> Bool {
+        command.hasPrefix("canvas.") || command.hasPrefix("camera.") || command.hasPrefix("screen.")
+    }
+
+    private func handleLocationInvoke(_ req: BridgeInvokeRequest) async throws -> BridgeInvokeResponse {
+        let mode = self.locationMode()
+        guard mode != .off else {
+            return BridgeInvokeResponse(
+                id: req.id,
+                ok: false,
+                error: ClawdbotNodeError(
+                    code: .unavailable,
+                    message: "LOCATION_DISABLED: enable Location in Settings"))
+        }
+        if self.isBackgrounded, mode != .always {
+            return BridgeInvokeResponse(
+                id: req.id,
+                ok: false,
+                error: ClawdbotNodeError(
+                    code: .backgroundUnavailable,
+                    message: "LOCATION_BACKGROUND_UNAVAILABLE: background location requires Always"))
+        }
+        let params = (try? Self.decodeParams(ClawdbotLocationGetParams.self, from: req.paramsJSON)) ??
+            ClawdbotLocationGetParams()
+        let desired = params.desiredAccuracy ??
+            (self.isLocationPreciseEnabled() ? .precise : .balanced)
+        let status = self.locationService.authorizationStatus()
+        if status != .authorizedAlways, status != .authorizedWhenInUse {
+            return BridgeInvokeResponse(
+                id: req.id,
+                ok: false,
+                error: ClawdbotNodeError(
+                    code: .unavailable,
+                    message: "LOCATION_PERMISSION_REQUIRED: grant Location permission"))
+        }
+        if self.isBackgrounded, status != .authorizedAlways {
+            return BridgeInvokeResponse(
+                id: req.id,
+                ok: false,
+                error: ClawdbotNodeError(
+                    code: .unavailable,
+                    message: "LOCATION_PERMISSION_REQUIRED: enable Always for background access"))
+        }
+        let location = try await self.locationService.currentLocation(
+            params: params,
+            desiredAccuracy: desired,
+            maxAgeMs: params.maxAgeMs,
+            timeoutMs: params.timeoutMs)
+        let isPrecise = self.locationService.accuracyAuthorization() == .fullAccuracy
+        let payload = ClawdbotLocationPayload(
+            lat: location.coordinate.latitude,
+            lon: location.coordinate.longitude,
+            accuracyMeters: location.horizontalAccuracy,
+            altitudeMeters: location.verticalAccuracy >= 0 ? location.altitude : nil,
+            speedMps: location.speed >= 0 ? location.speed : nil,
+            headingDeg: location.course >= 0 ? location.course : nil,
+            timestamp: ISO8601DateFormatter().string(from: location.timestamp),
+            isPrecise: isPrecise,
+            source: nil)
+        let json = try Self.encodePayload(payload)
+        return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: json)
+    }
+
+    private func handleCanvasInvoke(_ req: BridgeInvokeRequest) async throws -> BridgeInvokeResponse {
+        switch req.command {
+        case ClawdbotCanvasCommand.present.rawValue:
+            let params = (try? Self.decodeParams(ClawdbotCanvasPresentParams.self, from: req.paramsJSON)) ??
+                ClawdbotCanvasPresentParams()
+            let url = params.url?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+            if url.isEmpty {
+                self.screen.showDefaultCanvas()
+            } else {
+                self.screen.navigate(to: url)
+            }
+            return BridgeInvokeResponse(id: req.id, ok: true)
+        case ClawdbotCanvasCommand.hide.rawValue:
+            return BridgeInvokeResponse(id: req.id, ok: true)
+        case ClawdbotCanvasCommand.navigate.rawValue:
+            let params = try Self.decodeParams(ClawdbotCanvasNavigateParams.self, from: req.paramsJSON)
+            self.screen.navigate(to: params.url)
+            return BridgeInvokeResponse(id: req.id, ok: true)
+        case ClawdbotCanvasCommand.evalJS.rawValue:
+            let params = try Self.decodeParams(ClawdbotCanvasEvalParams.self, from: req.paramsJSON)
+            let result = try await self.screen.eval(javaScript: params.javaScript)
+            let payload = try Self.encodePayload(["result": result])
+            return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: payload)
+        case ClawdbotCanvasCommand.snapshot.rawValue:
+            let params = try? Self.decodeParams(ClawdbotCanvasSnapshotParams.self, from: req.paramsJSON)
+            let format = params?.format ?? .jpeg
+            let maxWidth: CGFloat? = {
+                if let raw = params?.maxWidth, raw > 0 { return CGFloat(raw) }
+                // Keep default snapshots comfortably below the gateway client's maxPayload.
+                // For full-res, clients should explicitly request a larger maxWidth.
+                return switch format {
+                case .png: 900
+                case .jpeg: 1600
+                }
+            }()
+            let base64 = try await self.screen.snapshotBase64(
+                maxWidth: maxWidth,
+                format: format,
+                quality: params?.quality)
+            let payload = try Self.encodePayload([
+                "format": format == .jpeg ? "jpeg" : "png",
+                "base64": base64,
+            ])
+            return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: payload)
+        default:
+            return BridgeInvokeResponse(
+                id: req.id,
+                ok: false,
+                error: ClawdbotNodeError(code: .invalidRequest, message: "INVALID_REQUEST: unknown command"))
+        }
+    }
+
+    private func handleCanvasA2UIInvoke(_ req: BridgeInvokeRequest) async throws -> BridgeInvokeResponse {
+        let command = req.command
+        switch command {
+        case ClawdbotCanvasA2UICommand.reset.rawValue:
+            guard let a2uiUrl = await self.resolveA2UIHostURL() else {
+                return BridgeInvokeResponse(
+                    id: req.id,
+                    ok: false,
+                    error: ClawdbotNodeError(
+                        code: .unavailable,
+                        message: "A2UI_HOST_NOT_CONFIGURED: gateway did not advertise canvas host"))
+            }
+            self.screen.navigate(to: a2uiUrl)
+            if await !self.screen.waitForA2UIReady(timeoutMs: 5000) {
+                return BridgeInvokeResponse(
+                    id: req.id,
+                    ok: false,
+                    error: ClawdbotNodeError(
+                        code: .unavailable,
+                        message: "A2UI_HOST_UNAVAILABLE: A2UI host not reachable"))
+            }
+
+            let json = try await self.screen.eval(javaScript: """
+            (() => {
+              if (!globalThis.clawdbotA2UI) return JSON.stringify({ ok: false, error: "missing clawdbotA2UI" });
+              return JSON.stringify(globalThis.clawdbotA2UI.reset());
+            })()
+            """)
+            return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: json)
+        case ClawdbotCanvasA2UICommand.push.rawValue, ClawdbotCanvasA2UICommand.pushJSONL.rawValue:
+            let messages: [AnyCodable]
+            if command == ClawdbotCanvasA2UICommand.pushJSONL.rawValue {
+                let params = try Self.decodeParams(ClawdbotCanvasA2UIPushJSONLParams.self, from: req.paramsJSON)
+                messages = try ClawdbotCanvasA2UIJSONL.decodeMessagesFromJSONL(params.jsonl)
+            } else {
+                do {
+                    let params = try Self.decodeParams(ClawdbotCanvasA2UIPushParams.self, from: req.paramsJSON)
+                    messages = params.messages
+                } catch {
+                    // Be forgiving: some clients still send JSONL payloads to `canvas.a2ui.push`.
+                    let params = try Self.decodeParams(ClawdbotCanvasA2UIPushJSONLParams.self, from: req.paramsJSON)
+                    messages = try ClawdbotCanvasA2UIJSONL.decodeMessagesFromJSONL(params.jsonl)
+                }
+            }
+
+            guard let a2uiUrl = await self.resolveA2UIHostURL() else {
+                return BridgeInvokeResponse(
+                    id: req.id,
+                    ok: false,
+                    error: ClawdbotNodeError(
+                        code: .unavailable,
+                        message: "A2UI_HOST_NOT_CONFIGURED: gateway did not advertise canvas host"))
+            }
+            self.screen.navigate(to: a2uiUrl)
+            if await !self.screen.waitForA2UIReady(timeoutMs: 5000) {
+                return BridgeInvokeResponse(
+                    id: req.id,
+                    ok: false,
+                    error: ClawdbotNodeError(
+                        code: .unavailable,
+                        message: "A2UI_HOST_UNAVAILABLE: A2UI host not reachable"))
+            }
+
+            let messagesJSON = try ClawdbotCanvasA2UIJSONL.encodeMessagesJSONArray(messages)
+            let js = """
+            (() => {
+              try {
+                if (!globalThis.clawdbotA2UI) return JSON.stringify({ ok: false, error: "missing clawdbotA2UI" });
+                const messages = \(messagesJSON);
+                return JSON.stringify(globalThis.clawdbotA2UI.applyMessages(messages));
+              } catch (e) {
+                return JSON.stringify({ ok: false, error: String(e?.message ?? e) });
+              }
+            })()
+            """
+            let resultJSON = try await self.screen.eval(javaScript: js)
+            return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: resultJSON)
+        default:
+            return BridgeInvokeResponse(
+                id: req.id,
+                ok: false,
+                error: ClawdbotNodeError(code: .invalidRequest, message: "INVALID_REQUEST: unknown command"))
+        }
+    }
+
+    private func handleCameraInvoke(_ req: BridgeInvokeRequest) async throws -> BridgeInvokeResponse {
+        switch req.command {
+        case ClawdbotCameraCommand.list.rawValue:
+            let devices = await self.camera.listDevices()
+            struct Payload: Codable {
+                var devices: [CameraController.CameraDeviceInfo]
+            }
+            let payload = try Self.encodePayload(Payload(devices: devices))
+            return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: payload)
+        case ClawdbotCameraCommand.snap.rawValue:
+            self.showCameraHUD(text: "Taking photo…", kind: .photo)
+            self.triggerCameraFlash()
+            let params = (try? Self.decodeParams(ClawdbotCameraSnapParams.self, from: req.paramsJSON)) ??
+                ClawdbotCameraSnapParams()
+            let res = try await self.camera.snap(params: params)
+
+            struct Payload: Codable {
+                var format: String
+                var base64: String
+                var width: Int
+                var height: Int
+            }
+            let payload = try Self.encodePayload(Payload(
+                format: res.format,
+                base64: res.base64,
+                width: res.width,
+                height: res.height))
+            self.showCameraHUD(text: "Photo captured", kind: .success, autoHideSeconds: 1.6)
+            return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: payload)
+        case ClawdbotCameraCommand.clip.rawValue:
+            let params = (try? Self.decodeParams(ClawdbotCameraClipParams.self, from: req.paramsJSON)) ??
+                ClawdbotCameraClipParams()
+
+            let suspended = (params.includeAudio ?? true) ? self.voiceWake.suspendForExternalAudioCapture() : false
+            defer { self.voiceWake.resumeAfterExternalAudioCapture(wasSuspended: suspended) }
+
+            self.showCameraHUD(text: "Recording…", kind: .recording)
+            let res = try await self.camera.clip(params: params)
+
+            struct Payload: Codable {
+                var format: String
+                var base64: String
+                var durationMs: Int
+                var hasAudio: Bool
+            }
+            let payload = try Self.encodePayload(Payload(
+                format: res.format,
+                base64: res.base64,
+                durationMs: res.durationMs,
+                hasAudio: res.hasAudio))
+            self.showCameraHUD(text: "Clip captured", kind: .success, autoHideSeconds: 1.8)
+            return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: payload)
+        default:
+            return BridgeInvokeResponse(
+                id: req.id,
+                ok: false,
+                error: ClawdbotNodeError(code: .invalidRequest, message: "INVALID_REQUEST: unknown command"))
+        }
+    }
+
+    private func handleScreenRecordInvoke(_ req: BridgeInvokeRequest) async throws -> BridgeInvokeResponse {
+        let params = (try? Self.decodeParams(ClawdbotScreenRecordParams.self, from: req.paramsJSON)) ??
+            ClawdbotScreenRecordParams()
+        if let format = params.format, format.lowercased() != "mp4" {
+            throw NSError(domain: "Screen", code: 30, userInfo: [
+                NSLocalizedDescriptionKey: "INVALID_REQUEST: screen format must be mp4",
+            ])
+        }
+        // Status pill mirrors screen recording state so it stays visible without overlay stacking.
+        self.screenRecordActive = true
+        defer { self.screenRecordActive = false }
+        let path = try await self.screenRecorder.record(
+            screenIndex: params.screenIndex,
+            durationMs: params.durationMs,
+            fps: params.fps,
+            includeAudio: params.includeAudio,
+            outPath: nil)
+        defer { try? FileManager.default.removeItem(atPath: path) }
+        let data = try Data(contentsOf: URL(fileURLWithPath: path))
+        struct Payload: Codable {
+            var format: String
+            var base64: String
+            var durationMs: Int?
+            var fps: Double?
+            var screenIndex: Int?
+            var hasAudio: Bool
+        }
+        let payload = try Self.encodePayload(Payload(
+            format: "mp4",
+            base64: data.base64EncodedString(),
+            durationMs: params.durationMs,
+            fps: params.fps,
+            screenIndex: params.screenIndex,
+            hasAudio: params.includeAudio ?? true))
+        return BridgeInvokeResponse(id: req.id, ok: true, payloadJSON: payload)
+    }
+
+    private func locationMode() -> ClawdbotLocationMode {
+        let raw = UserDefaults.standard.string(forKey: "location.enabledMode") ?? "off"
+        return ClawdbotLocationMode(rawValue: raw) ?? .off
+    }
+
+    private func isLocationPreciseEnabled() -> Bool {
+        if UserDefaults.standard.object(forKey: "location.preciseEnabled") == nil { return true }
+        return UserDefaults.standard.bool(forKey: "location.preciseEnabled")
+    }
+
     private static func decodeParams<T: Decodable>(_ type: T.Type, from json: String?) throws -> T {
         guard let json, let data = json.data(using: .utf8) else {
             throw NSError(domain: "Bridge", code: 20, userInfo: [