diff --git a/.agents/skills/async-state-safety/SKILL.md b/.agents/skills/async-state-safety/SKILL.md
new file mode 100644
index 000000000..47eded577
--- /dev/null
+++ b/.agents/skills/async-state-safety/SKILL.md
@@ -0,0 +1,47 @@
+---
+name: async-state-safety
+description: This skill should be used when the user asks to change "worker lifecycle", "cancellation", "retrigger behavior", "state machine", "delivery receipts", "timeouts", or "race conditions". Enforces explicit async/state invariants and targeted race-safe verification.
+---
+
+# Async State Safety
+
+## Goal
+
+Prevent race regressions in async and stateful paths.
+
+## Required Invariants
+
+- Define valid terminal states before coding.
+- Define allowed state transitions before coding.
+- Keep terminal transitions idempotent.
+- Ensure duplicate events cannot double-apply terminal effects.
+- Ensure retries do not corrupt state.
+
+## Race Checklist
+
+- Cancellation racing completion
+- Timeout racing completion
+- Retry racing ack/receipt update
+- Concurrent updates to the same worker/channel record
+- Missing-handle and stale-handle behavior
+
+## Implementation Checklist
+
+- Add or update transition guards.
+- Keep error handling explicit and structured.
+- Preserve status/event emission on all terminal branches.
+- Document why each race path converges safely.
+
+## Verification Checklist
+
+- Run targeted tests for each touched race path.
+- Add at least one negative-path test for terminal convergence.
+- Add at least one idempotency test where applicable.
+- Run broad gate checks after targeted checks pass.
+
+## Handoff Requirements
+
+- Terminal states and transition matrix
+- Race windows analyzed
+- Targeted commands and outcomes
+- Residual risks and follow-up tests
diff --git a/.agents/skills/messaging-adapter-parity/SKILL.md b/.agents/skills/messaging-adapter-parity/SKILL.md
new file mode 100644
index 000000000..9893dc52f
--- /dev/null
+++ b/.agents/skills/messaging-adapter-parity/SKILL.md
@@ -0,0 +1,40 @@
+---
+name: messaging-adapter-parity
+description: This skill should be used when the user asks to change "Slack adapter", "Telegram adapter", "Discord adapter", "Webhook adapter", "status delivery", "message routing", or "delivery receipts". Enforces cross-adapter parity and explicit delivery semantics.
+---
+
+# Messaging Adapter Parity
+
+## Goal
+
+Prevent adapter-specific regressions by validating behavior contracts across messaging backends.
+
+## Contract Areas
+
+- User-visible reply behavior
+- Status update behavior (`surfaced` vs `not surfaced`)
+- Delivery receipt ack/failure semantics
+- Retry behavior and bounded backoff
+- Error mapping and logging clarity
+
+## Parity Checklist
+
+- For every changed adapter path, compare expected behavior with at least one other adapter.
+- If an adapter intentionally does not surface a status, ensure receipt handling still converges correctly.
+- Ensure unsupported features degrade gracefully and predictably.
+- Ensure worker terminal notices cannot loop indefinitely.
+
+## Verification Checklist
+
+- Run targeted tests for the touched adapter.
+- Run targeted tests for receipt ack/failure paths.
+- Run at least one parity comparison check across adapters.
+- Run broad gate checks after targeted checks pass.
+
+## Required Handoff
+
+- Adapter paths changed
+- Contract decisions made
+- Receipt behavior outcomes
+- Verification evidence
+- Residual parity gaps
diff --git a/.agents/skills/pr-gates/SKILL.md b/.agents/skills/pr-gates/SKILL.md
new file mode 100644
index 000000000..0bcb22ae8
--- /dev/null
+++ b/.agents/skills/pr-gates/SKILL.md
@@ -0,0 +1,44 @@
+---
+name: pr-gates
+description: This skill should be used when the user asks to "open a PR", "prepare for review", "address review comments", "run gates", or "verify before pushing" in this repository. Enforces preflight/gate workflow, migration safety, and review-evidence closure.
+---
+
+# PR Gates
+
+## Mandatory Flow
+
+1. Run `just preflight` before finalizing changes.
+2. Run `just gate-pr` before pushing or updating a PR.
+3. If the same command fails twice in one session, stop rerunning and switch to root-cause debugging.
+4. Do not push when any gate is red.
+
+## Review Feedback Closure
+
+For every P1/P2 review finding, include all three:
+
+- Code change reference (file path and concise rationale)
+- Targeted verification command
+- Pass/fail evidence from that command
+
+## Async And Stateful Changes
+
+When touching worker lifecycle, cancellation, retries, state transitions, or caches:
+
+- Document terminal states and allowed transitions.
+- Explicitly reason about race windows and idempotency.
+- Run targeted tests in addition to broad gate runs.
+- Capture the exact command proving the behavior.
+
+## Migration Safety
+
+- Never edit an existing file in `migrations/`.
+- Add a new timestamped migration for every schema change.
+- If a gate flags migration edits, stop and create a new migration file.
+
+## Handoff Format
+
+- Summary
+- Changed files
+- Gate commands executed
+- P1/P2 finding-to-evidence mapping
+- Residual risk
diff --git a/.agents/skills/pr-slicer/SKILL.md b/.agents/skills/pr-slicer/SKILL.md
new file mode 100644
index 000000000..06909fc18
--- /dev/null
+++ b/.agents/skills/pr-slicer/SKILL.md
@@ -0,0 +1,55 @@
+---
+name: pr-slicer
+description: This skill should be used when the user asks to "split this PR", "make this smaller", "create stacked PRs", "slice this change", or "reduce review churn". Helps break work into low-risk, reviewable slices with clear verification per slice.
+---
+
+# PR Slicer
+
+## Goal
+
+Reduce review latency and rework by shipping smaller, independent slices.
+
+## Default Slice Budgets
+
+- Target `<= 400` changed lines per slice when practical.
+- Target `<= 10` changed files per slice when practical.
+- Target `1-4` commits per slice.
+- Keep each slice behaviorally coherent and independently verifiable.
+
+## Slicing Order
+
+1. Extract prerequisites first.
+2. Land mechanical refactors next.
+3. Land behavior changes after prerequisites are merged.
+4. Land UI/docs/polish last.
+
+## Slice Packet Template
+
+For each slice, define:
+
+- `Goal`
+- `Owned files`
+- `Out of scope`
+- `Risk level` (`low`/`medium`/`high`)
+- `Verification command(s)` with expected pass condition
+- `Rollback plan`
+
+## Hard Rules
+
+- Avoid mixing refactor and behavior changes in one slice unless unavoidable.
+- Avoid touching unrelated subsystems in one slice.
+- Avoid cross-slice hidden dependencies.
+- If a slice depends on unmerged work, state it explicitly.
+
+## Verification Discipline
+
+- Run narrow checks first for touched behavior.
+- Run project gate checks before handoff.
+- Record exact commands and outcomes for each slice.
+
+## Final Handoff Format
+
+- Slice list with order and purpose
+- Per-slice owned files
+- Per-slice verification evidence
+- Residual risk and follow-up slices
diff --git a/.agents/skills/provider-integration-checklist/SKILL.md b/.agents/skills/provider-integration-checklist/SKILL.md
new file mode 100644
index 000000000..e14d79429
--- /dev/null
+++ b/.agents/skills/provider-integration-checklist/SKILL.md
@@ -0,0 +1,41 @@
+---
+name: provider-integration-checklist
+description: This skill should be used when the user asks to add or modify an "LLM provider", "model routing", "OAuth flow", "auth token handling", "provider config", or "fallback chain". Enforces provider integration completeness across config, routing, docs, and verification.
+---
+
+# Provider Integration Checklist
+
+## Goal
+
+Ship provider and routing changes without regressions in auth, config, and model selection.
+
+## Change Checklist
+
+- Add config keys and defaults in one place.
+- Validate config resolution order (`env > DB > default` where applicable).
+- Validate model identifier parsing and normalization.
+- Validate routing defaults, task overrides, and fallback chains.
+- Validate auth flow behavior for both success and failure paths.
+- Validate token/secret handling and redaction behavior.
+
+## Compatibility Checklist
+
+- Keep existing providers unaffected.
+- Keep unknown-provider errors actionable.
+- Keep provider-specific errors distinguishable.
+- Keep docs and examples aligned with actual config keys.
+
+## Verification Checklist
+
+- Narrow tests for changed provider/routing/auth paths.
+- Negative-path tests for invalid config and auth failures.
+- Smoke path proving model call routes to expected backend.
+- Broad gate checks after targeted checks pass.
+
+## Required Handoff
+
+- Config keys changed
+- Routing behavior changed
+- Auth behavior changed
+- Verification evidence
+- Docs updated
diff --git a/.agents/skills/release-bump-changelog/SKILL.md b/.agents/skills/release-bump-changelog/SKILL.md
new file mode 100644
index 000000000..0c7f90e74
--- /dev/null
+++ b/.agents/skills/release-bump-changelog/SKILL.md
@@ -0,0 +1,56 @@
+---
+name: release-bump-changelog
+description: Use this skill when preparing a release bump or updating release notes. It writes a launch-style release story from the actual change set, then runs `cargo bump` so the generated GitHub notes and the marketing copy land together in `CHANGELOG.md`.
+---
+
+# Release Bump + Changelog
+
+## Goal
+
+Create a version bump commit where each release section includes both:
+
+- a launch-style narrative (marketing copy)
+- the exact GitHub-generated release notes
+
+## Workflow
+
+1. Ensure the working tree is clean (except allowed release files).
+2. Draft release story markdown from real changes (PR titles, release-note bullets, and diff themes).
+   - Target style: similar to the `v0.2.0` narrative (clear positioning + concrete highlights).
+   - Keep it factual and specific to the release.
+   - Write to a temp file (outside repo is preferred):
+     - `marketing_file="$(mktemp)"`
+     - write markdown content to `$marketing_file`
+3. Run `cargo bump <patch|minor|major|X.Y.Z>` with marketing copy input:
+   - `SPACEBOT_RELEASE_MARKETING_COPY_FILE="$marketing_file" cargo bump <...>`
+   - This invokes `scripts/release-tag.sh`.
+   - The script generates GitHub-native notes (`gh api .../releases/generate-notes`).
+   - The script upserts `CHANGELOG.md` with:
+     - `### Release Story` (from your marketing file)
+     - GitHub-generated notes body
+   - The script includes `CHANGELOG.md` in the release commit.
+4. Verify results:
+   - `git show --name-only --stat`
+   - Confirm commit contains `Cargo.toml`, `Cargo.lock` (if present), and `CHANGELOG.md`.
+   - Confirm tag was created (`git tag --list "v*" --sort=-v:refname | head -n 5`).
+
+## Requirements
+
+- `gh` CLI installed and authenticated (`gh auth status`).
+- `origin` remote points to GitHub, or set `SPACEBOT_RELEASE_REPO=<owner/repo>`.
+- Marketing copy is required unless explicitly bypassed with `SPACEBOT_SKIP_MARKETING_COPY=1`.
+
+## Release Story Format
+
+Use markdown only (no outer `## vX.Y.Z` heading; script adds it). Recommended structure:
+
+1. One strong opening paragraph (why this release matters)
+2. One paragraph on major technical shifts
+3. Optional short highlight bullets for standout additions/fixes
+
+Avoid vague hype. Tie claims to concrete shipped changes.
+
+## Notes
+
+- Do not use a standalone changelog sync script.
+- `CHANGELOG.md` is seeded from historical releases and then maintained by the release bump workflow.
diff --git a/.agents/skills/review-fix-loop/SKILL.md b/.agents/skills/review-fix-loop/SKILL.md
new file mode 100644
index 000000000..30314e881
--- /dev/null
+++ b/.agents/skills/review-fix-loop/SKILL.md
@@ -0,0 +1,47 @@
+---
+name: review-fix-loop
+description: This skill should be used when the user asks to "address review feedback", "fix PR comments", "close findings", "respond to reviewer notes", or "reduce review churn". Enforces a finding-to-evidence closure loop for every review round.
+---
+
+# Review Fix Loop
+
+## Goal
+
+Close review rounds with minimal back-and-forth by mapping every finding to a code change and proof.
+
+## Execution Loop
+
+1. Parse findings into `P1`, `P2`, `P3`.
+2. Build a closure table before editing.
+3. Implement the smallest coherent fix batch.
+4. Run targeted verification.
+5. Update closure table with outcomes.
+6. Run broader gate checks.
+
+## Closure Table
+
+Use one row per finding:
+
+| Finding | Severity | Owned files | Planned change | Verification command | Result |
+|---|---|---|---|---|---|
+
+## Re-Run Control
+
+- If the same command fails twice, stop rerunning.
+- Isolate a smaller reproduction command.
+- Patch the smallest likely cause.
+- Re-run narrow verification before broad checks.
+
+## Verification Ladder
+
+- Start narrow: unit/module behavior checks for touched paths.
+- Continue medium: compile/lint/type checks for touched surfaces.
+- End broad: repository gate commands.
+
+## Handoff Requirements
+
+- Findings closed
+- Commands executed
+- Pass/fail evidence per finding
+- Remaining open findings with rationale
+- Residual risk
diff --git a/.dockerignore b/.dockerignore
index 0e1a7bfc4..0291aae5e 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -9,10 +9,25 @@ interface/node_modules/
 interface/dist/
 
 # Not needed for the build
-docs/
 tests/
 scripts/
+
+# Exclude docs except what's needed for self_awareness.rs embeds
+docs/node_modules/
+docs/.next/
+docs/out/
+docs/app/
+docs/components/
+docs/lib/
+docs/design-docs/
+docs/*.json
+docs/*.ts
+docs/*.tsx
+docs/*.mjs
+docs/*.yaml
+docs/*.lock
+docs/.gitignore
+docs/.node-version
 fly.toml
-AGENTS.md
 RUST_STYLE_GUIDE.md
 LICENSE
diff --git a/.github/workflows/interface-ci.yml b/.github/workflows/interface-ci.yml
new file mode 100644
index 000000000..a8478caed
--- /dev/null
+++ b/.github/workflows/interface-ci.yml
@@ -0,0 +1,40 @@
+name: Interface CI
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "interface/**"
+      - ".github/workflows/interface-ci.yml"
+  pull_request:
+    branches: [main]
+    paths:
+      - "interface/**"
+      - ".github/workflows/interface-ci.yml"
+
+permissions:
+  contents: read
+
+concurrency:
+  group: interface-ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  quality:
+    name: Interface Quality
+    runs-on: ubuntu-24.04
+    defaults:
+      run:
+        working-directory: interface
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: "1.3"
+
+      - name: Install dependencies
+        run: bun ci
+
+      - name: Typecheck
+        run: bunx tsc --noEmit
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index f6cf8479f..a97fd8165 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -12,10 +12,66 @@ on:
 
 env:
   REGISTRY: ghcr.io
-  IMAGE: ghcr.io/spacedriveapp/spacebot
+  IMAGE: ghcr.io/${{ github.repository_owner }}/spacebot
 
 jobs:
-  build:
+  build-binaries:
+    strategy:
+      matrix:
+        include:
+          - target: x86_64-unknown-linux-gnu
+            runner: ubuntu-24.04
+            archive: tar.gz
+          - target: aarch64-unknown-linux-gnu
+            runner: ubuntu-24.04-arm
+            archive: tar.gz
+    runs-on: ${{ matrix.runner }}
+    permissions:
+      contents: write
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      - name: Install protoc
+        run: sudo apt-get update && sudo apt-get install -y protobuf-compiler
+
+      - name: Determine version tag
+        id: version
+        run: |
+          if [ -n "${{ github.event.inputs.tag }}" ]; then
+            VERSION="${{ github.event.inputs.tag }}"
+          elif [[ "$GITHUB_REF" == refs/tags/v* ]]; then
+            VERSION="${GITHUB_REF#refs/tags/}"
+          else
+            VERSION="dev-$(echo $GITHUB_SHA | head -c 7)"
+          fi
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+
+      - name: Build binary
+        run: cargo build --release --target ${{ matrix.target }}
+
+      - name: Package binary
+        run: |
+          cd target/${{ matrix.target }}/release
+          mkdir -p spacebot-${{ steps.version.outputs.version }}-${{ matrix.target }}
+          cp spacebot spacebot-${{ steps.version.outputs.version }}-${{ matrix.target }}/
+          tar -czvf ../../../spacebot-${{ steps.version.outputs.version }}-${{ matrix.target }}.${{ matrix.archive }} spacebot-${{ steps.version.outputs.version }}-${{ matrix.target }}
+
+      - name: Upload binary artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: spacebot-${{ matrix.target }}
+          path: spacebot-${{ steps.version.outputs.version }}-${{ matrix.target }}.${{ matrix.archive }}
+          retention-days: 1
+
+  build-docker:
     strategy:
       matrix:
         include:
@@ -59,30 +115,18 @@ jobs:
         id: platform
         run: echo "pair=$(echo ${{ matrix.platform }} | tr '/' '-')" >> "$GITHUB_OUTPUT"
 
-      - name: Build and push slim
+      - name: Build and push
         uses: docker/build-push-action@v6
         with:
           context: .
-          target: slim
           platforms: ${{ matrix.platform }}
           push: true
-          tags: ${{ env.IMAGE }}:slim-${{ steps.platform.outputs.pair }}
-          cache-from: type=gha,scope=slim-${{ steps.platform.outputs.pair }}
-          cache-to: type=gha,mode=max,scope=slim-${{ steps.platform.outputs.pair }}
+          tags: ${{ env.IMAGE }}:build-${{ steps.platform.outputs.pair }}
+          cache-from: type=gha,scope=build-${{ steps.platform.outputs.pair }}
+          cache-to: type=gha,mode=max,scope=build-${{ steps.platform.outputs.pair }}
 
-      - name: Build and push full
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          target: full
-          platforms: ${{ matrix.platform }}
-          push: true
-          tags: ${{ env.IMAGE }}:full-${{ steps.platform.outputs.pair }}
-          cache-from: type=gha,scope=full-${{ steps.platform.outputs.pair }}
-          cache-to: type=gha,mode=max,scope=full-${{ steps.platform.outputs.pair }}
-
-  merge:
-    needs: build
+  merge-docker:
+    needs: build-docker
     runs-on: ubuntu-24.04
     permissions:
       contents: write
@@ -99,24 +143,16 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Create slim multi-arch manifest
-        run: |
-          docker buildx imagetools create \
-            --tag ${{ env.IMAGE }}:${{ needs.build.outputs.version }}-slim \
-            --tag ${{ env.IMAGE }}:slim \
-            ${{ env.IMAGE }}:slim-linux-amd64 \
-            ${{ env.IMAGE }}:slim-linux-arm64
-
-      - name: Create full multi-arch manifest
+      - name: Create multi-arch manifest
         run: |
           docker buildx imagetools create \
-            --tag ${{ env.IMAGE }}:${{ needs.build.outputs.version }}-full \
-            --tag ${{ env.IMAGE }}:full \
+            --tag ${{ env.IMAGE }}:${{ needs.build-docker.outputs.version }} \
             --tag ${{ env.IMAGE }}:latest \
-            ${{ env.IMAGE }}:full-linux-amd64 \
-            ${{ env.IMAGE }}:full-linux-arm64
+            ${{ env.IMAGE }}:build-linux-amd64 \
+            ${{ env.IMAGE }}:build-linux-arm64
 
       - name: Log in to Fly registry
+        if: github.repository_owner == 'spacedriveapp'
         uses: docker/login-action@v3
         with:
           registry: registry.fly.io
@@ -124,23 +160,47 @@ jobs:
           password: ${{ secrets.FLY_API_TOKEN }}
 
       - name: Push to Fly registry
+        if: github.repository_owner == 'spacedriveapp'
         run: |
           docker buildx imagetools create \
-            --tag registry.fly.io/spacebot-image:${{ needs.build.outputs.version }} \
+            --tag registry.fly.io/spacebot-image:${{ needs.build-docker.outputs.version }} \
             --tag registry.fly.io/spacebot-image:latest \
             ${{ env.IMAGE }}:latest
 
       - name: Roll out to hosted instances
-        if: success()
+        if: github.repository_owner == 'spacedriveapp'
         run: |
           curl -sf -X POST https://api.spacebot.sh/api/admin/rollout \
             -H "Content-Type: application/json" \
             -H "X-Internal-Key: ${{ secrets.PLATFORM_INTERNAL_KEY }}" \
-            -d '{"image_tag": "${{ needs.build.outputs.version }}"}'
+            -d '{"image_tag": "${{ needs.build-docker.outputs.version }}"}'
+
+  create-release:
+    needs: build-binaries
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download all binary artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: binaries
+          pattern: spacebot-*
+          merge-multiple: false
+
+      - name: Flatten artifacts
+        run: |
+          mkdir -p release-assets
+          find binaries -name "*.tar.gz" -exec cp {} release-assets/ \;
+          ls -la release-assets/
 
       - name: Create GitHub Release
-        if: startsWith(github.ref, 'refs/tags/v')
         uses: softprops/action-gh-release@v2
         with:
-          tag_name: ${{ needs.build.outputs.version }}
+          tag_name: ${{ needs.build-binaries.outputs.version }}
           generate_release_notes: true
+          files: release-assets/*
diff --git a/AGENTS.md b/AGENTS.md
index ed0d02135..093231346 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -10,12 +10,39 @@ Single binary. No server dependencies. Runs on tokio. All data lives in embedded
 
 **Stack:** Rust (edition 2024), tokio, Rig (v0.30.0, agentic loop framework), SQLite (sqlx), LanceDB (embedded vector + FTS), redb (embedded key-value).
 
+## JavaScript Tooling (Critical)
+
+- For UI work in `spacebot/interface/`, use `bun` for all JS/TS package management and scripts.
+- **NEVER** use `npm`, `pnpm`, or `yarn` in this repo unless the user explicitly asks for one.
+- Standard commands:
+  - `bun install`
+  - `bun run dev`
+  - `bun run build`
+  - `bun run test`
+  - `bunx <tool>` (instead of `npx <tool>`)
+
 ## Migration Safety
 
 - **NEVER edit an existing migration file in place** once it has been committed or applied in any environment.
 - Treat migration files as immutable; modifying historical migrations causes checksum mismatches and can block startup.
 - For schema changes, always create a new migration with a new timestamp/version.
 
+## Delivery Gates (Mandatory)
+
+Run these checks in this order for code changes before pushing or updating a PR:
+
+1. `just preflight` — validate git/remote/auth state and avoid push-loop churn.
+2. `just gate-pr` — enforce formatting, compile checks, migration safety, lib tests, and integration test compile.
+
+If `just` is unavailable, run the equivalent scripts directly in the same order: `./scripts/preflight.sh` then `./scripts/gate-pr.sh`.
+
+Additional rules:
+
+- If the same command fails twice in one session, stop rerunning it blindly. Capture root cause and switch strategy.
+- For every external review finding marked P1/P2, add a targeted verification command in the final handoff.
+- For changes in async/stateful paths (worker lifecycle, cancellation, retrigger, recall cache behavior), include explicit race/terminal-state reasoning in the PR summary and run targeted tests in addition to `just gate-pr`.
+- Do not push if any gate is red.
+
 ## Architecture Overview
 
 Five process types. Every LLM process is a Rig `Agent<SpacebotModel, SpacebotHook>`. They differ in system prompt, tools, history, and hooks.
@@ -40,7 +67,7 @@ Creating a branch is `let branch_history = channel_history.clone()`.
 
 The branch result is injected into the channel's history as a distinct message type. Then the branch is deleted. Multiple branches can run concurrently per channel (configurable limit). First done, first incorporated.
 
-**Tools:** memory_recall, memory_save, channel_recall, spawn_worker  
+**Tools:** memory_recall, memory_save, memory_delete, channel_recall, spacebot_docs, task_create, task_list, task_update, spawn_worker  
 **Context:** Clone of channel history at fork time  
 **Lifecycle:** Short-lived. Returns a conclusion, then deleted.
 
@@ -79,6 +106,7 @@ System-level observer. Primary job: generate the **memory bulletin** — a perio
 Also observes system-wide signals for future health monitoring and memory consolidation.
 
 **Tools (bulletin generation):** memory_recall, memory_save  
+**Tools (interactive cortex chat):** memory + worker tools, `spacebot_docs`, `config_inspect`, task board tools  
 **Tools (future health monitoring):** memory_consolidate, system_monitor  
 **Context:** Fresh per bulletin run. No compaction needed.
 
@@ -146,12 +174,17 @@ src/
 │   ├── react.rs        — add emoji reaction (channel only)
 │   ├── memory_save.rs  — write memory to store (branch + cortex + compactor)
 │   ├── memory_recall.rs— search + curate memories (branch only)
-│   ├── channel_recall.rs— retrieve transcript from other channels (branch only)
+│   ├── channel_recall.rs— retrieve transcript from any channel (branch only)
 │   ├── set_status.rs   — update worker status (workers only)
 │   ├── shell.rs        — execute shell commands (task workers)
 │   ├── file.rs         — read/write/list files (task workers)
 │   ├── exec.rs         — run subprocess (task workers)
 │   ├── browser.rs      — web browsing (task workers)
+│   ├── task_create.rs  — create task-board task (branch + cortex chat)
+│   ├── task_list.rs    — list task-board tasks (branch + cortex chat)
+│   ├── task_update.rs  — update task-board task (branch + cortex chat)
+│   ├── spacebot_docs.rs — read embedded Spacebot docs/changelog (branch + cortex chat)
+│   ├── config_inspect.rs — inspect live runtime config (cortex chat)
 │   └── cron.rs         — cron management (channel only)
 │
 ├── memory.rs           → memory/
@@ -258,7 +291,7 @@ let branch_history = channel_history.clone();
 
 **ToolServer topology:**
 - Per-channel `ToolServer` (no memory tools, just channel action tools added per turn)
-- Per-branch `ToolServer` with memory tools (memory_save, memory_recall)
+- Per-branch `ToolServer` with memory tools (memory_save, memory_recall, memory_delete), channel recall, docs introspection (`spacebot_docs`), and task-board tools
 - Per-worker `ToolServer` with task-specific tools (shell, file, exec)
 - Per-cortex `ToolServer` with memory_save
 
@@ -347,7 +380,7 @@ Phase 6 — Hardening:
 
 These are validated patterns from research (see `docs/research/pattern-analysis.md`). Implement them when building the relevant module.
 
-**Tool nudging:** When an LLM responds with text instead of tool calls in the first 2 iterations, inject "Please proceed and use the available tools." Implement in `SpacebotHook.on_completion_response()`. Workers benefit most.
+**Tool nudging / outcome gate:** Workers cannot exit with a text-only response until they signal a terminal outcome via `set_status(kind: "outcome")`. If a worker returns text without an outcome signal, the hook fires `Terminate` and retries with a nudge prompt (up to 2 retries). After retries are exhausted the worker fails with `PromptCancelled`. See `docs/design-docs/tool-nudging.md`.
 
 **Fire-and-forget DB writes:** `tokio::spawn` for conversation history saves, memory writes, worker log persistence. User gets their response immediately.
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 000000000..972fd60d0
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,409 @@
+# Changelog
+
+Seeded from GitHub releases; maintained by the release bump workflow.
+
+## v0.2.2
+
+- Tag: `v0.2.2`
+- Published: 2026-03-01T13:00:02Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.2.2
+
+## What's Changed
+* fix: infer default routing from configured provider by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/266
+* Sandbox hardening: dynamic mode, env sanitization, leak detection by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/259
+* Secret store: credential isolation, encryption at rest, output scrubbing by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/260
+* feat: auto-download Chrome via fetcher, unify Docker image, fix singleton lock by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/268
+* fix: preserve conversation history and improve worker retrigger reliability by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/270
+* Add interface CI workflow by @marijnvdwerf in https://github.com/spacedriveapp/spacebot/pull/267
+* Split channel.rs and standardize adapter metadata keys by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/271
+* fix: allow trustd mach service in macOS sandbox for TLS cert verification by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/272
+* feat: add OpenRouter app attribution headers by @l33t0 in https://github.com/spacedriveapp/spacebot/pull/264
+* feat: implement link channels as task delegation (v3) by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/255
+
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.2.1...v0.2.2
+
+## v0.2.1
+
+- Tag: `v0.2.1`
+- Published: 2026-02-27T11:54:42Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.2.1
+
+## What's Changed
+* Improve task UI overflow handling and docker update rollback by @fyzz-dev in https://github.com/spacedriveapp/spacebot/pull/237
+* fix Anthropic empty text blocks in retrigger flow by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/243
+* Fix: Cleanup twitch_token.json when disconnecting Twitch platform by @Nebhay in https://github.com/spacedriveapp/spacebot/pull/212
+* feat: add email messaging adapter and setup docs by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/244
+* fix: match installed skills by source repo, not just name by @mwmdev in https://github.com/spacedriveapp/spacebot/pull/205
+* chore: add delivery gates and repo-local pr-gates skill by @vsumner in https://github.com/spacedriveapp/spacebot/pull/238
+* feat(channel): add deterministic temporal context by @vsumner in https://github.com/spacedriveapp/spacebot/pull/239
+* feat: add IMAP email_search tool for branch read-back by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/246
+* feat(cron): add strict wall-clock schedule support by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/247
+* feat: named messaging adapter instances by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/249
+* fix: log cross-channel messages to destination channel history by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/252
+* add DeepWiki badge to README by @devabdultech in https://github.com/spacedriveapp/spacebot/pull/251
+* fix(cortex): harden startup warmup and bulletin coordination by @vsumner in https://github.com/spacedriveapp/spacebot/pull/248
+* feat: Download images as bytes for interpretation in Slack/Discord etc and fix Slack file ingestion by @egenvall in https://github.com/spacedriveapp/spacebot/pull/159
+* fix: make Ollama provider testable from settings UI by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/253
+
+## New Contributors
+* @fyzz-dev made their first contribution in https://github.com/spacedriveapp/spacebot/pull/237
+* @devabdultech made their first contribution in https://github.com/spacedriveapp/spacebot/pull/251
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.2.0...v0.2.1
+
+## v0.2.0
+
+- Tag: `v0.2.0`
+- Published: 2026-02-26T08:16:48Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.2.0
+
+## v0.2.0 is the _biggest_ Spacebot release yet. 
+
+The agent is no longer a single-channel chatbot, it's a multi-agent system with real orchestration primitives.
+
+<img width="1074" height="655" alt="Screenshot_2026-02-23_at_12 48 29_PM copy" src="https://github.com/user-attachments/assets/04b4e72d-c646-4900-8096-eec7e5222ed6" />
+
+Agents coordinate through a spec-driven task system with a full kanban board in the UI. Tasks are structured markdown documents with requirements, constraints, and acceptance criteria. The cortex background loop picks up ready tasks, spawns workers, and handles completion or re-queuing on failure. Agents see the shared task board through the bulletin system, so delegation happens through specs, not conversation.
+
+Workers got a complete visibility overhaul. Full transcript persistence with gzip compression, live SSE streaming of tool calls as they happen, and a new worker_inspect tool so branches can verify what a worker actually did instead of trusting a one-line summary.
+
+On the security front, the old string-based command filtering (215+ lines of whack-a-mole regex) has been replaced with kernel-enforced filesystem sandboxing via bubblewrap on Linux and sandbox-exec on macOS. The LLM can't write outside the workspace because the OS won't let it.
+
+This release also brings OpenAI and Anthropic subscription auth support, better channel history preservation with deterministic retrigger handling, structured text payload blocking to keep raw JSON/XML out of user-facing messages, self-hosted update controls in the settings UI, new provider support (Kilo Gateway, OpenCode Go), prebuilt Linux binaries for amd64/arm64, a Nix flake, and a pile of fixes across cron scheduling, OAuth, model routing, and more.
+
+## What's Changed
+* feat(nix): add Nix flake for building and deploying Spacebot by @skulldogged in https://github.com/spacedriveapp/spacebot/pull/47
+* Fix chatgpt oauth by @marijnvdwerf in https://github.com/spacedriveapp/spacebot/pull/187
+* Multi-agent communication graph by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/150
+* Process sandbox: kernel-enforced filesystem containment for shell/exec by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/188
+* Workers tab: full transcript viewer, live SSE streaming, introspection tool by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/192
+* add settings update controls and harden self-hosted update flow by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/207
+* feat(web): ui/ux cleanup by @skulldogged in https://github.com/spacedriveapp/spacebot/pull/143
+* feat(ci): publish binaries for linux/amd64 and linux/arm64 on release by @morgaesis in https://github.com/spacedriveapp/spacebot/pull/94
+* block structured text payloads from user replies by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/209
+* Fix Z.AI Coding Plan model routing by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/210
+* fix: use Bearer auth when key comes from ANTHROPIC_AUTH_TOKEN by @worldofgeese in https://github.com/spacedriveapp/spacebot/pull/196
+* fix: use Bearer auth for ANTHROPIC_AUTH_TOKEN and add ANTHROPIC_MODEL by @worldofgeese in https://github.com/spacedriveapp/spacebot/pull/197
+* Task tracking system with kanban UI and spec-driven delegation by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/227
+* fix: make background result retriggers deterministic by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/231
+* fix: guide users to enable device code login for ChatGPT OAuth by @mwmdev in https://github.com/spacedriveapp/spacebot/pull/214
+* fix(cron): make cron scheduler reliable under load and in containers by @mmmeff in https://github.com/spacedriveapp/spacebot/pull/186
+* Fix Z.AI coding-plan model remap for GLM-5 by @vsumner in https://github.com/spacedriveapp/spacebot/pull/223
+* fix: Default cron delivery target to current conversation by @jaaneh in https://github.com/spacedriveapp/spacebot/pull/213
+* feat(llm): add Kilo Gateway and OpenCode Go provider support by @skulldogged in https://github.com/spacedriveapp/spacebot/pull/225
+
+## New Contributors
+* @morgaesis made their first contribution in https://github.com/spacedriveapp/spacebot/pull/94
+* @worldofgeese made their first contribution in https://github.com/spacedriveapp/spacebot/pull/196
+* @mwmdev made their first contribution in https://github.com/spacedriveapp/spacebot/pull/214
+* @mmmeff made their first contribution in https://github.com/spacedriveapp/spacebot/pull/186
+* @jaaneh made their first contribution in https://github.com/spacedriveapp/spacebot/pull/213
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.1.15...v0.2.0
+
+## v0.1.15
+
+- Tag: `v0.1.15`
+- Published: 2026-02-24T01:37:52Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.1.15
+
+## What's Changed
+* fix: resolve pre-existing CI failures (clippy, fmt, test) by @Marenz in https://github.com/spacedriveapp/spacebot/pull/174
+* fix: wire up ollama_base_url shorthand in config by @Marenz in https://github.com/spacedriveapp/spacebot/pull/175
+* fix: return synthetic empty text on Anthropic empty content response by @Marenz in https://github.com/spacedriveapp/spacebot/pull/171
+* fix: accept string values for timeout_seconds from LLMs by @Marenz in https://github.com/spacedriveapp/spacebot/pull/169
+* feat(telegram): use send_audio for audio MIME types by @Marenz in https://github.com/spacedriveapp/spacebot/pull/170
+* feat(skills): workers discover skills on demand via read_skill tool by @Marenz in https://github.com/spacedriveapp/spacebot/pull/172
+* fix: avoid panic on multibyte char boundary in log message truncation by @Marenz in https://github.com/spacedriveapp/spacebot/pull/176
+* ChatGPT OAuth browser flow + provider split by @marijnvdwerf in https://github.com/spacedriveapp/spacebot/pull/157
+* Fix worker completion results not reaching users by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/182
+* Default MiniMax to M2.5 and enable reasoning by @hotzen in https://github.com/spacedriveapp/spacebot/pull/180
+* fix: register groq/together/xai/mistral/deepseek providers from shorthand config keys by @Marenz in https://github.com/spacedriveapp/spacebot/pull/179
+* Bugfix: Update dependencies for Slack TLS by @egenvall in https://github.com/spacedriveapp/spacebot/pull/165
+* Add warmup readiness contract and dispatch safeguards by @vsumner in https://github.com/spacedriveapp/spacebot/pull/181
+* fix(slack): Slack channel fixes, DM filtering, emoji sanitization, and restore TLS on websocket by @sra in https://github.com/spacedriveapp/spacebot/pull/148
+
+## New Contributors
+* @vsumner made their first contribution in https://github.com/spacedriveapp/spacebot/pull/181
+* @sra made their first contribution in https://github.com/spacedriveapp/spacebot/pull/148
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.1.14...v0.1.15
+
+## v0.1.14
+
+- Tag: `v0.1.14`
+- Published: 2026-02-23T00:19:45Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.1.14
+
+## What's Changed
+* feat(mcp): add retry/backoff and CRUD API by @l33t0 in https://github.com/spacedriveapp/spacebot/pull/109
+* feat(ux): add drag-and-drop sorting for agents in sidebar by @MakerDZ in https://github.com/spacedriveapp/spacebot/pull/113
+* fix(channel): roll back history on PromptCancelled to prevent poisoned turns by @Marenz in https://github.com/spacedriveapp/spacebot/pull/114
+* Fix CI failures: rustfmt, clippy, and flaky test by @Marenz in https://github.com/spacedriveapp/spacebot/pull/116
+* fix(channel): prevent bot spamming from retrigger cascades by @PyRo1121 in https://github.com/spacedriveapp/spacebot/pull/115
+* feat(security): add auth middleware, SSRF protection, shell hardening, and encrypted secrets by @PyRo1121 in https://github.com/spacedriveapp/spacebot/pull/117
+* remove obsolete plan document from #58 by @hotzen in https://github.com/spacedriveapp/spacebot/pull/142
+* fix(build): restore compile after security middleware + URL validation changes by @bilawalriaz in https://github.com/spacedriveapp/spacebot/pull/125
+* fix(telegram): render markdown as Telegram HTML with safe, telegram-only fallbacks by @bilawalriaz in https://github.com/spacedriveapp/spacebot/pull/126
+* Fix Fireworks by @Nebhay in https://github.com/spacedriveapp/spacebot/pull/91
+* fix: harden 13 security vulnerabilities (phase 2) by @PyRo1121 in https://github.com/spacedriveapp/spacebot/pull/119
+* fix: replace .expect()/.unwrap() with proper error propagation in production code by @PyRo1121 in https://github.com/spacedriveapp/spacebot/pull/122
+* feat(twitch): Add Twitch token refresh by @Nebhay in https://github.com/spacedriveapp/spacebot/pull/144
+* feat: add minimax-cn provider for CN users by @shuuul in https://github.com/spacedriveapp/spacebot/pull/140
+* feat(telemetry): complete metrics instrumentation with cost tracking and per-agent context by @l33t0 in https://github.com/spacedriveapp/spacebot/pull/102
+* feat: support ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN and SPACEBOT_MODEL env vars by @adryserage in https://github.com/spacedriveapp/spacebot/pull/135
+* Fix cron timezone resolution and delete drift by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/149
+* feat: update Gemini model support with latest Google models by @adryserage in https://github.com/spacedriveapp/spacebot/pull/134
+* feat(web): add favicon files and update HTML to include them by @the-snesler in https://github.com/spacedriveapp/spacebot/pull/154
+* fix: add API body size limits and memory content validation by @PyRo1121 in https://github.com/spacedriveapp/spacebot/pull/123
+
+## New Contributors
+* @PyRo1121 made their first contribution in https://github.com/spacedriveapp/spacebot/pull/115
+* @hotzen made their first contribution in https://github.com/spacedriveapp/spacebot/pull/142
+* @bilawalriaz made their first contribution in https://github.com/spacedriveapp/spacebot/pull/125
+* @shuuul made their first contribution in https://github.com/spacedriveapp/spacebot/pull/140
+* @adryserage made their first contribution in https://github.com/spacedriveapp/spacebot/pull/135
+* @the-snesler made their first contribution in https://github.com/spacedriveapp/spacebot/pull/154
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.1.13...v0.1.14
+
+## v0.1.13
+
+- Tag: `v0.1.13`
+- Published: 2026-02-21T23:00:59Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.1.13
+
+## What's Changed
+* Improve channel reply flow and Discord binding behavior by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/95
+* feat(messaging): unify cross-channel delivery target resolution by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/97
+* feat: add dedicated voice model routing and attachment transcription by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/98
+* Fix all warnings and clippy lints by @Marenz in https://github.com/spacedriveapp/spacebot/pull/87
+* Add CI workflow (check, clippy, fmt, test) by @Marenz in https://github.com/spacedriveapp/spacebot/pull/101
+* Add native poll support to telegram adapter by @Marenz in https://github.com/spacedriveapp/spacebot/pull/93
+* docs(agents): update existing documentation when adding features by @Marenz in https://github.com/spacedriveapp/spacebot/pull/106
+* feat(llm): add Google Gemini API provider support by @MakerDZ in https://github.com/spacedriveapp/spacebot/pull/111
+* prompts: add missing memory-type guidance in memory flows by @marijnvdwerf in https://github.com/spacedriveapp/spacebot/pull/112
+* add mcp client support for workers by @nexxeln in https://github.com/spacedriveapp/spacebot/pull/103
+* Avoid requiring static API key for OAuth Login by @egenvall in https://github.com/spacedriveapp/spacebot/pull/100
+
+## New Contributors
+* @MakerDZ made their first contribution in https://github.com/spacedriveapp/spacebot/pull/111
+* @marijnvdwerf made their first contribution in https://github.com/spacedriveapp/spacebot/pull/112
+* @nexxeln made their first contribution in https://github.com/spacedriveapp/spacebot/pull/103
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.1.12...v0.1.13
+
+## v0.1.12
+
+- Tag: `v0.1.12`
+- Published: 2026-02-21T02:15:01Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.1.12
+
+## Note about v0.1.11
+
+v0.1.11 was removed due to a bad migration, and its tag/release were deleted.
+v0.1.12 includes those intended changes plus additional fixes.
+
+## Highlights included from the missing v0.1.11 window
+
+- Added hosted agent limit functionality
+- Added backup export and restore endpoints
+- Added storage status endpoint and filesystem usage reporting
+- Improved release tagging/version bump workflow (including Cargo.lock handling)
+
+## What's Changed
+* fix: register NVIDIA provider and base URL by @Nebhay in https://github.com/spacedriveapp/spacebot/pull/82
+* fix: Portal Chat isolation by @jnyecode in https://github.com/spacedriveapp/spacebot/pull/80
+* Nudge previously rejected DM users when added to allow list by @Marenz in https://github.com/spacedriveapp/spacebot/pull/78
+* Telegram adapter fixes: attachments, reply-to, and retry on startup by @Marenz in https://github.com/spacedriveapp/spacebot/pull/77
+* Anthropic OAuth authentication with PKCE and auto-refresh by @Marenz in https://github.com/spacedriveapp/spacebot/pull/76
+* fix: Prevent duplicate message replies by differentiating skip and replied flags by @thesammykins in https://github.com/spacedriveapp/spacebot/pull/69
+* fix(cron): prevent timer leak and improve scheduler reliability by @michaelbship in https://github.com/spacedriveapp/spacebot/pull/81
+* feat(cron): add configurable timeout_secs per cron job by @michaelbship in https://github.com/spacedriveapp/spacebot/pull/83
+* feat: add mention-gated Discord bindings and one-time cron jobs by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/88
+* docs: update README for new features since last update by @Marenz in https://github.com/spacedriveapp/spacebot/pull/92
+
+## New Contributors
+* @Nebhay made their first contribution in https://github.com/spacedriveapp/spacebot/pull/82
+* @michaelbship made their first contribution in https://github.com/spacedriveapp/spacebot/pull/81
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.1.10...v0.1.12
+
+## v0.1.10
+
+- Tag: `v0.1.10`
+- Published: 2026-02-20T08:45:11Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.1.10
+
+## What's Changed
+* feat: Add Z.AI Coding Plan provider by @thesammykins in https://github.com/spacedriveapp/spacebot/pull/67
+* chore: optimize release profile to reduce binary size by @thesammykins in https://github.com/spacedriveapp/spacebot/pull/70
+* feat(slack): cache user identities and resolve channel names by @jamiepine in https://github.com/spacedriveapp/spacebot/pull/71
+
+## New Contributors
+* @jamiepine made their first contribution in https://github.com/spacedriveapp/spacebot/pull/71
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.1.9...v0.1.10
+
+## v0.1.9
+
+- Tag: `v0.1.9`
+- Published: 2026-02-20T04:25:44Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.1.9
+
+## What's Changed
+* add local ollama provider by @mmattbtw in https://github.com/spacedriveapp/spacebot/pull/18
+* fix(docs): add favicon, fix theme toggle, and resolve og:image localhost issue by @andrasbacsai in https://github.com/spacedriveapp/spacebot/pull/29
+* feat(llm): add NVIDIA NIM provider support by @skulldogged in https://github.com/spacedriveapp/spacebot/pull/46
+* Update slack connector to include additional sender metadata by @ACPixel in https://github.com/spacedriveapp/spacebot/pull/43
+* feat(telemetry): add Prometheus metrics with feature-gated instrumentation by @l33t0 in https://github.com/spacedriveapp/spacebot/pull/35
+* fix(ingestion): do not delete ingest files when chunk processing fails by @sookochoff in https://github.com/spacedriveapp/spacebot/pull/57
+* feat: Improve Slack Markdown by @egenvall in https://github.com/spacedriveapp/spacebot/pull/52
+* fix: key Discord typing indicator by channel ID to prevent stuck indicator by @tomasmach in https://github.com/spacedriveapp/spacebot/pull/53
+* fix: Telegram adapter improvements by @Marenz in https://github.com/spacedriveapp/spacebot/pull/50
+* Adds pdf ingestion by @ACPixel in https://github.com/spacedriveapp/spacebot/pull/63
+* feat: add markdown preview toggle to identity editors by @tomasmach in https://github.com/spacedriveapp/spacebot/pull/59
+* Add GitHub CLI to default docker image by @ACPixel in https://github.com/spacedriveapp/spacebot/pull/61
+* feat(llm): add custom providers and dynamic API routing by @sbtobb in https://github.com/spacedriveapp/spacebot/pull/36
+* fix: prevent panic in split_message on multibyte UTF-8 char boundaries by @tomasmach in https://github.com/spacedriveapp/spacebot/pull/49
+* feat(slack): app_mention, ephemeral messages, Block Kit, scheduled messages, typing indicator by @sookochoff in https://github.com/spacedriveapp/spacebot/pull/58
+* feat(slack): slash commands (Phase 3) + Block Kit interactions (Phase 2b) by @sookochoff in https://github.com/spacedriveapp/spacebot/pull/60
+* Add Portal Chat for direct web-based agent interaction by @jnyecode in https://github.com/spacedriveapp/spacebot/pull/64
+* feat: add MiniMax as native provider by @ricorna in https://github.com/spacedriveapp/spacebot/pull/26
+* feat: add Moonshot AI (Kimi) as native provider by @ricorna in https://github.com/spacedriveapp/spacebot/pull/25
+* feat: Discord rich messages (Embeds, Buttons, Polls) by @thesammykins in https://github.com/spacedriveapp/spacebot/pull/66
+
+## New Contributors
+* @mmattbtw made their first contribution in https://github.com/spacedriveapp/spacebot/pull/18
+* @skulldogged made their first contribution in https://github.com/spacedriveapp/spacebot/pull/46
+* @ACPixel made their first contribution in https://github.com/spacedriveapp/spacebot/pull/43
+* @l33t0 made their first contribution in https://github.com/spacedriveapp/spacebot/pull/35
+* @sookochoff made their first contribution in https://github.com/spacedriveapp/spacebot/pull/57
+* @egenvall made their first contribution in https://github.com/spacedriveapp/spacebot/pull/52
+* @Marenz made their first contribution in https://github.com/spacedriveapp/spacebot/pull/50
+* @sbtobb made their first contribution in https://github.com/spacedriveapp/spacebot/pull/36
+* @jnyecode made their first contribution in https://github.com/spacedriveapp/spacebot/pull/64
+* @ricorna made their first contribution in https://github.com/spacedriveapp/spacebot/pull/26
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.1.8...v0.1.9
+
+## v0.1.8
+
+- Tag: `v0.1.8`
+- Published: 2026-02-19T05:26:17Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.1.8
+
+## What's Changed
+* fix: set skip_flag in ReplyTool to prevent double reply by @tomasmach in https://github.com/spacedriveapp/spacebot/pull/39
+* fix(daemon): create instance directory before binding IPC socket by @BruceMacD in https://github.com/spacedriveapp/spacebot/pull/37
+* otel by @Brendonovich in https://github.com/spacedriveapp/spacebot/pull/30
+* fix otel by @Brendonovich in https://github.com/spacedriveapp/spacebot/pull/41
+* make otel actually work by @Brendonovich in https://github.com/spacedriveapp/spacebot/pull/42
+
+## New Contributors
+* @tomasmach made their first contribution in https://github.com/spacedriveapp/spacebot/pull/39
+* @BruceMacD made their first contribution in https://github.com/spacedriveapp/spacebot/pull/37
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.1.7...v0.1.8
+
+## v0.1.7
+
+- Tag: `v0.1.7`
+- Published: 2026-02-18T18:09:56Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.1.7
+
+## What's Changed
+* fix(config): support numeric telegram chat_id binding match by @cyllas in https://github.com/spacedriveapp/spacebot/pull/34
+* Add ARM64 multi-platform Docker images by @andrasbacsai in https://github.com/spacedriveapp/spacebot/pull/27
+
+## New Contributors
+* @cyllas made their first contribution in https://github.com/spacedriveapp/spacebot/pull/34
+* @andrasbacsai made their first contribution in https://github.com/spacedriveapp/spacebot/pull/27
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.1.6...v0.1.7
+
+## v0.1.6
+
+- Tag: `v0.1.6`
+- Published: 2026-02-18T10:14:21Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.1.6
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.1.5...v0.1.6
+
+## v0.1.5
+
+- Tag: `v0.1.5`
+- Published: 2026-02-18T07:50:05Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.1.5
+
+## What's Changed
+* Fix broken documentation links in README by @joseph-lozano in https://github.com/spacedriveapp/spacebot/pull/11
+* fix: IPv6 socket address parsing for Docker deployments by @pablopunk in https://github.com/spacedriveapp/spacebot/pull/14
+
+## New Contributors
+* @joseph-lozano made their first contribution in https://github.com/spacedriveapp/spacebot/pull/11
+* @pablopunk made their first contribution in https://github.com/spacedriveapp/spacebot/pull/14
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.1.4...v0.1.5
+
+## v0.1.4
+
+- Tag: `v0.1.4`
+- Published: 2026-02-17T23:23:34Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.1.4
+
+## What's Changed
+* Run release workflow on x86 and ARM runners by @Brendonovich in https://github.com/spacedriveapp/spacebot/pull/3
+* Fix OpenCode Zen provider icon by @Brendonovich in https://github.com/spacedriveapp/spacebot/pull/5
+* better provider list by @Brendonovich in https://github.com/spacedriveapp/spacebot/pull/6
+* Fix Z.ai provider icon by @jiunshinn in https://github.com/spacedriveapp/spacebot/pull/7
+* improve docker build by @Brendonovich in https://github.com/spacedriveapp/spacebot/pull/4
+* Fix quick start by @doanbactam in https://github.com/spacedriveapp/spacebot/pull/8
+
+## New Contributors
+* @doanbactam made their first contribution in https://github.com/spacedriveapp/spacebot/pull/8
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.1.3...v0.1.4
+
+## v0.1.3
+
+- Tag: `v0.1.3`
+- Published: 2026-02-17T03:59:34Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.1.3
+
+## What's Changed
+* Add OpenCode Zen provider support by @Brendonovich in https://github.com/spacedriveapp/spacebot/pull/2
+
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.1.2...v0.1.3
+
+## v0.1.2
+
+- Tag: `v0.1.2`
+- Published: 2026-02-17T01:14:40Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.1.2
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/compare/v0.1.1...v0.1.2
+
+## v0.1.1
+
+- Tag: `v0.1.1`
+- Published: 2026-02-17T00:04:10Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.1.1
+
+## What's Changed
+* Add native Z.ai (GLM) provider by @jiunshinn in https://github.com/spacedriveapp/spacebot/pull/1
+
+## New Contributors
+* @jiunshinn made their first contribution in https://github.com/spacedriveapp/spacebot/pull/1
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/commits/v0.1.1
+
+## v0.1.0
+
+- Tag: `v0.1.0`
+- Published: 2026-02-15T22:31:48Z
+- URL: https://github.com/spacedriveapp/spacebot/releases/tag/v0.1.0
+
+**Full Changelog**: https://github.com/spacedriveapp/spacebot/commits/v0.1.0
diff --git a/Cargo.lock b/Cargo.lock
index 8b5bf8604..227ba0403 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -241,6 +241,18 @@ dependencies = [
  "syn 2.0.114",
 ]
 
+[[package]]
+name = "argon2"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c3610892ee6e0cbce8ae2700349fcf8f98adb0dbfbee85aec3c9179d29cc072"
+dependencies = [
+ "base64ct",
+ "blake2",
+ "cpufeatures",
+ "password-hash",
+]
+
 [[package]]
 name = "arraydeque"
 version = "0.5.1"
@@ -253,6 +265,12 @@ version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
 
+[[package]]
+name = "arrayvec"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
+
 [[package]]
 name = "arrayvec"
 version = "0.7.6"
@@ -345,7 +363,7 @@ dependencies = [
  "chrono",
  "comfy-table",
  "half",
- "lexical-core",
+ "lexical-core 1.0.6",
  "num-traits",
  "ryu",
 ]
@@ -409,7 +427,7 @@ dependencies = [
  "half",
  "indexmap 2.13.0",
  "itoa",
- "lexical-core",
+ "lexical-core 1.0.6",
  "memchr",
  "num-traits",
  "ryu",
@@ -636,7 +654,7 @@ dependencies = [
  "aligned",
  "anyhow",
  "arg_enum_proc_macro",
- "arrayvec",
+ "arrayvec 0.7.6",
  "log",
  "num-rational",
  "num-traits",
@@ -654,7 +672,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8cfddb07216410377231960af4fcab838eaa12e013417781b78bd95ee22077f8"
 dependencies = [
  "anyhow",
- "arrayvec",
+ "arrayvec 0.7.6",
  "log",
  "nom 8.0.0",
  "num-rational",
@@ -667,7 +685,7 @@ version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "375082f007bd67184fb9c0374614b29f9aaa604ec301635f72338bb65386a53d"
 dependencies = [
- "arrayvec",
+ "arrayvec 0.7.6",
 ]
 
 [[package]]
@@ -849,7 +867,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2468ef7d57b3fb7e16b576e8377cdbde2320c60e1491e961d11da40fc4f02a2d"
 dependencies = [
  "arrayref",
- "arrayvec",
+ "arrayvec 0.7.6",
  "cc",
  "cfg-if",
  "constant_time_eq 0.4.2",
@@ -943,7 +961,7 @@ version = "3.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "89ec27229c38ed0eb3c0feee3d2c1d6a4379ae44f418a29a658890e062d8f365"
 dependencies = [
- "darling 0.21.3",
+ "darling 0.23.0",
  "ident_case",
  "prettyplease",
  "proc-macro2",
@@ -983,6 +1001,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "bufstream"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40e38929add23cdf8a366df9b0e088953150724bcbe5fc330b0d8eb3b328eec8"
+
 [[package]]
 name = "built"
 version = "0.8.0"
@@ -1135,6 +1159,16 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
+[[package]]
+name = "charset"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1f927b07c74ba84c7e5fe4db2baeb3e996ab2688992e39ac68ce3220a677c7e"
+dependencies = [
+ "base64 0.22.1",
+ "encoding_rs",
+]
+
 [[package]]
 name = "chromiumoxide"
 version = "0.8.0"
@@ -1145,6 +1179,7 @@ dependencies = [
  "base64 0.22.1",
  "cfg-if",
  "chromiumoxide_cdp",
+ "chromiumoxide_fetcher",
  "chromiumoxide_types",
  "dunce",
  "fnv",
@@ -1159,7 +1194,7 @@ dependencies = [
  "tracing",
  "url",
  "which",
- "windows-registry 0.5.3",
+ "windows-registry",
 ]
 
 [[package]]
@@ -1174,6 +1209,23 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "chromiumoxide_fetcher"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e39b54dfcb6973284f55cf3639d44e84d23feed4e2e7d1faa4a9029a365737"
+dependencies = [
+ "anyhow",
+ "directories",
+ "reqwest 0.12.28",
+ "serde",
+ "thiserror 1.0.69",
+ "tokio",
+ "tracing",
+ "windows-version",
+ "zip 0.6.6",
+]
+
 [[package]]
 name = "chromiumoxide_pdl"
 version = "0.8.0"
@@ -1225,6 +1277,16 @@ dependencies = [
  "phf 0.12.1",
 ]
 
+[[package]]
+name = "chumsky"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eebd66744a15ded14960ab4ccdbfb51ad3b81f51f3f04a80adac98c985396c9"
+dependencies = [
+ "hashbrown 0.14.5",
+ "stacker",
+]
+
 [[package]]
 name = "cipher"
 version = "0.4.4"
@@ -1523,6 +1585,17 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "cron"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f8c3e73077b4b4a6ab1ea5047c37c57aee77657bc8ecd6f29b0af082d0b0c07"
+dependencies = [
+ "chrono",
+ "nom 7.1.3",
+ "once_cell",
+]
+
 [[package]]
 name = "crossbeam-channel"
 version = "0.5.15"
@@ -2425,7 +2498,7 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eddada51c8576df9d6a8450c351ff63042b092c9458b8ac7d20f89cbd0ffd313"
 dependencies = [
- "arrayvec",
+ "arrayvec 0.7.6",
  "proc-macro2",
  "quote",
  "strsim 0.10.0",
@@ -2556,6 +2629,15 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "directories"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16f5094c54661b38d03bd7e50df373292118db60b585c08a411c6d840017fe7d"
+dependencies = [
+ "dirs-sys",
+]
+
 [[package]]
 name = "dirs"
 version = "6.0.0"
@@ -2671,6 +2753,22 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "email-encoding"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9298e6504d9b9e780ed3f7dfd43a61be8cd0e09eb07f7706a945b0072b6670b6"
+dependencies = [
+ "base64 0.22.1",
+ "memchr",
+]
+
+[[package]]
+name = "email_address"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e079f19b08ca6239f47f8ba8509c11cf3ea30095831f7fed61441475edd8c449"
+
 [[package]]
 name = "emojis"
 version = "0.8.0"
@@ -3594,6 +3692,17 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "hostname"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "617aaa3557aef3810a6369d0a99fac8a080891b68bd9f9812a1eeda0c0730cbd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "htmlescape"
 version = "0.3.1"
@@ -3812,7 +3921,7 @@ dependencies = [
  "tokio",
  "tower-service",
  "tracing",
- "windows-registry 0.6.1",
+ "windows-registry",
 ]
 
 [[package]]
@@ -4076,6 +4185,29 @@ dependencies = [
  "quick-error",
 ]
 
+[[package]]
+name = "imap"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c617c55def8c42129e0dd503f11d7ee39d73f5c7e01eff55768b3879ff1d107d"
+dependencies = [
+ "base64 0.13.1",
+ "bufstream",
+ "chrono",
+ "imap-proto",
+ "lazy_static",
+ "native-tls",
+ "nom 5.1.3",
+ "regex",
+]
+
+[[package]]
+name = "imap-proto"
+version = "0.10.2"
+dependencies = [
+ "nom 5.1.3",
+]
+
 [[package]]
 name = "imgref"
 version = "1.12.0"
@@ -4462,7 +4594,7 @@ dependencies = [
  "object_store",
  "permutation",
  "pin-project",
- "prost 0.14.3",
+ "prost",
  "prost-types",
  "rand 0.9.2",
  "roaring",
@@ -4536,7 +4668,7 @@ dependencies = [
  "num_cpus",
  "object_store",
  "pin-project",
- "prost 0.14.3",
+ "prost",
  "rand 0.9.2",
  "roaring",
  "serde_json",
@@ -4575,7 +4707,7 @@ dependencies = [
  "lance-geo",
  "log",
  "pin-project",
- "prost 0.14.3",
+ "prost",
  "snafu",
  "tokio",
  "tracing",
@@ -4628,7 +4760,7 @@ dependencies = [
  "log",
  "lz4",
  "num-traits",
- "prost 0.14.3",
+ "prost",
  "prost-build",
  "prost-types",
  "rand 0.9.2",
@@ -4666,7 +4798,7 @@ dependencies = [
  "log",
  "num-traits",
  "object_store",
- "prost 0.14.3",
+ "prost",
  "prost-build",
  "prost-types",
  "snafu",
@@ -4739,7 +4871,7 @@ dependencies = [
  "ndarray",
  "num-traits",
  "object_store",
- "prost 0.14.3",
+ "prost",
  "prost-build",
  "prost-types",
  "rand 0.9.2",
@@ -4787,7 +4919,7 @@ dependencies = [
  "object_store",
  "path_abs",
  "pin-project",
- "prost 0.14.3",
+ "prost",
  "rand 0.9.2",
  "serde",
  "shellexpand",
@@ -4892,7 +5024,7 @@ dependencies = [
  "lance-io",
  "log",
  "object_store",
- "prost 0.14.3",
+ "prost",
  "prost-build",
  "prost-types",
  "rand 0.9.2",
@@ -5002,12 +5134,53 @@ version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a79a3332a6609480d7d0c9eab957bca6b455b91bb84e66d19f5ff66294b85b8"
 
+[[package]]
+name = "lettre"
+version = "0.11.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e13e10e8818f8b2a60f52cb127041d388b89f3a96a62be9ceaffa22262fef7f"
+dependencies = [
+ "async-trait",
+ "base64 0.22.1",
+ "chumsky",
+ "email-encoding",
+ "email_address",
+ "fastrand",
+ "futures-io",
+ "futures-util",
+ "hostname",
+ "httpdate",
+ "idna",
+ "mime",
+ "native-tls",
+ "nom 8.0.0",
+ "percent-encoding",
+ "quoted_printable",
+ "socket2 0.6.2",
+ "tokio",
+ "tokio-native-tls",
+ "url",
+]
+
 [[package]]
 name = "levenshtein_automata"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c2cdeb66e45e9f36bfad5bbdb4d2384e70936afbee843c6f6543f0c551ebb25"
 
+[[package]]
+name = "lexical-core"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6607c62aa161d23d17a9072cc5da0be67cdfc89d3afb1e8d9c842bebc2525ffe"
+dependencies = [
+ "arrayvec 0.5.2",
+ "bitflags 1.3.2",
+ "cfg-if",
+ "ryu",
+ "static_assertions",
+]
+
 [[package]]
 name = "lexical-core"
 version = "1.0.6"
@@ -5278,6 +5451,17 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "670fdfda89751bc4a84ac13eaa63e205cf0fd22b4c9a5fbfa085b63c1f1d3a30"
 
+[[package]]
+name = "mailparse"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60819a97ddcb831a5614eb3b0174f3620e793e97e09195a395bfa948fd68ed2f"
+dependencies = [
+ "charset",
+ "data-encoding",
+ "quoted_printable",
+]
+
 [[package]]
 name = "matchers"
 version = "0.2.0"
@@ -5576,6 +5760,17 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "nom"
+version = "5.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08959a387a676302eebf4ddbcbc611da04285579f76f88ee0506c63b1a61dd4b"
+dependencies = [
+ "lexical-core 0.7.6",
+ "memchr",
+ "version_check",
+]
+
 [[package]]
 name = "nom"
 version = "7.1.3"
@@ -5937,9 +6132,9 @@ dependencies = [
 
 [[package]]
 name = "opentelemetry"
-version = "0.29.1"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e87237e2775f74896f9ad219d26a2081751187eb7c9f5c58dde20a23b95d16c"
+checksum = "b84bcd6ae87133e903af7ef497404dda70c60d0ea14895fc8a5e6722754fc2a0"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -5951,71 +6146,67 @@ dependencies = [
 
 [[package]]
 name = "opentelemetry-http"
-version = "0.29.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46d7ab32b827b5b495bd90fa95a6cb65ccc293555dcc3199ae2937d2d237c8ed"
+checksum = "d7a6d09a73194e6b66df7c8f1b680f156d916a1a942abf2de06823dd02b7855d"
 dependencies = [
  "async-trait",
  "bytes",
  "http 1.4.0",
  "opentelemetry",
  "reqwest 0.12.28",
- "tracing",
 ]
 
 [[package]]
 name = "opentelemetry-otlp"
-version = "0.29.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d899720fe06916ccba71c01d04ecd77312734e2de3467fd30d9d580c8ce85656"
+checksum = "7a2366db2dca4d2ad033cad11e6ee42844fd727007af5ad04a1730f4cb8163bf"
 dependencies = [
- "futures-core",
  "http 1.4.0",
  "opentelemetry",
  "opentelemetry-http",
  "opentelemetry-proto",
  "opentelemetry_sdk",
- "prost 0.13.5",
+ "prost",
  "reqwest 0.12.28",
  "thiserror 2.0.18",
 ]
 
 [[package]]
 name = "opentelemetry-proto"
-version = "0.29.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c40da242381435e18570d5b9d50aca2a4f4f4d8e146231adb4e7768023309b3"
+checksum = "a7175df06de5eaee9909d4805a3d07e28bb752c34cab57fa9cff549da596b30f"
 dependencies = [
  "opentelemetry",
  "opentelemetry_sdk",
- "prost 0.13.5",
+ "prost",
  "tonic",
+ "tonic-prost",
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.29.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84b29a9f89f1a954936d5aa92f19b2feec3c8f3971d3e96206640db7f9706ae3"
+checksum = "e62e29dfe041afb8ed2a6c9737ab57db4907285d999ef8ad3a59092a36bdc846"
 
 [[package]]
 name = "opentelemetry_sdk"
-version = "0.29.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afdefb21d1d47394abc1ba6c57363ab141be19e27cc70d0e422b7f303e4d290b"
+checksum = "e14ae4f5991976fd48df6d843de219ca6d31b01daaab2dad5af2badeded372bd"
 dependencies = [
  "futures-channel",
  "futures-executor",
  "futures-util",
- "glob",
  "opentelemetry",
  "percent-encoding",
  "rand 0.9.2",
- "serde_json",
  "thiserror 2.0.18",
  "tokio",
  "tokio-stream",
- "tracing",
 ]
 
 [[package]]
@@ -6105,6 +6296,17 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
+[[package]]
+name = "password-hash"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166"
+dependencies = [
+ "base64ct",
+ "rand_core 0.6.4",
+ "subtle",
+]
+
 [[package]]
 name = "paste"
 version = "1.0.15"
@@ -6522,16 +6724,6 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
-[[package]]
-name = "prost"
-version = "0.13.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5"
-dependencies = [
- "bytes",
- "prost-derive 0.13.5",
-]
-
 [[package]]
 name = "prost"
 version = "0.14.3"
@@ -6539,7 +6731,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568"
 dependencies = [
  "bytes",
- "prost-derive 0.14.3",
+ "prost-derive",
 ]
 
 [[package]]
@@ -6554,26 +6746,13 @@ dependencies = [
  "multimap",
  "petgraph",
  "prettyplease",
- "prost 0.14.3",
+ "prost",
  "prost-types",
  "regex",
  "syn 2.0.114",
  "tempfile",
 ]
 
-[[package]]
-name = "prost-derive"
-version = "0.13.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"
-dependencies = [
- "anyhow",
- "itertools 0.14.0",
- "proc-macro2",
- "quote",
- "syn 2.0.114",
-]
-
 [[package]]
 name = "prost-derive"
 version = "0.14.3"
@@ -6593,7 +6772,7 @@ version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8991c4cbdb8bc5b11f0b074ffe286c30e523de90fee5ba8132f1399f23cb3dd7"
 dependencies = [
- "prost 0.14.3",
+ "prost",
 ]
 
 [[package]]
@@ -6712,6 +6891,12 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "quoted_printable"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "640c9bd8497b02465aeef5375144c26062e0dcd5939dfcbb0f5db76cb8c17c73"
+
 [[package]]
 name = "r-efi"
 version = "5.3.0"
@@ -6840,7 +7025,7 @@ dependencies = [
  "aligned-vec",
  "arbitrary",
  "arg_enum_proc_macro",
- "arrayvec",
+ "arrayvec 0.7.6",
  "av-scenechange",
  "av1-grain",
  "bitstream-io",
@@ -7070,7 +7255,6 @@ dependencies = [
  "base64 0.22.1",
  "bytes",
  "encoding_rs",
- "futures-channel",
  "futures-core",
  "futures-util",
  "h2 0.4.13",
@@ -7119,8 +7303,10 @@ checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801"
 dependencies = [
  "base64 0.22.1",
  "bytes",
+ "encoding_rs",
  "futures-core",
  "futures-util",
+ "h2 0.4.13",
  "http 1.4.0",
  "http-body 1.0.1",
  "http-body-util",
@@ -7129,6 +7315,8 @@ dependencies = [
  "hyper-util",
  "js-sys",
  "log",
+ "mime",
+ "mime_guess",
  "percent-encoding",
  "pin-project-lite",
  "quinn",
@@ -7137,6 +7325,7 @@ dependencies = [
  "rustls-platform-verifier",
  "serde",
  "serde_json",
+ "serde_urlencoded",
  "sync_wrapper 1.0.2",
  "tokio",
  "tokio-rustls 0.26.4",
@@ -7162,9 +7351,9 @@ dependencies = [
 
 [[package]]
 name = "rig-core"
-version = "0.30.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8f7a3f0c7c00eaced15a68ee16e1bd6bb709ff598d11b9aedac8b628217dc09"
+checksum = "437fa2a15825caf2505411bbe55b05c8eb122e03934938b38f9ecaa1d6ded7c8"
 dependencies = [
  "as-any",
  "async-stream",
@@ -7181,7 +7370,7 @@ dependencies = [
  "nanoid",
  "ordered-float",
  "pin-project-lite",
- "reqwest 0.12.28",
+ "reqwest 0.13.2",
  "rig-derive",
  "schemars 1.2.1",
  "serde",
@@ -7224,9 +7413,9 @@ dependencies = [
 
 [[package]]
 name = "rmcp"
-version = "0.16.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc4c9c94680f75470ee8083a0667988b5d7b5beb70b9f998a8e51de7c682ce60"
+checksum = "8a0ce46f9101dc911f07e1468084c057839d15b08040d110820c5513312ef56a"
 dependencies = [
  "async-trait",
  "base64 0.22.1",
@@ -7251,9 +7440,9 @@ dependencies = [
 
 [[package]]
 name = "rmcp-macros"
-version = "0.16.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90c23c8f26cae4da838fbc3eadfaecf2d549d97c04b558e7bd90526a9c28b42a"
+checksum = "abad6f5f46e220e3bda2fc90fd1ad64c1c2a2bd716d52c845eb5c9c64cda7542"
 dependencies = [
  "darling 0.23.0",
  "proc-macro2",
@@ -7550,7 +7739,7 @@ dependencies = [
  "security-framework 3.5.1",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -7642,18 +7831,6 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "schemars"
-version = "0.8.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fbf2ae1b8bc8e02df939598064d22402220cd5bbcca1c76f7d6a310974d5615"
-dependencies = [
- "dyn-clone",
- "schemars_derive 0.8.22",
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "schemars"
 version = "0.9.0"
@@ -7675,23 +7852,11 @@ dependencies = [
  "chrono",
  "dyn-clone",
  "ref-cast",
- "schemars_derive 1.2.1",
+ "schemars_derive",
  "serde",
  "serde_json",
 ]
 
-[[package]]
-name = "schemars_derive"
-version = "0.8.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32e265784ad618884abaea0600a9adf15393368d840e0222d101a072f3f7534d"
-dependencies = [
- "proc-macro2",
- "quote",
- "serde_derive_internals",
- "syn 2.0.114",
-]
-
 [[package]]
 name = "schemars_derive"
 version = "1.2.1"
@@ -7952,7 +8117,7 @@ version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9bde37f42765dfdc34e2a039e0c84afbf79a3101c1941763b0beb816c2f17541"
 dependencies = [
- "arrayvec",
+ "arrayvec 0.7.6",
  "async-trait",
  "base64 0.22.1",
  "bitflags 2.10.0",
@@ -8236,11 +8401,12 @@ dependencies = [
 
 [[package]]
 name = "spacebot"
-version = "0.1.15"
+version = "0.2.2"
 dependencies = [
  "aes-gcm",
  "anyhow",
  "arc-swap",
+ "argon2",
  "arrow-array",
  "arrow-schema",
  "async-stream",
@@ -8254,38 +8420,47 @@ dependencies = [
  "chrono-tz",
  "clap",
  "config",
+ "cron",
  "daemonize",
  "dialoguer",
  "dirs",
  "emojis",
  "fastembed",
+ "flate2",
  "futures",
  "hex",
  "ignore",
+ "imap",
  "indoc",
  "lance-index",
  "lancedb",
+ "lettre",
  "libc",
+ "mailparse",
  "mime_guess",
  "minijinja",
+ "moka",
+ "native-tls",
  "notify",
  "open",
  "opentelemetry",
  "opentelemetry-otlp",
  "opentelemetry-semantic-conventions",
  "opentelemetry_sdk",
+ "parking_lot",
  "pdf-extract",
  "pin-project",
  "prometheus",
  "rand 0.9.2",
  "redb",
  "regex",
- "reqwest 0.12.28",
+ "reqwest 0.13.2",
  "rig-core",
  "rmcp",
  "rust-embed",
  "rustls 0.23.36",
- "schemars 0.8.22",
+ "schemars 1.2.1",
+ "security-framework 3.5.1",
  "semver",
  "serde",
  "serde_json",
@@ -8310,7 +8485,7 @@ dependencies = [
  "twitch-irc",
  "urlencoding",
  "uuid",
- "zip",
+ "zip 2.4.2",
 ]
 
 [[package]]
@@ -9419,9 +9594,9 @@ checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 
 [[package]]
 name = "tonic"
-version = "0.12.3"
+version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877c5b330756d856ffcc4553ab34a5684481ade925ecc54bcd1bf02b1d0d4d52"
+checksum = "fec7c61a0695dc1887c1b53952990f3ad2e3a31453e1f49f10e75424943a93ec"
 dependencies = [
  "async-trait",
  "base64 0.22.1",
@@ -9431,13 +9606,24 @@ dependencies = [
  "http-body-util",
  "percent-encoding",
  "pin-project",
- "prost 0.13.5",
+ "sync_wrapper 1.0.2",
  "tokio-stream",
  "tower-layer",
  "tower-service",
  "tracing",
 ]
 
+[[package]]
+name = "tonic-prost"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a55376a0bbaa4975a3f10d009ad763d8f4108f067c7c2e74f3001fb49778d309"
+dependencies = [
+ "bytes",
+ "prost",
+ "tonic",
+]
+
 [[package]]
 name = "tower"
 version = "0.5.3"
@@ -9565,14 +9751,12 @@ dependencies = [
 
 [[package]]
 name = "tracing-opentelemetry"
-version = "0.30.0"
+version = "0.32.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd8e764bd6f5813fd8bebc3117875190c5b0415be8f7f8059bffb6ecd979c444"
+checksum = "1ac28f2d093c6c477eaa76b23525478f38de514fa9aeb1285738d4b97a9552fc"
 dependencies = [
  "js-sys",
- "once_cell",
  "opentelemetry",
- "opentelemetry_sdk",
  "smallvec",
  "tracing",
  "tracing-core",
@@ -10317,17 +10501,6 @@ dependencies = [
  "windows-strings 0.4.2",
 ]
 
-[[package]]
-name = "windows-registry"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
-dependencies = [
- "windows-link 0.2.1",
- "windows-result 0.4.1",
- "windows-strings 0.5.1",
-]
-
 [[package]]
 name = "windows-result"
 version = "0.3.4"
@@ -10490,6 +10663,15 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
+[[package]]
+name = "windows-version"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4060a1da109b9d0326b7262c8e12c84df67cc0dbc9e33cf49e01ccc2eb63631"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.42.2"
@@ -10991,6 +11173,18 @@ dependencies = [
  "syn 2.0.114",
 ]
 
+[[package]]
+name = "zip"
+version = "0.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "760394e246e4c28189f19d488c058bf16f564016aefac5d32bb1f3b51d5e9261"
+dependencies = [
+ "byteorder",
+ "crc32fast",
+ "crossbeam-utils",
+ "flate2",
+]
+
 [[package]]
 name = "zip"
 version = "2.4.2"
diff --git a/Cargo.toml b/Cargo.toml
index d2f24f0c3..87b37d721 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "spacebot"
-version = "0.1.15"
+version = "0.2.2"
 edition = "2024"
 default-run = "spacebot"
 
@@ -17,10 +17,10 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 
 # LLM / Rig framework
-rig = { version = "0.30.0", package = "rig-core", features = ["derive"] }
+rig = { version = "0.31", package = "rig-core", features = ["derive"] }
 
 # HTTP clients for LLM providers
-reqwest = { version = "0.12", features = ["json", "stream"] }
+reqwest = { version = "0.13", features = ["json", "stream", "form", "query", "gzip"] }
 
 # Databases
 sqlx = { version = "0.8", features = ["runtime-tokio", "sqlite", "migrate", "chrono", "uuid"] }
@@ -35,17 +35,20 @@ fastembed = "4"
 base64 = "0.22"
 hex = "0.4"
 
+# Compression
+flate2 = "1"
+
 # Logging and tracing
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 tracing-appender = "0.2"
 
 # OpenTelemetry
-opentelemetry = "0.29"
-opentelemetry_sdk = { version = "0.29", features = ["rt-tokio", "experimental_trace_batch_span_processor_with_async_runtime"] }
-opentelemetry-otlp = { version = "0.29", default-features = false, features = ["http-proto", "reqwest-client"] }
-opentelemetry-semantic-conventions = "0.29"
-tracing-opentelemetry = "0.30"
+opentelemetry = "0.31"
+opentelemetry_sdk = { version = "0.31", features = ["rt-tokio", "experimental_trace_batch_span_processor_with_async_runtime"] }
+opentelemetry-otlp = { version = "0.31", default-features = false, features = ["http-proto", "reqwest-client"] }
+opentelemetry-semantic-conventions = "0.31"
+tracing-opentelemetry = "0.32"
 
 # Configuration
 dirs = "6.0"
@@ -58,6 +61,7 @@ notify = "7"
 # Cryptography (for secrets)
 aes-gcm = "0.10"
 sha2 = "0.10"
+argon2 = "0.5"
 rand = "0.9"
 
 # UUID generation
@@ -66,6 +70,7 @@ uuid = { version = "1.15", features = ["v4", "serde"] }
 # Time handling
 chrono = { version = "0.4", features = ["serde"] }
 chrono-tz = "0.10"
+cron = "0.12"
 
 # Regular expressions (for leak detection)
 regex = "1.11"
@@ -75,8 +80,8 @@ futures = "0.3"
 pin-project = "1"
 
 # Schema validation
-schemars = "0.8"
-rmcp = { version = "0.16", features = ["client", "reqwest", "transport-child-process", "transport-streamable-http-client", "transport-streamable-http-client-reqwest"] }
+schemars = "1.2"
+rmcp = { version = "0.17", features = ["client", "reqwest", "transport-child-process", "transport-streamable-http-client", "transport-streamable-http-client-reqwest"] }
 
 # Command line (for main.rs)
 clap = { version = "4.5", features = ["derive"] }
@@ -105,6 +110,12 @@ teloxide = { version = "0.17", default-features = false, features = ["rustls"] }
 # Twitch
 twitch-irc = { version = "5.0", default-features = false, features = ["transport-tcp-rustls-webpki-roots", "refreshing-token-rustls-webpki-roots"] }
 
+# Email
+imap = "2.4"
+lettre = { version = "0.11", features = ["tokio1", "tokio1-native-tls"] }
+mailparse = "0.16"
+native-tls = "0.2"
+
 # Stream utilities
 tokio-stream = "0.1"
 
@@ -121,7 +132,7 @@ arrow-array = "57.3.0"
 arrow-schema = "57.3.0"
 
 # Browser automation
-chromiumoxide = { version = "0.8", features = ["tokio-runtime"], default-features = false }
+chromiumoxide = { version = "0.8", features = ["tokio-runtime", "_fetcher-rustls-tokio"], default-features = false }
 chromiumoxide_cdp = "0.8"
 
 # Templating for prompts
@@ -142,10 +153,14 @@ prometheus = { version = "0.13", optional = true }
 pdf-extract = "0.10.0"
 open = "5.3.3"
 urlencoding = "2.1.3"
+moka = "0.12.13"
 
 [features]
 metrics = ["dep:prometheus"]
 
+[patch.crates-io]
+imap-proto = { path = "vendor/imap-proto-0.10.2" }
+
 [lints.clippy]
 dbg_macro = "deny"
 todo = "deny"
@@ -153,6 +168,11 @@ unimplemented = "deny"
 
 [dev-dependencies]
 tokio-test = "0.4"
+parking_lot = "0.12"
+
+# OS keystore (macOS Keychain for master key storage)
+[target.'cfg(target_os = "macos")'.dependencies]
+security-framework = "3"
 
 [profile.release]
 lto = "thin"
diff --git a/Dockerfile b/Dockerfile
index 438462390..c90848f92 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -21,6 +21,7 @@ WORKDIR /build
 # 1. Fetch and cache Rust dependencies.
 #    cargo fetch needs a valid target, so we create stubs that get replaced later.
 COPY Cargo.toml Cargo.lock ./
+COPY vendor/ vendor/
 RUN mkdir src && echo "fn main() {}" > src/main.rs && touch src/lib.rs \
     && cargo build --release \
     && rm -rf src
@@ -35,17 +36,22 @@ RUN cd interface && bun run build
 #    build.rs runs the frontend build (already done above, node_modules present).
 #    prompts/ is needed for include_str! in src/prompts/text.rs.
 #    migrations/ is needed for sqlx::migrate! in src/db.rs.
+#    docs/ is needed for rust-embed in src/self_awareness.rs.
+#    AGENTS.md, README.md, CHANGELOG.md are needed for include_str! in src/self_awareness.rs.
 COPY build.rs ./
 COPY prompts/ prompts/
 COPY migrations/ migrations/
+COPY docs/ docs/
+COPY AGENTS.md README.md CHANGELOG.md ./
 COPY src/ src/
 RUN SPACEBOT_SKIP_FRONTEND_BUILD=1 cargo build --release \
     && mv /build/target/release/spacebot /usr/local/bin/spacebot \
     && cargo clean -p spacebot --release --target-dir /build/target
 
-# ---- Slim stage ----
-# Minimal runtime with just the binary. No browser.
-FROM debian:bookworm-slim AS slim
+# ---- Runtime stage ----
+# Minimal runtime with Chrome runtime libraries for fetcher-downloaded Chromium.
+# Chrome itself is downloaded on first browser tool use and cached on the volume.
+FROM debian:bookworm-slim
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
     ca-certificates \
@@ -53,28 +59,10 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     curl \
     gh \
     bubblewrap \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY --from=builder /usr/local/bin/spacebot /usr/local/bin/spacebot
-COPY docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
-RUN chmod +x /usr/local/bin/docker-entrypoint.sh
-
-ENV SPACEBOT_DIR=/data
-ENV SPACEBOT_DEPLOYMENT=docker
-EXPOSE 19898 18789
-
-HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
-    CMD curl -f http://localhost:19898/api/health || exit 1
-
-ENTRYPOINT ["docker-entrypoint.sh"]
-CMD ["spacebot", "start", "--foreground"]
-
-# ---- Full stage ----
-# Slim + Chromium for browser workers.
-FROM slim AS full
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    chromium \
+    openssh-server \
+    # Chrome runtime dependencies — required whether Chrome is system-installed
+    # or downloaded by the built-in fetcher. The fetcher provides the browser
+    # binary; these are the shared libraries it links against.
     fonts-liberation \
     libnss3 \
     libatk-bridge2.0-0 \
@@ -91,5 +79,16 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     libxtst6 \
     && rm -rf /var/lib/apt/lists/*
 
-ENV CHROME_PATH=/usr/bin/chromium
-ENV CHROME_FLAGS="--no-sandbox --disable-dev-shm-usage --disable-gpu"
+COPY --from=builder /usr/local/bin/spacebot /usr/local/bin/spacebot
+COPY docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
+RUN chmod +x /usr/local/bin/docker-entrypoint.sh
+
+ENV SPACEBOT_DIR=/data
+ENV SPACEBOT_DEPLOYMENT=docker
+EXPOSE 19898 18789
+
+HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
+    CMD curl -f http://localhost:19898/api/health || exit 1
+
+ENTRYPOINT ["docker-entrypoint.sh"]
+CMD ["spacebot", "start", "--foreground"]
diff --git a/README.md b/README.md
index 0387d04ec..eb7087898 100644
--- a/README.md
+++ b/README.md
@@ -20,6 +20,8 @@
   <a href="https://discord.gg/gTaF2Z44f5">
     <img src="https://img.shields.io/discord/949090953497567312?label=Discord&color=5865F2" />
   </a>
+
+  [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/spacedriveapp/spacebot)
 </p>
 
 <p align="center">
@@ -119,7 +121,8 @@ Every memory has a type, an importance score, and graph edges connecting it to r
 Cron jobs created and managed from conversation or config:
 
 - **Natural scheduling** — "check my inbox every 30 minutes" becomes a cron job with a delivery target
-- **Clock-aligned intervals** — sub-daily intervals snap to UTC boundaries so jobs fire on clean marks (e.g. every 30 min fires at :00 and :30)
+- **Strict wall-clock schedules** — use cron expressions for exact local-time execution (for example, `0 9 * * *` for 9:00 every day)
+- **Legacy interval compatibility** — existing `interval_secs` jobs still run and remain configurable
 - **Configurable timeouts** — per-job `timeout_secs` to cap execution time (defaults to 120s)
 - **Active hours** — restrict jobs to specific time windows (supports midnight wrapping)
 - **Circuit breaker** — auto-disables after 3 consecutive failures
@@ -184,7 +187,7 @@ coding = "ollama/qwen3"
 
 ```toml
 [llm.provider.my-provider]
-api_type = "openai_completions"  # or "anthropic"
+api_type = "openai_completions"  # or "openai_chat_completions", "openai_responses", "anthropic"
 base_url = "https://my-llm-host.example.com"
 api_key = "env:MY_PROVIDER_KEY"
 
@@ -192,7 +195,7 @@ api_key = "env:MY_PROVIDER_KEY"
 channel = "my-provider/my-model"
 ```
 
-Additional built-in providers include **NVIDIA**, **MiniMax**, **Moonshot AI (Kimi)**, and **Z.AI Coding Plan** — configure with `nvidia_key`, `minimax_key`, `moonshot_key`, or `zai_coding_plan_key` in `[llm]`.
+Additional built-in providers include **Kilo Gateway**, **OpenCode Go**, **NVIDIA**, **MiniMax**, **Moonshot AI (Kimi)**, and **Z.AI Coding Plan** — configure with `kilo_key`, `opencode_go_key`, `nvidia_key`, `minimax_key`, `moonshot_key`, or `zai_coding_plan_key` in `[llm]`.
 
 ### Skills
 
@@ -237,6 +240,39 @@ url = "https://mcp.sentry.io"
 headers = { Authorization = "Bearer ${SENTRY_TOKEN}" }
 ```
 
+### Security
+
+Spacebot runs autonomous LLM processes that execute arbitrary shell commands and spawn subprocesses. Security isn't an add-on — it's a layered system designed so that no single failure exposes credentials or breaks containment.
+
+#### Credential Isolation
+
+Secrets are split into two categories: **system** (LLM API keys, messaging tokens — never exposed to subprocesses) and **tool** (CLI credentials like `GH_TOKEN` — injected as env vars into workers). The category is auto-assigned based on the secret name, or set explicitly.
+
+- **Environment sanitization** — every subprocess starts with a clean environment (`--clearenv` on Linux, `env_clear()` everywhere else). Only safe baseline vars (`PATH`, `HOME`, `LANG`), tool-category secrets, and explicit `passthrough_env` entries are present. In sandbox mode, `HOME` is set to the workspace; in passthrough mode, `HOME` uses the parent environment. System secrets never enter any subprocess
+- **Secret store** — credentials live in a dedicated redb database, not in `config.toml`. Config references secrets by alias (`anthropic_key = "secret:ANTHROPIC_API_KEY"`), so the config file is safe to display, screenshot, or `cat`
+- **Encryption at rest** — optional AES-256-GCM encryption with a master key derived via Argon2id. The master key lives in the OS credential store (macOS Keychain, Linux kernel keyring) — never on disk, never in an env var, never accessible to worker subprocesses
+- **Keyring isolation** — on Linux, workers are spawned with a fresh empty session keyring via `pre_exec`. Even without the sandbox, workers cannot access the parent's kernel keyring where the master key lives
+- **Output scrubbing** — all tool secret values are redacted from worker output before it reaches channels or LLM context. A rolling buffer handles secrets split across stream chunks. Channels see `[REDACTED]`, never raw values
+- **Worker secret management** — workers can store credentials they obtain (API keys from account creation, OAuth tokens) via the `secret_set` tool. Stored secrets are immediately available to future workers
+
+#### Process Containment
+
+- **Process sandbox** — shell and exec tools run inside OS-level filesystem containment. On Linux, [bubblewrap](https://github.com/containers/bubblewrap) creates a mount namespace where the entire filesystem is read-only except the agent's workspace and configured writable paths. On macOS, `sandbox-exec` enforces equivalent restrictions via SBPL profiles. Kernel-enforced, not string-filtered
+- **Dynamic sandbox mode** — sandbox settings are hot-reloadable. Toggle via the dashboard or API without restarting the agent
+- **Workspace isolation** — file tools canonicalize all paths and reject anything outside the agent's workspace. Symlinks that escape are blocked
+- **Leak detection** — secret-pattern checks are enforced at channel egress (`reply` and plaintext fallback output) across plaintext, URL-encoded, base64, and hex encodings. Outbound text matching a secret pattern is blocked; worker tool outputs no longer hard-fail the worker
+- **Library injection blocking** — the exec tool blocks dangerous environment variables (`LD_PRELOAD`, `DYLD_INSERT_LIBRARIES`, `NODE_OPTIONS`, etc.) that could hijack child process loading
+- **SSRF protection** — the browser tool blocks requests to cloud metadata endpoints, private IPs, loopback, and link-local addresses
+- **Identity file protection** — writes to `SOUL.md`, `IDENTITY.md`, and `USER.md` are blocked at the application level
+- **Durable binary storage** — `tools/bin` directory on PATH survives hosted rollouts. Workers are instructed to install binaries there instead of ephemeral package manager locations
+
+```toml
+[agents.sandbox]
+mode = "enabled"                              # "enabled" (default) or "disabled"
+writable_paths = ["/home/user/projects/myapp"] # additional writable dirs beyond workspace
+passthrough_env = ["CUSTOM_VAR"]              # forward specific env vars to workers
+```
+
 ---
 
 ## How It Works
@@ -355,9 +391,9 @@ Memories are structured objects, not files. Every memory is a row in SQLite with
 
 Scheduled recurring tasks. Each cron job gets a fresh short-lived channel with full branching and worker capabilities.
 
-- Multiple cron jobs run independently at different intervals
+- Multiple cron jobs run independently on wall-clock schedules (or legacy intervals)
 - Stored in the database, created via config, conversation, or programmatically
-- Clock-aligned intervals snap to UTC boundaries for predictable firing times
+- Cron expressions execute against the resolved cron timezone for predictable local-time firing
 - Per-job `timeout_secs` to cap execution time
 - Circuit breaker auto-disables after 3 consecutive failures
 - Active hours support with midnight wrapping
@@ -381,7 +417,7 @@ Read the full vision in the [roadmap](docs/content/docs/(deployment)/roadmap.mdx
 ### Prerequisites
 
 - **Rust** 1.85+ ([rustup](https://rustup.rs/))
-- An LLM API key from any supported provider (Anthropic, OpenAI, OpenRouter, Z.ai, Groq, Together, Fireworks, DeepSeek, xAI, Mistral, NVIDIA, MiniMax, Moonshot AI, OpenCode Zen) — or use `spacebot auth login` for Anthropic OAuth
+- An LLM API key from any supported provider (Anthropic, OpenAI, OpenRouter, Kilo Gateway, Z.ai, Groq, Together, Fireworks, DeepSeek, xAI, Mistral, NVIDIA, MiniMax, Moonshot AI, OpenCode Zen, OpenCode Go) — or use `spacebot auth login` for Anthropic OAuth
 
 ### Build and Run
 
@@ -413,6 +449,12 @@ token = "env:DISCORD_BOT_TOKEN"
 agent_id = "my-agent"
 channel = "discord"
 guild_id = "your-discord-guild-id"
+
+# Optional: route a named adapter instance
+[[bindings]]
+agent_id = "my-agent"
+channel = "discord"
+adapter = "ops"
 ```
 
 ```bash
@@ -448,7 +490,7 @@ OAuth tokens are stored in `anthropic_oauth.json` and auto-refresh transparently
 | --------------- | --------------------------------------------------------------------------------------------------------------- |
 | Language        | **Rust** (edition 2024)                                                                                         |
 | Async runtime   | **Tokio**                                                                                                       |
-| LLM framework   | **[Rig](https://github.com/0xPlaygrounds/rig)** v0.30 — agentic loop, tool execution, hooks                     |
+| LLM framework   | **[Rig](https://github.com/0xPlaygrounds/rig)** v0.31 — agentic loop, tool execution, hooks                     |
 | Relational data | **SQLite** (sqlx) — conversations, memory graph, cron jobs                                                      |
 | Vector + FTS    | **[LanceDB](https://lancedb.github.io/lancedb/)** — embeddings (HNSW), full-text (Tantivy), hybrid search (RRF) |
 | Key-value       | **[redb](https://github.com/cberner/redb)** — settings, encrypted secrets                                       |
@@ -478,6 +520,8 @@ No server dependencies. Single binary. All data lives in embedded databases in a
 | [Cortex](docs/content/docs/(core)/cortex.mdx)                    | Memory bulletin and system observation                   |
 | [Cron Jobs](docs/content/docs/(features)/cron.mdx)               | Scheduled recurring tasks                                |
 | [Routing](docs/content/docs/(core)/routing.mdx)                  | Model routing and fallback chains                        |
+| [Secrets](docs/content/docs/(configuration)/secrets.mdx)         | Credential storage, encryption, and output scrubbing     |
+| [Sandbox](docs/content/docs/(configuration)/sandbox.mdx)         | Process containment and environment sanitization         |
 | [Messaging](docs/content/docs/(messaging)/messaging.mdx)         | Adapter architecture (Discord, Slack, Telegram, Twitch, Webchat, webhook) |
 | [Discord Setup](docs/content/docs/(messaging)/discord-setup.mdx) | Discord bot setup guide                                  |
 | [Browser](docs/content/docs/(features)/browser.mdx)              | Headless Chrome for workers                              |
@@ -503,11 +547,13 @@ Contributions welcome. Read [RUST_STYLE_GUIDE.md](RUST_STYLE_GUIDE.md) before wr
 
 1. Fork the repo
 2. Create a feature branch
-3. Run `./scripts/install-git-hooks.sh` once (installs pre-commit formatting hook)
-4. Make your changes
-5. Submit a PR
+3. Install `just` (https://github.com/casey/just) if it is not already available (for example: `brew install just` or `cargo install just --locked`)
+4. Run `./scripts/install-git-hooks.sh` once (installs pre-commit formatting hook)
+5. Make your changes
+6. Run `just preflight` and `just gate-pr`
+7. Submit a PR
 
-Formatting is still enforced in CI, but the hook catches it earlier by running `cargo fmt --all` before each commit.
+Formatting is still enforced in CI, but the hook catches it earlier by running `cargo fmt --all` before each commit. `just gate-pr` mirrors the CI gate and includes migration safety, compile checks, and test verification.
 
 ---
 
diff --git a/TODO b/TODO
new file mode 100644
index 000000000..d0c959599
--- /dev/null
+++ b/TODO
@@ -0,0 +1,31 @@
+Things to Fix:
+  ☐ Add behaviour settings per channel
+  ☐ Force branching before response
+
+Cortex Loops:
+  ☐ Check tasks + elevate todos
+  ☐ Improve bulletin
+  ☐ Better cortex loop context
+
+Improvements:
+  ☐ Improve cron
+  ☐ Named adapters
+  ☐ Thread names should be better, match channel name style
+
+Live Data Sources (maybe not needed):
+  ☐ Repos
+  ☐ Documentation
+
+Features:
+  ☐ Agent creation flow / onboarding UI
+  ☐ Cortex chat context inspection — should be able to read the full channel context at any time
+  ☐ Add streaming support
+
+Urgent:
+  ☐ Send customer emails ASAP
+
+Settings:
+  ☐ Disable sandboxing / sandbox settings
+
+Notes:
+  Testing inter-agent comms: send a message to the Spacebot Tech Lead, who forwards to the Community Manager, who picks a random word relating to fruit, technology, or space exploration, sending it back up the chain.
diff --git a/docs/.node-version b/docs/.node-version
new file mode 100644
index 000000000..209e3ef4b
--- /dev/null
+++ b/docs/.node-version
@@ -0,0 +1 @@
+20
diff --git a/docs/content/docs/(configuration)/config.mdx b/docs/content/docs/(configuration)/config.mdx
index f098b6d73..1193fa241 100644
--- a/docs/content/docs/(configuration)/config.mdx
+++ b/docs/content/docs/(configuration)/config.mdx
@@ -24,6 +24,7 @@ spacebot --config /path/to.toml  # CLI override
 anthropic_key = "env:ANTHROPIC_API_KEY"
 openai_key = "env:OPENAI_API_KEY"
 openrouter_key = "env:OPENROUTER_API_KEY"
+kilo_key = "env:KILO_API_KEY"
 zhipu_key = "env:ZHIPU_API_KEY"
 groq_key = "env:GROQ_API_KEY"
 together_key = "env:TOGETHER_API_KEY"
@@ -32,6 +33,7 @@ deepseek_key = "env:DEEPSEEK_API_KEY"
 xai_key = "env:XAI_API_KEY"
 mistral_key = "env:MISTRAL_API_KEY"
 opencode_zen_key = "env:OPENCODE_ZEN_API_KEY"
+opencode_go_key = "env:OPENCODE_GO_API_KEY"
 
 # Custom LLM providers (alternative to legacy keys)
 [llm.provider.my_anthropic]
@@ -60,6 +62,7 @@ context_window = 128000        # context window size in tokens
 history_backfill_count = 50    # messages to fetch from platform on new channel
 worker_log_mode = "errors_only" # "errors_only", "all_separate", or "all_combined"
 cron_timezone = "UTC"          # optional default timezone for cron active hours
+user_timezone = "UTC"          # optional default timezone for channel/worker time context
 
 # Model routing per process type.
 [defaults.routing]
@@ -87,7 +90,7 @@ emergency_threshold = 0.95     # drop oldest 50%, no LLM
 # Cortex (system observer) settings.
 [defaults.cortex]
 tick_interval_secs = 30
-worker_timeout_secs = 300
+worker_timeout_secs = 600
 branch_timeout_secs = 60
 circuit_breaker_threshold = 3  # consecutive failures before auto-disable
 
@@ -103,8 +106,10 @@ startup_delay_secs = 5
 enabled = true
 headless = true
 evaluate_enabled = false
-executable_path = "/path/to/chrome"     # optional, auto-detected
-screenshot_dir = "/path/to/screenshots" # optional, defaults to data_dir/screenshots
+persist_session = false                  # keep browser alive across worker lifetimes
+close_policy = "close_browser"           # "close_browser", "close_tabs", or "detach"
+executable_path = "/path/to/chrome"      # optional, auto-detected
+screenshot_dir = "/path/to/screenshots"  # optional, defaults to data_dir/screenshots
 
 # --- Agents ---
 # At least one agent is required. First agent or the one with default = true
@@ -114,6 +119,7 @@ id = "main"
 default = true
 workspace = "/custom/workspace/path"   # optional, defaults to ~/.spacebot/agents/{id}/workspace
 cron_timezone = "America/Los_Angeles"  # optional per-agent cron timezone override
+user_timezone = "America/Los_Angeles"  # optional per-agent timezone override for channel/worker time context
 
 # Per-agent routing overrides (merges with defaults).
 [agents.routing]
@@ -128,7 +134,7 @@ writable_paths = ["/home/user/projects/myapp"] # additional writable directories
 [[agents.cron]]
 id = "daily-check"
 prompt = "Check in on ongoing projects and report status."
-interval_secs = 86400
+cron_expr = "0 9 * * *"
 delivery_target = "discord:123456789"
 active_start_hour = 9
 active_end_hour = 17
@@ -163,17 +169,32 @@ agent_id = "main"
 channel = "webhook"
 ```
 
-## Environment Variable References
+## Value References
 
-Any string value in the config can reference an environment variable with the `env:` prefix:
+Any string value in the config supports three resolution modes:
+
+| Prefix | Resolution | Example |
+|--------|-----------|---------|
+| `secret:` | Look up from the [secret store](/docs/secrets) | `"secret:ANTHROPIC_API_KEY"` |
+| `env:` | Read from system environment variable | `"env:ANTHROPIC_API_KEY"` |
+| _(none)_ | Literal value | `"sk-ant-..."` |
 
 ```toml
-anthropic_key = "env:ANTHROPIC_API_KEY"
+# From the secret store (recommended)
+anthropic_key = "secret:ANTHROPIC_API_KEY"
+
+# From an environment variable
+openai_key = "env:OPENAI_API_KEY"
+
+# Literal value (not recommended — use secret: or env: instead)
+groq_key = "gsk_abc123..."
 ```
 
-This reads `ANTHROPIC_API_KEY` from the environment at startup. If the variable is unset, the value is treated as missing.
+The `secret:` prefix resolves from the agent's secret store at config load time. If the secret doesn't exist, the value is treated as missing and implicit env fallbacks are tried.
+
+LLM keys also have implicit env fallbacks — if no key is set in the TOML, Spacebot checks `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `OPENROUTER_API_KEY`, `KILO_API_KEY`, and `OPENCODE_GO_API_KEY` automatically.
 
-LLM keys also have implicit env fallbacks — if no key is set in the TOML, Spacebot checks `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, and `OPENROUTER_API_KEY` automatically.
+Use `POST /api/secrets/migrate` to automatically move plaintext credentials from `config.toml` into the secret store and replace them with `secret:` references. See [Secret Store -- Migration](/docs/secrets#migration) for details.
 
 ## Env-Only Mode
 
@@ -208,6 +229,7 @@ Model names include the provider as a prefix:
 | Anthropic | `anthropic/<model>` | `anthropic/claude-sonnet-4-20250514` |
 | OpenAI | `openai/<model>` | `openai/gpt-4o` |
 | OpenRouter | `openrouter/<provider>/<model>` | `openrouter/anthropic/claude-sonnet-4-20250514` |
+| Kilo Gateway | `kilo/<provider>/<model>` | `kilo/anthropic/claude-sonnet-4.5` |
 | Custom provider | `<provider_id>/<model>` | `my_openai/gpt-4o-mini` |
 
 You can mix providers across process types. See [Routing](/docs/routing) for the full routing system.
@@ -236,7 +258,7 @@ Most config values are hot-reloaded when their files change. Spacebot watches `c
 
 | Setting | Why |
 |---------|-----|
-| LLM API keys | Provider clients are initialized once |
+| LLM API keys | Provider clients are initialized once (applies to `secret:`, `env:`, and literal values) |
 | Messaging adapters (Discord token, webhook bind/port) | Adapter connections are long-lived |
 | Agent topology (adding/removing `[[agents]]`) | Databases and event buses are per-agent |
 | Database paths | Connections are opened once at startup |
@@ -290,6 +312,7 @@ System prompts (channel, branch, worker, compactor, cortex, etc.) are Jinja2 tem
         │   ├── lancedb/           # vector search
         │   ├── config.redb        # key-value settings
         │   ├── settings.redb      # runtime settings (worker_log_mode, etc.)
+        │   ├── secrets.redb       # secret store (categories, encryption)
         │   └── logs/              # worker execution logs
         └── archives/              # compaction transcripts
 ```
@@ -326,17 +349,19 @@ If you define a custom provider with the same ID as a legacy key, your custom co
 
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
-| `anthropic_key` | string | None | Anthropic API key (or `env:VAR_NAME`) |
-| `openai_key` | string | None | OpenAI API key (or `env:VAR_NAME`) |
-| `openrouter_key` | string | None | OpenRouter API key (or `env:VAR_NAME`) |
-| `zhipu_key` | string | None | Zhipu AI (GLM) API key (or `env:VAR_NAME`) |
-| `groq_key` | string | None | Groq API key (or `env:VAR_NAME`) |
-| `together_key` | string | None | Together AI API key (or `env:VAR_NAME`) |
-| `fireworks_key` | string | None | Fireworks AI API key (or `env:VAR_NAME`) |
-| `deepseek_key` | string | None | DeepSeek API key (or `env:VAR_NAME`) |
-| `xai_key` | string | None | XAI API key (or `env:VAR_NAME`) |
-| `mistral_key` | string | None | Mistral API key (or `env:VAR_NAME`) |
-| `opencode_zen_key` | string | None | OpenCode Zen API key (or `env:VAR_NAME`) |
+| `anthropic_key` | string | None | Anthropic API key (`secret:NAME`, `env:VAR_NAME`, or literal) |
+| `openai_key` | string | None | OpenAI API key (`secret:NAME`, `env:VAR_NAME`, or literal) |
+| `openrouter_key` | string | None | OpenRouter API key (`secret:NAME`, `env:VAR_NAME`, or literal) |
+| `kilo_key` | string | None | Kilo Gateway API key (`secret:NAME`, `env:VAR_NAME`, or literal) |
+| `zhipu_key` | string | None | Zhipu AI (GLM) API key (`secret:NAME`, `env:VAR_NAME`, or literal) |
+| `groq_key` | string | None | Groq API key (`secret:NAME`, `env:VAR_NAME`, or literal) |
+| `together_key` | string | None | Together AI API key (`secret:NAME`, `env:VAR_NAME`, or literal) |
+| `fireworks_key` | string | None | Fireworks AI API key (`secret:NAME`, `env:VAR_NAME`, or literal) |
+| `deepseek_key` | string | None | DeepSeek API key (`secret:NAME`, `env:VAR_NAME`, or literal) |
+| `xai_key` | string | None | XAI API key (`secret:NAME`, `env:VAR_NAME`, or literal) |
+| `mistral_key` | string | None | Mistral API key (`secret:NAME`, `env:VAR_NAME`, or literal) |
+| `opencode_zen_key` | string | None | OpenCode Zen API key (`secret:NAME`, `env:VAR_NAME`, or literal) |
+| `opencode_go_key` | string | None | OpenCode Go API key (`secret:NAME`, `env:VAR_NAME`, or literal) |
 
 #### Custom Providers
 
@@ -344,7 +369,7 @@ Custom providers allow configuring LLM providers with custom endpoints and API t
 
 ```toml
 [llm.provider.<id>]
-api_type = "anthropic"          # Required - one of: anthropic, openai_completions, openai_responses
+api_type = "anthropic"          # Required - see supported values below
 base_url = "https://api..."     # Required - valid URL
 api_key = "env:API_KEY"         # Required - API key (supports env:VAR_NAME format)
 name = "My Provider"            # Optional - friendly name for display
@@ -352,16 +377,18 @@ name = "My Provider"            # Optional - friendly name for display
 
 | Field | Type | Required | Description |
 |-------|------|----------|-------------|
-| `api_type` | string | Yes | API protocol type. One of: `anthropic` (Anthropic Messages API), `openai_completions` (OpenAI Chat Completions-compatible API), or `openai_responses` (OpenAI Responses API-compatible) |
+| `api_type` | string | Yes | API protocol type. One of: `anthropic`, `openai_completions`, `openai_chat_completions`, `openai_responses`, `gemini`, or `kilo_gateway` |
 | `base_url` | string | Yes | Base URL of the API endpoint. Must be a valid URL (including protocol) |
-| `api_key` | string | Yes | API key for authentication. Supports `env:VAR_NAME` syntax to reference environment variables |
+| `api_key` | string | Yes | API key for authentication. Supports `secret:NAME` and `env:VAR_NAME` syntax |
 | `name` | string | No | Optional friendly name for the provider (displayed in logs and UI) |
 
 > Note:
-> - For `openai_completions` and `openai_responses`, configure `base_url` as the provider root URL (usually without a trailing `/v1`).
+> - For `openai_completions`, `openai_chat_completions`, and `openai_responses`, configure `base_url` as the provider root URL (usually without a trailing `/v1`).
 > - Spacebot appends the endpoint path automatically:
 >   - `openai_completions` -> `/v1/chat/completions`
+>   - `openai_chat_completions` -> `/chat/completions`
 >   - `openai_responses` -> `/v1/responses`
+>   - `kilo_gateway` -> `/chat/completions` plus Kilo-required `HTTP-Referer` / `X-Title` headers
 > - If you include `/v1` in `base_url`, requests can end up with duplicated paths such as `/v1/v1/...`.
 
 **Provider ID Requirements:**
@@ -410,6 +437,7 @@ At least one provider (legacy key or custom provider) must be configured.
 | `history_backfill_count` | integer | 50 | Messages to fetch from platform on new channel |
 | `worker_log_mode` | string | `"errors_only"` | Worker log persistence: `"errors_only"`, `"all_separate"`, or `"all_combined"` |
 | `cron_timezone` | string | None | Default timezone for cron active-hours evaluation (IANA name like `UTC` or `America/New_York`) |
+| `user_timezone` | string | inherits `cron_timezone` | Default timezone for channel/worker temporal context (IANA name) |
 
 ### `[defaults.routing]`
 
@@ -475,9 +503,11 @@ Thresholds are fractions of `context_window`.
 
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
-| `tick_interval_secs` | integer | 30 | How often the cortex checks system state |
-| `worker_timeout_secs` | integer | 300 | Worker timeout before cancellation |
+| `tick_interval_secs` | integer | 30 | How often the cortex runtime loop runs maintenance ticks while continuously observing events |
+| `worker_timeout_secs` | integer | 600 | Worker idle timeout before cancellation |
 | `branch_timeout_secs` | integer | 60 | Branch timeout before cancellation |
+| `detached_worker_timeout_retry_limit` | integer | 2 | Retry limit before quarantining detached workers to backlog |
+| `supervisor_kill_budget_per_tick` | integer | 8 | Max number of overdue processes supervisor may cancel per health tick |
 | `circuit_breaker_threshold` | integer | 3 | Consecutive failures before auto-disable |
 
 ### `[defaults.warmup]`
@@ -489,11 +519,13 @@ Thresholds are fractions of `context_window`.
 | `refresh_secs` | integer | 900 | Seconds between background warmup passes |
 | `startup_delay_secs` | integer | 5 | Delay before first warmup pass after boot |
 
+When warmup is enabled, it is the primary bulletin refresh path. The cortex runtime loop still performs fallback bulletin/profile refresh when warmup is disabled or when the cached bulletin is stale (`bulletin_age_secs >= max(1, warmup.refresh_secs)`).
+
 Dispatch readiness is derived from warmup runtime state:
 
 - warmup state must be `warm`
 - embedding must be ready
-- bulletin age must be fresh (<= `max(60s, refresh_secs * 2)`)
+- bulletin age must be fresh (`<= max(60s, refresh_secs * 2)`)
 
 When branch/worker/cron dispatch happens before readiness is satisfied, Spacebot still dispatches, increments cold-dispatch metrics, and queues a forced warmup pass in the background.
 
@@ -504,6 +536,8 @@ When branch/worker/cron dispatch happens before readiness is satisfied, Spacebot
 | `enabled` | bool | true | Whether workers have browser tools |
 | `headless` | bool | true | Run Chrome headless |
 | `evaluate_enabled` | bool | false | Allow JavaScript evaluation |
+| `persist_session` | bool | false | Keep browser alive across worker lifetimes. Tabs, cookies, and logins survive between tasks. Requires agent restart to take effect. |
+| `close_policy` | string | `"close_browser"` | What happens on close: `"close_browser"` (kill Chrome), `"close_tabs"` (close tabs, keep browser), `"detach"` (disconnect, leave everything) |
 | `executable_path` | string | None | Custom Chrome/Chromium path |
 | `screenshot_dir` | string | None | Directory for screenshots |
 
@@ -515,6 +549,7 @@ When branch/worker/cron dispatch happens before readiness is satisfied, Spacebot
 | `default` | bool | false | Whether this is the default agent |
 | `workspace` | string | `~/.spacebot/agents/{id}/workspace` | Custom workspace path |
 | `cron_timezone` | string | inherits | Per-agent timezone override for cron active-hours evaluation |
+| `user_timezone` | string | inherits | Per-agent timezone override for channel/worker temporal context |
 | `max_concurrent_branches` | integer | inherits | Override instance default |
 | `max_turns` | integer | inherits | Override instance default |
 | `context_window` | integer | inherits | Override instance default |
@@ -523,12 +558,15 @@ Agent-specific routing is set via `[agents.routing]` with the same keys as `[def
 
 ### `[agents.sandbox]`
 
-OS-level filesystem containment for shell and exec tool subprocesses. Uses bubblewrap (Linux) or sandbox-exec (macOS) to enforce read-only access to everything outside the workspace.
+OS-level filesystem containment and environment sanitization for shell and exec tool subprocesses. Uses bubblewrap (Linux) or sandbox-exec (macOS) to enforce read-only access to everything outside the workspace. Environment sanitization runs in all modes -- workers never inherit the parent's environment variables.
+
+See [Sandbox](/docs/sandbox) for a full explanation of how containment, environment sanitization, leak detection, and durable binaries work.
 
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
-| `mode` | string | `"enabled"` | `"enabled"` for kernel-enforced containment, `"disabled"` for full host access |
+| `mode` | string | `"enabled"` | `"enabled"` for kernel-enforced containment, `"disabled"` for passthrough (full host filesystem access; env sanitization still applies) |
 | `writable_paths` | string[] | `[]` | Additional directories the agent can write to beyond its workspace |
+| `passthrough_env` | string[] | `[]` | Environment variable names to forward from the parent process to worker subprocesses |
 
 When `mode = "enabled"`, shell and exec commands run inside a mount namespace where the entire filesystem is read-only except:
 
@@ -539,7 +577,7 @@ When `mode = "enabled"`, shell and exec commands run inside a mount namespace wh
 
 The agent's data directory (databases, config) is explicitly re-mounted read-only even if it would otherwise be writable due to path overlap.
 
-When `SPACEBOT_DEPLOYMENT=hosted`, sandbox mode is always `"enabled"` regardless of config.
+Regardless of mode, all worker subprocesses start with a clean environment. Only `PATH` (with `tools/bin` prepended), safe variables (`HOME`, `USER`, `LANG`, `TERM`, `TMPDIR`), and any `passthrough_env` entries are injected. `HOME` is mode-dependent: workspace path when sandboxed, parent `HOME` when passthrough is enabled. Use `passthrough_env` with least privilege: only forward variables required by worker tools (for example specific credentials set in Docker Compose or systemd), and avoid forwarding broad or highly sensitive credentials.
 
 If the sandbox backend isn't available (e.g. bubblewrap not installed), processes run unsandboxed with a warning at startup.
 
@@ -547,6 +585,7 @@ If the sandbox backend isn't available (e.g. bubblewrap not installed), processe
 [agents.sandbox]
 mode = "enabled"
 writable_paths = ["/home/user/projects/myapp", "/var/data/shared"]
+passthrough_env = ["GH_TOKEN", "GITHUB_TOKEN"]
 ```
 
 ### `[[agents.cron]]`
@@ -555,6 +594,7 @@ writable_paths = ["/home/user/projects/myapp", "/var/data/shared"]
 |-----|------|---------|-------------|
 | `id` | string | **required** | Cron job identifier |
 | `prompt` | string | **required** | Prompt sent to a fresh channel on each tick |
+| `cron_expr` | string | None | Strict wall-clock schedule (cron expression, e.g. `0 9 * * *`) |
 | `interval_secs` | integer | 3600 | Seconds between firings |
 | `delivery_target` | string | **required** | Where to send results (`adapter:target`) |
 | `active_start_hour` | integer | None | Start of active hours window (24h format) |
@@ -570,22 +610,140 @@ Cron timezone precedence is:
 
 If a configured timezone is invalid, Spacebot logs a warning and falls back to server local time.
 
+Channel/worker temporal context timezone precedence is:
+
+1. `agents.user_timezone`
+2. `defaults.user_timezone`
+3. `SPACEBOT_USER_TIMEZONE`
+4. resolved cron timezone (from `agents.cron_timezone` / `defaults.cron_timezone` / `SPACEBOT_CRON_TIMEZONE`)
+5. server local timezone
+
 ### `[messaging.discord]`
 
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
 | `enabled` | bool | false | Enable Discord adapter |
 | `token` | string | None | Bot token (or `env:VAR_NAME`) |
+| `instances` | table[] | [] | Optional named Discord bot instances |
 | `dm_allowed_users` | string[] | [] | User IDs allowed to DM the bot |
 
+### `[[messaging.discord.instances]]`
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `name` | string | **required** | Instance selector used by bindings (`adapter = "name"`) |
+| `enabled` | bool | true | Enable this named instance |
+| `token` | string | **required** | Bot token (or `env:VAR_NAME`) |
+| `dm_allowed_users` | string[] | [] | User IDs allowed to DM this instance |
+| `allow_bot_messages` | bool | false | Whether this instance accepts bot-authored messages |
+
+### `[messaging.slack]`
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `enabled` | bool | false | Enable Slack adapter |
+| `bot_token` | string | None | Bot token (or `env:VAR_NAME`) |
+| `app_token` | string | None | App-level token (or `env:VAR_NAME`) |
+| `instances` | table[] | [] | Optional named Slack app instances |
+| `dm_allowed_users` | string[] | [] | Slack user IDs allowed to DM the bot |
+
+### `[[messaging.slack.instances]]`
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `name` | string | **required** | Instance selector used by bindings (`adapter = "name"`) |
+| `enabled` | bool | true | Enable this named instance |
+| `bot_token` | string | **required** | Bot token (or `env:VAR_NAME`) |
+| `app_token` | string | **required** | App-level token (or `env:VAR_NAME`) |
+| `dm_allowed_users` | string[] | [] | Slack user IDs allowed to DM this instance |
+
 ### `[messaging.telegram]`
 
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
 | `enabled` | bool | false | Enable Telegram adapter |
 | `token` | string | None | Bot token from @BotFather (or `env:VAR_NAME`). Falls back to `TELEGRAM_BOT_TOKEN` env var |
+| `instances` | table[] | [] | Optional named Telegram bot instances |
 | `dm_allowed_users` | string[] | [] | User IDs allowed to DM the bot. Empty = DMs from anyone accepted |
 
+### `[[messaging.telegram.instances]]`
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `name` | string | **required** | Instance selector used by bindings (`adapter = "name"`) |
+| `enabled` | bool | true | Enable this named instance |
+| `token` | string | **required** | Bot token (or `env:VAR_NAME`) |
+| `dm_allowed_users` | string[] | [] | User IDs allowed to DM this instance |
+
+### `[messaging.twitch]`
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `enabled` | bool | false | Enable Twitch adapter |
+| `username` | string | None | Bot login username |
+| `oauth_token` | string | None | OAuth token (`oauth:...` or plain token) |
+| `instances` | table[] | [] | Optional named Twitch bot instances |
+| `channels` | string[] | [] | Channels to join |
+| `trigger_prefix` | string | None | Optional prefix required to trigger replies |
+
+### `[[messaging.twitch.instances]]`
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `name` | string | **required** | Instance selector used by bindings (`adapter = "name"`) |
+| `enabled` | bool | true | Enable this named instance |
+| `username` | string | **required** | Bot login username |
+| `oauth_token` | string | **required** | OAuth token (`oauth:...` or plain token) |
+| `channels` | string[] | [] | Channels to join for this instance |
+| `trigger_prefix` | string | None | Optional prefix required to trigger replies |
+
+### `[messaging.email]`
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `enabled` | bool | false | Enable Email adapter |
+| `imap_host` | string | None | IMAP host (or `env:VAR_NAME`) |
+| `imap_port` | integer | 993 | IMAP port |
+| `imap_username` | string | None | IMAP username (or `env:VAR_NAME`) |
+| `imap_password` | string | None | IMAP password (or `env:VAR_NAME`) |
+| `imap_use_tls` | bool | true | Use direct TLS for IMAP |
+| `smtp_host` | string | None | SMTP host (or `env:VAR_NAME`) |
+| `smtp_port` | integer | 587 | SMTP port |
+| `smtp_username` | string | None | SMTP username (or `env:VAR_NAME`) |
+| `smtp_password` | string | None | SMTP password (or `env:VAR_NAME`) |
+| `smtp_use_starttls` | bool | true | Use STARTTLS for SMTP |
+| `from_address` | string | None | Sender address for outgoing replies (or `env:VAR_NAME`) |
+| `from_name` | string | None | Optional sender display name |
+| `poll_interval_secs` | integer | 30 | How often to check for new email |
+| `folders` | string[] | `["INBOX"]` | IMAP folders to poll |
+| `allowed_senders` | string[] | `[]` | Optional allowlist for inbound senders (empty = all) |
+| `max_body_bytes` | integer | 262144 | Max inbound body bytes before truncation |
+| `max_attachment_bytes` | integer | 10485760 | Max attachment bytes to process metadata for |
+
+### `[[messaging.email.instances]]`
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `name` | string | **required** | Instance selector used by bindings (`adapter = "name"`) |
+| `enabled` | bool | true | Enable this named instance |
+| `imap_host` | string | **required** | IMAP host (or `env:VAR_NAME`) |
+| `imap_port` | integer | 993 | IMAP port |
+| `imap_username` | string | **required** | IMAP username (or `env:VAR_NAME`) |
+| `imap_password` | string | **required** | IMAP password (or `env:VAR_NAME`) |
+| `imap_use_tls` | bool | true | Use direct TLS for IMAP |
+| `smtp_host` | string | **required** | SMTP host (or `env:VAR_NAME`) |
+| `smtp_port` | integer | 587 | SMTP port |
+| `smtp_username` | string | None | SMTP username (defaults to IMAP username) |
+| `smtp_password` | string | None | SMTP password (defaults to IMAP password) |
+| `smtp_use_starttls` | bool | true | Use STARTTLS for SMTP |
+| `from_address` | string | None | Sender address (defaults to SMTP username) |
+| `from_name` | string | None | Optional sender display name |
+| `poll_interval_secs` | integer | 30 | How often to check for new email |
+| `folders` | string[] | `["INBOX"]` | IMAP folders to poll |
+| `allowed_senders` | string[] | `[]` | Optional allowlist (empty = all) |
+| `max_body_bytes` | integer | 262144 | Max inbound body bytes |
+| `max_attachment_bytes` | integer | 10485760 | Max attachment bytes |
+
 ### `[messaging.webhook]`
 
 | Key | Type | Default | Description |
@@ -601,7 +759,8 @@ Routes platform conversations to agents. Checked in order; first match wins. Unm
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
 | `agent_id` | string | **required** | Which agent handles matched messages |
-| `channel` | string | **required** | Platform name (`discord`, `webhook`) |
+| `channel` | string | **required** | Platform name (`discord`, `slack`, `telegram`, `twitch`, `email`, `webhook`) |
+| `adapter` | string | None | Optional named adapter selector (e.g. `ops` => `discord:ops`) |
 | `guild_id` | string | None | Discord guild filter |
 | `chat_id` | string | None | Telegram chat filter |
 | `channel_ids` | string[] | [] | Discord channel ID filter (includes threads in those channels) |
diff --git a/docs/content/docs/(configuration)/meta.json b/docs/content/docs/(configuration)/meta.json
index 9ecb10d74..ef915e0d0 100644
--- a/docs/content/docs/(configuration)/meta.json
+++ b/docs/content/docs/(configuration)/meta.json
@@ -1,4 +1,4 @@
 {
   "title": "Configuration",
-  "pages": ["config", "permissions"]
+  "pages": ["config", "secrets", "sandbox", "permissions"]
 }
diff --git a/docs/content/docs/(configuration)/permissions.mdx b/docs/content/docs/(configuration)/permissions.mdx
index 51ea4aba0..4c6113cc1 100644
--- a/docs/content/docs/(configuration)/permissions.mdx
+++ b/docs/content/docs/(configuration)/permissions.mdx
@@ -9,7 +9,7 @@ Per-agent permission system that controls what tools can do, enforces inter-agen
 
 ## Design Principles
 
-**The container is the OS-level sandbox.** On spacebot.sh, each user runs in an isolated container. Self-hosters who need OS-level isolation can run Spacebot in Docker themselves. The permissions system does not attempt to replicate container-level security — it handles inter-agent boundaries and tool-level restrictions within a single Spacebot process.
+**OS-level containment is handled by the [Sandbox](/docs/sandbox) when sandboxing is enabled.** The sandbox enforces filesystem boundaries and environment sanitization at the kernel level, with exact guarantees depending on mode and backend/platform. On spacebot.sh, each user also runs in an isolated container. The permissions system handles a different layer -- inter-agent boundaries and tool-level restrictions within a single Spacebot process.
 
 **Deny is an error, not invisible.** When a tool call is denied, the tool still appears in the LLM's tool list, but returns a structured error explaining the restriction. The LLM can reason about the denial and adapt. This is better than hiding tools (which causes the LLM to attempt workarounds) and better than silent failures (which cause confusion).
 
@@ -50,7 +50,7 @@ But NOT:
 
 ```
 ~/.spacebot/agents/{other_agent}/          # other agents' data
-~/.spacebot/config.toml                    # instance config (contains API keys)
+~/.spacebot/config.toml                    # instance config (secret references, not plaintext keys)
 /etc/, /home/, /Users/                     # system paths
 ```
 
@@ -285,7 +285,7 @@ Default when no `[permissions]` block exists: all tools return permission denied
 
 ## What This Does NOT Do
 
-**OS-level sandboxing.** No Docker containers, no seccomp profiles, no capability dropping. Provisioned instances (spacebot.sh) or the user's own Docker setup handles this. Spacebot's permissions system is application-level.
+**OS-level sandboxing.** The permissions system is application-level -- it controls which tools the LLM can use and what paths it's allowed to access. OS-level containment is handled by the [Sandbox](/docs/sandbox), which operates independently when sandboxing is enabled; exact primitives vary by mode and backend/platform. Provisioned instances (spacebot.sh) also run in isolated containers. The permissions system and sandbox are complementary layers.
 
 **Shell command parsing.** We don't parse shell pipelines or analyze command strings for dangerous patterns. For `shell = "workspace"`, the `working_dir` is confined but the command itself runs unrestricted within that directory. Full command analysis is fragile and has diminishing returns — if you need that level of restriction, use `shell = "deny"`.
 
diff --git a/docs/content/docs/(configuration)/sandbox.mdx b/docs/content/docs/(configuration)/sandbox.mdx
new file mode 100644
index 000000000..4c801e7a0
--- /dev/null
+++ b/docs/content/docs/(configuration)/sandbox.mdx
@@ -0,0 +1,230 @@
+---
+title: Sandbox
+description: OS-level filesystem containment and environment sanitization for worker subprocesses.
+---
+
+# Sandbox
+
+OS-level containment for builtin worker subprocesses (`shell` and `exec`). Prevents workers from modifying the host filesystem, reading inherited environment secrets, and accessing the agent's internal data directory.
+
+## How It Works
+
+When a worker runs a shell or exec command, the sandbox wraps the subprocess in an OS-level containment layer before execution. The worker's command runs normally -- it can only read a minimal runtime allowlist plus workspace paths, and can only write to explicitly allowed paths.
+
+```
+Worker calls shell("npm test")
+  → Sandbox.wrap() builds a contained command
+  → Subprocess runs with:
+      - Read access to a minimal system allowlist + workspace
+      - Writable access only to the workspace + configured writable paths + /tmp
+      - Clean environment (no inherited secrets)
+      - HOME set to workspace in sandbox mode, parent HOME in passthrough mode
+      - TMPDIR set to /tmp
+      - tools/bin prepended to PATH
+  → stdout/stderr captured and returned to worker
+```
+
+Two things happen regardless of whether the sandbox is enabled or disabled:
+
+1. **Environment sanitization** -- worker subprocesses never inherit the parent's environment variables. Secrets like `ANTHROPIC_API_KEY` are never visible to workers.
+2. **PATH injection** -- the persistent `tools/bin` directory is prepended to PATH so durably installed binaries are always available.
+
+## Backends
+
+The sandbox auto-detects the best available backend at startup:
+
+| Platform | Backend | Mechanism |
+|----------|---------|-----------|
+| Linux | [bubblewrap](https://github.com/containers/bubblewrap) | Mount namespaces, PID namespaces, environment isolation |
+| macOS | sandbox-exec | SBPL profile with deny-default policy |
+| Other / not available | Passthrough | No filesystem containment (env sanitization still applies) |
+
+If the sandbox is enabled but no backend is available, processes run unsandboxed with a warning at startup. Environment sanitization still applies in all cases.
+
+### Linux (bubblewrap)
+
+The default on all hosted instances and most self-hosted Linux deployments. Bubblewrap creates a mount namespace where:
+
+- A minimal host runtime allowlist is mounted **read-only** (`/bin`, `/sbin`, `/usr`, `/lib`, `/lib64`, `/etc`, `/opt`, `/run`, `/nix` when present)
+- The persistent tools directory is mounted **read-only** (if present)
+- The workspace directory is mounted **read-write**
+- `writable_paths` entries are mounted **read-write**
+- `/tmp` is a private tmpfs per invocation
+- `/dev` has standard device nodes
+- `/proc` is a fresh procfs (when supported by the environment)
+- The agent's data directory is masked with an empty tmpfs (no reads/writes)
+- PID namespace isolation prevents the subprocess from seeing other processes
+- `--die-with-parent` ensures the subprocess is killed if the parent exits
+
+Nested containers (Docker-in-Docker, Fly Machines) may not support `--proc /proc`. The sandbox probes for this at startup and falls back gracefully -- `proc_supported: false` in the startup log means `/proc` inside the sandbox shows the host's process list rather than an isolated view.
+
+### macOS (sandbox-exec)
+
+Uses Apple's sandbox-exec with a generated SBPL (Sandbox Profile Language) profile. The profile starts with `(deny default)` and explicitly allows:
+
+- Process execution and forking
+- Reading only a backend allowlist (system runtime roots + workspace + configured writable paths + tools/bin)
+- Writing only to the workspace, configured writable paths, and `/tmp`
+- Network access (unrestricted)
+- Standard device and IPC operations
+
+The agent's data directory is denied for both reads and writes even if it falls under the workspace subtree.
+
+Note: `sandbox-exec` is deprecated by Apple but remains functional. It's the only user-space sandbox option on macOS without requiring a full VM.
+
+## Filesystem Boundaries
+
+When the sandbox is enabled, the subprocess sees:
+
+| Path | Access | Notes |
+|------|--------|-------|
+| System runtime allowlist | Read-only | Backend-specific system roots required to execute common tools |
+| Agent workspace | Read-write | Where the worker does its job |
+| `writable_paths` entries | Read-write | User-configured additional paths |
+| `{instance_dir}/tools/bin` | Read-only | Persistent binaries on PATH |
+| `/tmp` | Read-write | Private per invocation (bubblewrap) |
+| `/dev` | Read-write | Standard device nodes |
+| Agent data directory | **No access** | Masked/denied to protect databases and config |
+
+The data directory protection is important: even if the data directory overlaps with workspace-related paths, it's explicitly blocked. Workers can't read or modify databases, config files, or identity files at the kernel level.
+
+## Environment Sanitization
+
+Worker subprocesses start with a **clean environment**. The parent process's environment variables are never inherited. This applies in all sandbox modes -- even when the sandbox is disabled, `env_clear()` strips the environment.
+
+A worker running `printenv` sees only:
+
+| Variable | Source | Value |
+|----------|--------|-------|
+| `PATH` | Always | `{instance_dir}/tools/bin:{system_path}` |
+| `HOME` | Mode-dependent | Workspace path (sandbox enabled), parent `HOME` (sandbox disabled) |
+| `TMPDIR` | Always | `/tmp` |
+| `USER` | Always | From parent (if set) |
+| `LANG` | Always | From parent (if set) |
+| `TERM` | Always | From parent (if set) |
+| `passthrough_env` entries | Config | User-configured forwarding |
+
+Workers never see `ANTHROPIC_API_KEY`, `DISCORD_BOT_TOKEN`, `SPACEBOT_*` internal vars, or any other environment variables from the parent process.
+
+### passthrough_env
+
+Self-hosted users who set credentials as environment variables in Docker Compose or systemd can forward specific variables to worker subprocesses:
+
+```toml
+[agents.sandbox]
+passthrough_env = ["GH_TOKEN", "GITHUB_TOKEN", "NPM_TOKEN"]
+```
+
+Each listed variable is read from the parent process environment at subprocess spawn time and injected into the worker's environment. Variables not in the list are stripped.
+
+When the [secret store](/docs/secrets) is available, `passthrough_env` is redundant -- credentials should be stored in the secret store, which injects tool secrets automatically. The field is additive and continues to work alongside the store.
+
+## Durable Binaries
+
+On hosted instances, the root filesystem is ephemeral -- machine image rollouts replace it. Binaries installed via `apt-get install` or similar disappear on the next deploy.
+
+The `{instance_dir}/tools/bin` directory is on the persistent volume and is prepended to `PATH` for all worker subprocesses. Binaries placed here survive restarts and rollouts.
+
+Workers are instructed about this in their system prompt:
+
+```
+Persistent binary directory: /data/tools/bin (on PATH, survives restarts and rollouts)
+Binaries installed via package managers (apt, brew, etc.) land on the root filesystem
+which is ephemeral on hosted instances -- they disappear on rollouts. To install a tool
+durably, download or copy the binary into /data/tools/bin.
+```
+
+The `GET /agents/tools` API endpoint lists installed binaries for dashboard observability:
+
+```json
+{
+  "tools_bin": "/data/tools/bin",
+  "binaries": [
+    { "name": "gh", "size": 1234567, "modified": "2026-02-20T14:15:00Z" },
+    { "name": "ripgrep", "size": 3456789, "modified": "2026-02-15T10:30:00Z" }
+  ]
+}
+```
+
+## Leak Detection
+
+Secret-pattern detection is enforced at **channel egress** (outbound user-visible text), not as a hard-stop for worker tool execution.
+
+Channel output is blocked when patterns are detected in:
+
+- `reply` tool content
+- Plaintext fallback sends when a model returns raw text instead of calling `reply`
+
+Worker and branch tool outputs no longer terminate the process on pattern hits. This keeps long-running jobs from failing when secrets are handled internally.
+
+Detected patterns include:
+
+- OpenAI keys (`sk-...`)
+- Anthropic keys (`sk-ant-...`)
+- GitHub tokens (`ghp_...`)
+- Google API keys (`AIza...`)
+- Discord bot tokens
+- Slack tokens (`xoxb-...`, `xapp-...`)
+- Telegram bot tokens
+- PEM private keys
+- Base64-encoded, URL-encoded, and hex-encoded variants of the above
+
+Detection also covers encoded forms -- secrets wrapped in base64, URL encoding, or hex are decoded and checked against the same patterns.
+
+If a channel egress leak is detected, outbound text is blocked. The raw leaked value is never logged -- only the detection event and a truncated non-reversible fingerprint are recorded for debugging.
+
+### OpenCode Workers
+
+OpenCode workers (external coding agent processes) apply the same output scrubbing, and also scan SSE text/tool output for secret patterns for observability:
+
+1. **Output scrubbing** (exact-match redaction of known secret values) -- runs first
+2. **Leak-pattern scan** (regex pattern matching for unknown secrets) -- runs second
+
+The ordering ensures that stored tool secrets are redacted before pattern scanning runs, so expected secret values in worker output don't trigger false positives.
+
+## Dynamic Mode Switching
+
+Sandbox mode can be changed at runtime via the API or dashboard without restarting the agent. The `Sandbox` struct reads the current mode from a shared `ArcSwap<SandboxConfig>` on every `wrap()` call.
+
+```
+PUT /agents/config
+{
+  "sandbox": { "mode": "disabled" }
+}
+```
+
+Backend detection runs at startup regardless of the initial mode. If the sandbox starts disabled and is later enabled via the API, bubblewrap/sandbox-exec is already detected and ready to use.
+
+## Configuration
+
+```toml
+[agents.sandbox]
+mode = "enabled"                              # "enabled" | "disabled"
+writable_paths = ["/home/user/shared-data"]   # additional writable directories
+passthrough_env = ["GH_TOKEN"]                # env vars to forward to workers
+```
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `mode` | string | `"enabled"` | `"enabled"` for OS-level containment, `"disabled"` for passthrough |
+| `writable_paths` | string[] | `[]` | Additional directories workers can write to beyond the workspace |
+| `passthrough_env` | string[] | `[]` | Environment variable names to forward from the parent process |
+
+See [Configuration](/docs/config#agentssandbox) for the full config reference.
+
+## Protection Layers
+
+The sandbox is one layer in a defense-in-depth model:
+
+| Layer | What It Does | Scope |
+|-------|-------------|-------|
+| **Sandbox (filesystem)** | Read allowlist + writable workspace/writable_paths/tmp; blocks agent data dir | Shell, exec subprocesses |
+| **Env sanitization** | Clean environment, no inherited secrets | All subprocesses (including passthrough mode) |
+| **File tool workspace guard** | Path validation against workspace boundary | File tool only (in-process) |
+| **Exec env var blocklist** | Blocks `LD_PRELOAD`, `DYLD_INSERT_LIBRARIES`, etc. | Exec tool |
+| **Leak detection** | Regex scan of outbound channel text for secret patterns | Channel egress (`reply` + plaintext fallback) |
+| **Output scrubbing** | Exact-match redaction of known secret values | Worker output, status updates, OpenCode events |
+| **[Secret store](/docs/secrets)** | Categorized credential storage, config resolution, tool secret injection | All agents |
+| **Permissions system** | Application-level tool access control | All tools |
+
+The sandbox and permissions system are complementary. The [permissions system](/docs/permissions) controls which tools an agent can use and what paths the LLM is allowed to access at the application level. The sandbox enforces filesystem boundaries at the kernel level for subprocesses that are allowed to run.
diff --git a/docs/content/docs/(configuration)/secrets.mdx b/docs/content/docs/(configuration)/secrets.mdx
new file mode 100644
index 000000000..52342560c
--- /dev/null
+++ b/docs/content/docs/(configuration)/secrets.mdx
@@ -0,0 +1,299 @@
+---
+title: Secret Store
+description: Credential storage with categories, config resolution, encryption at rest, and output scrubbing.
+---
+
+# Secret Store
+
+Instance-level credential storage. Secrets are stored in a local database shared across all agents, resolved from `config.toml` via the `secret:` prefix, and injected into worker subprocesses based on their category. Values are scrubbed from tool output and status text, and are not included in LLM context by design.
+
+## Two Categories
+
+Every secret has a category that controls subprocess exposure:
+
+| Category | Subprocess Exposure | Use Case |
+|----------|-------------------|----------|
+| **System** | Never exposed | LLM API keys, messaging tokens, webhook secrets |
+| **Tool** | Injected as env vars | `GH_TOKEN`, `NPM_TOKEN`, `AWS_ACCESS_KEY_ID` |
+
+All secrets are readable by the agent's internal Rust code via `SecretsStore::get()`. The category only determines whether the value is passed to worker subprocesses as an environment variable.
+
+### Auto-Categorization
+
+When you add a secret without specifying a category, the store assigns one based on the name:
+
+**System** (never exposed to subprocesses):
+- LLM provider keys (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `OPENROUTER_API_KEY`, `GROQ_API_KEY`, `DEEPSEEK_API_KEY`, `XAI_API_KEY`, `MISTRAL_API_KEY`, `GEMINI_API_KEY`, etc.)
+- Messaging adapter tokens (`DISCORD_BOT_TOKEN`, `SLACK_BOT_TOKEN`, `SLACK_APP_TOKEN`, `TELEGRAM_BOT_TOKEN`, `TWITCH_OAUTH_TOKEN`, etc.)
+- Email credentials (`EMAIL_IMAP_USERNAME`, `EMAIL_IMAP_PASSWORD`, `EMAIL_SMTP_USERNAME`, `EMAIL_SMTP_PASSWORD`)
+- Internal tool keys (`BRAVE_SEARCH_API_KEY`)
+- Named adapter instance tokens -- any name matching `{PLATFORM}_{INSTANCE}_{FIELD}` for a known adapter field (e.g. `DISCORD_ALERTS_BOT_TOKEN`, `SLACK_SUPPORT_APP_TOKEN`, `TWITCH_GAMING_OAUTH_TOKEN`)
+
+**Tool** (everything else):
+- Any unrecognized name defaults to Tool -- exposed to worker subprocesses as an environment variable
+- Examples: `GH_TOKEN`, `NPM_TOKEN`, `AWS_ACCESS_KEY_ID`, `DOCKER_TOKEN`, `CARGO_REGISTRY_TOKEN`
+
+Auto-categorization is driven by the `SystemSecrets` trait. Each config section (LLM, messaging adapters, search integrations) declares its own credential fields. Adding a new adapter or provider automatically extends categorization without updating a central list.
+
+You can override the auto-categorization by specifying a category explicitly when adding a secret.
+
+## Config Resolution
+
+Any string value in `config.toml` supports three resolution modes:
+
+```
+secret:NAME      → look up NAME in the secret store
+env:VAR_NAME     → read VAR_NAME from the system environment
+anything else    → literal value
+```
+
+The `secret:` prefix is the recommended way to reference credentials in config:
+
+```toml
+[llm]
+anthropic_key = "secret:ANTHROPIC_API_KEY"
+openai_key = "secret:OPENAI_API_KEY"
+
+[messaging.discord]
+token = "secret:DISCORD_BOT_TOKEN"
+```
+
+This keeps `config.toml` free of plaintext credentials. The secret store resolves references at config load time via a thread-local store reference.
+
+### Resolution Order
+
+For LLM keys specifically, the resolution chain is:
+
+```
+config.toml value (secret: / env: / literal)
+  → implicit env fallback (ANTHROPIC_API_KEY, etc.)
+  → missing
+```
+
+If `anthropic_key` is set to `"secret:ANTHROPIC_API_KEY"` and the secret store has that key, it resolves to the stored value. If the store doesn't have it, the key is treated as missing and the implicit env fallback is tried.
+
+## How Secrets Reach Subprocesses
+
+Tool-category secrets are injected into worker subprocesses as environment variables. The flow:
+
+```
+Worker calls shell("npm publish")
+  → Sandbox.wrap() builds the subprocess command
+  → SecretsStore.tool_env_vars() returns Tool-category secrets
+  → Each secret is injected via --setenv (bubblewrap) or Command::env()
+  → Subprocess sees NPM_TOKEN in its environment
+  → System-category secrets (ANTHROPIC_API_KEY, etc.) are NOT injected
+```
+
+This works alongside [environment sanitization](/docs/sandbox#environment-sanitization). The subprocess starts with a clean environment -- no inherited variables from the parent process. Only the safe baseline variables (`PATH`, `HOME`, `USER`, `LANG`, `TERM`, `TMPDIR`), `passthrough_env` entries, and tool secrets are present.
+
+### Worker-Created Secrets
+
+Workers have a `secret_set` tool that lets them store credentials directly into the secret store. This enables autonomous workflows where a worker creates accounts, generates API keys, or obtains tokens that should persist for future use.
+
+```
+Worker creates a GitHub bot account
+  → Worker calls secret_set(name: "GH_TOKEN", value: "ghp_abc...")
+  → Secret is stored with auto-categorized category (tool)
+  → All future workers see GH_TOKEN in their environment
+```
+
+The tool accepts an optional `category` parameter to override auto-categorization. If omitted, the same rules as the API apply -- known internal credentials are categorized as system, everything else as tool.
+
+## Encryption at Rest
+
+The store has two modes:
+
+### Unencrypted (Default)
+
+Secrets are stored as plaintext in a redb database. All secret store features work -- categories, env injection, output scrubbing, config resolution. Only encryption at rest is missing.
+
+This is the default because it requires zero setup. The store is functional immediately.
+
+### Encrypted (Opt-In)
+
+AES-256-GCM encryption with a master key derived via Argon2id. The master key lives in the OS credential store, never on disk:
+
+| Platform | Credential Store | Isolation |
+|----------|-----------------|-----------|
+| macOS | Keychain (Security framework) | Access controlled by code signature -- worker subprocesses can't retrieve the key |
+| Linux | Kernel keyring (`keyctl` syscalls) | Workers are spawned with a fresh empty session keyring via `pre_exec` |
+| Other | Not available | Encryption cannot be enabled |
+
+#### Encryption Lifecycle
+
+```
+Unencrypted (default)
+  → enable_encryption()  → Unlocked (encrypted at rest, secrets readable)
+  → lock()               → Locked (secrets unreadable, store sealed)
+  → unlock(password)     → Unlocked
+  → rotate_key()         → Unlocked (new key, all secrets re-encrypted)
+```
+
+**States:**
+
+| State | Reads | Writes | Description |
+|-------|-------|--------|-------------|
+| Unencrypted | Yes | Yes | Plaintext storage, no master key |
+| Unlocked | Yes | Yes | Encrypted at rest, master key cached in memory |
+| Locked | No | No | Encrypted, master key evicted -- all operations return an error |
+
+When encryption is enabled:
+
+1. A random 16-byte salt is generated and stored in the database
+2. The password is derived into a 256-bit key via Argon2id (memory=64MB, iterations=3, parallelism=4)
+3. All existing secrets are re-encrypted with unique 12-byte nonces
+4. A sentinel value is encrypted and stored -- used to validate the key on unlock without decrypting every secret
+5. The master key is stored in the OS credential store
+
+#### Retrieving the Master Key
+
+If you need to retrieve the master key after encryption (e.g., you didn't copy it during setup), you can read it directly from the OS credential store:
+
+**macOS:**
+
+```bash
+security find-generic-password -s "sh.spacebot.master-key" -a "instance" -w
+```
+
+**Linux:**
+
+The key is stored in the kernel keyring under the description `sh.spacebot.master-key:instance`. Use `keyctl` to search for it:
+
+```bash
+keyctl search @s user "sh.spacebot.master-key:instance"
+# returns the key ID, then read it:
+keyctl print <key_id>
+```
+
+## API
+
+All endpoints operate on the instance-level secret store. No agent scoping is needed -- secrets are shared across all agents.
+
+### CRUD
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/secrets` | List all secrets (names, categories, timestamps -- not values) |
+| `PUT` | `/api/secrets` | Add or update a secret |
+| `DELETE` | `/api/secrets/{name}` | Remove a secret |
+| `GET` | `/api/secrets/{name}/info` | Get metadata for a specific secret |
+
+**PUT body:**
+```json
+{
+  "name": "GH_TOKEN",
+  "value": "ghp_abc123...",
+  "category": "tool"
+}
+```
+
+If `category` is omitted, auto-categorization assigns one based on the name.
+
+### Store Status
+
+```
+GET /api/secrets/status
+```
+
+Returns the current store state, secret count, encryption status, and category breakdown.
+
+### Encryption
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `POST` | `/api/secrets/encrypt` | Enable encryption (returns master key) |
+| `POST` | `/api/secrets/unlock` | Unlock with password |
+| `POST` | `/api/secrets/lock` | Lock the store (evict master key) |
+| `POST` | `/api/secrets/rotate` | Generate new key, re-encrypt all secrets |
+
+### Migration
+
+```
+POST /api/secrets/migrate
+```
+
+Scans `config.toml` for literal (plaintext) key values in known credential fields. For each one found:
+
+1. Stores the value in the secret store with the appropriate category
+2. Replaces the literal value in `config.toml` with a `secret:NAME` reference
+3. Writes the updated `config.toml` to disk
+
+Scanned fields are driven by `SystemSecrets` trait implementations -- the same declarations used for auto-categorization. This covers:
+
+- All `[llm]` provider keys
+- `[defaults]` search keys
+- Default messaging adapter tokens (e.g. `[messaging.discord].token`)
+- Named adapter instance tokens in `[[messaging.*.instances]]` arrays (e.g. `DISCORD_ALERTS_BOT_TOKEN` for an instance named `"alerts"`)
+
+Values already using `env:` or `secret:` prefixes are skipped. This is a one-shot operation -- run it once after setting up the secret store to migrate existing plaintext credentials.
+
+### Export / Import
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `POST` | `/api/secrets/export` | Export all secrets as JSON (values included) |
+| `POST` | `/api/secrets/import` | Import secrets from a JSON export |
+
+Export returns all secrets with their plaintext values, categories, and timestamps. The store must be unlocked (or unencrypted) to export. Import merges secrets into the store -- existing secrets with the same name are updated.
+
+## Output Protection
+
+Secret values are protected from appearing in tool output and LLM context through two layers:
+
+### Output Scrubbing
+
+The `StreamScrubber` performs exact-match redaction of all stored secret values across tool output. It handles chunk boundaries -- if a secret value spans two output chunks, it's still detected and redacted.
+
+All tool secrets and system secrets are registered with the scrubber. When a match is found, the value is replaced with `[REDACTED]`.
+
+### Leak Detection
+
+Regex-based pattern matching scans for secrets that may not be in the store. This catches secrets that were never added to the store but appear in output (e.g., hardcoded in source files). Detected patterns include API key formats for major providers, PEM private keys, and encoded variants (base64, URL-encoded, hex).
+
+See [Sandbox -- Leak Detection](/docs/sandbox#leak-detection) for the full list of detected patterns.
+
+The two layers run in sequence: scrubbing first (exact match), then leak detection (pattern match). This prevents stored secrets from triggering false-positive leak detection kills.
+
+## On-Disk Layout
+
+```
+~/.spacebot/data/
+└── secrets.redb          # redb database with three tables:
+    ├── secrets           # name → value (plaintext or nonce+ciphertext)
+    ├── secrets_metadata  # name → JSON (category, timestamps)
+    └── secrets_config    # encryption flag, argon2 salt, sentinel
+```
+
+The secrets database is instance-level -- a single store shared across all agents. It is separate from the main `spacebot.db` SQLite database. It uses redb for single-writer, lock-free reads.
+
+On first startup after upgrading from a per-agent store layout, the bootstrap process automatically migrates secrets from any legacy `~/.spacebot/agents/{id}/data/secrets.redb` files into the instance-level store.
+
+## Configuration
+
+The secret store requires no configuration in `config.toml`. It initializes automatically at instance startup, before config loading, and is shared across all agents.
+
+To use stored secrets in config, replace literal values or `env:` references with `secret:` references:
+
+```toml
+[llm]
+anthropic_key = "secret:ANTHROPIC_API_KEY"
+openai_key = "secret:OPENAI_API_KEY"
+
+[messaging.discord]
+token = "secret:DISCORD_BOT_TOKEN"
+
+[messaging.telegram]
+token = "secret:TELEGRAM_BOT_TOKEN"
+```
+
+The `secret:` prefix works anywhere `env:` works. Both can coexist in the same config -- some keys from the store, others from environment variables.
+
+## Relationship to Other Systems
+
+| System | Relationship |
+|--------|-------------|
+| [Sandbox](/docs/sandbox) | Injects tool secrets into sandboxed subprocesses. Environment sanitization ensures only tool-category secrets reach workers. |
+| [Configuration](/docs/config) | `secret:` prefix in config values resolves from the store at load time. Migration endpoint converts plaintext config to `secret:` references. |
+| [Permissions](/docs/permissions) | Permissions control which tools agents can use. The secret store controls which credentials those tools receive. Complementary layers. |
+| `passthrough_env` | Forwards env vars from the parent process. Redundant when using the secret store -- credentials should be stored in the store instead. Both work simultaneously. |
diff --git a/docs/content/docs/(core)/agents.mdx b/docs/content/docs/(core)/agents.mdx
index e89237cdf..30b73746c 100644
--- a/docs/content/docs/(core)/agents.mdx
+++ b/docs/content/docs/(core)/agents.mdx
@@ -232,7 +232,9 @@ Returns agents, humans, links, and groups for rendering.
 │   │   ├── data/
 │   │   │   ├── spacebot.db              # SQLite (memories, conversations, cron jobs)
 │   │   │   ├── lancedb/                 # LanceDB (embeddings, FTS)
-│   │   │   └── config.redb             # redb (agent-level settings, secrets)
+│   │   │   ├── config.redb             # redb (agent-level settings)
+│   │   │   ├── settings.redb            # redb (runtime settings)
+│   │   │   └── secrets.redb             # redb (secret store)
 │   │   └── archives/                    # compaction transcripts
 │   │
 │   └── engineering/
diff --git a/docs/content/docs/(core)/architecture.mdx b/docs/content/docs/(core)/architecture.mdx
new file mode 100644
index 000000000..89dd11c79
--- /dev/null
+++ b/docs/content/docs/(core)/architecture.mdx
@@ -0,0 +1,419 @@
+---
+title: Architecture
+description: System-level overview of how Spacebot's processes, databases, and messaging layer fit together.
+---
+
+# Architecture
+
+Spacebot is a single binary that runs multiple concurrent AI processes, each with a dedicated role. There's no server to install, no message broker, no external database. Everything is embedded -- the LLM orchestration, the databases, the messaging adapters, the control API, and the web UI all run inside one process.
+
+This page is the system-level view. It explains how the pieces connect. For deep dives into individual subsystems, see the linked pages throughout.
+
+## The Problem
+
+Most AI agent systems use a single LLM session for everything -- conversation, thinking, tool execution, memory retrieval, and context management all happen in one thread. This creates fundamental bottlenecks:
+
+- **Blocking:** When the agent is running a tool or compacting context, the user waits.
+- **Context pollution:** Tool outputs, internal reasoning, and raw search results fill the context window alongside conversation.
+- **No specialization:** The same prompt and model handle tasks that have very different requirements.
+- **No concurrency:** One thing happens at a time.
+
+Spacebot's architecture is designed around one principle: **delegation is the only way work gets done.**
+
+## Process Model
+
+Five process types, each implemented as a Rig `Agent<SpacebotModel, SpacebotHook>`. They differ in system prompt, available tools, history management, and hooks.
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                        Channel                          │
+│  User-facing conversation. Has personality and soul.    │
+│  Never blocks. Delegates everything.                    │
+│                                                         │
+│  Tools: reply, branch, spawn_worker, route, cancel,     │
+│         skip, react, cron, send_file, send_message      │
+├────────────┬────────────────────────┬───────────────────┤
+│            │                        │                   │
+│     ┌──────▼──────┐         ┌──────▼──────┐            │
+│     │   Branch    │         │   Worker    │            │
+│     │             │         │             │            │
+│     │ Fork of     │         │ Independent │            │
+│     │ channel     │         │ task. No    │            │
+│     │ context.    │         │ channel     │            │
+│     │ Thinks,     │         │ context.    │            │
+│     │ recalls,    │         │ Executes.   │            │
+│     │ returns a   │         │             │            │
+│     │ conclusion. │         │ Shell, file,│            │
+│     │             │         │ exec, browse│            │
+│     │ Memory      │         │             │            │
+│     │ tools only. │         │ Fire-and-   │            │
+│     └─────────────┘         │ forget or   │            │
+│                             │ interactive.│            │
+│                             └─────────────┘            │
+├─────────────────────────────────────────────────────────┤
+│                      Compactor                          │
+│  Programmatic monitor. NOT an LLM process.              │
+│  Watches context size, triggers compaction workers.     │
+│  80% → background, 85% → aggressive, 95% → emergency   │
+├─────────────────────────────────────────────────────────┤
+│                       Cortex                            │
+│  System-level observer. Sees across all channels.       │
+│  Generates the memory bulletin — an LLM-curated         │
+│  briefing injected into every channel's prompt.         │
+└─────────────────────────────────────────────────────────┘
+```
+
+### How Delegation Works
+
+The channel never searches memories, executes shell commands, or does heavy work. When it needs to think, it creates a **branch** -- a fork of its conversation context that goes off to reason, recall memories, and return a conclusion. When it needs work done, it spawns a **worker** -- an independent process with task tools and no conversation context.
+
+The channel is always responsive. Branches and workers run concurrently in `tokio::spawn`. Multiple branches can run simultaneously (configurable limit). Multiple workers can run simultaneously. The channel continues accepting messages while they work.
+
+```
+User message arrives
+  → Channel LLM turn
+    → Decides it needs to think → spawns Branch
+    → Decides it needs code written → spawns Worker
+    → Replies to user immediately
+  → Branch finishes → result injected into channel history → channel retriggered
+  → Worker finishes → status update injected → channel retriggered
+```
+
+For detailed coverage of each process type, see [Agents](/docs/agents), [Compaction](/docs/compaction), and [Cortex](/docs/cortex).
+
+## Inter-Process Communication
+
+Each agent uses two `broadcast::channel<ProcessEvent>` buses:
+
+- `event_tx` -- control/lifecycle events shared by channel, branches, workers, compactor, and UI streams
+- `memory_event_tx` -- memory-save telemetry consumed by the cortex (`MemorySaved` events only)
+
+This split keeps high-volume memory writes off the control bus so channel control events are less likely to lag under load.
+
+### Event Types
+
+| Event | Producer | Consumer | Purpose |
+|-------|----------|----------|---------|
+| `BranchStarted` | Channel | Status block | Branch is running |
+| `BranchResult` | Branch | Channel | Conclusion ready, retrigger |
+| `WorkerStarted` | Channel | Status block | Worker is running |
+| `WorkerStatus` | Worker | Channel, Status block | Progress update via `set_status` |
+| `WorkerComplete` | Worker | Channel | Task done, retrigger |
+| `ToolStarted` | Hook | Channel, UI | Tool call in progress |
+| `ToolCompleted` | Hook | Channel, UI | Tool call finished |
+| `MemorySaved` | Branch, Cortex | Cortex | New memory telemetry for signal buffer |
+| `CompactionTriggered` | Compactor | Channel | Context compacted |
+| `StatusUpdate` | Various | UI (SSE) | Typing indicators, lifecycle |
+| `TaskUpdated` | Branch, Worker | UI | Task board change |
+| `AgentMessageSent` | Channel | Link routing | Inter-agent message |
+| `AgentMessageReceived` | Link routing | Channel | Inbound inter-agent message |
+
+### Retriggering
+
+When a branch or worker completes, the channel doesn't poll for results. The completion event **retriggers** the channel -- it runs another LLM turn with the result injected into its history. This keeps the channel reactive without polling loops.
+
+Retrigger events are debounced. If multiple branches complete within a short window, the channel batches them into a single turn. A retrigger limit (default: 3 per turn) prevents infinite cascades where a branch result triggers a new branch that triggers another retrigger.
+
+### Status Block
+
+Every turn, the channel receives a live snapshot of all active processes:
+
+```markdown
+## Currently Active
+
+### Workers
+- **[code-review]** (running, 45s) — "Reviewing changes in src/memory/store.rs"
+- **[test-runner]** (waiting for input, 2m) — "Tests passed. Awaiting further instructions."
+
+### Recently Completed
+- **[search]** completed 30s ago — "Found 3 relevant files for the query."
+```
+
+Workers set their own status via the `set_status` tool. Short branches (< 3 seconds) are invisible in the status block to avoid noise. The status block is injected into the system prompt, giving the LLM awareness of concurrent activity.
+
+## Data Layer
+
+Three embedded databases, each purpose-built. No server processes, no network connections. Everything lives in the agent's data directory.
+
+```
+~/.spacebot/agents/{agent_id}/data/
+├── spacebot.db          # SQLite — relational data
+├── lancedb/             # LanceDB — vector embeddings, full-text search
+├── config.redb          # redb — key-value settings
+├── settings.redb        # redb — runtime settings
+└── secrets.redb         # redb — secret store (categories, encryption)
+```
+
+### SQLite (via sqlx)
+
+The primary database. Stores everything that benefits from relational queries:
+
+| Table | Purpose |
+|-------|---------|
+| `memories` | Memory content, types, importance scores, timestamps |
+| `associations` | Graph edges between memories (weighted, typed) |
+| `conversation_messages` | Persistent conversation history per channel |
+| `channels` | Active channel registry with platform metadata |
+| `cron_jobs` | Scheduled task definitions |
+| `cron_executions` | Execution history for cron jobs |
+| `worker_runs` | Worker execution history with transcripts |
+| `branch_runs` | Branch execution history |
+| `cortex_events` | Cortex action log (bulletin generations, maintenance) |
+| `cortex_chat_messages` | Persistent admin chat with cortex |
+| `tasks` | Structured task board (backlog → in_progress → done) |
+| `ingestion_progress` | Chunk-level progress for file ingestion |
+| `agent_profile` | Cortex-generated personality data |
+
+Migrations are in `migrations/` and are **immutable once committed**. Schema changes always go in new migration files. See [Memory](/docs/memory) for the memory graph schema.
+
+### LanceDB
+
+Vector storage and search. Paired with SQLite on memory ID.
+
+- **Embeddings** stored in Lance columnar format with HNSW indexing
+- **Full-text search** via built-in Tantivy integration
+- **Hybrid search** combines vector similarity and keyword matching via Reciprocal Rank Fusion (RRF)
+
+The embedding model runs locally via FastEmbed -- no external API calls for embeddings. See [Memory](/docs/memory) for search details.
+
+### redb
+
+Embedded key-value stores for configuration, settings, and secrets.
+
+- **config.redb** — key-value pairs (UI preferences, feature flags)
+- **settings.redb** — runtime settings (worker_log_mode, etc.)
+- **secrets.redb** — per-agent credential storage with categories (system/tool), optional AES-256-GCM encryption at rest. See [Secret Store](/docs/secrets).
+
+Separated from SQLite so credentials can be managed and backed up independently.
+
+## Messaging Layer
+
+Spacebot connects to multiple messaging platforms simultaneously. All adapters implement the same `Messaging` trait and feed into a unified inbound message stream.
+
+```
+Discord ─┐
+Slack ───┤
+Telegram ┼──→ MessagingManager ──→ InboundMessage stream ──→ main.rs event loop
+Twitch ──┤                                                        │
+Webhook ─┤                                                        ▼
+WebChat ─┘                                              Channel.handle_message()
+                                                                  │
+                                                                  ▼
+                                                          OutboundResponse
+                                                                  │
+                                                   ┌──────────────┼──────────────┐
+                                                   ▼              ▼              ▼
+                                                Discord        Slack        Telegram
+```
+
+### Inbound Flow
+
+1. Platform adapter receives a message (Discord event, Slack webhook, Telegram update, etc.)
+2. Adapter converts to `InboundMessage` — a unified type with text, media, sender info, conversation ID, and platform metadata
+3. `MessagingManager` fans all adapters into a single `mpsc::channel`
+4. `main.rs` event loop receives the message, resolves the target agent via message bindings, and routes to the appropriate `Channel`
+5. If no `Channel` exists for this conversation ID, one is created and its event loop spawned
+
+### Outbound Flow
+
+1. Channel tools (reply, react, send_file) produce `OutboundResponse` values
+2. Each channel has an outbound routing task that receives responses via `mpsc::channel`
+3. The routing task determines the platform from the channel ID prefix (`discord:`, `slack:`, `telegram:`, etc.)
+4. `MessagingManager::broadcast()` delivers the response to the correct platform adapter
+5. Responses are also forwarded to SSE clients (WebChat, dashboard) for real-time UI updates
+
+### Message Bindings
+
+Each agent declares which messaging channels route to it:
+
+```toml
+[[agents]]
+id = "main"
+
+[[agents.bindings.discord]]
+guild_id = "1323900500600422472"
+channel_ids = ["1471388652562284626"]
+
+[[agents.bindings.telegram]]
+chat_ids = [551234, -1001234567890]
+
+[[agents.bindings.webhook]]
+endpoints = ["github-ci", "monitoring"]
+```
+
+When a message arrives, the binding resolver matches the conversation ID against all agent bindings. If no specific binding matches, the message goes to the default agent (if one is configured). See [Messaging](/docs/messaging) and the individual platform setup guides for configuration details.
+
+## LLM Integration
+
+Spacebot uses [Rig](https://github.com/0xPlaygrounds/rig) as the agentic loop framework. Every process is a Rig `Agent` with a custom `CompletionModel` implementation that routes through Spacebot's `LlmManager`.
+
+### Custom Model Layer
+
+Spacebot doesn't use Rig's built-in provider clients. Instead, `SpacebotModel` implements `CompletionModel` and delegates to `LlmManager`, which handles:
+
+- **Provider routing** — resolving model names to provider clients (Anthropic, OpenAI, Google, etc.)
+- **Process-type defaults** — different models for channels, branches, workers, compactor, cortex
+- **Task-type overrides** — specific models for coding, summarization, deep reasoning tasks
+- **Fallback chains** — automatic fallback to alternative models on failure
+
+```
+Channel LLM call
+  → SpacebotModel.completion(messages, tools)
+    → LlmManager.resolve_model("anthropic/claude-sonnet-4-20250514")
+      → Anthropic client
+        → API call with prompt caching, custom parameters
+```
+
+See [Routing](/docs/routing) for the full routing configuration.
+
+### Agent Construction
+
+```rust
+let agent = AgentBuilder::new(model.clone())
+    .preamble(&system_prompt)
+    .hook(SpacebotHook::new(process_id, process_type, event_tx.clone()))
+    .tool_server_handle(tools.clone())
+    .default_max_turns(50)
+    .build();
+```
+
+### Hooks
+
+Two hook implementations control process behavior:
+
+**`SpacebotHook`** (channels, branches, workers) — sends `ProcessEvent`s for real-time status, tracks token usage, enforces cancellation signals, implements tool nudging (prompts the LLM to use tools if it responds with text instead of tool calls in early iterations), and runs leak detection on tool outputs.
+
+**`CortexHook`** (cortex only) — lighter implementation for system observation, no tool nudging.
+
+Hooks return `Continue`, `Terminate`, or `Skip` after each LLM turn, giving the system fine-grained control over process lifecycle.
+
+For profile synthesis, cortex uses Rig structured output (`prompt_typed`) so profile fields are schema-validated instead of parsed from free-form fenced JSON.
+
+### Max Turns
+
+Rig defaults to 0 (single call). Spacebot sets explicit limits per process type:
+
+| Process | Max Turns | Rationale |
+|---------|-----------|-----------|
+| Channel | 5 | Typically 1-3 turns. Prevents runaway conversations. |
+| Branch | 10 | A few iterations to think, recall, and conclude. |
+| Worker | 50 | Many iterations for complex tasks. Segmented into 25-turn blocks. |
+| Compactor | 10 | Summarize and extract memories. Bounded. |
+| Cortex | 10 | Bulletin generation. Single-pass with tool calls. |
+
+## Control API
+
+An embedded Axum HTTP server provides the control API for the dashboard and external integrations. Default port: `19898`.
+
+### Key Endpoint Groups
+
+| Group | Prefix | Purpose |
+|-------|--------|---------|
+| Agents | `/api/agents` | CRUD for agent definitions |
+| Channels | `/api/channels` | Channel listing, history, deletion |
+| Workers | `/api/workers` | Worker status, history, timeline |
+| Cortex | `/api/cortex` | Bulletin, profile, cortex chat |
+| Memory | `/api/memories` | Memory CRUD, graph queries |
+| Config | `/api/config` | Runtime configuration read/write |
+| Providers | `/api/providers` | LLM provider key management |
+| Links | `/api/links` | Communication graph management |
+| Tasks | `/api/tasks` | Task board CRUD |
+| Cron | `/api/cron` | Scheduled task management |
+| System | `/api/system` | Health, version, metrics |
+| WebChat | `/api/webchat` | Embedded chat interface |
+| Models | `/api/models` | Available model listing |
+| Topology | `/api/topology` | Full communication graph |
+
+The dashboard UI is a React SPA embedded in the binary via `rust-embed` and served at the root path. It communicates with these API endpoints for all operations.
+
+### Real-Time Updates
+
+The API supports Server-Sent Events (SSE) for real-time streaming to connected clients. Status updates, tool call progress, worker lifecycle events, and memory changes are all pushed via SSE, giving the dashboard and WebChat live visibility into agent activity.
+
+## Startup Sequence
+
+```
+CLI (clap) → parse args
+  → Load config.toml
+  → Optionally daemonize (Unix socket for IPC)
+  → Build tokio runtime
+  → Initialize tracing + OpenTelemetry (optional)
+  → run()
+    → Start IPC server (stop/status commands)
+    → Start Axum API server
+    → Initialize shared resources:
+        LlmManager, EmbeddingModel, PromptEngine, agent links
+    → For each agent:
+        → Run SQLite migrations
+        → Initialize MemoryStore, LanceDB tables
+        → Load RuntimeConfig + identity + skills
+    → Best-effort startup warmup pass (bounded wait)
+    → Initialize MessagingManager (start all platform adapters)
+    → Initialize CronScheduler
+    → Start Cortex loops (warmup, bulletin fallback, association, ready-task)
+        → Register agent in active agents map
+    → Enter main event loop (tokio::select!)
+        → Inbound messages → route to Channel instances
+        → Agent registration/removal
+        → Provider setup events
+        → Shutdown signal → graceful shutdown
+```
+
+All long-running loops respect a shutdown signal via `broadcast::channel`. On shutdown, active workers are cancelled, channels are flushed, and database connections are closed cleanly.
+
+## Module Structure
+
+The crate uses the sibling file module pattern -- `src/memory.rs` is the module root for `src/memory/`, never `mod.rs`.
+
+```
+src/
+├── main.rs              — CLI entry, config, startup, event loop
+├── lib.rs               — module declarations, shared types
+├── config.rs            — configuration loading and validation
+├── error.rs             — top-level Error enum
+├── db.rs                — database connection bundle
+│
+├── agent/               — process implementations
+│   ├── channel.rs       — user-facing conversation
+│   ├── branch.rs        — forked thinking process
+│   ├── worker.rs        — task execution
+│   ├── compactor.rs     — context monitor
+│   ├── cortex.rs        — system observer
+│   └── status.rs        — live status snapshot
+│
+├── tools/               — 27 tool implementations (one per file)
+├── memory/              — memory graph, search, embeddings
+├── llm/                 — model routing, provider clients
+├── messaging/           — platform adapters
+├── conversation/        — history persistence, context assembly
+├── prompts/             — template engine
+├── hooks/               — PromptHook implementations
+├── cron/                — scheduled tasks
+├── api/                 — 21 Axum endpoint modules
+├── identity/            — identity file loading
+├── secrets/             — secret store, OS keystore, output scrubbing
+├── settings/            — key-value settings
+├── tasks/               — task board
+├── links/               — communication graph types
+├── skills/              — skill management
+├── opencode/            — OpenCode worker integration
+├── sandbox/             — command sandboxing
+├── telemetry/           — metrics (feature-gated)
+└── update/              — self-update checker
+```
+
+## Design Principles
+
+**Never block the channel.** The channel never waits on branches, workers, or compaction. If something takes time, it runs concurrently and retriggers the channel when done.
+
+**Raw data never reaches the channel.** Memory recall goes through a branch, which curates. The channel gets clean conclusions, not raw database rows.
+
+**Workers have no channel context.** A worker gets a task description and tools. If something needs conversation context, it's a branch, not a worker.
+
+**The compactor is not an LLM.** It's a programmatic monitor that watches a number and spawns workers. The LLM work happens in the workers it spawns.
+
+**Prompts are files.** System prompts live in `prompts/` as Jinja2 templates, not as string constants in Rust code. Identity files (SOUL.md, IDENTITY.md, USER.md, ROLE.md) are loaded from the agent's workspace directory.
+
+**Three databases, three purposes.** SQLite for relational queries, LanceDB for vector search, redb for key-value config. Each doing what it's best at.
+
+**Graceful everything.** All loops respect shutdown signals. Errors are propagated, not silenced. The only exception is `.ok()` on channel sends where the receiver may already be dropped.
diff --git a/docs/content/docs/(core)/cortex.mdx b/docs/content/docs/(core)/cortex.mdx
index e349bfc6e..3355751ae 100644
--- a/docs/content/docs/(core)/cortex.mdx
+++ b/docs/content/docs/(core)/cortex.mdx
@@ -17,7 +17,9 @@ This is what makes Spacebot feel like it actually *knows* you. Without the bulle
 
 Bulletin generation is a two-phase process: programmatic retrieval, then LLM synthesis.
 
-On a configurable interval (default: 60 minutes), the cortex:
+When warmup is enabled (default), warmup is the primary bulletin refresher on `warmup.refresh_secs` (default: 15 minutes). The bulletin loop still runs on `bulletin_interval_secs` (default: 60 minutes) as a fallback when warmup is disabled or when the cached bulletin is stale (`bulletin_age_secs >= max(1, warmup.refresh_secs)`).
+
+Each bulletin generation pass does:
 
 1. **Retrieves** memory data across eight predefined sections by querying the memory store directly (no LLM needed for retrieval):
    - Identity & Core Facts — typed search for Identity memories, sorted by importance
@@ -34,7 +36,7 @@ On a configurable interval (default: 60 minutes), the cortex:
 
 This design avoids the problem of an LLM formulating search queries without conversation context. The retrieval phase uses `SearchMode::Typed`, `SearchMode::Recent`, and `SearchMode::Important` — metadata-based modes that query SQLite directly without needing vector embeddings or search terms. The LLM only gets involved for the part it's good at: turning structured data into readable prose.
 
-The first bulletin is generated immediately on startup. Subsequent runs happen every `bulletin_interval_secs`. If a generation fails, the previous bulletin is preserved. If the memory graph is empty, an empty bulletin is stored without invoking the LLM.
+On startup, Spacebot runs a best-effort warmup pass before adapters accept traffic (bounded wait), so the first bulletin is usually already present when the first user message arrives. If generation fails, the previous bulletin is preserved. If the memory graph is empty, an empty bulletin is stored without invoking the LLM.
 
 ### What Channels See
 
@@ -138,6 +140,17 @@ The cortex is the only singleton in the system (per agent). There's one cortex p
 
 **The cortex** is an LLM-assisted process that sees across all channels. It doesn't manage context size (that's the compactor's job). It manages the memory bulletin, and will eventually handle memory coherence and system health.
 
+## Interactive Cortex Chat
+
+Spacebot also exposes a direct admin chat session with the cortex. This is intentionally self-referential and diagnostic-focused:
+
+- The system prompt includes embedded architecture context (`AGENTS.md`) and changelog highlights.
+- The prompt includes a live redacted runtime-config snapshot so behavior can be diagnosed against current resolved values.
+- `config_inspect` returns live hot-reloaded config sections on demand.
+- `spacebot_docs` reads embedded Spacebot docs/changelog/AGENTS content directly from the binary.
+
+This makes cortex chat a practical control-room interface for troubleshooting, validation, and operations — not a user-facing conversation mode.
+
 ## Configuration
 
 ```toml
@@ -151,8 +164,8 @@ bulletin_interval_secs = 3600
 # Target word count for the memory bulletin.
 bulletin_max_words = 500
 
-# Worker is considered hanging if no status update for this long.
-worker_timeout_secs = 300
+# Worker is considered hanging if no activity for this long.
+worker_timeout_secs = 600
 
 # Branch is considered stale after this duration.
 branch_timeout_secs = 60
@@ -223,7 +236,7 @@ Branch, worker, and cron dispatch paths consult a derived `ready_for_work` signa
 
 - warmup state is `warm`
 - embedding model is ready
-- bulletin age is fresh (<= `max(60s, refresh_secs * 2)`)
+- bulletin age is fresh (`<= max(60s, refresh_secs * 2)`)
 
 If dispatch arrives while not ready, Spacebot does **not** block the channel or scheduler:
 
diff --git a/docs/content/docs/(core)/meta.json b/docs/content/docs/(core)/meta.json
index 53cfc2a04..0e07391ec 100644
--- a/docs/content/docs/(core)/meta.json
+++ b/docs/content/docs/(core)/meta.json
@@ -2,6 +2,7 @@
   "title": "Core Concepts",
   "pages": [
     "philosophy",
+    "architecture",
     "agents",
     "memory",
     "routing",
diff --git a/docs/content/docs/(deployment)/roadmap.mdx b/docs/content/docs/(deployment)/roadmap.mdx
index 6711bdd2d..09673870f 100644
--- a/docs/content/docs/(deployment)/roadmap.mdx
+++ b/docs/content/docs/(deployment)/roadmap.mdx
@@ -18,7 +18,7 @@ The full message-in → LLM → response-out pipeline is wired end-to-end across
 - **Config** — hierarchical TOML with `Config`, `AgentConfig`, `ResolvedAgentConfig`, `Binding`, `MessagingConfig`. File watcher with event filtering and content hash debounce for hot-reload.
 - **Multi-agent** — per-agent database isolation, `Agent` struct bundles all dependencies
 - **Database connections** — SQLite + LanceDB + redb per-agent, migrations for all tables
-- **LLM** — `SpacebotModel` implements Rig's `CompletionModel`, routes through `LlmManager` via HTTP with retries and fallback chains across 11 providers (Anthropic, OpenAI, OpenRouter, Z.ai, Groq, Together, Fireworks, DeepSeek, xAI, Mistral, OpenCode Zen)
+- **LLM** — `SpacebotModel` implements Rig's `CompletionModel`, routes through `LlmManager` via HTTP with retries and fallback chains across 13 providers (Anthropic, OpenAI, OpenRouter, Kilo Gateway, Z.ai, Groq, Together, Fireworks, DeepSeek, xAI, Mistral, OpenCode Zen, OpenCode Go)
 - **Model routing** — `RoutingConfig` with process-type defaults, task overrides, fallback chains
 - **Memory** — full stack: types, SQLite store (CRUD + graph), LanceDB (embeddings + vector + FTS), fastembed, hybrid search (RRF fusion). `memory_type` filter wired end-to-end through SearchConfig. `total_cmp` for safe sorting.
 - **Memory maintenance** — decay + prune implemented
@@ -36,7 +36,7 @@ The full message-in → LLM → response-out pipeline is wired end-to-end across
 - **Telegram adapter** — full teloxide implementation (long polling, typing indicators, attachment extraction, chat/DM filtering, 4096 char splitting)
 - **Slack adapter** — full slack-morphism implementation (Socket Mode, thread replies, file upload v2, reactions, streaming via edit, workspace/channel/DM filtering via hot-reloadable permissions)
 - **Webhook adapter** — Axum HTTP server (POST /send, GET `/poll/{id}`, GET /health)
-- **Tools** — 16 tools implement Rig's `Tool` trait with real logic (reply, branch, spawn_worker, route, cancel, skip, react, memory_save, memory_recall, set_status, shell, file, exec, browser, cron, web_search)
+- **Tools** — 20+ tools implement Rig's `Tool` trait with real logic (including task board tools, memory tools, `spacebot_docs`, and `config_inspect` alongside reply/branch/worker/browser/shell primitives)
 - **Workspace containment** — file tool validates paths stay within workspace boundary, shell/exec tools block instance directory traversal, sensitive file access, and secret env var leakage
 - **Conversation persistence** — `ConversationLogger` with fire-and-forget SQLite writes, compaction archiving
 - **Cron** — scheduler with timers, active hours, circuit breaker (3 failures → disable), creates real channels. CronTool wired into channel tool factory.
@@ -61,7 +61,7 @@ The full message-in → LLM → response-out pipeline is wired end-to-end across
 
 ### Streaming
 
-Implement `SpacebotModel.stream()` with SSE parsing. The messaging adapters already handle `StreamStart`/`StreamChunk`/`StreamEnd` response types — this is purely the LLM layer.
+`SpacebotModel.stream()` is implemented with provider SSE parsing. Remaining work is wiring stream-native Rig loops (`stream_prompt`) into runtime paths that still use non-streaming `.prompt(...)` calls (for example, cortex chat and channel loops).
 
 ### Cortex Consolidation
 
@@ -71,9 +71,9 @@ Implement `SpacebotModel.stream()` with SSE parsing. The messaging adapters alre
 - Wire real values into `observe()` signal extraction
 - Implement CortexHook observation logic (anomaly detection, consolidation triggers)
 
-### Secrets Store
+### ~~Secrets Store~~ ✓ Shipped
 
-Encrypted credentials in redb with `DecryptedSecret` wrapper type. ChaCha20-Poly1305 AEAD with a local key file. All sensitive config values (`token`, `*_key`) encrypted at rest.
+Implemented. Per-agent credential storage in `secrets.redb` with two categories (system/tool), `secret:` config resolution, auto-migration from plaintext config, and optional AES-256-GCM encryption at rest with OS keystore integration. See [Secret Store](/docs/secrets).
 
 ### Cost Tracking
 
@@ -97,7 +97,6 @@ Per-agent token usage and cost tracking with budget enforcement. Session, daily,
 
 ### Additional Channel Adapters
 
-- **Email** — IMAP polling for inbound, SMTP for outbound. Each email thread maps to a conversation.
 - **WhatsApp** — Meta Cloud API. Hosted instances receive webhooks via the platform proxy. Self-hosted users point the callback URL at their own reverse proxy or Tailscale funnel.
 - **Matrix** — decentralized chat protocol. Bridges to self-hosted Matrix/Element deployments.
 - **iMessage** — macOS-only, AppleScript bridge. Personal use on self-hosted Mac instances.
diff --git a/docs/content/docs/(features)/browser.mdx b/docs/content/docs/(features)/browser.mdx
index 219bdde9f..4c299022f 100644
--- a/docs/content/docs/(features)/browser.mdx
+++ b/docs/content/docs/(features)/browser.mdx
@@ -42,8 +42,8 @@ Single `browser` tool with an `action` discriminator. All actions share one argu
 
 | Action | Required Args | Description |
 |--------|--------------|-------------|
-| `launch` | -- | Start Chrome. Must be called first. |
-| `close` | -- | Shut down Chrome and clean up all state. |
+| `launch` | -- | Start Chrome (or reconnect to a persistent browser). Must be called first. |
+| `close` | -- | Shut down, close tabs, or detach depending on `close_policy`. |
 
 ### Navigation
 
@@ -130,6 +130,8 @@ Browser config lives in `config.toml` under `[defaults.browser]` (or per-agent o
 enabled = true            # include browser tool in worker ToolServers
 headless = true           # run Chrome without a visible window
 evaluate_enabled = false  # allow JavaScript evaluation via the tool
+persist_session = false   # keep browser alive across worker lifetimes
+close_policy = "close_browser"  # what happens on close
 executable_path = ""      # custom Chrome binary path (auto-detected if empty)
 screenshot_dir = ""       # override screenshot storage location
 ```
@@ -143,34 +145,68 @@ id = "web-scraper"
 [agents.browser]
 evaluate_enabled = true   # this agent's workers can run JS
 headless = false          # show the browser window for debugging
+persist_session = true    # keep tabs and logins between worker runs
+close_policy = "detach"   # workers disconnect without closing tabs
 ```
 
 When `enabled = false`, the browser tool is not registered on worker ToolServers. Workers for that agent won't see it in their available tools.
 
+### Close Policy
+
+Controls what happens when a worker calls `close`:
+
+| Policy | Behavior |
+|--------|----------|
+| `close_browser` | Kill Chrome and reset all state. Default. |
+| `close_tabs` | Close all tracked tabs but keep Chrome running. |
+| `detach` | Disconnect without touching tabs or the browser process. |
+
+`close_policy` is most useful with `persist_session = true`. With `detach`, workers leave the browser exactly as they found it.
+
+## Persistent Sessions
+
+By default, each worker launches its own Chrome process. When the worker finishes, the browser dies and all session state (cookies, tabs, logins) is lost.
+
+With `persist_session = true`, all workers for an agent share a single browser instance via a `SharedBrowserHandle` held in `RuntimeConfig`. The browser and its tabs survive across worker lifetimes.
+
+When a new worker calls `launch` on a persistent browser that's already running, it reconnects to the existing process, discovers all open tabs, and can continue where the previous worker left off. Combined with `close_policy = "detach"`, workers leave the browser untouched when they finish.
+
+This is useful for:
+
+- **Login persistence** -- log in once, reuse the session across multiple worker runs.
+- **Watching the agent work** -- set `headless = false` to see a visible Chrome window that stays open.
+- **Multi-step workflows** -- a worker can leave tabs open for a follow-up worker to pick up.
+
+```toml
+[defaults.browser]
+headless = false          # visible Chrome window
+persist_session = true    # keep alive across workers
+close_policy = "detach"   # workers just disconnect
+```
+
+Changing `persist_session` requires an agent restart.
+
 ## Architecture
 
 ```
-Worker (Rig Agent)
-  │
-  ├── shell, file, exec, set_status   (standard worker tools)
-  │
-  └── browser                          (BrowserTool)
-        │
-        ├── Arc<Mutex<BrowserState>>   (shared across tool invocations)
-        │     ├── Browser              (chromiumoxide handle)
-        │     ├── pages: HashMap       (target_id → Page)
-        │     ├── active_target        (current tab)
-        │     └── element_refs         (snapshot ref → ElementRef)
-        │
-        └── Config
-              ├── headless
-              ├── evaluate_enabled
-              └── screenshot_dir
+# Default mode (persist_session = false):
+Worker A → BrowserTool { own BrowserState }  → own Chrome process
+Worker B → BrowserTool { own BrowserState }  → own Chrome process
+
+# Persistent mode (persist_session = true):
+RuntimeConfig → SharedBrowserHandle (Arc<Mutex<BrowserState>>)
+Worker A → BrowserTool { shared state } ──┐
+Worker B → BrowserTool { shared state } ──┤→ single Chrome process
+Worker C → BrowserTool { shared state } ──┘
 ```
 
-Each worker gets its own `BrowserTool` instance with its own `BrowserState`. The state is behind `Arc<Mutex<>>` because the Rig tool trait requires `Clone`. The Chrome process (and its CDP WebSocket handler task) live for the lifetime of the worker.
+In both modes, `BrowserState` holds:
+- `Browser` -- chromiumoxide handle
+- `pages: HashMap` -- target_id to Page
+- `active_target` -- current tab
+- `element_refs` -- snapshot ref to ElementRef
 
-The CDP handler runs as a background tokio task that polls the WebSocket stream. It's spawned during `launch` and dropped when the browser closes or the worker completes.
+The state is behind `Arc<Mutex<>>` because the Rig tool trait requires `Clone`. The CDP handler runs as a background tokio task that polls the WebSocket stream, spawned during `launch`.
 
 ## Implementation
 
@@ -192,5 +228,5 @@ Element resolution: refs map to CSS selectors built from `[role='...']` and `[ar
 - **No file upload/download** -- chromiumoxide doesn't expose file chooser interception. Use `shell` + `curl` for downloads.
 - **No network interception** -- request blocking and response modification aren't exposed through the tool, though chromiumoxide supports it via raw CDP commands.
 - **No cookie/storage management** -- not exposed as tool actions. Could be added if needed.
-- **Single browser per worker** -- each worker gets one Chrome process. No connection pooling across workers.
+- **Single browser per worker by default** -- with `persist_session = false` (default), each worker gets its own Chrome process. With `persist_session = true`, all workers for an agent share one browser and reconnect to existing tabs on `launch`.
 - **Selector fragility** -- the `[role][aria-label]` selector strategy works for well-structured pages but can fail on pages with missing ARIA attributes. The `content` action + `evaluate` (when enabled) serve as fallbacks.
diff --git a/docs/content/docs/(features)/cron.mdx b/docs/content/docs/(features)/cron.mdx
index 946d2e4e9..19307c4da 100644
--- a/docs/content/docs/(features)/cron.mdx
+++ b/docs/content/docs/(features)/cron.mdx
@@ -44,6 +44,7 @@ The configuration table. One row per cron job.
 CREATE TABLE cron_jobs (
     id TEXT PRIMARY KEY,
     prompt TEXT NOT NULL,
+    cron_expr TEXT,
     interval_secs INTEGER NOT NULL DEFAULT 3600,
     delivery_target TEXT NOT NULL,
     active_start_hour INTEGER,
@@ -57,6 +58,7 @@ CREATE TABLE cron_jobs (
 |--------|-------------|
 | `id` | Short unique name (e.g. "check-email", "daily-summary") |
 | `prompt` | The instruction to execute on each run |
+| `cron_expr` | Optional strict wall-clock schedule (cron expression, e.g. `0 9 * * *`) |
 | `interval_secs` | Seconds between runs (3600 = hourly, 86400 = daily) |
 | `delivery_target` | Where to send results, format `adapter:target` (e.g. `discord:123456789`) |
 | `active_start_hour` | Optional start of active window (0-23, 24h local time) |
@@ -112,6 +114,12 @@ delivery_target = "discord:123456789012345678"
 active_start_hour = 9
 active_end_hour = 10
 
+[[agents.cron]]
+id = "daily-standup"
+prompt = "Post a standup reminder."
+cron_expr = "0 9 * * 1-5"
+delivery_target = "discord:123456789012345678"
+
 [[agents.cron]]
 id = "check-inbox"
 prompt = "Check the inbox for anything that needs attention."
@@ -130,6 +138,7 @@ A user says "check my email every day at 9am" and the channel LLM calls the `cro
   "action": "create",
   "id": "check-email",
   "prompt": "Check the user's email inbox and summarize any important messages.",
+  "cron_expr": "0 9 * * *",
   "interval_secs": 86400,
   "delivery_target": "discord:123456789",
   "active_start_hour": 9,
@@ -164,7 +173,7 @@ If active hours are not set, the cron job runs at all hours.
 
 If a configured timezone is invalid, Spacebot logs a warning and falls back to server local timezone.
 
-Active hours don't affect the timer interval — the timer still ticks at `interval_secs`. When a tick lands outside the active window, it's skipped. The next tick happens at the normal interval, not "as soon as the window opens."
+For cron-expression jobs, active hours are evaluated at fire time and can further gate delivery. For legacy interval jobs, active hours don't change tick cadence — ticks outside the window are skipped.
 
 ## Circuit Breaker
 
@@ -279,7 +288,7 @@ pub struct CronContext {
 
 ## What's Not Implemented Yet
 
-- **Cron expressions** — only fixed intervals for now. A cron job that should run "at 9am daily" currently uses `interval_secs: 86400` with `active_start_hour: 9, active_end_hour: 10`. Real cron scheduling would be more precise.
+- **Cron expressions in config/tool/API are now supported** and are preferred for exact local-time schedules.
 - **Error backoff** — on failure, the next attempt happens at the normal interval. Progressive backoff (30s → 1m → 5m → 15m → 60m) would reduce cost during outages.
 - **Cross-run context** — each cron job starts with a blank history. A cron job that needs to know what it found last time would need to use memory recall.
 - **Cortex management** — the cortex should be able to observe cron job health, re-enable circuit-broken jobs, and create new cron jobs based on patterns.
diff --git a/docs/content/docs/(features)/meta.json b/docs/content/docs/(features)/meta.json
index 0c4bb20b8..a9903832a 100644
--- a/docs/content/docs/(features)/meta.json
+++ b/docs/content/docs/(features)/meta.json
@@ -1,4 +1,4 @@
 {
   "title": "Features",
-  "pages": ["workers", "opencode", "tools", "mcp", "browser", "cron", "skills", "ingestion"]
+  "pages": ["workers", "tasks", "opencode", "tools", "mcp", "browser", "cron", "skills", "ingestion"]
 }
diff --git a/docs/content/docs/(features)/tasks.mdx b/docs/content/docs/(features)/tasks.mdx
new file mode 100644
index 000000000..cf48bb645
--- /dev/null
+++ b/docs/content/docs/(features)/tasks.mdx
@@ -0,0 +1,343 @@
+---
+title: Tasks
+description: Kanban-style task board with structured tracking, cortex pickup, and worker execution.
+---
+
+# Tasks
+
+A kanban-style task board built into every agent. Tasks are spec-driven documents — the description is a full markdown spec that evolves through conversation, with pre-filled subtasks as an execution plan. Each task has a short title, rich description, status, priority, subtasks, and a numeric reference (`#42`). Each agent has its own independent task store backed by its own SQLite database.
+
+Tasks are not tickets. They're living specs written for workers who have no conversation context. A good task description includes requirements, constraints, file paths, examples, and acceptance criteria. The branch refines the spec as the user clarifies scope, and moves it to `ready` when it's complete. The cortex picks it up and spawns a worker that executes against the spec.
+
+## Creation Paths
+
+Tasks enter the system three ways:
+
+### 1. Conversational (via branch tools)
+
+The primary path. A user manages tasks through natural conversation — creating, listing, updating, approving, and closing tasks by talking to the agent. The channel delegates to a branch, and the branch uses `task_create`, `task_list`, and `task_update` tools.
+
+```
+User: "Create a task to refactor the auth module, high priority"
+  → Channel branches
+    → Branch calls task_create(
+        title: "Refactor auth module",
+        priority: "high",
+        description: "## Goal\nExtract auth logic from ...\n\n## Requirements\n- ...\n## Constraints\n- ...",
+        subtasks: ["Audit current auth endpoints", "Extract shared middleware", "Update tests", "Verify CI passes"]
+      )
+    → Branch returns: "Created task #7 with 4 subtasks"
+
+User: "Actually, we also need to migrate the session store to Redis"
+  → Channel branches
+    → Branch calls task_update(task_number: 7, description: "<updated spec with Redis section>")
+    → Branch returns: "Updated #7 — added Redis migration to the spec"
+
+User: "Looks good, run it"
+  → Channel branches
+    → Branch calls task_update(task_number: 7, status: "ready")
+    → Cortex ready-task loop picks it up → Worker executes against the spec → Done
+```
+
+Tasks created conversationally default to `backlog` status. The branch writes a rich markdown description and pre-fills subtasks as an execution plan. The user refines scope through conversation, and the branch updates the spec accordingly. When the spec is complete, moving to `ready` triggers automatic execution.
+
+### 2. Cortex promotion (from Todo memories)
+
+The cortex bridges the gap between quick captures and structured work. A cortex loop scans recent `Todo` memories, evaluates whether they're actionable, and promotes them to tasks in `pending_approval` status. The human reviews and approves before execution begins.
+
+```
+Branch saves a Todo memory during conversation
+  → Cortex evaluates the todo (promotion loop)
+    → Cortex creates a Task in "pending_approval"
+      → Human approves on the kanban board
+        → Cortex ready-task loop picks it up
+          → Worker executes → Done
+```
+
+This path is for things the agent noticed were actionable but the user didn't explicitly ask to track — the cortex catches what falls through the cracks.
+
+### 3. UI / API
+
+Tasks can be created directly from the kanban board UI or via the REST API. These default to `backlog` status with `created_by: "human"`.
+
+## Status (Kanban Columns)
+
+Five columns on the board:
+
+| Status | Description |
+|--------|-------------|
+| `pending_approval` | Created by cortex, awaiting human sign-off |
+| `backlog` | Captured but not ready for work. Default for conversational and UI-created tasks |
+| `ready` | Approved and waiting for the cortex to pick up |
+| `in_progress` | A worker is actively executing this task |
+| `done` | Completed |
+
+### Status Transitions
+
+Transitions are validated. You can't skip steps or go backwards (except to `backlog`, which is always allowed as a "re-shelve" action).
+
+```
+pending_approval → ready         (approval)
+pending_approval → backlog       (shelve)
+backlog → ready                  (manual promotion)
+ready → in_progress              (cortex pickup)
+in_progress → done               (worker success)
+in_progress → ready              (worker failure, re-queued)
+done → backlog                   (reopen)
+```
+
+Attempting an invalid transition (e.g., `pending_approval → in_progress`, `ready → done`) returns an error.
+
+## Priority
+
+Four levels, ordered by urgency:
+
+```
+critical > high > medium > low
+```
+
+Default: `medium`. The cortex ready-task loop respects priority — a critical task is picked up before a low-priority one, regardless of creation order.
+
+## Subtasks
+
+Simple checklist items stored as a JSON array. One level deep, no nesting.
+
+```json
+[
+  {"title": "Research existing API endpoints", "completed": false},
+  {"title": "Draft schema changes", "completed": true},
+  {"title": "Implement migration", "completed": false}
+]
+```
+
+Subtasks are included in the worker's prompt as an execution plan. Workers can mark subtasks complete via the `task_update` tool as they progress.
+
+## Metadata
+
+Arbitrary key-value pairs stored as a JSON object. Used for linking to external resources.
+
+```json
+{
+  "github_issue": "https://github.com/org/repo/issues/123",
+  "estimated_effort": "small",
+  "worker_type": "opencode",
+  "skill": "rust-dev",
+  "notes": "Depends on the auth refactor landing first"
+}
+```
+
+No enforced schema. The UI renders known keys with special formatting (e.g., GitHub links become clickable) and displays unknown keys as plain key-value pairs.
+
+## Task Numbering
+
+Per-agent, monotonically increasing. The next number is `MAX(task_number) + 1` within the agent's task table. Tasks are referenced as `#1`, `#42`, etc. Numbers are never reused — deleting task `#5` doesn't free up the number.
+
+## Execution
+
+### Cortex Ready-Task Loop
+
+The primary execution path. A background loop runs every `cortex.tick_interval_secs` (default 30 seconds):
+
+1. **Claim** — Atomically finds the oldest `ready` task with the highest priority and moves it to `in_progress`
+2. **Build prompt** — Renders the worker system prompt with the task title, description, and subtask checklist
+3. **Spawn worker** — Creates a new worker with full tool access (shell, file, exec, browser)
+4. **Bind** — Sets `worker_id` on the task, linking it to the executing worker
+5. **Execute** — The worker runs its loop, using subtasks as an execution plan
+6. **Complete** — On success, the task moves to `done` with `completed_at` set. On failure, the task moves back to `ready` with `worker_id` cleared, so it gets re-queued for another attempt
+
+Worker success/failure is determined by whether `worker.run()` returns `Ok` or `Err`. The cortex doesn't evaluate the quality of the work — a worker that completes without errors is considered successful.
+
+### API Execute Endpoint
+
+The `/api/agents/tasks/:number/execute` endpoint moves a task to `ready` (if it's in `backlog` or `pending_approval`), letting the cortex loop pick it up. Tasks already in `ready` or `in_progress` are returned as-is.
+
+This means execution always flows through the cortex — the API doesn't spawn workers directly.
+
+### Worker Scope
+
+Workers executing a task get a restricted version of the `task_update` tool. They can only:
+
+- Update subtasks (mark complete, replace the checklist)
+- Update metadata
+
+They cannot change the task's status, priority, title, description, or worker binding. These fields are managed by the cortex and the API. This prevents a worker from marking its own task as `done` — only the cortex does that based on whether the worker succeeded or failed.
+
+## Bulletin Integration
+
+Active tasks (non-done) are included in the cortex memory bulletin under an "Active Tasks" section. Each task is listed with its number, status, priority, title, and subtask progress:
+
+```
+### Active Tasks
+
+- #3 [in_progress] (high) Implement auth refactor [2/5]
+- #7 [ready] (medium) Update deployment docs
+- #12 [backlog] (low) Clean up unused dependencies
+```
+
+This gives every channel and branch awareness of the agent's current task board without querying the task store directly.
+
+## LLM Tools
+
+Three tools available to branches and cortex chat sessions:
+
+### task_create
+
+Creates a new task.
+
+| Argument | Type | Required | Default |
+|----------|------|----------|---------|
+| `title` | string | yes | - |
+| `description` | string | no | - |
+| `priority` | string | no | `"medium"` |
+| `subtasks` | string[] | no | `[]` |
+| `metadata` | object | no | `{}` |
+| `status` | string | no | `"backlog"` |
+
+Returns the created task number and status.
+
+### task_list
+
+Lists tasks with optional filters.
+
+| Argument | Type | Required | Default |
+|----------|------|----------|---------|
+| `status` | string | no | all |
+| `priority` | string | no | all |
+| `limit` | integer | no | 20 |
+
+### task_update
+
+Updates an existing task. Available to branches (unrestricted) and workers (restricted to subtasks and metadata only).
+
+| Argument | Type | Required | Notes |
+|----------|------|----------|-------|
+| `task_number` | integer | yes | The `#N` reference |
+| `title` | string | no | Branch only |
+| `description` | string | no | Branch only |
+| `status` | string | no | Branch only |
+| `priority` | string | no | Branch only |
+| `subtasks` | object[] | no | Full replacement |
+| `metadata` | object | no | Merged with existing |
+| `complete_subtask` | integer | no | Index to mark complete |
+
+## API Endpoints
+
+All endpoints require `agent_id` as a query parameter or in the request body.
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/api/agents/tasks` | List tasks (filterable by status, priority) |
+| `GET` | `/api/agents/tasks/:number` | Get single task by number |
+| `POST` | `/api/agents/tasks` | Create task |
+| `PUT` | `/api/agents/tasks/:number` | Update task |
+| `DELETE` | `/api/agents/tasks/:number` | Delete task |
+| `POST` | `/api/agents/tasks/:number/approve` | Approve (moves to `ready`) |
+| `POST` | `/api/agents/tasks/:number/execute` | Execute (moves to `ready` for cortex pickup) |
+
+### SSE Events
+
+Task state changes emit `task_updated` SSE events to connected clients:
+
+```json
+{
+  "type": "task_updated",
+  "agent_id": "main",
+  "task_number": 42,
+  "status": "in_progress",
+  "action": "updated"
+}
+```
+
+The `action` field is one of `"created"`, `"updated"`, or `"deleted"`. The kanban board UI uses these events for real-time updates.
+
+## Interface
+
+### Kanban Board
+
+The **Tasks** tab on the agent page renders a five-column kanban board. Each column corresponds to a task status. Task cards show:
+
+- `#N` task number and title
+- Priority badge (color-coded: red for critical, amber for high, default for medium, outline for low)
+- Subtask progress bar (if subtasks exist)
+- Worker badge (if a worker is bound)
+- Quick action buttons (Approve, Execute, Mark Done)
+- Creation timestamp and author
+
+Clicking a card opens a detail dialog with the full description, subtask checklist, metadata, timestamps, and status action buttons.
+
+### Create Task
+
+The "Create Task" button opens a dialog with fields for title, description, priority, and initial status. Tasks created from the UI default to `backlog` status and `"human"` as the creator.
+
+## Storage
+
+One SQLite table in the agent's database.
+
+```sql
+CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL,
+    task_number INTEGER NOT NULL,
+    title TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'backlog',
+    priority TEXT NOT NULL DEFAULT 'medium',
+    subtasks TEXT,                    -- JSON array
+    metadata TEXT,                    -- JSON object
+    source_memory_id TEXT,
+    worker_id TEXT,
+    created_by TEXT NOT NULL,
+    approved_at TIMESTAMP,
+    approved_by TEXT,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    completed_at TIMESTAMP,
+    UNIQUE(agent_id, task_number)
+);
+```
+
+Indexes on `agent_id`, `status`, `(agent_id, task_number)`, `source_memory_id`, and `worker_id`.
+
+## Module Layout
+
+```
+src/
+├── tasks.rs                → tasks/
+│   └── store.rs            — TaskStore: CRUD, status transitions, claim_next_ready
+│
+├── tools/
+│   ├── task_create.rs      — task_create LLM tool (branches + cortex chat)
+│   ├── task_list.rs        — task_list LLM tool (branches + cortex chat)
+│   └── task_update.rs      — task_update LLM tool (branches + workers, scoped)
+│
+├── api/
+│   └── tasks.rs            — REST endpoints (list, get, create, update, delete,
+│                             approve, execute) with SSE event emission
+│
+├── agent/
+│   └── cortex.rs           — spawn_ready_task_loop, pickup_one_ready_task,
+│                             gather_active_tasks (bulletin integration)
+│
+└── migrations/
+    └── 20260219000001_tasks.sql
+```
+
+## Prompt Integration
+
+The channel, branch, and cortex chat prompts are all task-aware:
+
+- **Channel prompt** (`channel.md.j2`) — has a dedicated "Task Board" section explaining spec-driven tasks and the kanban board. The Delegation section tells the channel to branch for task management. Active tasks appear in the Memory Context via the bulletin.
+- **Branch prompt** (`branch.md.j2`) — documents all three task tools (`task_create`, `task_list`, `task_update`) with spec-driven guidance. `task_create` emphasizes rich markdown descriptions and pre-filled subtasks. `task_update` is framed as iterative spec refinement. Moving to `ready` triggers cortex auto-pickup.
+- **Cortex chat prompt** (`cortex_chat.md.j2`) — lists task board management as a core capability with spec-driven language. The cortex chat has all three task tools.
+- **Tool descriptions** — each task tool has a description template in `prompts/en/tools/` that reinforces the spec-driven philosophy: `task_create` tells the LLM to write full markdown specs with subtask execution plans, `task_update` tells it to refine specs as scope evolves.
+
+The channel itself has no task tools — it always branches to manage tasks. This keeps the channel responsive and ensures task operations go through a thinking process.
+
+## What's Not Implemented Yet
+
+- **Cortex todo-promotion loop** — the cortex loop that scans `Todo` memories and promotes them to `pending_approval` tasks. The data model and execution path are ready; the promotion evaluation prompt and loop are not yet built.
+- **Drag-and-drop** — the kanban board has quick action buttons but no drag-and-drop between columns yet.
+- **Activity timeline** — the detail dialog doesn't show a history of status changes, approvals, and worker events.
+- **Task count badge** — the Tasks tab doesn't show a badge with the pending approval count yet.
+- **Task archival** — done tasks accumulate indefinitely. Options: auto-archive after N days, a separate `archived` status, or UI filtering (currently, done tasks are shown in the Done column).
+- **Rejection feedback** — when a human deletes a pending task, that signal isn't fed back to the cortex. Saving it as a memory would help the cortex learn what's not actionable.
diff --git a/docs/content/docs/(features)/tools.mdx b/docs/content/docs/(features)/tools.mdx
index f1def1fc5..05fa01679 100644
--- a/docs/content/docs/(features)/tools.mdx
+++ b/docs/content/docs/(features)/tools.mdx
@@ -1,6 +1,6 @@
 ---
 title: Tools
-description: All 16 tools that give LLM processes the ability to act.
+description: Tools that give LLM processes the ability to act.
 ---
 
 # Tools
@@ -11,7 +11,7 @@ How Spacebot gives LLM processes the ability to act.
 
 Every tool implements Rig's `Tool` trait and lives in `src/tools/`. Tools are organized by function, not by consumer. Which process gets which tools is configured via ToolServer factory functions in `src/tools.rs`.
 
-All 16 tools:
+Core tools include:
 
 | Tool | Purpose | Consumers |
 |------|---------|-----------|
@@ -25,6 +25,9 @@ All 16 tools:
 | `memory_save` | Write a memory to the store | Branch, Cortex, Compactor |
 | `memory_recall` | Search memories via hybrid search | Branch |
 | `channel_recall` | Retrieve transcript from another channel | Branch |
+| `spacebot_docs` | Read embedded Spacebot docs/changelog/AGENTS | Branch, Cortex Chat |
+| `email_search` | Search IMAP mailbox content directly | Branch |
+| `config_inspect` | Inspect live resolved runtime config (redacted) | Cortex Chat |
 | `set_status` | Report worker progress to the channel | Worker |
 | `shell` | Execute shell commands | Worker |
 | `file` | Read, write, and list files | Worker |
@@ -36,7 +39,7 @@ All 16 tools:
 
 Rig's `ToolServer` runs as a tokio task. You register tools on it, call `.run()` to get a `ToolServerHandle`, and pass that handle to agents. The handle is `Clone` — all clones point to the same server task.
 
-Spacebot uses four ToolServer configurations:
+Spacebot uses five ToolServer configurations:
 
 ### Channel ToolServer (per-channel)
 
@@ -70,11 +73,13 @@ Each branch gets its own isolated ToolServer, created at spawn time via `create_
 ├──────────────────────────────────────────────┤
 │   memory_save      (Arc<MemorySearch>)       │
 │   memory_recall    (Arc<MemorySearch>)       │
+│   spacebot_docs    (embedded docs)            │
 │   channel_recall   (ConversationLogger)      │
+│   email_search     (IMAP mailbox search)     │
 └──────────────────────────────────────────────┘
 ```
 
-Branch isolation ensures `memory_recall` and `channel_recall` are never visible to the channel. All tools are registered at creation and live for the lifetime of the branch.
+Branch isolation ensures `memory_recall`, `channel_recall`, `spacebot_docs`, and `email_search` are never visible to the channel. All tools are registered at creation and live for the lifetime of the branch.
 
 ### Worker ToolServer (per-worker)
 
@@ -89,10 +94,12 @@ Each worker gets its own isolated ToolServer, created at spawn time via `create_
 │   exec                                   │
 │   set_status  (agent_id, worker_id, ...) │
 │   browser     (if browser.enabled)       │
+│   web_search  (if configured)            │
+│   mcp_*       (registered at worker startup for MCP tools connected at that time) │
 └──────────────────────────────────────────┘
 ```
 
-`shell` and `exec` hold a shared `Sandbox` reference that wraps commands in OS-level containment (bubblewrap on Linux, sandbox-exec on macOS). `file` validates paths against the workspace boundary. `set_status` is bound to a specific worker's ID so status updates route to the right place in the channel's status block. `browser` is conditionally registered based on the agent's `browser.enabled` config.
+`shell` and `exec` hold a shared `Sandbox` reference that wraps commands in OS-level containment (bubblewrap on Linux, sandbox-exec on macOS). `file` validates paths against the workspace boundary. `set_status` is bound to a specific worker's ID so status updates route to the right place in the channel's status block. `browser` is conditionally registered based on the agent's `browser.enabled` config. MCP tools are fetched and registered once at worker startup for servers connected at that time.
 
 Workers don't get memory tools or channel tools. They can't talk to the user, can't recall memories, can't spawn branches. They execute their task and report status.
 
@@ -110,6 +117,24 @@ One per agent, minimal.
 
 The cortex writes consolidated memories. It doesn't need recall (it's the consolidator, not the recaller) or any channel/worker tools.
 
+### Cortex Chat ToolServer
+
+One per cortex-chat session context, full diagnostic/admin toolset.
+
+```
+┌──────────────────────────────────────────────┐
+│         Cortex Chat ToolServer              │
+├──────────────────────────────────────────────┤
+│   memory_save / memory_recall / memory_delete│
+│   channel_recall                            │
+│   task_create / task_list / task_update     │
+│   spacebot_docs / config_inspect            │
+│   shell / file / exec                       │
+│   browser     (if enabled)                  │
+│   web_search  (if configured)               │
+└──────────────────────────────────────────────┘
+```
+
 ## Factory Functions
 
 All in `src/tools.rs`:
@@ -125,18 +150,21 @@ remove_channel_tools(handle)
 // Per branch spawn — creates an isolated ToolServer with memory + channel recall tools
 create_branch_tool_server(memory_search, conversation_logger) -> ToolServerHandle
 
-// Per worker spawn — creates an isolated ToolServer (browser conditionally included)
+// Per worker spawn — creates an isolated ToolServer (browser/web_search/MCP conditionally included)
 create_worker_tool_server(agent_id, worker_id, channel_id, event_tx, browser_config, screenshot_dir) -> ToolServerHandle
 
 // Agent startup — creates the cortex ToolServer
 create_cortex_tool_server(memory_search) -> ToolServerHandle
+
+// Cortex chat startup — creates an interactive admin ToolServer
+create_cortex_chat_tool_server(...) -> ToolServerHandle
 ```
 
 ## Tool Lifecycle
 
 ### Static tools (registered at creation)
 
-`memory_save`, `memory_recall`, `channel_recall` on branch ToolServers. `shell`, `file`, `exec` on worker ToolServers. `memory_save` on cortex and compactor ToolServers. These are registered before `.run()` via the builder pattern and live for the lifetime of the ToolServer.
+`memory_save`, `memory_recall`, `channel_recall`, `spacebot_docs`, `email_search` on branch ToolServers. `shell`, `file`, `exec` on worker ToolServers. `memory_save` on cortex and compactor ToolServers. These are registered before `.run()` via the builder pattern and live for the lifetime of the ToolServer.
 
 ### Dynamic tools (added/removed at runtime)
 
@@ -153,7 +181,7 @@ create_cortex_tool_server(memory_search) -> ToolServerHandle
 
 ### Per-process tools (created and destroyed with the process)
 
-Branch and worker ToolServers are created when the process spawns and dropped when it finishes. Each branch gets `memory_save` + `memory_recall` + `channel_recall`. Each worker gets `shell`, `file`, `exec`, `set_status` (bound to that worker's ID), and optionally `browser`.
+Branch and worker ToolServers are created when the process spawns and dropped when it finishes. Each branch gets `memory_save` + `memory_recall` + `channel_recall` + `spacebot_docs` + `email_search` (plus task board tools). Each worker gets `shell`, `file`, `exec`, `set_status` (bound to that worker's ID), and optionally `browser`, `web_search`, and connected `mcp_*` tools.
 
 ## Tool Design Patterns
 
@@ -173,19 +201,17 @@ async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
 
 ### Sandbox containment
 
-Shell and exec commands run inside an OS-level sandbox (bubblewrap on Linux, sandbox-exec on macOS). The entire filesystem is mounted read-only except the workspace, `/tmp`, and any configured `writable_paths`. The agent's data directory (databases, config files) is explicitly protected. See [Configuration](/docs/config#agentssandbox) for sandbox config options.
+Shell and exec commands run inside an OS-level sandbox (bubblewrap on Linux, sandbox-exec on macOS). The entire filesystem is mounted read-only except the workspace, `/tmp`, and any configured `writable_paths`. The agent's data directory (databases, config files) is explicitly protected.
+
+Worker subprocesses also start with a clean environment -- they never inherit the parent's environment variables. System secrets (LLM API keys, messaging tokens) are never visible to workers regardless of sandbox mode. See [Sandbox](/docs/sandbox) for full details.
 
 The `file` tool independently validates paths against the workspace boundary and rejects writes to identity files (`SOUL.md`, `IDENTITY.md`, `USER.md`). The `exec` tool blocks dangerous environment variables (`LD_PRELOAD`, `DYLD_INSERT_LIBRARIES`, etc.) that enable library injection regardless of sandbox state.
 
-Leak detection (via `SpacebotHook`) scans all tool output for secret patterns (API keys, tokens, PEM keys) and terminates the process if a leak is found.
+Leak detection (via `SpacebotHook`) scans all tool output for secret patterns (API keys, tokens, PEM keys) and terminates the process if a leak is found. This includes base64-encoded, URL-encoded, and hex-encoded variants.
 
 ### Status reporting
 
-Workers report progress via `set_status`. The channel sees these in its status block. Status updates use `try_send` (non-blocking) so a slow event bus never blocks tool execution.
-
-### Fire-and-forget sends
-
-`set_status` uses `try_send` instead of `.await` on the event channel. If the channel is full, the update is dropped rather than blocking the worker.
+Workers report progress via `set_status`, and the channel sees those updates in its status block. `set_status` uses `try_send` (non-blocking), so if the event channel is full the update is dropped instead of blocking the worker.
 
 ## What Each Tool Does
 
@@ -228,6 +254,10 @@ If the name doesn't match any channel, falls back to list mode so the LLM can se
 
 Channel names are resolved from the `discord_channel_name` field stored in message metadata. The tool queries `conversation_messages` in SQLite directly — it reads persisted messages, not in-memory Rig history.
 
+### email_search
+
+Searches the configured email mailbox directly over IMAP with filters like sender (`from`), subject, text query, unread-only, and time window (`since_days`). Returns message metadata plus a body snippet for precise read-back in email workflows.
+
 ### set_status
 
 Reports the worker's current progress. The status string appears in the channel's status block so the user-facing process knows what's happening without polling.
diff --git a/docs/content/docs/(features)/workers.mdx b/docs/content/docs/(features)/workers.mdx
index 3e0a1096a..84e9d3a5c 100644
--- a/docs/content/docs/(features)/workers.mdx
+++ b/docs/content/docs/(features)/workers.mdx
@@ -55,6 +55,7 @@ Conditionally added:
 |------|-----------|
 | `browser` | When `browser.enabled = true` in agent config |
 | `web_search` | When a Brave Search API key is configured |
+| `mcp_*` | One tool per connected MCP server tool, fetched at worker start |
 
 Workers don't get memory tools, channel tools, or branch tools. They can't talk to the user, recall memories, or spawn other processes. They execute their task and report status.
 
@@ -143,7 +144,7 @@ Worker execution logs are controlled by `worker_log_mode`:
 
 Logs include: worker ID, channel ID, timestamp, state, task, error (if any), and the full message history with tool calls and results.
 
-## Sandbox and Protected Paths
+## Sandbox and Environment
 
 Worker shell and exec commands run inside an OS-level sandbox (bubblewrap on Linux, sandbox-exec on macOS). The entire host filesystem is mounted read-only except:
 
@@ -151,11 +152,13 @@ Worker shell and exec commands run inside an OS-level sandbox (bubblewrap on Lin
 - `/tmp` (private per invocation)
 - Any paths listed in `[agents.sandbox].writable_paths`
 
-The agent's data directory (databases, config files) is explicitly re-mounted read-only. This is enforced at the kernel level — no amount of command creativity can bypass it.
+The agent's data directory (databases, config files) is explicitly re-mounted read-only. This is enforced at the kernel level -- no amount of command creativity can bypass it.
 
-The `file` tool additionally validates paths against the workspace boundary and blocks writes to identity files (`SOUL.md`, `IDENTITY.md`, `USER.md`). The `exec` tool blocks dangerous environment variables (`LD_PRELOAD`, `DYLD_INSERT_LIBRARIES`, etc.) that enable library injection.
+Worker subprocesses also start with a **clean environment**. Workers only receive `PATH` (with `tools/bin` prepended), safe variables (`HOME`, `USER`, `LANG`, `TERM`, `TMPDIR`), tool-category secrets from the [secret store](/docs/secrets), and any explicitly configured `passthrough_env` entries. `HOME` is mode-dependent: workspace path when sandboxed, parent `HOME` in passthrough mode. System secrets like LLM API keys are hidden by default unless explicitly forwarded via `passthrough_env`. Environment sanitization applies regardless of whether the sandbox is enabled or disabled.
 
-Sandbox mode is configurable per agent via `[agents.sandbox]`. See [Configuration](/docs/config#agentssandbox).
+The `file` tool validates paths against the workspace boundary and rejects writes to identity/memory paths (for example `SOUL.md`, `IDENTITY.md`, `USER.md`) with an explicit error directing the LLM to the appropriate tool. The `exec` tool blocks dangerous environment variables (`LD_PRELOAD`, `DYLD_INSERT_LIBRARIES`, etc.) that enable library injection.
+
+See [Sandbox](/docs/sandbox) for full details on containment, environment sanitization, leak detection, and durable binaries.
 
 ## Configuration
 
@@ -171,10 +174,11 @@ worker = "anthropic/claude-haiku-4.5-20250514"
 coding = "anthropic/claude-sonnet-4-20250514"
 
 # Sandbox is enabled by default. Disable for self-hosted/local setups
-# that need full host filesystem access.
+# that need full host filesystem access. Env sanitization always applies.
 [agents.sandbox]
 mode = "enabled"
 writable_paths = []
+passthrough_env = []
 ```
 
 ## OpenCode Workers
diff --git a/docs/content/docs/(getting-started)/docker.mdx b/docs/content/docs/(getting-started)/docker.mdx
index 2302f5097..ece45fbae 100644
--- a/docs/content/docs/(getting-started)/docker.mdx
+++ b/docs/content/docs/(getting-started)/docker.mdx
@@ -206,11 +206,23 @@ healthcheck:
 
 Spacebot checks for new releases on startup and every hour. When a new version is available, a banner appears in the web UI.
 
+You can also open **Settings → Updates** for update status, one-click apply controls (Docker), and manual command snippets.
+
+`latest` is supported and continues to receive updates (it tracks the rolling `full` image). Use explicit version tags only when you want controlled rollouts.
+
 ### Manual Update
 
 ```bash
-docker pull ghcr.io/spacedriveapp/spacebot:slim
-docker compose up -d
+docker compose pull spacebot
+docker compose up -d --force-recreate spacebot
+```
+
+If you're not using Compose:
+
+```bash
+docker pull ghcr.io/spacedriveapp/spacebot:latest
+docker stop spacebot && docker rm spacebot
+# re-run your original docker run command with the new image tag
 ```
 
 ### One-Click Update
@@ -236,6 +248,18 @@ When the socket is mounted, the update banner shows an **Update now** button tha
 
 Without the socket mount, the banner still notifies you of new versions but you'll need to update manually.
 
+One-click updates are intended for containers running Spacebot release tags. If you're running a custom/self-built image, update by rebuilding your image and recreating the container.
+
+### Native / Source Builds
+
+If Spacebot is installed from source (`cargo install --path .` or a local release build), updates are manual:
+
+1. Pull latest source
+2. Rebuild/reinstall the binary
+3. Restart Spacebot
+
+The web UI still shows update availability, but it cannot rebuild binaries for native installs.
+
 ### Update API
 
 You can also check for and trigger updates programmatically:
diff --git a/docs/content/docs/(getting-started)/quickstart.mdx b/docs/content/docs/(getting-started)/quickstart.mdx
index 0cfb813ce..3c7c55319 100644
--- a/docs/content/docs/(getting-started)/quickstart.mdx
+++ b/docs/content/docs/(getting-started)/quickstart.mdx
@@ -30,13 +30,24 @@ docker run -d \
 
 See [Docker deployment](/docs/docker) for image variants, compose files, and configuration options.
 
+To update Docker installs, pull and recreate the container:
+
+```bash
+docker pull ghcr.io/spacedriveapp/spacebot:latest
+docker stop spacebot && docker rm spacebot
+# re-run your docker run command
+```
+
+If you mount `/var/run/docker.sock`, the web UI can apply Docker updates directly from the update banner.
+You can also manage updates from **Settings → Updates** in the web UI.
+
 ## Build from source
 
 ### Prerequisites
 
 - **Rust 1.85+** — `rustup update stable`
 - **Bun** (optional, for the web UI) — `curl -fsSL https://bun.sh/install | bash`
-- **An LLM API key** — Anthropic, OpenAI, or OpenRouter
+- **An LLM API key** — Anthropic, OpenAI, OpenRouter, Kilo Gateway, or OpenCode Go
 
 ### Install
 
@@ -77,6 +88,8 @@ Create `~/.spacebot/config.toml`:
 [llm]
 anthropic_key = "sk-ant-..."
 # or: openrouter_key = "sk-or-..."
+# or: kilo_key = "sk-..."
+# or: opencode_go_key = "..."
 # or: openai_key = "sk-..."
 # Keys also support env references: anthropic_key = "env:ANTHROPIC_API_KEY"
 
diff --git a/docs/content/docs/(messaging)/email-setup.mdx b/docs/content/docs/(messaging)/email-setup.mdx
new file mode 100644
index 000000000..1e3dc6769
--- /dev/null
+++ b/docs/content/docs/(messaging)/email-setup.mdx
@@ -0,0 +1,160 @@
+---
+title: Email Setup
+description: Connect Spacebot to an inbox with IMAP + SMTP.
+---
+
+# Email Setup
+
+Connect Spacebot to any mailbox that supports IMAP and SMTP. Inbound messages are polled over IMAP, and replies are sent over SMTP.
+
+You need:
+
+- an IMAP host, username, and password
+- an SMTP host, username, and password
+- a sender address (`from_address`) for outbound replies
+
+Most providers require an app password when MFA is enabled.
+
+## Step 1: Prepare mailbox access
+
+In your mail provider settings:
+
+1. Enable IMAP access for the mailbox.
+2. Create an app password (recommended) for IMAP/SMTP.
+3. Confirm IMAP and SMTP hosts/ports.
+
+Typical defaults are IMAP `993` (TLS) and SMTP `587` (STARTTLS).
+
+## Step 2: Add Email credentials to Spacebot
+
+<Tabs items={["Spacebot UI", "TOML Config"]}>
+<Tab value="Spacebot UI">
+
+1. Open **Settings** -> **Messaging Platforms**.
+2. Expand the **Email** card.
+3. Enter IMAP and SMTP credentials.
+4. Set **From Address** (and optional **From Name**).
+5. Click **Connect**.
+
+</Tab>
+<Tab value="TOML Config">
+
+```toml
+[messaging.email]
+enabled = true
+
+imap_host = "imap.example.com"
+imap_port = 993
+imap_username = "inbox@example.com"
+imap_password = "env:EMAIL_IMAP_PASSWORD"
+imap_use_tls = true
+
+smtp_host = "smtp.example.com"
+smtp_port = 587
+smtp_username = "inbox@example.com"
+smtp_password = "env:EMAIL_SMTP_PASSWORD"
+smtp_use_starttls = true
+
+from_address = "bot@example.com"
+from_name = "Spacebot"
+
+poll_interval_secs = 30
+folders = ["INBOX"]
+allowed_senders = []
+```
+
+Credentials support `env:VAR_NAME` references.
+
+</Tab>
+</Tabs>
+
+## Step 3: Add a binding
+
+Add an Email binding to route inbound mail to an agent.
+
+```toml
+[[bindings]]
+agent_id = "main"
+channel = "email"
+```
+
+If no Email binding exists, inbound email falls back to your default agent.
+
+## Email intake behavior
+
+Email channels are treated as intake streams, not always-on chat threads.
+
+- Spacebot triages inbound mail first.
+- Inbound email channels are reply-disabled by default (no automatic outbound email response).
+- For non-spam mail, it is encouraged to persist key memory (sender, subject, commitments, deadlines, urgency).
+- For urgent mail, it can escalate to another active channel using cross-channel messaging.
+- If you need to send an email intentionally, initiate it from another channel using cross-channel tooling.
+
+## Intentional outbound email from another channel
+
+When the Email adapter is configured, you can intentionally send email from a non-email channel (for example, Telegram or Discord) using cross-channel messaging.
+
+- explicit format: `email:alice@example.com`
+- bare address also works: `alice@example.com`
+
+This keeps email channels inbound-only while still allowing deliberate outbound send workflows.
+
+## Search mailbox content (`email_search`)
+
+Branches can use `email_search` to query IMAP directly when you ask for exact read-back details.
+
+Examples:
+
+- "Find emails from Alice about renewal in the last 14 days"
+- "Search unread emails mentioning invoice"
+- "Look for subject containing Q1 roadmap"
+
+Use specific filters (`from`, `subject`, `query`, `since_days`) to avoid broad mailbox scans.
+
+## Thread behavior
+
+Spacebot keeps one conversation per email thread. It uses `References`, `In-Reply-To`, and `Message-ID` headers to map replies back to the correct conversation.
+
+Outbound replies include the correct threading headers so responses stay in the same mail thread in clients like Gmail and Outlook.
+
+## Filtering inbound senders
+
+Use `allowed_senders` to restrict who can trigger the bot.
+
+```toml
+[messaging.email]
+allowed_senders = ["@example.com", "vip@customer.com", "partner.org"]
+```
+
+- `"@example.com"` allows the whole domain
+- `"vip@customer.com"` allows one exact sender
+- `"partner.org"` is treated as a domain rule (`@partner.org`)
+
+## Folders and polling
+
+Poll multiple folders by setting `folders`:
+
+```toml
+[messaging.email]
+folders = ["INBOX", "Support", "Escalations"]
+poll_interval_secs = 30
+```
+
+Use a longer interval if your provider rate limits IMAP polling.
+
+## Verify it's working
+
+1. Send an email to the configured mailbox from an allowed sender.
+2. Confirm a new channel appears in Spacebot with a subject-based name.
+3. Reply in the same thread and confirm the message is ingested into the same conversation thread (no automated reply by default).
+4. If direct email replies are explicitly enabled in your setup, verify outbound replies preserve threading headers.
+
+## Troubleshooting
+
+| Symptom | Likely cause | Fix |
+|---------|--------------|-----|
+| Adapter won't connect to IMAP | Wrong host/port or IMAP disabled | Recheck provider IMAP settings; verify `imap_host`, `imap_port`, TLS mode |
+| SMTP send fails | Bad SMTP credentials or blocked auth | Use provider app password; verify `smtp_host`, `smtp_port`, STARTTLS |
+| No inbound messages | Folder not polled or sender blocked | Add folder to `folders`; check `allowed_senders` rules |
+| Bot ignores automated mails | Auto-response headers detected | Expected behavior; Spacebot skips auto-generated mail loops |
+| Replies create a new thread | Missing/rewritten message headers upstream | Check provider/forwarder preserves `Message-ID`, `In-Reply-To`, `References` |
diff --git a/docs/content/docs/(messaging)/messaging.mdx b/docs/content/docs/(messaging)/messaging.mdx
index cd4764bca..2856c4dbe 100644
--- a/docs/content/docs/(messaging)/messaging.mdx
+++ b/docs/content/docs/(messaging)/messaging.mdx
@@ -1,6 +1,6 @@
 ---
 title: Messaging
-description: How Spacebot connects to Discord, Slack, Telegram, Twitch, and webhooks.
+description: How Spacebot connects to Discord, Slack, Telegram, Twitch, Email, and webhooks.
 ---
 
 # Messaging
@@ -15,8 +15,8 @@ Spacebot connects to chat platforms so your agent can talk to people where they
 | [Slack](/docs/slack-setup) | Supported | Bot token + app token via Socket Mode |
 | [Telegram](/docs/telegram-setup) | Supported | Bot token via BotFather |
 | [Twitch](/docs/twitch-setup) | Supported | OAuth token via Twitch IRC |
+| [Email](/docs/email-setup) | Supported | IMAP polling + SMTP replies |
 | Webhook | Supported | HTTP endpoint for programmatic access |
-| Email | Coming soon | IMAP/SMTP |
 | WhatsApp | Coming soon | Meta Cloud API |
 | Matrix | Coming soon | Decentralized chat protocol |
 | iMessage | Coming soon | macOS only |
@@ -25,11 +25,13 @@ Spacebot connects to chat platforms so your agent can talk to people where they
 
 1. You connect a platform by adding your tokens in the dashboard or config
 2. Spacebot opens a persistent connection to that platform
-3. When someone sends a message, Spacebot receives it, thinks, and replies
+3. When someone sends a message, Spacebot receives it and decides whether to reply, skip, or delegate work
 4. Each conversation (channel, thread, DM) gets its own isolated history
 
 You can connect multiple platforms at the same time. An agent on Discord and Slack simultaneously is just two bindings pointing at the same agent.
 
+For Email specifically, Spacebot treats inbound mail as intake-first by default: triage, memory capture for meaningful non-spam messages, and escalation to other channels for urgent items. Inbound email channels do not auto-reply. When the Email adapter is configured, intentional outbound email can still be initiated from other channels using an explicit target such as `email:alice@example.com`.
+
 ## Bindings
 
 Bindings route messages from a platform to a specific agent. A binding says "messages from this place go to this agent."
@@ -41,7 +43,8 @@ Go to **Settings** → **Bindings** tab to create and manage bindings.
 
 Each binding specifies:
 - Which **agent** handles the messages
-- Which **platform** (Discord, Slack, Telegram)
+- Which **platform** (Discord, Slack, Telegram, Twitch, Email)
+- Optionally which **adapter instance** on that platform
 - Optionally which **server/workspace/chat** to scope it to
 - Optionally which **channels** within that server
 
@@ -55,6 +58,13 @@ agent_id = "main"
 channel = "discord"
 guild_id = "123456789"
 
+# Route only the named Discord adapter instance `ops`
+[[bindings]]
+agent_id = "main"
+channel = "discord"
+adapter = "ops"
+guild_id = "987654321"
+
 # Route a Slack workspace to the main agent
 [[bindings]]
 agent_id = "main"
@@ -73,6 +83,8 @@ chat_id = "-100123456789"
 
 Without any filtering (no guild ID, workspace ID, or chat ID), a binding accepts messages from anywhere on that platform.
 
+Named adapters use `adapter = "<name>"` in bindings. Omit `adapter` to target the platform default adapter (`discord`, `slack`, `telegram`, `twitch`, `email`, `webhook`).
+
 If no binding matches an incoming message, it's routed to the default agent automatically. This means the bot responds everywhere out of the box — add bindings to restrict it to specific channels or servers.
 
 ## Multiple Agents
@@ -121,6 +133,7 @@ Each chat context maps to its own Spacebot conversation with isolated history:
 | Slack | Each channel, each thread, each DM |
 | Telegram | Each chat (group, DM, or channel) |
 | Twitch | Each channel |
+| Email | Each email thread |
 | Webhook | Each unique conversation ID in the request |
 
 Threads are first-class on Discord and Slack — a thread gets its own conversation, separate from the parent channel.
@@ -141,4 +154,4 @@ curl -X POST http://localhost:18789/webhook \
 
 ## Hot Reloading
 
-Changes to bindings and permissions (channel filters, DM allowed users) take effect within a couple seconds — no restart needed. Token changes require a restart, or you can re-save from the dashboard which reconnects automatically.
+Changes to bindings and permissions (channel filters, DM allowed users) take effect within a couple of seconds — no restart needed. Token and credential changes are applied by reconnecting the adapter.
diff --git a/docs/content/docs/(messaging)/meta.json b/docs/content/docs/(messaging)/meta.json
index 24c0c1a7b..3e5764b49 100644
--- a/docs/content/docs/(messaging)/meta.json
+++ b/docs/content/docs/(messaging)/meta.json
@@ -1,4 +1,4 @@
 {
   "title": "Messaging",
-  "pages": ["messaging", "discord-setup", "slack-setup", "telegram-setup", "twitch-setup"]
+  "pages": ["messaging", "discord-setup", "slack-setup", "telegram-setup", "twitch-setup", "email-setup"]
 }
diff --git a/docs/content/docs/(messaging)/twitch-setup.mdx b/docs/content/docs/(messaging)/twitch-setup.mdx
index 6c99c3297..26812466a 100644
--- a/docs/content/docs/(messaging)/twitch-setup.mdx
+++ b/docs/content/docs/(messaging)/twitch-setup.mdx
@@ -5,29 +5,83 @@ description: Connect Spacebot to Twitch chat.
 
 # Twitch Setup
 
-Connect Spacebot to Twitch chat. Takes about 5 minutes.
+Connect Spacebot to Twitch chat. Takes about 10 minutes.
 
-You need a **Twitch account** for the bot and an **OAuth token**.
+You need a **Twitch account** for the bot and a **Twitch application** registered at dev.twitch.tv.
 
 ## Step 1: Create a Twitch Account
 
 Create a Twitch account for your bot (or use an existing one). The bot will send messages as this account.
 
-## Step 2: Get an OAuth Token
+## Step 2: Register a Twitch Application
 
-The TwitchApps TMI token generator has been discontinued.
+1. Go to [dev.twitch.tv/console/apps](https://dev.twitch.tv/console/apps) and log in with **any** Twitch account (doesn't need to be the bot account)
+2. Click **Register Your Application**
+3. Fill in the form:
+   - **Name:** anything (e.g. "My Spacebot")
+   - **OAuth Redirect URL:** `http://localhost:3000`
+   - **Category:** Chat Bot
+4. Click **Create**
+5. Click **Manage** on your new app
+6. Copy the **Client ID**
+7. Click **New Secret** and copy the **Client Secret**
 
-For quick setup, use [Twitch Token Generator by swiftyspiffy](https://twitchtokengenerator.com/) and authorize with the bot account using `chat:read` and `chat:edit` scopes.
+<Callout type="warning">
+Keep the client secret safe. If you lose it, you can generate a new one from the app management page, but the old one is immediately invalidated.
+</Callout>
 
-The site returns an **ACCESS TOKEN**, **REFRESH TOKEN**, and **CLIENT ID**. For Spacebot, use the **ACCESS TOKEN** and prefix it with `oauth:`.
+## Step 3: Get an OAuth Token
 
-Example: if the generator shows `abc123def456`, set `oauth_token` to `oauth:abc123def456`.
+You need to authorize the bot account with `chat:read` and `chat:edit` scopes. The easiest way is the Twitch CLI, but you can also do it manually.
 
-<Callout type="warning">
-If you're building an app or service for other users, don't rely on third-party token generators. Create your own Twitch OAuth app at [dev.twitch.tv/console/apps](https://dev.twitch.tv/console/apps) and run the OAuth flow directly in your product.
-</Callout>
+<Tabs items={["Twitch CLI", "Manual (curl)"]}>
+<Tab value="Twitch CLI">
+
+Install the [Twitch CLI](https://dev.twitch.tv/docs/cli/) and configure it with your app credentials:
+
+```bash
+twitch configure
+# Enter your Client ID and Client Secret when prompted
+```
 
-## Step 3: Add Credentials to Spacebot
+Then generate a user token. This opens a browser where you log in as the **bot account**:
+
+```bash
+twitch token -u -s 'chat:read chat:edit'
+```
+
+The CLI prints the **access token** and **refresh token**. Copy both.
+
+</Tab>
+<Tab value="Manual (curl)">
+
+**1. Open this URL in a browser where you're logged in as the bot account** (replace `YOUR_CLIENT_ID`):
+
+```
+https://id.twitch.tv/oauth2/authorize?client_id=YOUR_CLIENT_ID&redirect_uri=http://localhost:3000&response_type=code&scope=chat:read+chat:edit
+```
+
+**2. Authorize the app.** You'll be redirected to `http://localhost:3000?code=AUTHORIZATION_CODE`. The page won't load — that's fine. Copy the `code` parameter from the URL.
+
+**3. Exchange the code for tokens:**
+
+```bash
+curl -X POST 'https://id.twitch.tv/oauth2/token' \
+  -d 'client_id=YOUR_CLIENT_ID' \
+  -d 'client_secret=YOUR_CLIENT_SECRET' \
+  -d 'code=AUTHORIZATION_CODE' \
+  -d 'grant_type=authorization_code' \
+  -d 'redirect_uri=http://localhost:3000'
+```
+
+The response contains `access_token` and `refresh_token`. Copy both.
+
+</Tab>
+</Tabs>
+
+## Step 4: Add Credentials to Spacebot
+
+Spacebot needs your **username**, **OAuth token**, **client ID**, **client secret**, and **refresh token**. With all five, Spacebot automatically refreshes expired tokens.
 
 <Tabs items={["Spacebot UI", "TOML Config"]}>
 <Tab value="Spacebot UI">
@@ -35,7 +89,7 @@ If you're building an app or service for other users, don't rely on third-party
 1. Open your Spacebot dashboard
 2. Go to **Settings** → **Messaging Platforms**
 3. Click **Setup** on the Twitch card
-4. Enter the bot's **username** and **OAuth token**
+4. Enter the bot's **username**, **OAuth token**, **client ID**, **client secret**, and **refresh token**
 5. Click **Save**
 
 Spacebot connects immediately — no restart needed.
@@ -48,9 +102,14 @@ Spacebot connects immediately — no restart needed.
 enabled = true
 username = "my_bot"
 oauth_token = "oauth:abc123def456..."
+client_id = "your_client_id"
+client_secret = "your_client_secret"
+refresh_token = "your_refresh_token"
 channels = ["somechannel", "anotherchannel"]
 ```
 
+Prefix the access token with `oauth:`. For example, if the token is `abc123def456`, set `oauth_token` to `oauth:abc123def456`.
+
 You can also reference environment variables:
 
 ```toml
@@ -58,6 +117,9 @@ You can also reference environment variables:
 enabled = true
 username = "env:TWITCH_BOT_USERNAME"
 oauth_token = "env:TWITCH_OAUTH_TOKEN"
+client_id = "env:TWITCH_CLIENT_ID"
+client_secret = "env:TWITCH_CLIENT_SECRET"
+refresh_token = "env:TWITCH_REFRESH_TOKEN"
 channels = ["somechannel"]
 ```
 
@@ -66,7 +128,7 @@ Token changes in config require a restart.
 </Tab>
 </Tabs>
 
-## Step 4: Join Channels
+## Step 5: Join Channels
 
 Specify which Twitch channels the bot should join. Channel names are case-insensitive and should not include the `#` prefix.
 
@@ -211,7 +273,7 @@ Each Twitch channel maps to a single conversation (`twitch:<channel_name>`). Unl
 
 | Symptom | Cause | Fix |
 |---------|-------|-----|
-| `Login authentication failed` | Invalid OAuth token | Generate a fresh token using [Twitch Token Generator](https://twitchtokengenerator.com/) or your own OAuth app |
+| `Login authentication failed` | Invalid or expired OAuth token | Re-run the token flow from Step 3. If you have `client_id`, `client_secret`, and `refresh_token` configured, Spacebot refreshes automatically — check that all three are set. |
 | Bot connects but doesn't respond | Trigger prefix set | Messages must start with the configured prefix (e.g. `!ask`) |
 | Bot responds to everything | No trigger prefix | Set `trigger_prefix` in the config to limit when the bot responds |
 | Messages getting dropped | Rate limit | Reduce response frequency or get the bot account verified |
diff --git a/docs/content/docs/index.mdx b/docs/content/docs/index.mdx
index ca5bba05e..ead345b0a 100644
--- a/docs/content/docs/index.mdx
+++ b/docs/content/docs/index.mdx
@@ -21,13 +21,13 @@ Spacebot runs as a single binary with no server dependencies. All data lives in
 
 - **SQLite** — Relational data (conversations, memory graph, cron jobs)
 - **LanceDB** — Vector embeddings and full-text search
-- **redb** — Key-value settings and encrypted secrets
+- **redb** — Key-value settings and [secret store](/docs/secrets)
 
 ## Quick Links
 
 <Cards>
   <Card title="Quickstart" href="/docs/quickstart" />
-  <Card title="Architecture" href="/docs/philosophy" />
+  <Card title="Architecture" href="/docs/architecture" />
   <Card title="Configuration" href="/docs/config" />
   <Card title="Memory System" href="/docs/memory" />
 </Cards>
diff --git a/docs/design-docs/autonomy-loop.md b/docs/design-docs/autonomy-loop.md
new file mode 100644
index 000000000..e9eb0e2fe
--- /dev/null
+++ b/docs/design-docs/autonomy-loop.md
@@ -0,0 +1,474 @@
+# Autonomy Loop
+
+Today Spacebot is reactive. It responds to messages, executes cron jobs from scratch, and runs four hardcoded cortex loops (warmup, bulletin, association, ready-task pickup). It has no mechanism for proactive, self-directed cognition — the kind where the agent works overnight tracking issues, processing emails, monitoring repos, and surfaces curated intelligence when you ask for it in the morning.
+
+The [custom cortex loops](./custom-cortex-loops.md) design proposed solving this with user-created, per-topic cortex processes. This doc supersedes that approach. The core objection: the cortex should be something the user never thinks about. It is the system's internal monologue, not a user-configurable surface. Exposing "cortex loops" as a concept — with a creation tool, dashboard tab, and per-loop settings — turns internal cognition into just a fancier cron job.
+
+This doc proposes two changes instead:
+
+1. **The autonomy loop** — a single new built-in cortex process that gives the agent general proactive behavior, driven by its identity and role rather than user-enumerated monitoring tasks.
+2. **Stateful cron jobs** — adding optional memory continuity to the existing cron system so scheduled jobs can accumulate knowledge across runs.
+
+Together these cover the same use cases as custom cortex loops with far less conceptual overhead. The user tells the agent what it is (identity files) and what it should do on a schedule (cron jobs). The system figures out the rest.
+
+## The Problem
+
+When a user tells their agent "keep tabs on the Spacedrive issues" or "give me a morning briefing every day at 9am," there's no good mechanism for this today:
+
+1. **Cron jobs** spin up a fresh channel each time. No cross-run context. No accumulated knowledge. The cron fires, the agent sees the prompt cold, does its thing, delivers the result. Each run is isolated — the agent doesn't build on what it learned last time.
+
+2. **The existing cortex loops** are hardcoded system functions (bulletin, associations, task pickup). They don't support user-directed proactive work.
+
+3. **The ready-task pickup loop** provides autonomous execution, but only for tasks that were explicitly created by a human conversation. The agent never generates its own work.
+
+The gap: there's no way for the agent to think on its own about the things it's been told to care about.
+
+## The Autonomy Loop
+
+A new fifth built-in cortex loop, alongside warmup, bulletin, association, and ready-task pickup. One per agent. Not user-created — it's part of the system, like the bulletin.
+
+### What It Does
+
+Each cycle, the autonomy loop wakes up as a branch with memory tools and worker-spawning capability. It receives the agent's full identity context (soul, role) and the current memory bulletin. It recalls its own previous findings. Then it decides what to do — what to check on, what to investigate, what to follow up on — based on what it knows about its role, its recent history, and the tools available to it.
+
+The key insight: the agent's identity files already define what it should care about. A ROLE.md that says "You manage the Spacedrive project" implies the agent should be tracking Spacedrive issues, PRs, and CI. A SOUL.md that says "You are Jamie's engineering assistant" implies it should be aware of Jamie's email, calendar, and active projects. The autonomy loop operationalizes the identity — it's the system asking itself "given who I am and what I know, what should I be doing right now?"
+
+### What It Doesn't Do
+
+- It doesn't deliver results to the user. It saves memories and creates tasks. The bulletin and cron jobs handle delivery.
+- It doesn't have its own personality or conversation context. It's a cortex process — internal cognition.
+- It doesn't replace cron jobs. Cron jobs are "do X at time Y and tell the user." The autonomy loop is "think about what I should be aware of."
+- It doesn't require user configuration beyond identity files. The agent figures out what to monitor.
+
+### Execution Model
+
+The autonomy loop runs on a configurable interval (default: 30 minutes). Each cycle:
+
+```
+1. CONTEXT ASSEMBLY
+   ├─ Load identity context (soul.md, role.md, identity.md, user.md)
+   ├─ Load current memory bulletin
+   ├─ Load active tasks from the task board
+   └─ Load recent cortex event log (what happened since last cycle)
+
+2. RECALL PHASE
+   ├─ Recall memories with source "cortex:autonomy" (previous cycle findings)
+   ├─ Recall recent high-importance memories (what's changed in the world)
+   └─ Build a context summary of current state + recent changes
+
+3. EXECUTION PHASE (branch with worker-spawning capability)
+   ├─ System prompt: autonomy_loop.md.j2
+   ├─ Identity context + bulletin + recalled context injected
+   ├─ Branch decides what to investigate this cycle:
+   │   ├─ Check integrations relevant to its role (GitHub, email, etc.)
+   │   ├─ Follow up on unresolved items from previous cycles
+   │   ├─ Evaluate task board for stale or blocked items
+   │   └─ Look for patterns or emerging issues across recent activity
+   ├─ Spawns workers for actual work (API calls, shell commands)
+   ├─ Saves findings as memories (source: "cortex:autonomy")
+   ├─ Creates tasks for actionable items (status: pending_approval or backlog)
+   └─ Max turns from config (default: 15)
+
+4. SAVE PHASE
+   ├─ Force-save a cycle summary memory (source: "cortex:autonomy")
+   │   covering: what was checked, what was found, what was deferred
+   ├─ Log execution to cortex_events
+   └─ Update last_executed_at
+```
+
+### Why One Loop, Not Many
+
+The custom cortex loops design had separate loops for each concern ("track-spacedrive-issues", "monitor-email", "weekly-project-review"). The autonomy loop is a single process that handles all proactive concerns. The trade-offs:
+
+**What you lose:**
+- Per-topic interval control ("check issues every 5 min, email every hour")
+- Per-topic circuit breakers and failure isolation
+- Clear separation of concerns in execution logs
+
+**What you gain:**
+- The agent prioritizes dynamically. If there's a CI failure, it focuses on that instead of dutifully running all N loops regardless of urgency.
+- No user-facing complexity. No "cortex loop" concept to explain, no creation tool, no dashboard tab.
+- Natural cross-concern reasoning. The agent can connect "Alice emailed about the contract" with "there's a PR pending review from Alice" in a single thought process, rather than having two separate loops that don't talk to each other.
+- Bounded resource consumption. One branch + N workers per cycle, not N branches each spawning their own workers.
+- The agent gets better over time. As it accumulates memories about what's relevant, it naturally spends more cycles on what matters and less on what doesn't.
+
+**The prioritization concern is key.** With separate loops, each topic gets equal treatment regardless of urgency. With a single autonomy loop, the agent can look at everything it knows and decide "the CI failure is the most important thing right now, I'll check email later." This is closer to how human awareness actually works.
+
+### Source-Tagged Memory Accumulation
+
+The autonomy loop uses the source tag `cortex:autonomy` on all memories it creates. This requires making source tags functional in the memory system — today they're stored but never filtered on.
+
+**Required changes to the memory system:**
+
+1. Add `source: Option<String>` to `SearchConfig`
+2. Add a `WHERE source = ?` clause to `MemoryStore::get_sorted()` when source is set
+3. Add source post-filtering in `MemorySearch::hybrid_search()` (alongside the existing `memory_type` filter)
+4. Add a `source` parameter to `MemoryRecallArgs` in the recall tool
+5. Add a SQLite index on the `source` column: `CREATE INDEX idx_memories_source ON memories(source)`
+6. Expose `source` in the API query structs (`MemoriesListQuery`, `MemoriesSearchQuery`)
+
+The autonomy loop's recall phase uses source filtering to pull memories from previous cycles. But the memories also surface naturally through semantic recall — when a user asks "what's going on with Spacedrive issues?", autonomy loop memories about Spacedrive surface by relevance alongside memories from conversations.
+
+### Interaction with Existing Systems
+
+**Bulletin.** No changes needed. The bulletin already queries memories across all sources. Autonomy loop memories appear in the "Recent Memories," "Observations," "Events," and other bulletin sections based on type and recency. The bulletin is how the agent's autonomous findings reach every conversation.
+
+**Ready-task pickup.** The autonomy loop creates tasks. The ready-task loop executes them. This is the natural flow: **autonomy loop monitors and discovers → creates task → task system executes**. Tasks created by the autonomy loop should default to `pending_approval` unless the agent's config allows auto-approval for autonomy-generated tasks.
+
+**Cron jobs.** The autonomy loop builds awareness. Cron jobs deliver it on schedule. A morning briefing cron fires, branches to recall, and autonomy loop memories surface. No direct integration needed — the memory system bridges them.
+
+**Email adapter.** Email channels already handle immediate triage (save memories about important emails, skip spam). The autonomy loop synthesizes across email memories: "5 emails today, 1 urgent from Alice about a contract deadline." The channel handles triage; the autonomy loop handles synthesis.
+
+**Association loop.** Continues to run independently. Autonomy loop memories get the same auto-association treatment as all other memories.
+
+### Configuration
+
+Add to `CortexConfig`:
+
+```rust
+pub struct CortexConfig {
+    // ... existing fields ...
+
+    /// Whether the autonomy loop is enabled. Default: true.
+    pub autonomy_enabled: bool,
+    /// Interval between autonomy loop cycles in seconds. Default: 1800 (30 min).
+    /// Minimum: 300 (5 min).
+    pub autonomy_interval_secs: u64,
+    /// Max LLM turns per autonomy cycle. Default: 15.
+    pub autonomy_max_turns: usize,
+    /// Max concurrent workers the autonomy loop can spawn per cycle. Default: 3.
+    pub autonomy_max_workers: usize,
+    /// Whether autonomy-created tasks require approval. Default: true.
+    pub autonomy_tasks_require_approval: bool,
+}
+```
+
+These are system settings, not user-facing configuration. They're tunable in `config.toml` or via the API but don't require a dedicated UI.
+
+### System Prompt
+
+New template: `prompts/en/autonomy_loop.md.j2`
+
+```jinja
+You are the autonomy process for {{ agent_name }}. You are the agent's proactive awareness — the part that thinks about what's going on without being asked.
+
+This is not a conversation. There is no user present. You are background cognition, waking up periodically to stay informed, identify emerging issues, and prepare knowledge that will be useful when the user next interacts.
+
+{% if identity_context %}
+{{ identity_context }}
+{% endif %}
+
+{% if memory_bulletin %}
+## Current Awareness
+{{ memory_bulletin }}
+{% endif %}
+
+## Previous Cycle Findings
+{{ recalled_context }}
+
+## Active Tasks
+{{ active_tasks }}
+
+## Recent Activity
+{{ recent_events }}
+
+## Instructions
+
+Based on your identity, role, and current awareness:
+
+1. **Assess the current state.** What do you know? What has changed since your last cycle? What are the most important things happening right now?
+
+2. **Decide what to investigate.** You have access to workers that can execute shell commands, check APIs, read files, browse the web. What would be most valuable to check right now? Prioritize by urgency and relevance to your role.
+
+3. **Do the work.** Spawn workers to gather information. Review what they find. Connect it to what you already know.
+
+4. **Save what you learn.** Every finding, observation, status change, or emerging pattern should be saved as a memory. Use appropriate memory types:
+   - **event** — something that happened (CI failed, PR merged, email received)
+   - **observation** — a pattern or trend you notice (build times increasing, certain contributor very active)
+   - **fact** — a concrete piece of information (current issue count, deployment status)
+   - **decision** — something you decided or concluded (this issue is urgent, this can wait)
+
+5. **Create tasks for actionable items.** If you discover something that needs human attention or automated action, create a task on the board. Be specific about what needs to happen and why.
+
+6. **Decide what to defer.** You can't check everything every cycle. Note what you're deferring and why, so you can pick it up next time.
+
+Tag all memories with source "cortex:autonomy". Be efficient with your turn budget — spawn workers for the actual work, use your turns for reasoning and synthesis.
+```
+
+### Implementation
+
+The autonomy loop is implemented as `spawn_autonomy_loop` alongside the existing four cortex loops. It follows the same pattern: a `tokio::spawn` that runs for the lifetime of the process.
+
+```
+spawn_autonomy_loop(deps, logger)
+  └─ loop:
+       1. Sleep for autonomy_interval_secs
+       2. Check autonomy_enabled (hot-reload via ArcSwap)
+       3. Acquire execution lock (prevent overlap)
+       4. Assemble context:
+          a. Load identity (from RuntimeConfig)
+          b. Load bulletin (from RuntimeConfig)
+          c. Load active tasks (from TaskStore)
+          d. Query recent cortex events
+          e. Recall memories with source "cortex:autonomy" (latest N)
+       5. Create a branch:
+          - System prompt: autonomy_loop.md.j2 with assembled context
+          - Tools: memory_save, memory_recall, spawn_worker, task_create, task_list
+          - Max turns: autonomy_max_turns
+          - Worker limit: autonomy_max_workers
+       6. Run the branch
+       7. Force-save cycle summary memory (source: "cortex:autonomy")
+       8. Log to cortex_events
+       9. Circuit breaker: disable after N consecutive failures
+```
+
+The branch creation reuses the existing `Branch` infrastructure. The only new code is the runner function, the prompt template, and the context assembly.
+
+## Stateful Cron Jobs
+
+The second half of the design. Today, cron jobs are stateless — each run spins up a fresh channel with no memory of previous runs. This is fine for simple reminders ("remind me at 9am") but insufficient for recurring analytical tasks ("give me a morning briefing of what changed overnight").
+
+### The Change
+
+Add an optional `source_tag` field to `CronConfig`. When set, the cron job's channel automatically:
+
+1. **Recalls memories** tagged with this source before executing the prompt
+2. **Saves relevant findings** tagged with this source after execution
+3. **Accumulates knowledge** across runs — each execution builds on the previous
+
+```rust
+pub struct CronConfig {
+    // ... existing fields ...
+
+    /// Optional source tag for memory continuity across runs.
+    /// When set, the cron channel recalls memories with this source
+    /// before execution and saves findings with this source after.
+    /// Format: "cron:{id}" (auto-set from job ID if enabled).
+    pub stateful: bool,  // default: false
+}
+```
+
+When `stateful` is true, the source tag is automatically derived as `cron:{id}` (e.g., `cron:morning-briefing`). No user-specified tags — keep it simple.
+
+### How It Works
+
+When a stateful cron job fires, the existing `run_cron_job` flow is modified:
+
+```
+1. Create fresh channel (same as today)
+2. NEW: If stateful, inject a recall preamble:
+   "You are running a recurring scheduled task. Here is context
+    from previous executions:"
+   + recalled memories filtered by source "cron:{id}"
+3. Send the cron prompt as a synthetic message (same as today)
+4. Collect responses and deliver (same as today)
+5. NEW: If stateful, spawn a brief memory-persistence branch
+   that saves relevant findings with source "cron:{id}"
+```
+
+The recall happens before the prompt, injected as part of the system context. The save happens after delivery, as a fire-and-forget branch (same pattern as the existing `memory_persistence` branches that run after conversations). The cron job itself doesn't need to know about memory mechanics — it's handled by the runtime.
+
+### Cron Tool Update
+
+The `CronTool` gains a `stateful` parameter on the `create` action:
+
+```
+Arguments (create):
+  id: String (required)
+  prompt: String (required)
+  interval_secs: u64 (optional, default 3600)
+  delivery_target: String (required)
+  active_hours: String (optional)
+  run_once: bool (optional, default false)
+  stateful: bool (optional, default false)    // NEW
+```
+
+The LLM decides whether a cron job should be stateful based on the user's request:
+
+- "Remind me at 9am to check email" → stateful: false (one-shot reminder)
+- "Give me a morning briefing every day" → stateful: true (needs to accumulate overnight context)
+- "Check the build status every hour and ping me if it fails" → stateful: true (needs to know previous state to detect changes)
+
+### Migration
+
+```sql
+ALTER TABLE cron_jobs ADD COLUMN stateful INTEGER NOT NULL DEFAULT 0;
+```
+
+### What This Replaces
+
+In the custom cortex loops design, the suggested approach for a "morning briefing" was:
+
+1. Create cortex loop `track-spacebot-repo` (monitors repo every 30 min)
+2. Create cortex loop `monitor-email` (monitors email every 15 min)
+3. Create cron job `morning-briefing` (delivers at 9am, recalls loop memories)
+
+With the autonomy loop + stateful cron approach:
+
+1. The autonomy loop already monitors things relevant to the agent's role (repo, email, etc.) — no user action needed
+2. Create stateful cron job `morning-briefing` (delivers at 9am, recalls previous briefing memories + autonomy loop memories surface naturally via the bulletin)
+
+The user creates one thing (the cron job) instead of three. The system handles the rest.
+
+## How It All Fits Together
+
+```
+Identity files (SOUL.md, ROLE.md, etc.)
+  │
+  │ define what the agent cares about
+  ▼
+Autonomy Loop (runs every 30 min)
+  │ proactively monitors relevant integrations
+  │ saves findings as memories (source: "cortex:autonomy")
+  │ creates tasks for actionable items
+  │
+  ├──► Memory system ◄── Email channels (triage incoming mail)
+  │         │              Conversations (save user context)
+  │         │              Compactor (extract from history)
+  │         │
+  │         ▼
+  │    Bulletin (synthesizes all memories hourly)
+  │         │
+  │         ▼
+  │    Every channel reads the bulletin
+  │         │
+  │         ▼
+  │    User conversations have ambient awareness
+  │
+  ├──► Task board
+  │         │
+  │         ▼
+  │    Ready-task pickup loop (executes autonomy-created tasks)
+  │
+  └──► Stateful cron jobs
+          │ recall previous run memories + autonomy memories surface via bulletin
+          │ deliver accumulated knowledge on schedule
+          ▼
+       User gets a morning briefing with overnight findings
+```
+
+## Example Scenarios
+
+### Scenario 1: Overnight Monitoring + Morning Briefing
+
+**Setup:**
+- ROLE.md says: "You are the engineering assistant for the Spacebot project. You monitor the spacebot repo, track CI status, and keep the team informed."
+- User creates a stateful cron job: "Every morning at 9am, give me a briefing of what happened overnight"
+
+**Overnight:**
+- Autonomy loop runs every 30 min:
+  - Cycle 1: Recalls no previous findings (first run). Reads role.md — should monitor spacebot repo. Spawns worker to check GitHub. Finds 2 new issues, 1 merged PR. Saves as memories.
+  - Cycle 2: Recalls cycle 1 findings. Spawns worker to check CI — main build passing. Checks issues again — 1 new comment on issue #423. Saves findings.
+  - Cycle 3: Recalls cycles 1-2. CI still passing. No new issues. Defers to next cycle.
+  - Cycle 4: Recalls previous cycles. New email from Alice about contract renewal (surfaced via email channel memories in bulletin). Notes this is important. Saves observation: "Alice's contract renewal needs attention by Friday."
+
+**9am:**
+- Morning briefing cron fires (stateful)
+- Recalls its own previous briefing memories (context from last briefing)
+- Bulletin has been refreshed with autonomy loop findings
+- Channel branches to recall — autonomy memories surface by relevance
+- Delivers: "Good morning. Overnight: 2 new issues on spacebot (#423 memory leak, #424 docs update), PR #420 merged (email adapter). CI is green. Alice emailed about her contract renewal — deadline is Friday."
+
+### Scenario 2: Proactive Task Creation
+
+**Setup:**
+- Agent has been told it's responsible for CI health
+
+**Autonomy cycle:**
+- Recalls previous findings: CI was passing last cycle
+- Spawns worker to check GitHub Actions — build failing for 2 hours
+- Saves event memory: "CI failure on main: test_memory_search failing since commit abc123"
+- Creates task: "Investigate CI failure: test_memory_search on main" (status: pending_approval, priority: high)
+- Saves observation: "CI has been unstable this week — 3 failures in 5 days"
+
+**Next bulletin refresh:**
+- Bulletin picks up the CI failure event and the instability observation
+- Every channel now has ambient awareness of the CI problem
+
+**User opens chat:**
+- Agent's channel prompt includes the bulletin with CI failure info
+- User asks "what's going on?" — agent already knows, no recall needed
+
+### Scenario 3: Email Synthesis
+
+**Ongoing:**
+- Email channels process incoming mail (already implemented on `feat/email-adapter`)
+- Each email is triaged: save memories for important ones, skip spam
+- Email memories accumulate: sender, subject, urgency, key content
+
+**Autonomy cycle:**
+- Recalls recent email-related memories (they surface by relevance alongside cortex:autonomy memories)
+- Synthesizes: "5 emails today. 1 urgent from Alice (contract renewal, Friday deadline). 2 newsletters (skipped). 1 from Bob about the API redesign meeting next Tuesday. 1 GitHub notification (PR review requested)."
+- Saves consolidated observation
+
+**User asks "any important emails?":**
+- Branch recalls autonomy observations about email
+- Can also use `email_search` tool to read specific emails on demand
+- Delivers curated summary without the user needing to check their inbox
+
+## Phases
+
+### Phase 1: Source Filter Infrastructure
+
+- Add `source: Option<String>` to `SearchConfig`
+- Add source filtering to `MemoryStore::get_sorted()` SQL queries
+- Add source post-filtering in `MemorySearch::hybrid_search()`
+- Add `source` parameter to `MemoryRecallArgs` and the API query structs
+- Add SQLite index on `memories.source`
+- This is prerequisite for both the autonomy loop and stateful cron
+
+### Phase 2: Autonomy Loop
+
+- `spawn_autonomy_loop` function in `cortex.rs`
+- `autonomy_loop.md.j2` system prompt template
+- Context assembly: identity + bulletin + tasks + recent events + recalled memories
+- Branch creation with memory tools + worker spawning + task tools
+- Forced cycle summary save (source: "cortex:autonomy")
+- Execution logging to `cortex_events`
+- Circuit breaker (disable after N consecutive failures)
+- `CortexConfig` extensions (autonomy_enabled, autonomy_interval_secs, etc.)
+- Wire into `main.rs` alongside existing cortex loops
+
+### Phase 3: Stateful Cron Jobs
+
+- Add `stateful` column to `cron_jobs` table (migration)
+- Add `stateful` field to `CronConfig` and `CronJob`
+- Modify `run_cron_job` to inject recalled memories when stateful
+- Add post-execution memory persistence branch for stateful crons
+- Update `CronTool` to accept `stateful` parameter on create
+- Update cron tool description prompt to explain when to use stateful
+
+### Phase 4: Polish
+
+- Bulletin section showing autonomy loop status and recent findings
+- SSE events for autonomy cycle state changes
+- Smart model routing — use cheaper model for recall/save phases
+- Concurrency limiting for autonomy-spawned workers
+- Dashboard visibility: autonomy loop status in the cortex section (read-only, not configurable)
+
+### Phase Ordering
+
+```
+Phase 1 (source filters)  — standalone, unblocks 2 and 3
+Phase 2 (autonomy loop)   — depends on Phase 1
+Phase 3 (stateful cron)   — depends on Phase 1, independent of Phase 2
+Phase 4 (polish)           — depends on Phases 2 + 3
+```
+
+Phases 2 and 3 can run in parallel after Phase 1.
+
+## Open Questions
+
+**Autonomy loop prioritization.** How does the autonomy loop decide what to check each cycle? The prompt instructs it to prioritize by urgency and role relevance, but in practice the LLM might fall into a rut (always checking the same things). Options: (a) trust the LLM and let memory accumulation guide it naturally, (b) inject a "what haven't you checked recently?" nudge using the cycle summary from the previous run, (c) rotate through a checklist derived from the role. Starting with (a) + (b) seems right — the cycle summary already captures what was deferred.
+
+**Autonomy loop depth vs. breadth.** Should the loop try to check everything each cycle (broad, shallow) or focus on one area per cycle (narrow, deep)? The prompt says "decide what to investigate" — leaving it to the LLM. A 30-minute interval with 15 max turns is enough for 2-3 worker spawns with reasoning around them. If the loop is too shallow, increase max_turns or decrease interval. This is a tuning problem, not an architectural one.
+
+**Task approval for autonomy-generated tasks.** The design defaults to `pending_approval` for tasks created by the autonomy loop. This prevents the agent from auto-executing potentially expensive or destructive work. But it means someone has to approve tasks — which defeats the purpose of autonomous operation for trusted agents. The `autonomy_tasks_require_approval` config flag allows disabling this per-agent. High-trust deployments (personal assistants) might auto-approve; team deployments might require approval.
+
+**Stateful cron recall budget.** How many memories should a stateful cron recall from previous runs? Too few and it loses continuity; too many and the channel's context fills up before the prompt even runs. A default of 10-15 most recent memories from `cron:{id}` is probably right, with a configurable cap.
+
+**Autonomy loop and multi-agent.** In a multi-agent setup, each agent has its own autonomy loop. Should they coordinate? The multi-agent communication system (send_agent_message) handles cross-agent messaging, but the autonomy loops run independently. If two agents both monitor the same repo, they'll duplicate work. This is acceptable for now — the memory system is per-agent, and each agent needs its own awareness. Cross-agent deduplication is a future concern.
+
+**Warmup gating.** The autonomy loop should respect the same `WorkReadiness` gates as branches and workers. It should not run until the warmup state is `Warm` and the first bulletin has been generated. This ensures it has a bulletin to reference on its first cycle.
+
+**Cycle budget allocation.** With 15 max turns per cycle: how many should go to reasoning vs. worker spawns? Workers run asynchronously — the branch spawns them and they report back. If the branch spawns 3 workers at turn 2 and they all complete by turn 5, it has 10 turns to reason about results and save memories. If workers are slow, the branch might hit its turn limit before results arrive. The branch-worker interaction pattern in the existing codebase handles this (branches wait for workers or move on), but the autonomy loop prompt should instruct the LLM to spawn workers early in the turn budget.
diff --git a/docs/design-docs/cortex-chat.md b/docs/design-docs/cortex-chat.md
index d44ae83f6..814bc7411 100644
--- a/docs/design-docs/cortex-chat.md
+++ b/docs/design-docs/cortex-chat.md
@@ -4,13 +4,14 @@ A global admin chat panel that provides a direct interactive line to the cortex.
 
 ## Concept
 
-The cortex chat is not a branch of a channel — it's a persistent, agent-scoped conversation with the cortex in interactive mode. It has the full toolset (memory, shell, file, exec, browser, web search, spawn worker) and streams responses via SSE with text deltas and tool activity.
+The cortex chat is not a branch of a channel — it's a persistent, agent-scoped conversation with the cortex in interactive mode. It has the full toolset (memory, shell, file, exec, browser, web search, spawn worker) and uses SSE for response delivery and tool activity events.
 
 Key properties:
 - **One conversation per agent** — same thread regardless of which channel page you're viewing
 - **Channel context is ephemeral** — injected into the system prompt, not the chat history. Switching channels changes the context for the next message
 - **Persistent history** — stored in SQLite, survives refresh and navigation
-- **Full text streaming** — character-by-character response streaming via SSE
+- **Current behavior** — SSE emits tool activity and a final `done` message with full response text
+- **Target behavior** — character-by-character text delta streaming via SSE
 - **Full tool access** — everything except reply/react/skip (those are channel-only platform tools)
 
 ## Data Model
@@ -31,7 +32,7 @@ CREATE TABLE cortex_chat_messages (
 
 ## Phase 1: LLM Streaming Infrastructure
 
-`SpacebotModel::stream()` is currently stubbed. Streaming is required for the cortex chat UX and is reusable across the system (channel platform streaming, future features).
+`SpacebotModel::stream()` was stubbed when this design was drafted; the LLM streaming layer now exists. Remaining work is adopting stream-native Rig loops in cortex chat (`stream_prompt`) so SSE can emit text deltas instead of only final responses.
 
 ### 1a. Anthropic SSE Streaming
 
@@ -81,8 +82,8 @@ Core struct holding: agent deps, tool server, store.
 1. Load cortex chat history from DB
 2. If `channel_context_id` is provided, fetch the last 50 messages from that channel
 3. Render `cortex_chat.md.j2` with: identity context, memory bulletin, channel transcript (if any), worker capabilities
-4. Build Rig Agent with streaming: `agent.stream_prompt(user_text).with_history(&mut history).multi_turn(50)`
-5. Consume the stream, forwarding events as `CortexChatEvent` variants
+4. Current implementation: `agent.prompt(user_text).with_history(&mut history)` with SSE tool events + final response
+5. Target implementation: `agent.stream_prompt(user_text).with_history(...).multi_turn(50)` with text-delta forwarding
 6. Save both user message and assistant response to DB
 
 ### 2d. Tool Server Factory
@@ -112,10 +113,11 @@ Add to `ApiState` in `src/api/state.rs`:
 | Method | Path | Description |
 |--------|------|-------------|
 | `GET` | `/api/cortex-chat/messages?agent_id=...&limit=50` | Load persisted history |
-| `POST` | `/api/cortex-chat/send` | Send message, returns SSE stream |
+| `POST` | `/api/cortex-chat/send` | Send message, returns SSE stream (`409` when a send is already in flight) |
 | `DELETE` | `/api/cortex-chat/messages?agent_id=...` | Clear history |
 
-POST accepts `{ agent_id, message, channel_id? }` and returns `Content-Type: text/event-stream`:
+POST accepts `{ agent_id, message, channel_id? }` and returns `Content-Type: text/event-stream`.
+If a prior send is still running for the same agent session, the endpoint now returns `409 CONFLICT` with no stream; clients should wait briefly and retry:
 
 ```
 event: text_delta
diff --git a/docs/design-docs/cortex-history.md b/docs/design-docs/cortex-history.md
index 381b5e448..885309eb7 100644
--- a/docs/design-docs/cortex-history.md
+++ b/docs/design-docs/cortex-history.md
@@ -16,13 +16,13 @@ Only things the cortex **did**, not things it passively observed. Every action f
 | `memory_pruned` | Low-importance orphans removed | count, importance threshold |
 | `association_created` | Cross-channel association made | source_id, target_id, relation_type, reason |
 | `contradiction_flagged` | Contradicting memories found | memory_a_id, memory_b_id, description |
-| `worker_killed` | Cortex killed a hanging worker | worker_id, channel_id, reason (timeout, error loop) |
-| `branch_killed` | Cortex killed a stale branch | branch_id, channel_id, reason (timeout) |
-| `circuit_breaker_tripped` | Component hit failure threshold | component_key, failure_count, action_taken |
+| `worker_killed` | Cortex killed a hanging worker | worker_id, channel_id (optional), timeout_secs, reason |
+| `branch_killed` | Cortex killed a stale branch | branch_id, channel_id, timeout_secs, reason |
+| `circuit_breaker_tripped` | Component hit failure threshold | key, failure_count, threshold, action_taken |
 | `observation_created` | Cortex created an observation memory | memory_id, content_preview |
-| `health_check` | Periodic health summary | active_workers, active_branches, active_channels, memory_count |
+| `health_check` | Periodic health summary | kill_skipped_due_to_lag, kill_budget, kill_attempts, kill_actions, worker_timeout_secs, branch_timeout_secs, pruned_dead_channels |
 
-These map to the phases in `cortex-implementation.md`: bulletin (exists today), maintenance (Phase 3), health supervision (Phase 2), consolidation (Phase 4). The table schema supports all of them from day one even though only bulletin events will be emitted initially. The rest light up as the cortex implementation progresses.
+These map to the phases in `cortex-implementation.md`: bulletin (exists today), maintenance (Phase 3), health supervision (Phase 2, implemented), consolidation (Phase 4). Health supervision currently emits `worker_killed`, `branch_killed`, `circuit_breaker_tripped`, and `health_check`; maintenance and consolidation emit their own events as those phases land.
 
 ## Data Model
 
@@ -68,7 +68,9 @@ One method. The caller constructs the summary and details.
 
 **Maintenance** (Phase 3, future): The `MaintenanceReport` from `run_maintenance()` already contains decayed/pruned/merged counts — log a single `maintenance_run` event.
 
-**Health supervision** (Phase 2, future): Log `worker_killed`, `branch_killed`, `circuit_breaker_tripped` when those actions are taken.
+**Health supervision** (Phase 2, implemented): Log `worker_killed`, `branch_killed`, `circuit_breaker_tripped`, and `health_check` from the supervision tick.
+
+Phase 2 breaker state is intentionally volatile (in-memory only). After restart, counters/tripped flags reset and begin accumulating again from live events.
 
 **Consolidation** (Phase 4, future): Log `memory_merged`, `association_created`, `contradiction_flagged`, `observation_created` as the consolidation agent acts.
 
diff --git a/docs/design-docs/cortex-implementation.md b/docs/design-docs/cortex-implementation.md
index e0a0f6644..f18b6ead3 100644
--- a/docs/design-docs/cortex-implementation.md
+++ b/docs/design-docs/cortex-implementation.md
@@ -1,58 +1,64 @@
 # Cortex Implementation Plan
 
-The cortex is designed to be the system's self-awareness — supervising processes, maintaining memory coherence, and generating the memory bulletin. Today, only the bulletin works. Everything else is dead code or stubs.
+The cortex is designed to be the system's self-awareness — supervising processes, maintaining memory coherence, and generating the memory bulletin. Phase 1 plumbing and Phase 2 health supervision are now live; maintenance and consolidation phases remain.
 
 This doc covers the path from "bulletin generator" to "full system supervisor."
 
 ## What Exists Today
 
 **Running:**
-- `spawn_bulletin_loop()` — generates the memory bulletin on startup, refreshes hourly via LLM synthesis of pre-gathered memory data. Fully functional.
+- `spawn_cortex_loop()` — instantiates `Cortex`, subscribes to both control and memory event buses, runs a `tokio::select!` loop for event observation and periodic ticks, and refreshes bulletin/profile on interval.
+- `spawn_bulletin_loop()` — compatibility alias to `spawn_cortex_loop()`.
+- `spawn_warmup_loop()` — asynchronous warmup that keeps bulletin/embedding readiness fresh.
 
-**Defined but never instantiated:**
-- `Cortex` struct — has `observe()` (converts 3 of 12 event types into signals with hardcoded dummy values) and `run_consolidation()` (logs and returns `Ok(())`).
-- `Signal` enum — 6 variants, none ever constructed at runtime.
+**Defined and instantiated:**
+- `Cortex` struct — observes all `ProcessEvent` variants, builds a rolling signal buffer, and runs on configurable tick cadence.
+- `Signal` enum — aligned to current `ProcessEvent` surface (worker/branch/tool/memory/compaction/task/link events).
 - `CortexHook` — all methods return `Continue` with trace logging.
 
 **Implemented but never called:**
 - `memory/maintenance.rs` — `apply_decay()` and `prune_memories()` work. `merge_similar_memories()` is a stub returning `Ok(0)`.
 
-**Wired through config but never read:**
-- `CortexConfig` fields: `tick_interval_secs` (30), `worker_timeout_secs` (300), `branch_timeout_secs` (60), `circuit_breaker_threshold` (3). All resolve through `env > DB > default` and support hot-reload.
+**Wired through config:**
+- `tick_interval_secs` and `bulletin_interval_secs` are read by the running cortex loop and hot-reload during runtime.
+- Phase 2 knobs are active and hot-reloaded: `worker_timeout_secs`, `branch_timeout_secs`, `detached_worker_timeout_retry_limit`, `supervisor_kill_budget_per_tick`, and `circuit_breaker_threshold`.
 
 **Referenced in prompts but don't exist:**
 - `memory_consolidate` tool
 - `system_monitor` tool
 
-**Event bus:**
-- 12 `ProcessEvent` variants on a `broadcast::Sender<ProcessEvent>` per agent.
-- `MemorySaved` and `CompactionTriggered` variants are defined but never emitted by any code.
+**Event buses:**
+- Two per-agent `broadcast::Sender<ProcessEvent>` streams:
+  - `event_tx` for control/lifecycle events (channel, branch, worker, compactor, task/link events)
+  - `memory_event_tx` for `MemorySaved` telemetry emitted by `memory_save`
+- `CompactionTriggered` is emitted by the compactor on `event_tx` when thresholds are reached.
 
-## Phase 1: The Tick Loop
+## Phase 1: The Tick Loop (Implemented)
 
 Get the cortex running as a persistent process that observes the event bus and ticks on an interval. Purely programmatic — no LLM.
 
-### Wire missing event emission
+### Wire missing event emission (done)
 
 - Emit `MemorySaved` from `memory_save` tool after successful save
 - Emit `CompactionTriggered` from the compactor when thresholds are hit
 
-### Instantiate the cortex
+### Instantiate the cortex (done)
 
-- Call `Cortex::new()` in `main.rs` alongside `spawn_bulletin_loop()`
-- Subscribe to the event bus via `deps.event_tx.subscribe()`
+- Call `Cortex::new()` from `spawn_cortex_loop()` during agent startup
+- Subscribe to both buses via `deps.event_tx.subscribe()` and `deps.memory_event_tx.subscribe()`
 - Run a `tokio::select!` loop:
-  - Receive events → feed through `observe()`
+  - Receive control events → feed through `observe()`
+  - Receive memory events (`MemorySaved`) → feed through `observe()`
   - Tick on `cortex_config.tick_interval_secs`
 - Move bulletin generation into the cortex's tick loop (currently a standalone free function)
 
-### Fix `observe()` to extract real values
+### Fix `observe()` to extract real values (done)
 
 - Map all 12 `ProcessEvent` variants, not just 3
 - Pull real `memory_type`, `importance`, content summaries from events
 - Enrich `MemorySaved` event variant with `memory_type` and `importance` fields so the cortex gets useful data without querying the store
 
-### Rework `Signal` enum
+### Rework `Signal` enum (done)
 
 - Align variants with what `ProcessEvent` actually provides
 - Add `WorkerStarted`, `BranchStarted`, `WorkerStatus`
@@ -60,42 +66,63 @@ Get the cortex running as a persistent process that observes the event bus and t
 
 **End state:** The cortex is running, consuming all events, building a signal buffer, and ticking. It sees everything but doesn't act on anything yet.
 
-## Phase 2: System Health
+## Phase 2: System Health (Implemented)
 
-The supervisor role. Still no LLM — state tracking and threshold checks.
+The supervisor role is now active and still fully programmatic (no LLM loop for health decisions).
 
-### Track active processes
+### Control plane
 
-Maintain state maps in the cortex:
+- `ProcessControlRegistry` provides cancellation routing for:
+  - live channel workers/branches through weak `ChannelControlHandle`s
+  - detached ready-task workers through registered `DetachedWorkerControl` entries
+- Channel cancel convergence now uses reason-aware methods that emit terminal synthetic events:
+  - worker cancel emits one `WorkerComplete` payload (`result`, `notify`, `success`)
+  - branch cancel removes branch status, logs terminal run, emits one synthetic `BranchResult`
 
+### Detached worker single-winner lifecycle
+
+Detached ready-task workers use a lifecycle state machine:
+
+```text
+0 active -> 1 completing -> 3 terminal
+0 active -> 2 killing    -> 3 terminal
 ```
-HashMap<WorkerId, WorkerTracker>  — start time, last status time, channel_id, error count
-HashMap<BranchId, BranchTracker>  — start time, channel_id
-```
 
-Populated from `WorkerStarted`, `WorkerStatus`, `WorkerComplete`, `BranchStarted`, `BranchResult` events. Cleaned up on completion events.
+- Completion path must win `CAS(0 -> 1)` before terminal side-effects.
+- Supervisor kill path must win `CAS(0 -> 2)` (or observe prior `2`) before timeout side-effects.
+- Losing path performs no terminal writes/events.
+
+### Timeout retry and quarantine policy
+
+On detached timeout kill, a single task update writes both status and metadata:
+
+- `supervisor_timeout_count` increments each timeout.
+- `supervisor_timeout_exhausted` flips to `true` once the retry limit is exceeded.
+- If count is `<= detached_worker_timeout_retry_limit`: task returns to `ready` and clears `worker_id`.
+- If count is `> detached_worker_timeout_retry_limit`: task moves to `backlog` and clears `worker_id`.
 
-### Worker supervision (each tick)
+### Lag-aware health tick
 
-- Detect workers with no status update in `worker_timeout_secs`
-- Kill hanging workers via cancellation token (needs a direct cancellation path — the current `CancelTool` works through `ChannelState`, which the cortex doesn't have)
-- Clean up completed workers that haven't been acknowledged
-- Log worker lifecycle stats
+Per tick, cortex maintains runtime maps for workers, branches, branch latency, and breaker state.
 
-### Branch supervision (each tick)
+- If control receiver lag occurred since the prior tick, kill enforcement is skipped for that tick only.
+- `health_check` logs include `kill_skipped_due_to_lag=true` when skipped.
+- Lag flag is cleared at tick end so enforcement resumes next interval.
 
-- Detect branches running longer than `branch_timeout_secs`
-- Kill stale branches via cancellation token
-- Track branch latency (rolling average) for system health visibility
+### Kill budget and ordering
 
-### Circuit breaker
+- Overdue workers/branches are selected in deterministic oldest-first order.
+- Cancellation attempts are capped by `supervisor_kill_budget_per_tick` each tick.
+- Remaining overdue items roll to subsequent ticks.
 
-- Track consecutive failures by component key (tool name, provider name, operation type)
-- After `circuit_breaker_threshold` consecutive failures, flag the component and log a warning
-- Reset counter on success
-- How flags affect behavior is an open question (see below)
+### Observe-only circuit breaker
 
-**End state:** The cortex actively monitors process health and cleans up stuck/stale processes.
+- Worker failures increment `worker_type:<type>` counters.
+- Tool failures increment only on structured JSON results with boolean `success=false` or `ok=false`.
+- No text heuristics are used in Phase 2.
+- Threshold crossing emits `circuit_breaker_tripped` with `action_taken="observe_only"`.
+- Success resets the counter/tripped flag for that key.
+- Breaker state is in-memory only in Phase 2 and resets on process restart.
 
 ## Phase 3: Memory Maintenance
 
diff --git a/docs/design-docs/link-channels-task-delegation.md b/docs/design-docs/link-channels-task-delegation.md
new file mode 100644
index 000000000..3d85230c0
--- /dev/null
+++ b/docs/design-docs/link-channels-task-delegation.md
@@ -0,0 +1,274 @@
+# Link Channels as Task Delegation (v3)
+
+Replaces the LLM-to-LLM conversational model from link-channels-v2 with deterministic task-based delegation. Agents don't talk to each other — they assign tasks. Link channels become audit logs of delegated work, not conversation threads.
+
+## Why
+
+The v2 design had agents exchange messages through mirrored link channels, with each side running its own LLM to process and respond. This was fundamentally brittle:
+
+- **Recursive loops**: Agents ping-pong conclusions, replies, or re-delegations endlessly.
+- **Context loss**: When a link channel re-opens after concluding, the LLM has no memory of prior work and re-sends the original task.
+- **Turn count gaming**: Safety caps fire, force-conclude, then the next message resets the budget.
+- **Conclusion non-compliance**: Agents ignore `conclude_link` instructions and chat until the safety cap.
+- **Result routing corruption**: `initiated_from` metadata gets overwritten by subsequent messages, causing results to bridge to the wrong channel.
+
+Every fix added more special-case logic (drop guards, peer-initiated flags, history seeding, mechanical passthroughs). The system was getting more complex with each bug, not simpler. The core problem is irreducible: two LLMs having a conversation is non-deterministic and uncontrollable.
+
+## The New Model
+
+Instead of conversations, agents delegate through **tasks**. The existing task tracking system (Phase 1 already implemented on `task-tracking` branch) provides the structured, deterministic substrate.
+
+```
+User asks Agent A to do something
+  -> Agent A decides it should be delegated to Agent B
+    -> Agent A calls send_agent_message (modified)
+      -> A task is created in Agent B's task store
+      -> A record is logged in the link channel between A and B
+      -> Agent A's turn ends (skip flag)
+    -> Agent B's cortex ready-task loop picks up the task
+      -> Worker executes the task
+      -> Task moves to done
+      -> Completion record logged in link channel
+      -> Agent A is notified (retrigger on originating channel)
+```
+
+No LLM-to-LLM conversation. No reply relay. No conclusion handshake. No turn counting. The delegation is a database write; the execution is a worker; the result is a task status change.
+
+## What Link Channels Become
+
+Link channels shift from conversation threads to **audit logs**. They record:
+
+1. **Task created**: "Agent A assigned task #42 to Agent B: [title]"
+2. **Task completed**: "Agent B completed task #42: [summary]"
+3. **Task failed**: "Agent B's worker failed on task #42: [error]"
+4. **Task requeued**: "Task #42 returned to ready after worker failure"
+
+These are **system messages** — not LLM-generated text. The link channel is a historical record of delegation activity between two agents. When a human opens a link channel in the dashboard, they see a timeline of tasks assigned and results returned.
+
+Link channels are no longer processed by the LLM. There is no `handle_message()` call, no branching, no worker spawning from link channels. They are write-only logs read by humans through the UI.
+
+### Channel ID Convention
+
+Keep `link:{agent_a}:{agent_b}` as the channel ID format. The `ChannelStore` records these for the UI to discover. Messages are persisted via `ConversationLogger` with `source: "system"` so they're never fed into an LLM context window.
+
+## Modified `send_agent_message` Tool
+
+The tool's external interface stays the same — the LLM calls it with a target agent and a message. The implementation changes completely:
+
+```
+Before (v2):
+  1. Construct InboundMessage
+  2. Inject into target agent's message pipeline
+  3. Target agent's link channel processes it with LLM
+  4. Reply routed back through outbound handler
+  5. Source agent processes reply with LLM
+  6. Back and forth until conclude_link
+
+After (v3):
+  1. Validate link exists and permits this direction
+  2. Create task in target agent's task store
+     - title: extracted from message (first sentence or explicit title)
+     - description: full message content
+     - status: ready (skip pending_approval for agent-delegated tasks)
+     - priority: inferred or default medium
+     - created_by: "agent:{source_agent_id}"
+     - metadata: { delegated_by, originating_channel, link_id }
+  3. Log delegation record in link channel (system message)
+  4. Set skip flag (end source agent's turn)
+  5. Return { success: true, task_number }
+```
+
+The tool needs access to the **target agent's** `TaskStore`, not just the source agent's. This means `send_agent_message` needs a way to resolve task stores across agents.
+
+### Cross-Agent Task Store Access
+
+Currently, `TaskStore` instances are per-agent and stored in `ApiState::task_stores`. The tool runs inside a specific agent's process and only has access to that agent's `AgentDeps`.
+
+**Decision: Per-agent task stores.** Each agent owns its own `TaskStore` backed by its own SQLite database. A superior agent instructs task creation via the link channel system and can query/read a subordinate agent's tasks (read-only cross-agent access). The task store registry (`HashMap<AgentId, Arc<TaskStore>>`) is passed to tools that need cross-agent visibility, but task *creation* on another agent goes through the link channel mechanism, not direct writes.
+
+This preserves agent isolation — each agent's task board is its own — while giving the hierarchy the ability to observe and manage work across the org.
+
+## Task Completion Notification
+
+When a delegated task completes, the delegating agent needs to know. Two mechanisms:
+
+### 1. Link Channel Record
+
+When a worker completes a task that has `metadata.delegated_by`, the cortex (or the task completion handler in `cortex.rs`) logs a completion message in the link channel:
+
+```
+[System] Task #42 completed by community-manager: "Published 3 posts to Discord announcements channel. Links: [...]"
+```
+
+This is a passive record — it doesn't trigger the delegating agent's LLM.
+
+### 2. Originating Channel Retrigger
+
+The task metadata includes `originating_channel` (the channel where the user originally asked for the work). When the task completes, a system message is injected into that channel:
+
+```
+[System] Delegated task completed by community-manager: "Published 3 posts..."
+```
+
+This **does** retrigger the channel's LLM, which can then relay the result to the user naturally. The message has `source: "system"` and no `formatted_author`, so it renders as a plain system notification.
+
+This replaces the old `bridge_to_initiator` mechanism but is much simpler — it's a single message injection on task completion, not a recursive conclusion chain.
+
+### 3. Task Status Polling (Optional, Future)
+
+The delegating agent's cortex could periodically check on delegated tasks via `task_list` filtered by `metadata.delegated_by`. This is a pull model that doesn't require any special routing — the cortex just queries its own task store for tasks it created on other agents.
+
+Not needed for v1 since the push notification (retrigger) handles the common case.
+
+## What Gets Removed
+
+### Files to Delete
+
+| File | Reason |
+|------|--------|
+| `src/tools/conclude_link.rs` | Conversational conclusion mechanism |
+| `prompts/en/fragments/link_context.md.j2` | "You're in a conversation with agent X" prompt |
+| `prompts/en/tools/conclude_link_description.md.j2` | Tool description for deleted tool |
+
+### Code to Remove from `src/agent/channel.rs`
+
+All link-conversation handling logic:
+
+- `link_concluded` field and all checks against it
+- `link_turn_count` field and safety cap logic
+- `peer_initiated_conclusion` field
+- `initiated_from` field and capture logic
+- `originating_channel` / `originating_source` fields
+- `build_link_context()` method (~40 lines)
+- `route_link_conclusion()` / `handle_link_conclusion()` / `bridge_to_initiator()` methods (~160 lines)
+- History seeding for link channels (original_sent_message replay)
+- Coalesce bypass for link channels
+- Drop guard for concluded link channels
+- `conclude_link` tool registration in `run_agent_turn()`
+- `ConcludeLinkFlag` / `ConcludeLinkSummary` return values from `run_agent_turn()`
+- `is_link_channel` checks throughout
+
+### Code to Remove from `src/main.rs`
+
+- Outbound reply relay for `source == "internal"` channels (~90 lines, ~lines 981-1072)
+- This is the code that intercepts Agent B's reply on `link:B:A` and injects it into `link:A:B`
+
+### Code to Remove from `src/tools.rs`
+
+- `pub mod conclude_link` and re-exports
+- `conclude_link` parameter in `add_channel_tools()` / `remove_channel_tools()`
+- `link_counterparty_for_agent()` helper
+- `has_other_delegation_targets` complexity (simplify to basic "has any link targets")
+
+### Prompt Changes
+
+- Remove `conclude_link` text entry from `src/prompts/text.rs`
+- Update `org_context.md.j2` wording — replace conversation language with task delegation language
+- Update `send_agent_message` tool description — "assigns a task" not "sends a message"
+
+## What Gets Kept
+
+### Link Infrastructure (Unchanged)
+
+- `src/links.rs` + `src/links/types.rs` — `AgentLink`, `LinkDirection`, `LinkKind`, store utilities
+- `src/config.rs` — `[[links]]` TOML parsing, `LinkDef`
+- `src/main.rs` — Link initialization, `ArcSwap` plumbing, `AgentDeps.links`
+- `ProcessEvent::AgentMessageSent` / `AgentMessageReceived`
+- `src/api/links.rs` — Link CRUD API
+- Topology API
+
+### Link Prompt Context (Modified)
+
+- `org_context.md.j2` — Keep the hierarchy rendering (superiors/subordinates/peers). Update the instruction text from "send a message" to "assign a task".
+- `build_org_context()` in `channel.rs` — Keep as-is. It reads link topology and renders the org hierarchy.
+
+### Task System (From `task-tracking` Branch)
+
+- `migrations/20260219000001_tasks.sql` — Schema
+- `src/tasks.rs` + `src/tasks/store.rs` — `TaskStore`, CRUD, status transitions
+- `src/api/tasks.rs` — REST API
+- `src/tools/task_create.rs`, `task_list.rs`, `task_update.rs` — LLM tools
+- `src/agent/cortex.rs` — `spawn_ready_task_loop`, `pickup_one_ready_task`
+
+## New Code Needed
+
+### 1. Cross-Agent Task Creation in `send_agent_message.rs`
+
+Rewrite the tool's `call()` method to create a task instead of injecting a message. Needs a `task_stores: Arc<HashMap<AgentId, Arc<TaskStore>>>` field.
+
+### 2. Task Completion Callback in `cortex.rs`
+
+After `pickup_one_ready_task` marks a task as `Done`, check if `metadata.delegated_by` exists. If so:
+
+1. Log completion in the link channel via `ConversationLogger`
+2. Inject a system message into `metadata.originating_channel` to retrigger the delegating agent
+
+This replaces the entire `bridge_to_initiator` mechanism with ~20 lines of straightforward code.
+
+### 3. Link Channel System Message Logging
+
+A small helper that writes system messages to link channels:
+
+```rust
+fn log_link_event(
+    conversation_logger: &ConversationLogger,
+    link_channel_id: &str,
+    message: &str,
+) {
+    // Persist as a system message (source: "system", role: "system")
+    // Not fed to any LLM — purely for UI display
+}
+```
+
+Called from `send_agent_message` (task created) and from the cortex completion handler (task done/failed).
+
+### 4. `send_agent_message` Tool Description Update
+
+Rewrite `prompts/en/tools/send_agent_message_description.md.j2` to describe task delegation:
+
+> Assign a task to another agent. The target agent's cortex will pick it up and execute it autonomously. Use this when work falls outside your scope or belongs to a subordinate. Your turn ends after delegation — the result will be delivered when the task completes.
+
+## Implementation Order
+
+### Phase 1: Tear Out LLM Conversations
+
+1. Delete `conclude_link.rs`, `link_context.md.j2`, conclude_link prompt text
+2. Remove all link-conversation logic from `channel.rs` (fields, methods, guards)
+3. Remove outbound reply relay from `main.rs`
+4. Remove conclude_link from `tools.rs` registration
+5. Simplify `add_channel_tools()` — drop conclude_link param, simplify delegation target logic
+6. Verify compilation, run tests
+
+### Phase 2: Wire Task Delegation into `send_agent_message`
+
+1. Add `task_stores` registry to `SendAgentMessageTool`
+2. Rewrite `call()` to create a task in the target agent's store
+3. Add link channel system message logging on task creation
+4. Update tool description prompt
+5. Update `org_context.md.j2` wording
+
+### Phase 3: Task Completion Notifications
+
+1. Add `delegated_by` / `originating_channel` metadata checks to cortex task completion handler
+2. Log completion in link channel
+3. Inject retrigger system message into originating channel
+4. Test full delegation round-trip
+
+### Phase 4: UI + Polish
+
+1. Link channel UI shows task timeline instead of conversation
+2. Task board shows delegated tasks with source agent badge
+3. SSE events for delegation activity
+4. Dashboard topology graph shows task flow between agents
+
+## Open Questions
+
+**Per-agent vs instance-level task store**: Should delegated tasks live in the target agent's per-agent SQLite database, or should all tasks move to `instance.db`? Per-agent is cleaner for isolation but requires cross-agent store access. Instance-level is simpler but changes the storage model.
+
+**Task approval for delegated tasks**: Should agent-delegated tasks skip `pending_approval` and go straight to `ready`? The design assumes yes — if Agent A trusts Agent B enough to have a link, the task should execute without human approval. But some deployments might want human-in-the-loop for all delegated work.
+
+**Bidirectional task results**: When Agent B completes a task delegated by Agent A, should A get the full worker output or just a summary? Full output could be large (coding task transcripts). A summary is more practical but loses detail. Could store the full result in task metadata and show a summary in the retrigger message.
+
+**Multi-hop delegation**: Agent A delegates to Agent B, who delegates to Agent C. The completion notification needs to bubble up through all hops. Task metadata can track `delegation_chain: [A, B]` so C's completion notifies B, which notifies A. But this adds complexity — start with single-hop and extend later.
+
+**Task priority inheritance**: Should delegated tasks inherit priority from the delegating agent's context? If the user marked something urgent, the delegated task should probably be `high` priority. The LLM could set this explicitly in the `send_agent_message` call, or it could be inferred.
diff --git a/docs/design-docs/named-messaging-adapters.md b/docs/design-docs/named-messaging-adapters.md
index 70c40e011..26799771e 100644
--- a/docs/design-docs/named-messaging-adapters.md
+++ b/docs/design-docs/named-messaging-adapters.md
@@ -85,7 +85,7 @@ Add:
 
 ### Messaging config structs
 
-For each platform with token-based auth (Discord, Telegram, Slack, Twitch):
+For each platform (Discord, Telegram, Slack, Twitch, Email, Webhook):
 
 - Keep existing singleton fields (`token`, `bot_token`, `app_token`, etc.)
 - Add optional `instances: Vec<...InstanceConfig>` with:
@@ -157,10 +157,44 @@ Response payloads should include adapter instance identity so UI can render mult
 
 ## UI Changes
 
-- Keep current quick setup flow for default token
-- Add “Add another token” flow that requires a name
-- Settings display becomes list of adapter instances per platform
-- Binding editor adds optional adapter selector (default preselected)
+Two-column layout replacing the current single-column platform accordion.
+
+### Layout
+
+```
+┌───────────────────────┬────────────────────────────────────────┐
+│  Available            │  Configured Instances                  │
+│                       │                                        │
+│  [Discord        ＋]  │  ┌─ discord ───────────────────────┐   │
+│  [Slack          ＋]  │  │ Discord (default)       ● on    │   │
+│  [Telegram       ＋]  │  │ Bindings: 2                     │   │
+│  [Twitch         ＋]  │  │ [Edit] [Disable] [Remove]       │   │
+│  [Email          ＋]  │  └──────────────────────────────────┘   │
+│  [Webhook        ＋]  │  ┌─ telegram ──────────────────────┐   │
+│                       │  │ Telegram (default)       ● on   │   │
+│  Coming Soon          │  │ Bindings: 1                     │   │
+│  WhatsApp             │  │ [Edit] [Disable] [Remove]       │   │
+│  Matrix               │  └──────────────────────────────────┘   │
+│  iMessage             │  ┌─ telegram:support ──────────────┐   │
+│  IRC                  │  │ Telegram "support"       ● on   │   │
+│  Lark                 │  │ Bindings: 1                     │   │
+│  DingTalk             │  │ [Edit] [Disable] [Remove]       │   │
+│                       │  └──────────────────────────────────┘   │
+│                       │                                        │
+│                       │  (empty state when nothing configured) │
+└───────────────────────┴────────────────────────────────────────┘
+```
+
+- **Left column:** Platform catalog. Each platform has a "+" button to add an instance. Coming-soon platforms listed but disabled. Always visible regardless of configured count.
+- **Right column:** Configured adapter instances as expandable summary cards. Compact view shows platform icon, instance name (or "default"), enabled status, binding count. Expands to show credentials, full binding list, and controls.
+
+### Interaction model
+
+- **Add instance:** Clicking "+" on a platform creates a new card inline in the right column in editing state. Name input (required for non-default), credential fields. Save creates the instance and collapses to summary.
+- **First instance:** When a platform has no instances, the first "+" creates the default instance. No name input required — same single-token paste flow as today.
+- **Subsequent instances:** "+" when a platform already has the default instance creates a named instance. Name input is required.
+- **Instance cards:** Expandable accordions. Click to expand, showing credentials (masked), bindings section, enable/disable toggle, disconnect/remove button.
+- **Bindings:** Edited per-instance inside each expanded card. Each instance card contains its own bindings section with add/edit/remove. Binding form auto-populates the `adapter` field.
 
 The common single-token path remains one step.
 
@@ -193,40 +227,62 @@ No migration required for existing users.
 
 ### Phase 1: Config and binding model
 
-1. Add `adapter` to binding structs and TOML parsing
-2. Add per-platform `instances` config parsing
-3. Add validation rules (names, existence, duplicates)
-4. Update docs for config reference
+1. Add `adapter: Option<String>` to `Binding` (`config.rs:~1153`) and `TomlBinding` (`config.rs:~2302`)
+2. Add per-platform instance config structs: `DiscordInstanceConfig`, `SlackInstanceConfig`, `TelegramInstanceConfig`, `TwitchInstanceConfig`, `EmailInstanceConfig`, `WebhookInstanceConfig` — each with `name: String`, `enabled: bool`, and the same credential fields as the parent platform config
+3. Add `instances: Vec<XInstanceConfig>` to all platform configs: `DiscordConfig`, `SlackConfig`, `TelegramConfig`, `TwitchConfig`, `EmailConfig`, `WebhookConfig`
+4. Add matching TOML deser structs (`TomlXInstanceConfig`) for `[[messaging.<platform>.instances]]` array-of-tables
+5. Add validation: no duplicate instance names within a platform, no empty or `"default"` names, `binding.adapter` must reference an existing configured instance
+6. Update `Binding::matches()` (`config.rs:~1170`) to accept adapter identity parameter
 
 ### Phase 2: Runtime adapter identity
 
-1. Refactor `MessagingManager` keying from platform name to runtime adapter key
-2. Instantiate default + named adapters per platform
-3. Attach adapter identity to inbound messages
-4. Route outbound operations via inbound adapter identity
+1. Define runtime key format — `"telegram"` for default, `"telegram:support"` for named — as a type alias or newtype
+2. Refactor `MessagingManager` `HashMap<String, Arc<dyn MessagingDyn>>` (`manager.rs:~17`) to key by runtime key instead of `adapter.name()`. Update `register()`, `register_and_start()`, `remove_adapter()`, `respond()`, `has_adapter()`
+3. Make adapter constructors accept an optional instance name so `name()` / `runtime_key()` returns the full key. Or add `runtime_key()` to the `Messaging` trait
+4. Add `adapter: String` field to `InboundMessage` carrying the runtime adapter key
+5. Update startup to instantiate default adapter from root config + one adapter per `instances` entry, all registered with the manager
+6. Update `respond()` (`manager.rs:~203`) to route outbound by adapter runtime key captured on inbound, not `message.source`
 
 ### Phase 3: Binding resolution and permissions
 
-1. Extend binding match logic with adapter selector
-2. Build per-adapter permission sets from filtered bindings
-3. Ensure hot-reload updates per-adapter permissions correctly
+1. Extend `Binding::matches()` to check `binding.adapter` against inbound adapter identity. `None` matches default adapter only. `Some("x")` matches named adapter `"x"` only
+2. Build per-adapter permission sets by filtering bindings on `(platform, adapter)` when constructing each platform's permission struct
+3. Update hot-reload to rebuild and `ArcSwap` permissions per adapter instance independently
+
+### Phase 4: API
+
+1. Refactor `GET /api/messaging/status` (`api/messaging.rs:~16-23`) from hardcoded per-platform struct to `Vec<AdapterInstanceStatus>` with `{platform, name, configured, enabled}`
+2. Add optional `adapter: Option<String>` to `TogglePlatformRequest` and `DisconnectPlatformRequest` (`api/messaging.rs`). Omitted = default instance
+3. Add adapter instance CRUD: `POST /api/messaging/instances` (create named instance with credentials), `DELETE /api/messaging/instances` (remove named instance + associated bindings)
+4. Add optional `adapter` to bindings CRUD payloads (`api/bindings.rs`): `CreateBindingRequest`, `UpdateBindingRequest`, `DeleteBindingRequest`. Old payloads without `adapter` remain valid
+
+### Phase 5: UI
+
+1. Update TypeScript types (`interface/src/api/client.ts`): new `AdapterInstance` type, update `MessagingStatusResponse` to return instance list, add `adapter` to `BindingInfo` and binding request types
+2. Replace `ChannelsSection` (`interface/src/routes/Settings.tsx:~785`) single-column layout with two-column: left platform catalog, right configured instances
+3. Build platform catalog (left column): platform list with "+" buttons, coming-soon platforms grayed out
+4. Refactor `ChannelSettingCard` (`interface/src/components/ChannelSettingCard.tsx`) into expandable instance summary cards: platform icon, instance name, status badge, binding count. Expand for credentials, bindings, controls
+5. Build add-instance flow: "+" creates inline card in editing state, name input for non-default instances, credential fields, save calls instance API
+6. Scope binding editor per-instance: existing `BindingsSection` logic scoped to the instance's adapter, binding form auto-populates `adapter` field
+7. Default instance UX: first instance of any platform = default, no name required, same single-token paste experience as today. Only second+ instances require a name
+
+### Phase 6: Tests
+
+1. Config parsing/validation tests: valid instance arrays, empty names, duplicate names, `"default"` name rejection
+2. Binding match tests: default adapter match, named adapter match, mismatch rejection, adapter-less binding matches default only
+3. API backward compat tests: payloads without `adapter` field work unchanged
+4. Permission filtering tests: per-adapter permission sets built correctly from filtered bindings
 
-### Phase 4: API and UI
+## Risk Notes
 
-1. Extend bindings API payloads with optional `adapter`
-2. Extend messaging status/toggle/disconnect APIs for adapter instances
-3. Update dashboard settings and binding editor for named instances
-4. Preserve platform-only behavior for default adapter paths
+**Phase 2 is the most invasive.** Changing how `MessagingManager` keys adapters touches every adapter, startup, hot-reload, and outbound routing. Most bugs will surface here. Consider landing Phase 2 as its own PR with focused review.
 
-### Phase 5: Test coverage and rollout docs
+**`ChannelEditModal` duplication.** The current UI has duplicated adapter logic between `ChannelSettingCard` and `ChannelEditModal`. The Phase 5 refactor is a good opportunity to consolidate, but optional — updating `ChannelSettingCard` alone is sufficient if the modal is used elsewhere.
 
-1. Add config parsing/validation tests for named instances
-2. Add routing tests for adapter-specific bindings
-3. Add API tests for backward compatible payloads
-4. Add setup docs for multi-bot per platform scenarios
+**Build order is backend-first.** Phases 1-4 are Rust. Phase 5 is React. This avoids building UI against speculative API contracts.
 
-## Open Questions
+## Resolved Questions
 
-- Should adapter identity be surfaced as a first-class field on `InboundMessage` instead of metadata?
-- For Slack, should named instances support independent app-level settings beyond tokens in this phase?
-- Should proactive broadcast endpoints require explicit adapter for platforms with multiple configured instances, or keep default fallback?
+- **Adapter identity on `InboundMessage`:** Yes, first-class `adapter: String` field, not metadata. Binding resolution and outbound routing both depend on it directly.
+- **Slack app-level settings beyond tokens:** No, not in this phase. Named Slack instances share the same config shape (bot_token + app_token). Independent app-level settings can be added later if needed.
+- **Proactive broadcast with multiple instances:** Keep default fallback. Broadcast targets the default adapter unless the caller explicitly specifies a runtime key. This matches existing behavior and avoids breaking proactive sends for users who add named instances alongside their default.
diff --git a/docs/design-docs/sandbox-hardening.md b/docs/design-docs/sandbox-hardening.md
new file mode 100644
index 000000000..a7defcd6f
--- /dev/null
+++ b/docs/design-docs/sandbox-hardening.md
@@ -0,0 +1,461 @@
+# Sandbox Hardening
+
+Dynamic sandbox mode, hot-reload fix, capability manager, and policy enforcement for shell and OpenCode workers.
+
+## 1. Dynamic Sandbox Mode (Hot-Reload Fix)
+
+### Problem
+
+Disabling the sandbox on an agent via the UI doesn't work. The setting visually reverts to "enabled" and the actual sandbox enforcement doesn't change. The config file on disk is written correctly, but the in-memory state is never updated.
+
+### Root Cause
+
+Three failures in the reload path:
+
+1. **`reload_config()` skips sandbox.** `config.rs:5012-5014` has an explicit comment: "sandbox config is not hot-reloaded here because the Sandbox instance is constructed once at startup and shared via Arc. Changing sandbox settings requires an agent restart." Every other config field gets `.store(Arc::new(...))` in `reload_config()`, but `self.sandbox` is skipped.
+
+2. **API returns stale data.** `get_agent_config()` reads from `rc.sandbox.load()` (`api/config.rs:232`), which still holds the startup value. The UI receives this stale response and resets the toggle.
+
+3. **`Sandbox` struct stores mode as a plain field.** The `Sandbox` instance (`sandbox.rs:60-68`) captures `mode: SandboxMode` at construction. Even if the `RuntimeConfig.sandbox` ArcSwap were updated, the `Arc<Sandbox>` in `AgentDeps` would still enforce the old mode in `wrap()`.
+
+### Sequence Diagram
+
+```
+UI: PUT /agents/config {sandbox: {mode: "disabled"}}
+  -> api/config.rs writes mode="disabled" to config.toml      (correct)
+  -> api/config.rs calls rc.reload_config()                    (skips sandbox)
+  -> api/config.rs calls get_agent_config()                    (reads stale ArcSwap)
+  -> returns {sandbox: {mode: "enabled"}}                      (wrong)
+UI: displays "enabled"                                         (reverted)
+
+~2s later:
+  file watcher detects config.toml change
+  -> calls reload_config() for all agents                      (skips sandbox again)
+  -> all agents log "runtime config reloaded"                  (sandbox unchanged)
+```
+
+### Fix
+
+#### Change 1: Update `RuntimeConfig.sandbox` in `reload_config()` (config.rs ~line 5011)
+
+Add the sandbox store alongside the other fields. Remove the skip comment.
+
+```rust
+self.warmup.store(Arc::new(resolved.warmup));
+self.sandbox.store(Arc::new(resolved.sandbox.clone()));
+
+mcp_manager.reconcile(&old_mcp, &new_mcp).await;
+```
+
+This fixes the API response so `get_agent_config()` returns the correct value after a config change.
+
+#### Change 2: Wrap `RuntimeConfig.sandbox` in `Arc` (config.rs:4920)
+
+Change the field from `ArcSwap<SandboxConfig>` to `Arc<ArcSwap<SandboxConfig>>` so it can be shared with the `Sandbox` struct:
+
+```rust
+// Before
+pub sandbox: ArcSwap<SandboxConfig>,
+
+// After
+pub sandbox: Arc<ArcSwap<SandboxConfig>>,
+```
+
+Update `RuntimeConfig::new()` accordingly:
+
+```rust
+// Before
+sandbox: ArcSwap::from_pointee(agent_config.sandbox.clone()),
+
+// After
+sandbox: Arc::new(ArcSwap::from_pointee(agent_config.sandbox.clone())),
+```
+
+All existing `.load()` and `.store()` calls work through `Arc`'s `Deref` with no changes.
+
+#### Change 3: Make `Sandbox` read mode dynamically (sandbox.rs)
+
+Replace the `mode: SandboxMode` field with `config: Arc<ArcSwap<SandboxConfig>>`. Always detect the backend at startup (even when mode is initially Disabled), so we know what's available if the user later enables it.
+
+```rust
+pub struct Sandbox {
+    config: Arc<ArcSwap<SandboxConfig>>,
+    workspace: PathBuf,
+    data_dir: PathBuf,
+    tools_bin: PathBuf,
+    backend: SandboxBackend,
+}
+```
+
+Change `Sandbox::new()` signature to accept the shared ArcSwap:
+
+```rust
+pub async fn new(
+    config: Arc<ArcSwap<SandboxConfig>>,
+    workspace: PathBuf,
+    instance_dir: &Path,
+    data_dir: PathBuf,
+) -> Self
+```
+
+Backend detection always runs. The initial mode only affects the startup log message.
+
+In `wrap()`, read the current mode dynamically:
+
+```rust
+pub fn wrap(&self, program: &str, args: &[&str], working_dir: &Path) -> Command {
+    let config = self.config.load();
+    // ...
+    if config.mode == SandboxMode::Disabled {
+        return self.wrap_passthrough(program, args, working_dir, &path_env);
+    }
+    match self.backend {
+        SandboxBackend::Bubblewrap { proc_supported } => { ... }
+        SandboxBackend::SandboxExec => { ... }
+        SandboxBackend::None => self.wrap_passthrough(program, args, working_dir, &path_env),
+    }
+}
+```
+
+The `writable_paths` field is removed from the struct. Paths are read from the ArcSwap config and canonicalized in `wrap()`. This is a cheap syscall and commands aren't spawned at rates where it matters.
+
+#### Change 4: Pass the shared ArcSwap to `Sandbox::new()` at both construction sites
+
+**main.rs ~line 1358:**
+
+```rust
+let sandbox = std::sync::Arc::new(
+    spacebot::sandbox::Sandbox::new(
+        runtime_config.sandbox.clone(),  // Arc<ArcSwap<SandboxConfig>>
+        agent_config.workspace.clone(),
+        &config.instance_dir,
+        agent_config.data_dir.clone(),
+    )
+    .await,
+);
+```
+
+**api/agents.rs ~line 665:** Same change.
+
+### What Doesn't Change
+
+- `AgentDeps.sandbox` stays as `Arc<Sandbox>` (lib.rs:214). The `Sandbox` itself now reads mode dynamically, so the `Arc<Sandbox>` reference doesn't need to be swapped.
+- `ShellTool` and `ExecTool` continue holding `Arc<Sandbox>` and calling `.wrap()`. No changes needed.
+- The bubblewrap and sandbox-exec wrapping logic is unchanged. Only the dispatch in `wrap()` reads the dynamic mode.
+
+### Files Changed
+
+| File | Change |
+|------|--------|
+| `src/config.rs` | `RuntimeConfig.sandbox` type to `Arc<ArcSwap<SandboxConfig>>`; `RuntimeConfig::new()` wraps in `Arc::new()`; `reload_config()` adds `self.sandbox.store()` and removes skip comment |
+| `src/sandbox.rs` | `Sandbox.mode` field replaced with `config: Arc<ArcSwap<SandboxConfig>>`; `writable_paths` removed from struct, read dynamically; `Sandbox::new()` signature change; `wrap()` reads mode from ArcSwap; backend detection always runs |
+| `src/main.rs` | Pass `runtime_config.sandbox.clone()` to `Sandbox::new()` |
+| `src/api/agents.rs` | Same `Sandbox::new()` signature update |
+
+---
+
+## 2. Environment Sanitization
+
+### Problem
+
+Sandbox does NOT call `env_clear()`. Bubblewrap wrapping uses `--setenv PATH` but does not use `--clearenv`. Workers inherit the full parent environment. A worker can run `printenv ANTHROPIC_API_KEY` and get the raw key. Even `remove_var` on startup doesn't help because Linux `/proc/self/environ` is an immutable kernel snapshot from exec time.
+
+MCP processes already do this correctly (`mcp.rs:309` calls `env_clear()`).
+
+### Design
+
+Sandbox `wrap()` must call `env_clear()` (or the bwrap equivalent `--clearenv`) and explicitly re-inject only approved variables. Three categories:
+
+**Always passed through:**
+- `PATH` (with tools/bin prepended, as today)
+- `HOME`, `USER`, `LANG`, `TERM` (basic process operation)
+- `TMPDIR` (if needed)
+
+**Passed from secret store (tool secrets only):**
+- Credentials for CLI tools workers invoke (`GH_TOKEN`, `GITHUB_TOKEN`, `NPM_TOKEN`, `AWS_*`, etc.)
+- The secret store categorizes secrets as **system** (internal — LLM API keys, messaging tokens) or **tool** (external — CLI credentials). Only tool secrets are injected into worker subprocesses. System secrets stay in Rust memory and never enter any subprocess environment.
+- `wrap()` reads the current tool secrets from the store and injects each via `--setenv` (bubblewrap) or `Command::env()` (passthrough/sandbox-exec).
+- Skills that expect `GH_TOKEN` in the environment just work. Skills never see `ANTHROPIC_API_KEY` because it's a system secret.
+
+**Passed from `passthrough_env` config (fallback for self-hosted without secret store):**
+- A user-configured list of env var names to forward from the parent process: `passthrough_env = ["GH_TOKEN", "GITHUB_TOKEN"]`
+- This is the escape hatch for self-hosted users who set env vars in Docker/systemd but don't configure a master key. Without it, `--clearenv` would silently strip their credentials.
+- When the secret store is available, `passthrough_env` is redundant (everything should be in the store). The field still works — it's additive.
+- See `docs/design-docs/secret-store.md` "Env Passthrough for Self-Hosted" for details.
+
+**Always stripped:**
+- All `SPACEBOT_*` internal vars (the master key is never in the environment — it lives in the OS credential store; see `docs/design-docs/secret-store.md`)
+- All system secrets (LLM API keys, messaging tokens — see `docs/design-docs/secret-store.md`)
+- Any env var not in the above three categories
+
+For the passthrough (no sandbox) case: same env sanitization applies in the shell/exec tools directly via `Command::env_clear()` before `Command::env()` for the allowed + secret + passthrough vars.
+
+This is a **hard prerequisite for the secret store** — see `docs/design-docs/secret-store.md`. The master key is protected independently by the OS credential store (Keychain / kernel keyring), but without `--clearenv`, system secrets and other sensitive env vars still leak to workers.
+
+### Files Changed
+
+| File | Change |
+|------|--------|
+| `src/sandbox.rs` | Add `--clearenv` to bubblewrap wrapping; add `env_clear()` to sandbox-exec and passthrough modes; re-add safe vars + tool secrets + `passthrough_env` vars |
+| `src/config.rs` | Parse `passthrough_env: Vec<String>` in `SandboxConfig` |
+| `src/tools/shell.rs` | Env sanitization for passthrough (no sandbox) mode |
+| `src/tools/exec.rs` | Same env sanitization |
+
+---
+
+## 3. Durable Binary Location
+
+### Problem
+
+On hosted instances, binaries installed via `apt-get` land on the root filesystem which is ephemeral — machine image rollouts replace it. Any ad-hoc `apt-get install git` disappears on the next deploy. The agent reinstalls on demand, but this is slow and wastes turns.
+
+### Existing Infrastructure
+
+The durable path already works:
+
+- `{instance_dir}/tools/bin` exists — hosted boot flow creates it (`mkdir -p "$SPACEBOT_DIR/tools/bin"`).
+- `Sandbox` already prepends `tools/bin` to `PATH` for worker subprocesses (`sandbox.rs:138-149`).
+- `/data` survives hosted machine image rollouts.
+
+### Design
+
+No internal registry, no install manager, no package-manager guards. The agent can install binaries however it wants — `apt-get`, `curl`, compile from source. The system's only job is to tell the agent where to put them so they survive.
+
+#### Worker System Prompt Instruction
+
+Workers get a line in their system prompt:
+
+```
+Persistent binary directory: /data/tools/bin (on PATH, survives restarts and rollouts)
+Binaries installed via package managers (apt, brew, etc.) land on the root filesystem
+which is ephemeral on hosted instances — they disappear on rollouts. To install a tool
+durably, download or copy the binary into /data/tools/bin.
+```
+
+This is an instruction, not a guard. If the agent runs `apt install gh`, it works. The binary is ephemeral. If the agent is smart it downloads to `tools/bin` instead. If it's not, the binary disappears and it reinstalls next time. Not our problem to gatekeep.
+
+#### Dashboard Observability (Optional)
+
+A lightweight API endpoint that lists the contents of `tools/bin`:
+
+**`GET /api/tools`**
+
+```json
+{
+  "tools_bin": "/data/tools/bin",
+  "binaries": [
+    { "name": "git", "size": 3456789, "modified": "2026-02-15T10:30:00Z" },
+    { "name": "gh", "size": 1234567, "modified": "2026-02-20T14:15:00Z" }
+  ]
+}
+```
+
+Just a directory listing — no state machine, no install locks, no checksums. The dashboard can render this as a "Tools" panel showing what's installed. Purely observational.
+
+### Files Changed
+
+| File | Change |
+|------|--------|
+| `prompts/worker.md` | Add durable binary location instruction |
+| `src/api/tools.rs` | Optional: `GET /api/tools` directory listing endpoint |
+
+---
+
+## 4. OpenCode Auto-Allow (Independent Bug)
+
+### Problem
+
+OpenCode workers auto-allow all permission prompts (`opencode/worker.rs:429-432`). When OpenCode asks permission to run a bash command, the worker replies `PermissionReply::Once` unconditionally. OpenCode worker output is also not scanned by SpacebotHook, so leak detection doesn't apply.
+
+This is an independent bug regardless of the other sections — OpenCode workers operate with no policy checks at all.
+
+### Design
+
+The auto-allow behavior is intentional for now (OpenCode needs to run commands to be useful as a worker backend). The fix is to wire OpenCode worker output through **both** protection layers that cover builtin workers:
+
+1. **Output scrubbing (exact match)** — `StreamScrubber` from `src/secrets/scrub.rs` (see `secret-store.md`, Output Scrubbing). Replaces tool secret values with `[REDACTED:<name>]` in SSE events before they're forwarded. Uses the rolling buffer strategy to handle secrets split across SSE chunks. This runs first — proactive redaction.
+
+2. **Leak detection (regex)** — shared regex patterns from `SpacebotHook` (see `src/hooks/spacebot.rs`). Scans for known API key formats (`sk-ant-*`, `ghp_*`, etc.) in the scrubbed output. If a match is found after scrubbing, it's a leak of a secret not in the store — kill the agent. This runs second — reactive safety net.
+
+The sequencing matters: scrubbing first means stored tool secrets are redacted before leak detection runs, so leak detection only fires on unknown/unstored secrets. Without this order, leak detection would fire on every tool secret value (which is expected in worker output) and kill the agent unnecessarily.
+
+Longer term, OpenCode's permission model could be integrated with the sandbox — permissions for bash commands routed through the same `wrap()` path. But that requires understanding OpenCode's permission protocol better (see Open Questions).
+
+### Files Changed
+
+| File | Change |
+|------|--------|
+| `src/opencode/worker.rs` | Wire SSE output through `StreamScrubber` (exact-match redaction) then leak detection (regex) before forwarding |
+| `src/secrets/scrub.rs` | `StreamScrubber` — rolling buffer scrubber for chunked output (shared with other streaming paths) |
+| `src/hooks/spacebot.rs` | Extract leak detection regex into a shared function callable from OpenCode worker |
+
+---
+
+## Tool Protection Audit
+
+### File Tool Workspace Guard
+
+Workers get `ShellTool`, `FileTool`, and `ExecTool` in the same toolbox. The file tool's `resolve_path()` workspace guard (`file.rs:26-75`) is security theater when sandbox is off:
+
+- Worker wants to read `/data/config.toml`
+- `FileTool.resolve_path()` rejects it — "outside workspace"
+- Worker uses `ShellTool` with `cat /data/config.toml` — works fine, no sandbox enforcement
+- Or `ExecTool` with `cat` — same thing
+
+The file tool's check only prevents the LLM from using that specific tool for out-of-workspace access. It doesn't prevent anything because shell and exec are right there in the same toolbox with no equivalent restriction when sandbox is off.
+
+When sandbox **is** on, the file tool's check is also redundant in the other direction — bwrap/sandbox-exec already makes everything outside the workspace read-only at the kernel level. The file tool runs in-process (not a subprocess), so the sandbox doesn't wrap it, but the workspace guard duplicates what the sandbox already enforces for writes. For reads, the sandbox allows reading everywhere (read-only mounts), and the file tool is actually **more restrictive** than the sandbox by blocking reads outside workspace too.
+
+The file tool workspace guard has exactly one scenario where it provides unique value: **sandbox is on, and you want to prevent the LLM from reading files outside the workspace via the file tool** (since the sandbox allows reads everywhere). That's a defense-in-depth argument, not a security boundary. It's worth keeping for that reason, but it should not be confused with actual containment.
+
+### Protection Matrix
+
+Current state of protection across all tool paths, with sandbox disabled:
+
+| Tool | Workspace Guard | Sandbox Enforcement | Env Inherited | Leak Detection | Net Protection |
+|------|----------------|--------------------|----|-----|----|
+| `file` (read/write/list) | Yes — `resolve_path()` blocks outside workspace | No (in-process, not a subprocess) | N/A | Yes (tool output scanned) | Workspace guard only — bypassable via shell/exec in the same toolbox |
+| `shell` | Working dir validation only | Sandbox wraps subprocess — but disabled | Full parent env | Yes (args + output scanned) | Leak detection only |
+| `exec` | Working dir validation only | Sandbox wraps subprocess — but disabled | Full parent env | Yes (args + output scanned) | Leak detection + dangerous env var blocklist |
+| `send_file` | **None** — any absolute path | No (in-process read) | N/A | Yes (output scanned) | Leak detection only |
+| `browser` | N/A | N/A | N/A | Yes (output scanned) | SSRF protection (blocks metadata endpoints, private IPs) |
+| OpenCode workers | Workspace-scoped by OpenCode | Not sandboxed | Full parent env via OpenCode subprocess | No (OpenCode output not scanned by SpacebotHook) | Auto-allow on all permissions |
+
+### Key Observations
+
+- The file tool's workspace guard is the only tool-level path restriction, but it's trivially bypassed via shell/exec which are in the same toolbox. It gives a false sense of containment.
+- With sandbox off, the only real protection across all tools is leak detection (reactive, pattern-based, kills the agent after the fact).
+- `send_file` has no workspace validation at all — can exfiltrate any readable file as a message attachment. This is an independent bug regardless of sandbox state.
+- OpenCode workers bypass both sandbox and leak detection. They inherit the full environment and auto-allow all permission prompts.
+- The file tool guard's only real value is as read-containment when sandbox is on (preventing LLM from reading sensitive files outside workspace via the file tool specifically, since bwrap mounts everything read-only but still readable).
+
+---
+
+## Phase Plan
+
+### Phase 1: Dynamic Sandbox Mode (Hot-Reload Fix)
+
+Fix the user-facing bug where toggling sandbox mode via UI doesn't take effect. Changes to `config.rs`, `sandbox.rs`, `main.rs`, `api/agents.rs`.
+
+1. Wrap `RuntimeConfig.sandbox` in `Arc`.
+2. Add `self.sandbox.store()` to `reload_config()`.
+3. Refactor `Sandbox` to read mode from `Arc<ArcSwap<SandboxConfig>>`.
+4. Update both `Sandbox::new()` call sites.
+5. Verify: change sandbox mode via API, confirm `GET /agents/config` returns the new value, confirm `wrap()` uses the new mode.
+
+### Phase 2: Environment Sanitization
+
+Prevent secret leakage through environment variable inheritance. Secret-store-aware — workers get tool secrets (CLI credentials) but never system secrets (LLM keys, messaging tokens) or internal vars.
+
+1. Add `--clearenv` to bubblewrap wrapping, re-add only safe vars + tool secrets from the secret store.
+2. Add `env_clear()` to sandbox-exec and passthrough wrapping modes with same allowlist.
+3. Add `env_clear()` to shell/exec tools for the no-sandbox case.
+4. Verify: worker running `printenv` shows PATH/HOME/LANG + tool secrets (e.g., `GH_TOKEN`), but NOT `ANTHROPIC_API_KEY` or other system/internal vars. (The master key is never in the environment — it lives in the OS credential store.)
+
+### Phase 3: Durable Binary Instruction
+
+Add the persistent binary location instruction to worker prompts and optional dashboard observability.
+
+1. Add tools/bin instruction to worker system prompt.
+2. Optionally add `GET /api/tools` directory listing endpoint.
+3. Verify: worker prompt includes the durable path; dashboard shows installed tools.
+
+### Phase 4: OpenCode Output Protection
+
+Wire OpenCode worker output through both protection layers (output scrubbing + leak detection) that cover builtin workers.
+
+1. Wire SSE output through `StreamScrubber` (exact-match redaction of tool secret values, rolling buffer for split secrets). Runs first — proactive.
+2. Extract leak detection regex from SpacebotHook into a shared function.
+3. Scan scrubbed SSE output through leak detection. Runs second — reactive safety net for secrets not in the store.
+4. Verify: a stored tool secret in OpenCode output is redacted to `[REDACTED:<name>]`; an unknown secret pattern triggers the same kill behavior as builtin workers.
+
+### Phase 5: send_file Workspace Validation
+
+Fix the independent bug where `send_file` can exfiltrate any readable file.
+
+1. Add workspace validation to `send_file` matching the file tool's `resolve_path()` pattern.
+2. Verify: `send_file` with a path outside workspace returns an error.
+
+---
+
+## Open Questions
+
+1. **OpenCode permission protocol.** Can OpenCode's permission model be integrated with the sandbox? Would need to route bash permission requests through `wrap()`. Requires understanding the OpenCode permission protocol internals.
+2. **Dynamic writable_paths.** The hot-reload fix reads `writable_paths` from the ArcSwap on every `wrap()` call, canonicalizing each time. If an agent has many writable paths and spawns commands at high frequency, this could be optimized with a change-detection cache. Likely not a concern in practice.
+3. **Tool secret injection interface.** How does `wrap()` get tool secrets? Options: (a) `Sandbox` holds an `Arc<SecretsStore>` and calls `tool_env_vars()` on each `wrap()`, (b) tool secrets cached in an `Arc<ArcSwap<HashMap<String, String>>>` updated when secrets change. Option (b) avoids decryption on every subprocess spawn. Tool secrets change rarely (only via dashboard), so the cache is almost always warm.
+4. **Worker keyring isolation.** The `pre_exec` hook that gives workers a fresh session keyring (see `secret-store.md`) should be wired into `wrap()` alongside env sanitization. Both run regardless of sandbox state — `--clearenv` strips env vars, `keyctl(JOIN_SESSION_KEYRING)` strips keyring access. Need to verify this works correctly with bubblewrap's `--unshare-pid` (the keyring is per-session, not per-PID-namespace, so both should be independent).
+
+---
+
+## Future: True Sandboxing (VM Isolation via stereOS)
+
+Everything above operates at the namespace level — bubblewrap restricts mounts, `--clearenv` strips the environment, policy guards block specific commands. These are necessary fixes but they share a fundamental limitation: the agent and the host share a kernel. A compromised or misconfigured bubblewrap invocation can be escaped. `/proc` attacks, kernel exploits, and symlink races all exist within the same kernel boundary.
+
+stereOS (see `docs/design-docs/stereos-integration.md`) offers a stronger primitive: **run worker processes inside a purpose-built VM with a separate kernel**. This section captures how that maps to the sandbox architecture as a future upgrade path.
+
+### Per-Agent VM, Not Per-Worker
+
+The right granularity is one VM per agent, not one per worker:
+
+- **Startup cost.** stereOS boots in ~2-3 seconds. Fine once at agent boot; unacceptable per fire-and-forget worker. Workers spawn constantly, agents don't.
+- **Shared workspace.** All workers for an agent already share the same workspace and data directory. One VM matches the existing `Arc<Sandbox>` isolation boundary.
+- **Resource overhead.** One VM per agent (~128-256MB RAM) is manageable. One per worker would balloon memory with concurrent workers.
+
+The VM boots when the agent starts and stays up for the agent's lifetime. Workers spawn and die inside it. This directly parallels how the current `Sandbox` struct is constructed once at agent startup and shared via `Arc` across all workers.
+
+### What Changes
+
+Worker tool execution (shell, file, exec) currently calls `sandbox.wrap()` which prepends bubblewrap arguments to a `Command`. With VM isolation, these tools would instead dispatch commands over a vsock RPC layer to the agent's VM:
+
+```
+Current:  ShellTool → sandbox.wrap() → bwrap ... -- sh -c "command" (same kernel)
+Future:   ShellTool → vm_rpc.exec()  → agentd → sh -c "command"   (guest kernel)
+```
+
+The `Sandbox` trait boundary stays the same — `wrap()` produces a `Command`. The VM backend would produce a `Command` that speaks vsock instead of forking a local subprocess. Tools don't need to know which backend they're using.
+
+stereOS's `agentd` daemon already handles session management inside the VM. Worker commands would be dispatched as agentd sessions, with stdout/stderr streamed back over vsock.
+
+### Security Model Upgrade
+
+stereOS adds layers that bubblewrap cannot provide:
+
+| Layer | bubblewrap (current) | stereOS VM |
+|-------|---------------------|------------|
+| **Kernel isolation** | Shared kernel (namespace-level) | Separate kernel (VM-level) |
+| **PATH restriction** | Sandbox prepends `tools/bin` | Restricted shell with curated PATH, Nix tooling excluded |
+| **Privilege escalation** | Relies on namespace user mapping | Explicit sudo denial (`agent ALL=(ALL:ALL) !ALL`), no wheel group |
+| **Kernel hardening** | Host kernel settings apply | ptrace blocked, kernel pointers hidden, dmesg restricted, core dumps disabled |
+| **Secret injection** | Env vars (cleared by `--clearenv`) | Written to tmpfs at `/run/stereos/secrets/` with root-only permissions (0700), never on disk |
+| **User isolation** | UID mapping in namespace | Immutable users, no passwords, SSH keys injected ephemerally over vsock |
+
+The secret injection model is particularly relevant. Today, the secret store design (see `docs/design-docs/secret-store.md`) protects the master key via the OS credential store (Keychain / kernel keyring) — workers can't access it regardless of sandbox state. With stereOS, an even stronger model is possible: the master key stays on the host entirely, never entering the VM. Secrets are injected individually into the guest's tmpfs by `stereosd`. The agent process inside the VM reads from `/run/stereos/secrets/`. The OS credential store and VM isolation are complementary — the credential store protects on the host, the VM boundary protects in the guest.
+
+### Network Isolation
+
+bubblewrap's `--unshare-net` exists but breaks most useful worker tasks (git clone, API calls, web browsing). It's all-or-nothing.
+
+VM-level networking is controllable with more granularity. The host can configure the VM's virtual NIC to allow outbound connections to specific hosts/ports while blocking everything else. This enables scenarios like "workers can reach github.com and the OpenAI API but nothing else" — impossible with bubblewrap without a userspace proxy.
+
+### Blockers
+
+This is not ready to implement. Key gaps from the stereOS integration research:
+
+1. **Fly/Firecracker format mismatch.** Fly Machines use Firecracker, which expects ext4 rootfs + kernel binary. stereOS produces raw EFI, QCOW2, and kernel artifacts (bzImage + initrd). Firecracker doesn't use initrd the same way. Either stereOS needs a `formats/firecracker.nix` output, or we run QEMU/KVM on Fly (non-standard).
+
+2. **Architecture.** stereOS is aarch64-linux only. Fly Machines are predominantly x86_64. Cross-compilation in Nix is straightforward but untested for stereOS.
+
+3. **Control plane protocol.** `stereosd` speaks a custom vsock protocol. `spacebot-platform` would need a Rust client, or stereOS would need an HTTP API layer. The protocol isn't documented publicly yet.
+
+4. **Workspace persistence.** stereOS VMs are ephemeral by design. Spacebot needs persistent storage (SQLite, LanceDB, workspace files). Requires virtio-fs mounts to persistent volumes, which stereOS supports but the Fly integration path would need to map to Fly volumes.
+
+### Relationship to Current Work
+
+The phases above (1-5) are prerequisites, not alternatives:
+
+- **Phases 1-2** (hot-reload fix, env sanitization) fix correctness bugs that matter regardless of backend. Even with VM isolation, the host process still needs `--clearenv` for any non-VM code paths (MCP processes, in-process tools).
+- **Phase 3** (durable binary instruction) applies inside the VM too — the VM image would include `tools/bin` on the persistent volume mount.
+- **Phases 4-5** (OpenCode leak detection, send_file fix) are bug fixes that apply regardless of sandbox backend.
+
+bubblewrap remains the default sandbox backend for all deployments. VM isolation would be an opt-in upgrade for the hosted platform where multi-tenant security justifies the resource overhead. Self-hosted users who want maximum isolation could run a `spacebot-mixtape` directly (NixOS image, no Docker) as an alternative deployment path.
+
diff --git a/docs/design-docs/sandbox.md b/docs/design-docs/sandbox.md
index 62333fb19..a65c34cc4 100644
--- a/docs/design-docs/sandbox.md
+++ b/docs/design-docs/sandbox.md
@@ -124,8 +124,6 @@ mode = "enabled"
 writable_paths = ["/home/user/projects/myapp"]
 ```
 
-When `SPACEBOT_DEPLOYMENT=hosted`, the platform boot script forces `mode = "enabled"` regardless of user config.
-
 ### Types
 
 ```rust
diff --git a/docs/design-docs/secret-store.md b/docs/design-docs/secret-store.md
new file mode 100644
index 000000000..60766366d
--- /dev/null
+++ b/docs/design-docs/secret-store.md
@@ -0,0 +1,853 @@
+# Secret Store
+
+Credential storage with two secret categories: system secrets (internal, never exposed) and tool secrets (passed to worker subprocesses as env vars). Works out of the box without encryption — the master key is an optional hardening layer that adds encryption at rest.
+
+**Hard dependency:** Environment sanitization (sandbox-hardening.md, Phase 2) must ship before or alongside this. Without `--clearenv` in sandbox wrapping, system secrets and other env vars leak to workers.
+
+## Current State
+
+All secrets currently live in config.toml as plaintext:
+
+**config.toml** — the vast majority of users (all hosted, most self-hosted) set up API keys through the dashboard's provider UI. The dashboard sends the key to `PUT /api/providers`, which writes the literal value directly into config.toml (`anthropic_key = "sk-ant-abc123..."`). The `env:` prefix (`anthropic_key = "env:ANTHROPIC_API_KEY"`) exists as a mechanism but is only used in the initial boot script template and by a small number of self-hosted users who configure env vars manually. In practice, nearly every instance has plaintext API keys in config.toml on the persistent volume.
+
+This file is accessible via `GET /api/config/raw` in the dashboard and via `cat /data/config.toml` through the shell tool when sandbox is off. Users have leaked keys by screensharing their config page.
+
+**Environment variables** on a live hosted instance are all non-sensitive infrastructure vars:
+
+```
+# Fly metadata (non-sensitive)
+FLY_APP_NAME=sb-0759a0a6
+FLY_REGION=iad
+FLY_VM_MEMORY_MB=8192
+FLY_IMAGE_REF=registry.fly.io/spacebot-image:v0.2.1
+
+# Spacebot config (non-sensitive)
+SPACEBOT_DEPLOYMENT=hosted
+SPACEBOT_DIR=/data
+
+# Standard process vars
+HOME=/root
+PATH=/data/tools/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+PWD=/data/agents/spacedrive-discord/workspace
+
+# Browser config
+CHROME_FLAGS=--no-sandbox --disable-dev-shm-usage --disable-gpu
+```
+
+API keys are NOT in the environment today — they're in config.toml. The secret store keeps it that way for system secrets and only exposes tool secrets as env vars.
+
+**The existing secret store** (`src/secrets/store.rs`) implements AES-256-GCM encrypted key-value storage on redb with a `DecryptedSecret` wrapper that redacts in Debug/Display. It exists, is tested, but has zero callers in production.
+
+## Problems
+
+1. **Config is toxic to display.** The dashboard shows config.toml which contains literal API keys for nearly every user. Users have leaked keys by opening their config in screenshares or screenshots.
+
+2. **Workers can read all secrets.** The config file is on disk at a known path (`/data/config.toml`). With sandbox off, `cat /data/config.toml` via the shell tool dumps every key. With sandbox on, the file is read-only but still readable.
+
+3. **Agents can't safely inspect their own config.** The file tool blocks `/data/config.toml` (outside workspace), but workers have shell/exec which bypass that trivially. If keys were not in the config, agents could freely read it — useful for self-diagnosis ("what model am I configured to use?", "which messaging adapters are enabled?").
+
+4. **No separation between internal and external secrets.** LLM API keys (needed only by the Rust process internally) and tool credentials (needed by CLI tools workers invoke) are stored and handled identically. There's no reason a worker subprocess should ever see `ANTHROPIC_API_KEY`.
+
+5. **Prompt injection risk.** A malicious message in a Discord channel could attempt to convince the agent to read and output the config file. The leak detection hook catches known API key patterns, but if the key format isn't in the pattern list, it goes through.
+
+## Design
+
+### Two Secret Categories
+
+The category controls **subprocess exposure**, not internal access. All secrets in the store are readable by Rust code via `SecretsStore::get()` regardless of category. The category answers one question: **should this value be injected as an env var into worker subprocesses?**
+
+**System secrets** — not exposed to subprocesses. Rust code reads them from the store for internal use (LLM clients, messaging adapters, webhook integrations). Workers never see these as env vars.
+
+Examples:
+
+- `ANTHROPIC_API_KEY`
+- `OPENAI_API_KEY`
+- `DISCORD_BOT_TOKEN`
+- `TELEGRAM_BOT_TOKEN`
+- Slack tokens, webhook signing secrets
+
+**Tool secrets** — exposed to subprocesses as env vars. Rust code can also read them from the store if needed (e.g., a `GITHUB_TOKEN` used by both a Rust webhook integration and by `gh` CLI in workers). `wrap()` injects these via `--setenv` (bubblewrap) or `Command::env()` (passthrough).
+
+Examples:
+
+- `GH_TOKEN` / `GITHUB_TOKEN`
+- `NPM_TOKEN`
+- `AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY`
+- `DOCKER_TOKEN`
+- Any user-configured credential their agent needs at the shell level
+
+Tool is a superset of system in terms of access — tool secrets are readable by Rust code AND visible to workers. System secrets are readable by Rust code only. If a credential is needed by both Rust internals and CLI tools, make it a tool secret. There's no "both" category because tool already implies both.
+
+### Category Assignment
+
+The dashboard's secrets panel exposes the category when adding or editing a secret. Known keys are auto-categorized:
+
+| Pattern                                   | Category       | Rationale                                                 |
+| ----------------------------------------- | -------------- | --------------------------------------------------------- |
+| `*_API_KEY` matching known LLM providers  | System         | Only LlmManager needs these                               |
+| `DISCORD_BOT_TOKEN`, `TELEGRAM_BOT_TOKEN` | System         | Only MessagingManager needs these                         |
+| `SLACK_*_TOKEN`, `SLACK_SIGNING_SECRET`   | System         | Only Slack adapter needs these                            |
+| `GH_TOKEN`, `GITHUB_TOKEN`                | Tool           | `gh` CLI expects this                                     |
+| `NPM_TOKEN`                               | Tool           | `npm` expects this                                        |
+| `AWS_*`                                   | Tool           | AWS CLI expects these                                     |
+| Everything else                           | **System (default)** | Unknown credentials default to the more restrictive category — not exposed to workers |
+
+Users can override the auto-categorization. The default for unknown secrets is **system** (not exposed to workers) because defaulting to tool would be privilege-expanding — an internal credential accidentally categorized as tool becomes visible to every worker subprocess. It's safer to require the user to explicitly opt a secret into tool category if workers need it. The dashboard shows a clear prompt: *"Should worker processes have access to this credential? (Required for CLI tools like `gh`, `npm`, `aws`.)"*
+
+### Two Modes: Unencrypted and Encrypted
+
+The secret store operates in two modes:
+
+**Unencrypted (default):** Secrets are stored in plaintext in `secrets.redb`. The store is always available — no master key needed, no unlock step, no setup. All secret store features work: `secret:` config references, system/tool categorization, env sanitization, output scrubbing, worker secret name injection. The only thing missing is encryption at rest — if someone gets access to the redb file, they can read the secrets.
+
+This is still a significant improvement over the current state (plaintext keys in config.toml) because:
+- Config.toml is safe to display (only `secret:` aliases).
+- System secrets never enter subprocess environments.
+- Tool secret values are scrubbed from worker output.
+- The dashboard secrets panel never shows plaintext values.
+- The attack surface narrows from "read a config file" to "read a specific redb file and know how to parse it."
+
+**Encrypted (opt-in, recommended):** User enables encryption by generating a master key. Secrets are encrypted with AES-256-GCM in redb. The master key is stored in the OS credential store (macOS Keychain, Linux kernel keyring) — never as an env var or file on disk. Even if the volume is compromised, secrets are unreadable without the key.
+
+Hosted instances are always encrypted — the platform generates and manages the master key automatically. Self-hosted users can enable encryption at any time via the dashboard or CLI.
+
+### Master Key Storage (Encrypted Mode)
+
+When encryption is enabled, the master key is stored in the **OS credential store** — macOS Keychain or Linux kernel keyring. It never exists as an environment variable or a file readable by workers. This is the only approach that definitively protects the key from LLM-driven workers regardless of sandbox state.
+
+#### Why Not an Env Var or File?
+
+Both are readable by workers when sandbox is off:
+
+- **Env var:** `std::env::remove_var()` removes the variable from libc's environ list, but on Linux `/proc/self/environ` is an immutable kernel snapshot from exec time. A worker running `cat /proc/<pid>/environ | strings | grep MASTER` retrieves the key even after removal. On macOS, `ps eww <pid>` can show environment variables.
+- **File on disk:** Without sandbox, the worker runs as the same user and can `cat /data/.master_key` or any other path. File permissions don't help — same user, same access.
+
+With sandbox on, both can be protected (bubblewrap's `--unshare-pid` hides `/proc`, and the key file can be excluded from bind mounts). But the secret store should be secure regardless of sandbox state — sandbox protects the workspace, the OS credential store protects the master key. Independent layers.
+
+#### macOS: Keychain
+
+- Store via `SecItemAdd` / retrieve via `SecItemCopyMatching` using the Security framework.
+- Access is controlled by the calling binary's code signature and ACL. A `bash` subprocess spawned by ShellTool is a different binary — Keychain will not grant access without explicit user authorization.
+- Even `security find-generic-password` from a worker fails because the Keychain item's access list only includes the Spacebot binary.
+- The `security-framework` crate provides safe Rust bindings.
+
+**Keychain item:**
+```
+Service:  "sh.spacebot.master-key"
+Account:  "<instance_id>" (or "default" for self-hosted single-instance)
+Data:     <32 random bytes>
+Access:   Spacebot binary only (kSecAttrAccessibleAfterFirstUnlock)
+```
+
+#### Linux: Kernel Keyring (`keyctl`)
+
+- Store via `add_key("user", "spacebot_master", key_bytes, session_keyring)` — the key lives in kernel memory, not on any filesystem.
+- Scoped to a **session keyring**. Spacebot creates a new session keyring on startup via `keyctl_join_session_keyring()`. Workers are spawned with a fresh empty session keyring via `pre_exec` — they cannot access the parent's keyring.
+- No file to `cat`, no env var to read, no `/proc` exposure. The key is only accessible via the `keyctl` syscall with the correct keyring ID, which workers don't have.
+- Works without sandbox, without root. The kernel enforces access control at the syscall level.
+
+**Worker isolation (pre_exec):**
+```rust
+// Before exec'ing the worker subprocess:
+unsafe {
+    command.pre_exec(|| {
+        // Give the child a new empty session keyring.
+        // It cannot access the parent's session keyring.
+        // CRITICAL: if this fails, the child inherits the parent's keyring
+        // and can access the master key. Fail hard — do not spawn the worker.
+        let result = libc::syscall(
+            libc::SYS_keyctl,
+            0x01, /* KEYCTL_JOIN_SESSION_KEYRING */
+            std::ptr::null::<libc::c_char>(),
+        );
+        if result < 0 {
+            return Err(std::io::Error::last_os_error());
+        }
+        Ok(())
+    });
+}
+```
+
+If `KEYCTL_JOIN_SESSION_KEYRING` fails (returns -1), `pre_exec` returns `Err`, which causes `Command::spawn()` to fail. The worker is not started. This is the correct behavior — a worker that inherits the parent's session keyring could access the master key via `keyctl read`. The failure should be logged as an error with the errno for debugging (common causes: kernel compiled without `CONFIG_KEYS`, seccomp policy blocking `keyctl`).
+
+This is additive to `--clearenv` — env sanitization strips env vars, the session keyring swap strips keyring access. Both run regardless of sandbox state.
+
+#### Hosted Deployment
+
+The platform generates a per-instance master key on provisioning and stores it in the platform database (tied to the user's account). On instance startup, the platform writes the key to a **tmpfs file** that Spacebot reads once, then the platform deletes it. Spacebot stores the key in the Linux kernel keyring immediately and never persists it to the volume.
+
+Flow:
+1. Platform provisions instance → generates 32-byte random key → stores in platform DB (`instances.master_key`, encrypted at rest).
+2. Platform starts Fly machine → writes key to `/run/spacebot/master_key` (tmpfs, 0600, root-only).
+3. Spacebot startup → reads `/run/spacebot/master_key` → stores in kernel keyring → deletes the tmpfs file.
+4. Key is now only in kernel memory. Volume compromise doesn't expose it. `/run` is tmpfs, wiped on restart.
+5. On next restart, the platform re-injects the key via the same tmpfs mechanism.
+
+Properties:
+- The key persists across restarts and rollouts — the platform always re-injects it from its database.
+- The key is tied to the user's platform account, not to the volume. If the volume is compromised without platform access, the `secrets.redb` file is useless.
+- The key is platform-managed. The user never sees the raw master key — the platform handles injection and rotation. The user can trigger rotation via the dashboard ("Rotate Encryption Key"), which calls the platform API to generate a new key, re-encrypt, and update its database. No key is displayed to the user.
+- The platform database becomes a store of master keys, but it already stores auth tokens and Stripe credentials — same protection requirements.
+
+#### Self-Hosted Deployment
+
+The secret store is **always enabled** on self-hosted instances — it works in unencrypted mode out of the box. Users can opt into encryption through the dashboard:
+
+1. User navigates to Settings → Secrets. The secrets panel is fully functional (add, edit, delete secrets). A banner shows: *"Secrets are stored without encryption. Enable encryption for protection against volume compromise."*
+2. User clicks "Enable Encryption."
+3. Spacebot generates a 32-byte random master key, encrypts all existing secrets in place.
+4. The key is stored in the OS credential store (Keychain on macOS, kernel keyring on Linux).
+5. The dashboard displays the key once: *"Save this master key somewhere safe. You'll need it to unlock the secret manager after a reboot (Linux) or if the Keychain is reset (macOS)."*
+6. The key is **not written to disk**. No `.master_key` file, no env var, no config entry. The only durable copies are the OS credential store and whatever the user saved externally.
+
+**On macOS**, the Keychain persists across restarts. The encrypted store unlocks automatically on every boot. The user's saved copy is a disaster-recovery backup only.
+
+**On Linux**, the kernel keyring is cleared on reboot. After a reboot, the encrypted store starts in a **locked** state. The user unlocks it via the dashboard or CLI by providing the master key (see "Dashboard & CLI Secret Management" below). This is a deliberate trade-off:
+
+- **No key file on disk** means no file for workers to `cat` — the master key is protected regardless of sandbox state. This was the entire motivation for the OS credential store design.
+- **Unlock on reboot** is a one-time action per boot. For a headless bot that reboots rarely (planned maintenance, kernel updates), this is an acceptable cost.
+- **All secrets are unavailable while locked.** `POST /api/secrets/encrypt` does an in-place encryption — plaintext values are wiped and replaced with encrypted versions. There is no parallel plaintext copy. When locked, `secret:` references fail to resolve, LLM providers and messaging adapters start without credentials (degraded mode). The bot starts and the control API is available (so the unlock command has something to talk to), but it cannot process messages or make LLM calls until unlocked.
+- **Secrets configured via `env:` or literal values in config.toml still work while locked** — they don't go through the secret store. If a user keeps some credentials in `env:` config references as a fallback for critical services (e.g., the Discord bot token to stay connected and receive the unlock command), those work regardless of store state. This is a valid pattern for Linux self-hosters who want encryption but also want the bot to stay reachable after reboot.
+
+For users who don't want the unlock-after-reboot requirement, the unencrypted store works indefinitely. All features except encryption at rest are available.
+
+**Startup flow (all deployments):**
+
+1. Open `SecretsStore` (redb). The store always initializes — it works in unencrypted mode by default.
+2. Check if the store contains encrypted secrets (encryption header in redb metadata).
+3. If **unencrypted** (or no secrets yet): store is immediately available. Read all secrets. Skip to step 7.
+4. If **encrypted**: check OS credential store for master key (Keychain / kernel keyring).
+5. If master key found (or injected via tmpfs on hosted → load into OS credential store → delete tmpfs file): derive AES-256-GCM cipher key via Argon2id (~100ms), decrypt all secrets. Store is **unlocked**.
+6. If master key not found: store enters **locked** state. Encrypted secrets are unavailable. **The bot still starts** — the control API (port 19898) and embedded dashboard come up so the user can issue the unlock command. LLM providers and messaging adapters that depend on `secret:` references start in degraded mode (no credentials). Components configured via `env:` or literal config values still work. On unlock (via dashboard or CLI): key is loaded into OS credential store → derive cipher → decrypt → re-initialize dependent components.
+7. **System secrets:** passed directly to Rust components (`LlmManager`, `MessagingManager`, etc.). Never set as env vars.
+8. **Tool secrets:** held in a `HashMap<String, String>` for `Sandbox::wrap()` injection via `--setenv`.
+
+#### Key Derivation
+
+Argon2id rather than the current SHA-256 in `build_cipher()`. For hosted instances where the platform generates a random high-entropy key, SHA-256 would be fine — but self-hosted users may use a passphrase (future: dashboard "set your own key" option), and SHA-256 of a passphrase is trivially brutable. Argon2id handles both cases correctly (memory-hard, resistant to GPU/ASIC attacks) and the cost is a one-time ~100ms at startup. No reason to ship the weak path and upgrade later.
+
+#### Upgrade Path
+
+1. **New version ships.** The secret store is enabled by default in unencrypted mode. Auto-migration runs on first boot: literal keys in config.toml → secret store (unencrypted), config.toml rewritten with `secret:` references. All security features work immediately (env sanitization, system/tool separation, output scrubbing, safe config display).
+2. **Hosted users:** The platform also generates master keys for all instances and injects them via tmpfs. Migration encrypts secrets automatically. Fully encrypted from day one, no user action required.
+3. **Self-hosted users:** Migration to the unencrypted store is automatic. The dashboard shows a banner encouraging encryption: *"Secrets are stored without encryption. Enable encryption for protection against volume compromise."* Encryption is opt-in — user clicks "Enable Encryption" when ready.
+
+On startup, Spacebot scans the environment for variables matching known secret patterns (anything with `TOKEN`, `KEY`, `SECRET`, `PASSWORD` in the name). If found and `passthrough_env` doesn't list them, a prominent warning is logged: "Detected secrets in environment variables. Consider moving them to the secret store." The warning is informational — nothing breaks, nothing is stripped.
+
+### Config Resolution Prefixes
+
+Config values support three resolution modes via prefix:
+
+```toml
+# Literal — plaintext value inline (current default, what migration replaces)
+anthropic_key = "sk-ant-abc123..."
+
+# env: — read from system environment variable at resolve time
+anthropic_key = "env:ANTHROPIC_API_KEY"
+
+# secret: — read from secret store (held in memory)
+anthropic_key = "secret:ANTHROPIC_API_KEY"
+```
+
+The `secret:` prefix is a resolution directive: "this value lives in the `SecretsStore`, look it up by this name, return the value." The config doesn't know or care whether the secret is categorized as system or tool, or whether the store is encrypted — it just gets the resolved string. The category is metadata on the secret in the store and only matters at `wrap()` time when deciding what to inject into worker subprocesses.
+
+**Secret names use UPPER_SNAKE_CASE matching env var convention.** The secret name in the store IS the env var name — `GH_TOKEN`, not `gh_token`. For tool secrets, `wrap()` iterates the store and does `--setenv {name} {value}` with no translation. For system secrets, the name is just an identifier (they're never env vars), but using the same convention keeps everything consistent. Skills that say "set `GH_TOKEN`" map directly to a secret named `GH_TOKEN` in the dashboard.
+
+### Config Key Migration
+
+All provider keys and sensitive tokens move from config.toml to the secret store. Config.toml changes from:
+
+```toml
+[llm]
+anthropic_key = "sk-ant-abc123..."
+
+[messaging.discord]
+token = "env:DISCORD_BOT_TOKEN"
+```
+
+To:
+
+```toml
+[llm]
+anthropic_key = "secret:ANTHROPIC_API_KEY"
+
+[messaging.discord]
+token = "secret:DISCORD_BOT_TOKEN"
+```
+
+The `resolve_env_value()` function (`config.rs:2974`) is extended to handle the `secret:` prefix:
+
+```rust
+fn resolve_secret_or_env(value: &str, secrets: &SecretsStore) -> Option<String> {
+    if let Some(alias) = value.strip_prefix("secret:") {
+        secrets.get(alias).ok().map(|s| s.expose().to_string())
+    } else if let Some(var_name) = value.strip_prefix("env:") {
+        std::env::var(var_name).ok()
+    } else {
+        Some(value.to_string()) // literal
+    }
+}
+```
+
+The resolved values are consumed by Rust code (provider constructors, adapter init). They are never set as env vars. The `secret:` prefix is the config-level reference; the category (system vs tool) determines runtime behavior.
+
+**Migration path:**
+
+1. On first boot with the new version, if config.toml contains literal key values (not `env:` or `secret:` prefixed), auto-migrate: store each literal value in the secret store under a deterministic UPPER_SNAKE_CASE name (e.g., `anthropic_key` → `secret:ANTHROPIC_API_KEY`), with auto-detected category. Encryption is not required — migration works in unencrypted mode.
+2. Rewrite config.toml in place to replace literal values with `secret:` references.
+3. Log every migration step. If migration fails for any key, leave the original value in config.toml and warn.
+4. For `env:` prefixed values, leave them as-is. They're already not storing the secret in the config. Users who want to migrate `env:` values to the secret store can do so explicitly via the dashboard.
+5. The `env:` prefix continues to work for users who prefer env-var-based key management.
+6. **Hosted:** Migration runs automatically on first boot. The platform also enables encryption (see Upgrade Path above).
+7. **Self-hosted:** Migration runs automatically on first boot. The store starts in unencrypted mode. Users can enable encryption later via the dashboard.
+
+### Dashboard Changes
+
+- **Provider setup** writes `secret:` references by default. The "API Key" field in the provider UI is a password input that sends the value to the API, which stores it in the secret store (as a system secret) and writes `secret:provider_name` to config.toml.
+- **Raw config view** (`GET /api/config/raw`) is safe to display since config.toml only contains aliases.
+- **Secrets panel** — list all secrets with name, category (system/tool), and masked value. Add/remove/rotate. Category is editable. Never displays plaintext values (shows masked `***` with a copy button that copies from a short-lived in-memory decryption).
+- **Secret store status** — indicator showing store state: `unencrypted` (working, encryption available), `unlocked` (encrypted and operational), or `locked` (encrypted, needs master key). For hosted instances, always `unlocked` (platform-managed). See "Dashboard & CLI Secret Management" for full UX details.
+
+### Env Sanitization Integration
+
+The sandbox `wrap()` function (see sandbox-hardening.md, Section 2) handles the env var injection:
+
+1. `--clearenv` strips everything from the subprocess.
+2. Re-add safe vars: `PATH` (with tools/bin), `HOME`, `USER`, `LANG`, `TERM`.
+3. Re-add **tool secrets only** — iterate the secret store's tool category, `--setenv` each into the subprocess.
+4. System secrets are **never** injected. The master key is never in the process environment (it lives in the OS credential store), so there's nothing to strip — but even if it were, `--clearenv` would exclude it.
+
+The `Sandbox` struct needs access to the tool secrets. Options:
+
+- `Sandbox` holds an `Arc<ArcSwap<HashMap<String, String>>>` of tool env vars, updated when secrets change.
+- The `SecretsStore` exposes a `tool_env_vars() -> HashMap<String, String>` method, and `Sandbox` holds an `Arc<SecretsStore>`.
+
+Either way, `wrap()` reads the current tool secrets on each call and injects them. This is cheap — the set changes rarely (only when the user adds/removes secrets via the dashboard).
+
+### Worker Secret Awareness
+
+Workers get the **names** of available tool secrets injected into their system prompt — never the values. This tells the worker what credentials are available without it having to run `printenv` to discover them:
+
+```
+Available tool secrets (set as environment variables in your shell):
+  GH_TOKEN, NPM_TOKEN, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY
+
+Commands that use these credentials will work automatically (e.g., gh commands
+use GH_TOKEN). Do not echo, print, or log secret values.
+```
+
+This is assembled at worker construction time from the tool secret names in the store. The list updates when secrets change (workers spawned after a secret is added/removed get the updated list).
+
+**Why this matters:**
+- Without it, the worker has to guess or run `printenv` to find out what's available. That wastes a turn and the `printenv` output contains the actual values in the worker's own context (even though the scrubber would catch them before they reach the channel).
+- With it, the worker knows `GH_TOKEN` is available and can use `gh` commands immediately. No discovery step, no secret values in context.
+- Skills that say "requires `GH_TOKEN`" align directly — the worker sees the name in its prompt and knows the credential is present.
+- The "do not print secret values" instruction is a soft guardrail. The real guardrail is the output scrubber. But telling the LLM not to do it reduces the frequency, which means less scrubbing and less noise in logs.
+
+### Output Scrubbing (Tool Secret Redaction)
+
+Workers need tool secrets in their subprocess environment to run CLI tools. But there's no reason the secret _values_ should propagate back up to channels or branches. A worker running `gh pr create` needs `GH_TOKEN` in its env, but the channel receiving the worker's result doesn't need to see the token value if it leaks into stdout.
+
+**Mechanism:** Every string that flows from a worker back toward a channel or branch is checked against the current set of tool secret values (exact substring match). Any match is replaced with `[REDACTED:<secret_name>]`.
+
+```
+Worker stdout: "Authenticated as user X. Token: ghp_abc123def456..."
+Scrubber: checks against all tool_env_vars() values
+Match found: "ghp_abc123def456..." == tool secret "GH_TOKEN"
+Redacted:    "Authenticated as user X. Token: [REDACTED:GH_TOKEN]"
+```
+
+**Where it runs:**
+
+| Output path              | Scrubbing point                                                    |
+| ------------------------ | ------------------------------------------------------------------ |
+| Worker result text       | Before injection into channel/branch history                       |
+| `set_status` tool output | Before adding to the status block (channels read this every turn)  |
+| OpenCode SSE events      | Before forwarding to the worker event handler                      |
+| Branch conclusions       | Before injection into channel history (branches can spawn workers) |
+
+**Why exact match, not regex:** Leak detection (SpacebotHook) already does regex pattern matching for known key formats (`sk-ant-*`, `ghp_*`, etc.). The scrubber is complementary — it catches secrets that don't have recognizable patterns. A random 64-char string the user stored as a tool secret has no regex pattern, but the scrubber knows its exact value and catches it. The two layers work together:
+
+- **Leak detection (regex):** catches known formats even if the secret isn't in the store (e.g., a key the user typed inline). Reactive — kills the agent after detection.
+- **Output scrubbing (exact match):** catches any stored tool secret regardless of format. Proactive — redacts before the value reaches the channel. The channel sees `[REDACTED:GH_TOKEN]` and knows the secret was used, but never sees the value.
+
+**Streaming safety (split-secret problem):** If a secret value is split across two adjacent SSE events or stream chunks, a per-string exact match misses it. For example, `GH_TOKEN = "ghp_abc123def456"` split as `"...ghp_abc123"` + `"def456..."` — neither chunk contains the full secret.
+
+Fix: the scrubber maintains a **rolling buffer** per output stream. For each stream (identified by worker ID + output path), the scrubber holds the tail of the previous chunk, sized to `max_secret_length - 1` bytes. On each new chunk, it concatenates `[tail_of_previous | new_chunk]`, scrubs the combined string, then emits everything except the new tail (which is held for the next chunk). On stream end, the held tail is flushed and scrubbed.
+
+```rust
+struct StreamScrubber {
+    buffer: String,
+    max_secret_len: usize, // max length across all tool secret values
+}
+
+impl StreamScrubber {
+    fn scrub_chunk(&mut self, chunk: &str, secrets: &HashMap<String, String>) -> String {
+        self.buffer.push_str(chunk);
+        let emit_up_to = self.buffer.len().saturating_sub(self.max_secret_len - 1);
+        let to_emit = scrub_secrets(&self.buffer[..emit_up_to], secrets);
+        self.buffer = self.buffer[emit_up_to..].to_string();
+        to_emit
+    }
+
+    fn flush(&mut self, secrets: &HashMap<String, String>) -> String {
+        let remaining = std::mem::take(&mut self.buffer);
+        scrub_secrets(&remaining, secrets)
+    }
+}
+```
+
+This adds latency of `max_secret_len` bytes per chunk — typically 40-100 bytes for API keys. Negligible for worker output which is displayed progressively anyway.
+
+For non-streaming paths (worker result text, branch conclusions), the full string is available at once — no buffer needed, simple `scrub_secrets()` call.
+
+**Cost:** Comparing every worker output string against every tool secret value. With typically <20 secrets and output in the KB range, this is a substring search over a small set — negligible. The secret values are already in memory (the tool env var cache). No decryption on each check.
+
+**Implementation:** A `scrub_secrets(text: &str, tool_secrets: &HashMap<String, String>) -> String` function that iterates the map and replaces all occurrences, plus `StreamScrubber` for chunked output paths (OpenCode SSE, streaming tool output). Both live in `src/secrets/scrub.rs`.
+
+### Protection Layers (Summary)
+
+| Layer                                                  | Requires Encryption | What It Protects Against                                                       |
+| ------------------------------------------------------ | ------------------- | ------------------------------------------------------------------------------ |
+| `secret:` aliases in config.toml                       | No                  | Config file exposure (screenshare, `cat`, dashboard display)                   |
+| System/tool category separation                        | No                  | Workers seeing LLM API keys, messaging tokens, or other internal credentials   |
+| `DecryptedSecret` wrapper                              | No                  | Accidental logging of secret values in tracing output                          |
+| Env sanitization (`--clearenv` + selective `--setenv`) | No                  | Workers only get tool secrets, never system secrets or internal vars |
+| Worker secret name injection (prompt)                  | No                  | Workers know what credentials are available without running `printenv` — no secret values in LLM context |
+| Output scrubbing (exact match)                         | No                  | Tool secret values propagating from worker output back to channels/branches |
+| Leak detection (SpacebotHook, regex)                   | No                  | Last-resort safety net — known key format patterns in any tool output          |
+| Secret store encryption (AES-256-GCM)                  | **Yes**             | Disk access to secrets.redb (stolen volume, backup leak)                       |
+| Master key in OS credential store (Keychain / kernel keyring) | **Yes**       | Worker access to the encryption key — OS enforces access control at the binary/keyring level, independent of sandbox state |
+| Worker session keyring isolation (`pre_exec`)          | **Yes**             | Workers accessing parent's kernel keyring on Linux (additive to `--clearenv`)  |
+
+### What This Doesn't Solve
+
+- **Workers can see tool secrets in their own process.** A worker running `printenv GH_TOKEN` gets the value in its subprocess. This is by design — the worker needs it to run `gh` commands. But the value is scrubbed from the worker's output before it reaches the channel.
+- **Side channels within the workspace.** A worker could write a tool secret to a file, then a subsequent worker reads it. The sandbox limits where files can be written, but within the workspace it's unrestricted. Output scrubbing catches the value if it appears in any worker's output, but not if it stays in a file.
+- **Encoding/obfuscation.** A worker could base64-encode a secret value before outputting it. The exact-match scrubber wouldn't catch the encoded form. Leak detection's regex patterns also wouldn't match. This is a theoretical attack by a deliberately adversarial LLM, not an accidental leak.
+
+The key properties: **system secrets never leave Rust memory.** Tool secrets reach worker subprocesses (necessary) but are scrubbed from all output flowing back to channels (the LLM context). A channel never sees a secret value — it sees `[REDACTED:GH_TOKEN]` at most.
+
+## Files Changed
+
+| File                                  | Change                                                                                                                                                              |
+| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `src/secrets/store.rs`                | Add unencrypted mode; add secret category (system/tool); add `tool_env_vars()` method; add `tool_secret_names()` for prompt injection; encrypt-in-place support; Argon2id key derivation for encrypted mode |
+| `src/secrets/scrub.rs`                | New: `scrub_secrets()` — exact-match redaction of tool secret values in output strings                                                                              |
+| `src/config.rs`                       | Extend `resolve_env_value()` to handle `secret:` prefix; wire `SecretsStore` into config loading; migration logic for existing literal/env keys                     |
+| `src/sandbox.rs`                      | `wrap()` injects tool secrets via `--setenv`; holds reference to secret store or tool env var cache                                                                 |
+| `src/agent/worker.rs`                 | Scrub worker result text through `scrub_secrets()` before injecting into channel/branch history; inject tool secret names into worker system prompt                  |
+| `src/tools/set_status.rs`             | Scrub status text through `scrub_secrets()` before updating status block                                                                                            |
+| `src/opencode/worker.rs`              | Scrub OpenCode SSE output events through `scrub_secrets()` before forwarding                                                                                        |
+| `src/api/secrets.rs`                  | New: secret CRUD, status, encrypt, unlock/lock, rotate, migrate, export/import endpoints                                                                           |
+| `src/api/server.rs`                   | Add secret management routes                                                                                                                                        |
+| `src/secrets/keystore.rs`             | New: OS credential store abstraction — `KeyStore` trait with `MacOSKeyStore` (Security framework / Keychain) and `LinuxKeyStore` (kernel keyring / keyctl) backends  |
+| `src/main.rs`                         | Initialize `SecretsStore` (unencrypted or encrypted), auto-migrate literal keys from config.toml on first boot, load master key from OS credential store if encrypted (or enter locked state), pass system secrets to provider init |
+| `src/agent/worker.rs`                 | Add `pre_exec` hook to spawn workers with a fresh empty session keyring (Linux) |
+| `spacebot-platform/api/src/fly.rs`    | Generate per-instance master key on provisioning, store in platform DB, inject via tmpfs at `/run/spacebot/master_key` in `machine_config()`                        |
+| `spacebot-platform/api/src/db.rs`     | Add `master_key` column to instances table (encrypted at rest)                                                                                                      |
+| `spacebot-platform/api/src/routes.rs` | Add master key rotation endpoint for dashboard                                                                                                                      |
+
+## Phase Plan
+
+**Hard dependency on sandbox-hardening.md Phase 2 (env sanitization).** The master key is protected independently by the OS credential store, but without `--clearenv`, system secrets and other env vars still leak to worker subprocesses.
+
+### Phase 1: Core Secret Store (Unencrypted)
+
+The secret store ships and works immediately for all users without any setup.
+
+1. Extend `SecretsStore` to support unencrypted mode (plaintext values in redb, no cipher needed).
+2. Extend `resolve_env_value()` to handle `secret:` prefix.
+3. Auto-migration on first boot: detect literal keys in config.toml → store in redb → rewrite config.toml with `secret:` references.
+4. System secrets: pass values directly to `LlmManager`, `MessagingManager`, etc. during init. Never set as env vars.
+5. Tool secrets: expose via `tool_env_vars()` for `Sandbox::wrap()` injection.
+6. Inject tool secret names (not values) into worker system prompts at construction time.
+7. Secret CRUD API: `GET/PUT/DELETE /api/secrets/:name`, `GET /api/secrets/status`.
+8. Dashboard secrets panel: list, add, edit, delete secrets with category assignment.
+
+### Phase 1.5: Encryption (Opt-In)
+
+Layered on top of the working unencrypted store.
+
+1. Implement `KeyStore` abstraction with macOS Keychain and Linux kernel keyring backends (`src/secrets/keystore.rs`).
+2. `POST /api/secrets/encrypt` — generate master key, encrypt all existing secrets in place, store key in OS credential store.
+3. Add `pre_exec` hook to worker spawning: children get a fresh empty session keyring (Linux).
+4. Startup: detect encrypted store → load master key from OS credential store → derive cipher key via Argon2id → decrypt. If key not found → locked state.
+5. Unlock/lock API: `POST /api/secrets/unlock`, `POST /api/secrets/lock`.
+6. Platform: generate per-instance master key on provisioning, store in platform DB, inject via tmpfs at `/run/spacebot/master_key`. Hosted instances are always encrypted.
+7. Key rotation: `POST /api/secrets/rotate`.
+8. Export/import for backup and migration.
+
+### Phase 2: Output Scrubbing
+
+1. Implement `scrub_secrets()` — exact substring match against all tool secret values, replace with `[REDACTED:<name>]`.
+2. Wire into worker result path (before channel/branch history injection).
+3. Wire into `set_status` (before status block update).
+4. Wire into OpenCode SSE event forwarding.
+5. Wire into branch conclusion path (before channel history injection).
+6. Verify: worker running `echo $GH_TOKEN` produces `[REDACTED:GH_TOKEN]` in the channel's view of the result.
+
+### Phase 3: Hosted Encryption Rollout
+
+1. Platform generates master keys for all existing instances, stores in platform DB.
+2. On next image rollout, keys are injected via tmpfs. Encryption is enabled automatically on first boot with the new image.
+3. Verify: all hosted instances have encrypted stores; config.toml contains no plaintext keys; `GET /api/config/raw` is safe to display.
+
+### Phase 4: Dashboard & CLI
+
+1. Secrets panel: list secrets with name, category (system/tool), masked value. Add/remove/rotate. Works in both unencrypted and unlocked states.
+2. Provider setup UI writes `secret:` references and stores as system secrets.
+3. Secret store status indicator (`unencrypted` / `locked` / `unlocked`).
+4. Encryption onboarding banner for unencrypted self-hosted stores.
+5. Unlock prompt for locked stores (after Linux reboot).
+6. CLI `spacebot secrets` subcommand tree. See "Dashboard & CLI Secret Management" for full specification.
+7. Hosted: master key rotation via platform API.
+
+## Open Questions
+
+1. **Secret rotation and hot-reload.** When a user rotates a key (e.g., regenerates their Anthropic API key), the workflow is: update via dashboard → store encrypts new value → config references unchanged. But the LLM manager holds the old key in memory. Do we need a reload hook that re-reads system secrets from the store? Tool secrets are re-read on each `wrap()` call so they update automatically.
+2. **Migration rollback.** After migrating keys from config.toml to the secret store, if the secret store becomes corrupted or the master key is lost, is there a recovery path? Should we keep a one-time encrypted backup of the pre-migration config?
+3. **Platform master key storage.** The platform database will store per-instance master keys. What's the encryption/protection model for the platform database itself? Should the platform encrypt master keys at rest with its own key?
+4. **Category override UX.** How prominent should the system/tool toggle be in the dashboard? Auto-categorization handles the common cases, but users need to understand the distinction to make informed overrides.
+5. ~~**Self-hosted tool secrets without master key.**~~ **Resolved — see `passthrough_env` below.**
+6. ~~**Linux key file exposure without sandbox.**~~ **Resolved — no key file on disk.** Linux uses the kernel keyring only. After reboot, the secret store enters a locked state and the user unlocks via dashboard or CLI. See "Dashboard & CLI Secret Management" below.
+7. **Keychain ACL on unsigned dev builds.** During development, the Spacebot binary may not be code-signed. macOS Keychain ACLs based on code signature won't work for unsigned binaries — need to handle this gracefully (fall back to file-based storage in dev mode, or use a less restrictive Keychain access policy).
+
+### Env Passthrough for Self-Hosted
+
+Some self-hosted users set credentials as env vars in Docker compose or systemd rather than through the dashboard. With env sanitization (`--clearenv`), these env vars get stripped from worker subprocesses. The secret store handles this for secrets it knows about (they're injected via `--setenv`), but env vars that haven't been migrated to the store would be silently lost. That's a breaking change.
+
+**Fix:** A configurable passthrough list in the sandbox config:
+
+```toml
+[agents.sandbox]
+mode = "enabled"
+passthrough_env = ["GH_TOKEN", "GITHUB_TOKEN", "NPM_TOKEN"]
+```
+
+`wrap()` builds the subprocess environment from three sources, checked in order:
+
+1. **Safe vars** — always passed: `PATH` (with tools/bin), `HOME`, `USER`, `LANG`, `TERM`.
+2. **Tool secrets from the store** — all tool-category secrets are injected via `--setenv` (works in both unencrypted and encrypted mode).
+3. **`passthrough_env` list** — for each name in the list, if the var exists in the parent process environment, pass it through to the subprocess. This is the escape hatch for self-hosted users without a master key.
+
+When secrets have been migrated to the store, `passthrough_env` is redundant for those vars. The config field still works (it's additive), but the dashboard can show a hint: "You have passthrough env vars configured. Consider moving these to the secret store."
+
+On hosted instances, `passthrough_env` is empty by default and has no effect — the platform manages all secrets via the store.
+
+**Why not just skip `--clearenv` when there's no master key?** Because `--clearenv` protects more than just the master key — it prevents system secrets, internal vars (`SPACEBOT_*`), and any other env vars from leaking to workers. The master key is protected by the OS credential store regardless of `--clearenv`, but env sanitization is still necessary for everything else. The passthrough list is explicit — the user declares exactly which vars they want forwarded. Everything else is stripped.
+
+---
+
+## Dashboard & CLI Secret Management
+
+The secret store needs a complete management interface — onboarding, unlock/lock lifecycle, secret CRUD, and key backup/rotation. Both the embedded dashboard (SPA) and the CLI provide access to the same underlying API.
+
+### Secret Store States
+
+The store has three states, exposed via `GET /api/secrets/status`:
+
+| State | Meaning | Dashboard Display |
+|-------|---------|-------------------|
+| **`unencrypted`** | Store is active, secrets stored in plaintext in redb. No master key configured. | Full secrets panel + banner: "Enable encryption for protection against volume compromise" |
+| **`locked`** | Encryption is enabled but master key is not currently in the OS credential store. Happens after Linux reboot. | Unlock prompt: "Enter your master key to unlock encrypted secrets" + limited panel (can see secret names but not add/edit/read) |
+| **`unlocked`** | Encryption is enabled and master key is in the OS credential store. Secrets are decrypted and operational. | Full secrets panel |
+
+```json
+// GET /api/secrets/status
+{
+  "state": "unencrypted",      // "unencrypted" | "locked" | "unlocked"
+  "encrypted": false,          // whether encryption is enabled
+  "secret_count": 12,          // total secrets in store
+  "system_count": 5,           // system category count
+  "tool_count": 7,             // tool category count
+  "platform_managed": false    // true on hosted (encryption is automatic, UI hides encryption controls)
+}
+```
+
+How to distinguish states: the redb metadata contains an `encrypted` flag. If `encrypted == false` → `unencrypted`. If `encrypted == true` and master key is in OS credential store → `unlocked`. If `encrypted == true` and master key not found → `locked`.
+
+### Enabling Encryption (Self-Hosted)
+
+The secret store works immediately without encryption. Enabling encryption is a separate step.
+
+**Dashboard:**
+
+1. User navigates to Settings → Secrets. The secrets panel is fully functional. A banner shows: *"Secrets are stored without encryption. Enable encryption for protection against volume compromise."*
+2. Clicks "Enable Encryption."
+3. `POST /api/secrets/encrypt` — Spacebot generates a 32-byte random key, stores it in the OS credential store, encrypts all existing secrets in place, returns the key as a hex string.
+4. Dashboard displays the key in a modal with a copy button and a warning: *"Save this key somewhere safe. On Linux, you'll need it to unlock the secret manager after a reboot. This is the only time the key will be shown."*
+5. User confirms they've saved the key. Banner disappears. Store is now encrypted.
+
+**CLI:**
+
+```bash
+# Enable encryption
+spacebot secrets encrypt
+# Output:
+# Encrypting 12 secrets...
+# Master key: a1b2c3d4e5f6...  (64 hex chars)
+#
+# IMPORTANT: Save this key. You will need it to unlock the
+# secret manager after a reboot. This is the only time it
+# will be displayed.
+
+# Migration (separate from encryption — runs automatically on first boot,
+# or manually if needed)
+spacebot secrets migrate
+# Output:
+# Detected 4 plaintext keys in config.toml:
+#   anthropic_key     → ANTHROPIC_API_KEY (system)
+#   openai_key        → OPENAI_API_KEY (system)
+#   discord.token     → DISCORD_BOT_TOKEN (system)
+#   github_token      → GH_TOKEN (tool)
+# Migrate? [y/N]: y
+# Migrated 4 keys. config.toml updated.
+```
+
+### Unlock / Lock Flow (Encrypted Mode Only)
+
+Only applies when encryption is enabled. Unencrypted stores are always available.
+
+**Dashboard:**
+
+1. On page load, dashboard checks `GET /api/secrets/status`.
+2. If `locked`: shows unlock card with a password input: *"Encrypted secrets are locked. Enter your master key to unlock."*
+3. User pastes key → `POST /api/secrets/unlock` with `{ "master_key": "<hex>" }`.
+4. Server validates the key (attempts to derive cipher and decrypt a known sentinel value in the store). If valid: loads into OS credential store, decrypts all secrets, re-initializes LLM providers and messaging adapters that were started without their secrets. Returns `200`.
+5. If invalid: returns `401` with *"Invalid master key."* Dashboard shows error, lets user retry.
+6. On success, dashboard transitions to the full secrets panel.
+
+**CLI:**
+
+```bash
+# Unlock
+spacebot secrets unlock
+# Enter master key: ********
+# Secret manager unlocked. 12 secrets decrypted.
+# Re-initialized: LlmManager (3 providers), MessagingManager (2 adapters).
+
+# Unlock non-interactively (for automation — key in stdin)
+# NOTE: This example uses an env var for illustration. For production
+# automation, pipe from a secrets manager or file, not a shell env var
+# (env vars are visible in /proc and process listings — the same exposure
+# the OS credential store is designed to avoid).
+cat /run/secrets/spacebot_key | spacebot secrets unlock --stdin
+
+# Lock (clears key from OS credential store — useful for maintenance)
+spacebot secrets lock
+# Secret manager locked. Secrets remain encrypted on disk.
+# The bot will continue running with cached credentials until restart.
+
+# Check status
+spacebot secrets status
+# State: unlocked
+# Secrets: 12 (5 system, 7 tool)
+```
+
+**Lock behavior:** `POST /api/secrets/lock` removes the master key from the OS credential store. The derived cipher key in memory is zeroed. New secret operations fail. Already-decrypted values held by LLM providers and messaging adapters continue working until the process restarts — we don't forcefully kill active connections. On next restart, the store comes up locked.
+
+### Secret CRUD
+
+Available when the store is `unencrypted` or `unlocked`. When `locked`, read-only endpoints (`GET /api/secrets`, `GET /api/secrets/:name/info`) still work — secret names, categories, and metadata are stored as unencrypted headers in redb. Mutation endpoints (`PUT`, `DELETE`) and any operation that touches secret values return `423 Locked`.
+
+**List secrets:**
+
+```
+GET /api/secrets
+```
+```json
+{
+  "secrets": [
+    {
+      "name": "ANTHROPIC_API_KEY",
+      "category": "system",
+      "created_at": "2026-02-25T10:30:00Z",
+      "updated_at": "2026-02-25T10:30:00Z"
+    },
+    {
+      "name": "GH_TOKEN",
+      "category": "tool",
+      "created_at": "2026-02-25T10:31:00Z",
+      "updated_at": "2026-02-27T14:00:00Z"
+    }
+  ]
+}
+```
+
+Values are never returned in list responses. Names and categories only.
+
+**Add / update a secret:**
+
+```
+PUT /api/secrets/:name
+```
+```json
+{
+  "value": "ghp_abc123...",
+  "category": "tool"
+}
+```
+
+If the secret already exists, its value and/or category are updated. The `updated_at` timestamp is refreshed. For tool secrets, the change is immediately available to the next `wrap()` call — no restart needed.
+
+For system secrets, the change is stored but active components (LLM providers, adapters) continue using the old value until a config reload or restart. The response indicates this:
+
+```json
+{
+  "name": "ANTHROPIC_API_KEY",
+  "category": "system",
+  "reload_required": true,
+  "message": "Secret updated. Reload config or restart for the new value to take effect."
+}
+```
+
+**Delete a secret:**
+
+```
+DELETE /api/secrets/:name
+```
+
+Removes from the store. If the secret is referenced by config.toml (`secret:NAME`), the config reference becomes a dangling pointer — `resolve_secret_or_env` returns `None` and the component logs a warning. The response warns about this:
+
+```json
+{
+  "deleted": "GH_TOKEN",
+  "config_references": ["agents.tools.github_token"],
+  "warning": "This secret is referenced in config.toml. The reference will fail to resolve."
+}
+```
+
+**CLI equivalents:**
+
+```bash
+# List
+spacebot secrets list
+# NAME                  CATEGORY   UPDATED
+# ANTHROPIC_API_KEY     system     2026-02-25 10:30
+# GH_TOKEN              tool       2026-02-27 14:00
+
+# Add/update
+spacebot secrets set GH_TOKEN --category tool
+# Enter value: ********
+# Secret GH_TOKEN saved (tool).
+
+# Or non-interactively
+echo "ghp_abc123" | spacebot secrets set GH_TOKEN --category tool --stdin
+
+# Delete
+spacebot secrets delete GH_TOKEN
+# Warning: GH_TOKEN is referenced in config.toml at agents.tools.github_token
+# Delete anyway? [y/N]: y
+# Deleted GH_TOKEN.
+
+# Show category info
+spacebot secrets info GH_TOKEN
+# Name:     GH_TOKEN
+# Category: tool
+# Created:  2026-02-25 10:31
+# Updated:  2026-02-27 14:00
+# Config:   agents.tools.github_token = "secret:GH_TOKEN"
+```
+
+### Key Rotation
+
+Master key rotation replaces the encryption key without changing the stored secrets:
+
+1. User initiates rotation via dashboard or CLI.
+2. `POST /api/secrets/rotate` — Spacebot generates a new master key, re-encrypts all secrets with the new key, stores the new key in the OS credential store, returns the new key for the user to save.
+3. The old key is invalidated. The user's previously saved key no longer works for unlock.
+
+**Dashboard:** Settings → Secrets → "Rotate Master Key" button. Confirms with a warning that the old key becomes invalid. Shows the new key in a modal.
+
+**CLI:**
+
+```bash
+spacebot secrets rotate
+# WARNING: This will invalidate your current master key.
+# You will need to save the new key for future unlocks.
+# Continue? [y/N]: y
+#
+# New master key: f7e8d9c0b1a2...
+# Re-encrypted 12 secrets.
+#
+# IMPORTANT: Save this new key. Your old key no longer works.
+```
+
+**Hosted:** Key rotation is handled by the platform. The user clicks "Rotate Key" in the dashboard, which calls the platform API. The platform generates a new key, updates its database, re-injects on next restart. The user never sees the key.
+
+### Key Export / Import
+
+For disaster recovery and instance migration:
+
+```bash
+# Export all secrets (encrypted with the current master key)
+spacebot secrets export --output secrets-backup.enc
+# Exported 12 secrets to secrets-backup.enc
+# This file is encrypted with your current master key.
+
+# Import secrets from a backup
+spacebot secrets import --input secrets-backup.enc
+# Enter the master key used to create this backup: ********
+# Imported 12 secrets. 3 conflicts (existing secrets with same name):
+#   ANTHROPIC_API_KEY — kept existing (use --overwrite to replace)
+#   GH_TOKEN — kept existing
+#   NPM_TOKEN — kept existing
+
+# Import with overwrite
+spacebot secrets import --input secrets-backup.enc --overwrite
+```
+
+**Unencrypted store warning:** If encryption is not enabled, the export file contains plaintext secrets. The CLI warns:
+
+```
+# WARNING: Encryption is not enabled. This export contains
+# plaintext secrets. Store it securely or enable encryption
+# first with: spacebot secrets encrypt
+```
+
+When encryption is enabled, the export file is the raw encrypted redb data plus a header with the Argon2id salt. It's useless without the master key. This covers:
+- **Backup before migration** — export before upgrading, import if something goes wrong.
+- **Instance migration** — export from old instance, import into new instance with the same master key.
+- **Disaster recovery** — if `secrets.redb` is corrupted, import from backup.
+
+### API Summary
+
+| Endpoint | Method | Auth | Description |
+|----------|--------|------|-------------|
+| `/api/secrets/status` | GET | Token | Store state (`unencrypted` / `locked` / `unlocked`), secret counts |
+| `/api/secrets` | GET | Token | List all secrets (name + category, no values) |
+| `/api/secrets/:name` | PUT | Token | Add or update a secret |
+| `/api/secrets/:name` | DELETE | Token | Delete a secret |
+| `/api/secrets/:name/info` | GET | Token | Secret metadata + config references |
+| `/api/secrets/migrate` | POST | Token | Auto-migrate literal keys from config.toml (runs automatically on first boot, manual trigger if needed) |
+| `/api/secrets/encrypt` | POST | Token | Enable encryption: generate master key, encrypt all secrets, store key in OS credential store (only when `unencrypted`) |
+| `/api/secrets/unlock` | POST | Token | Provide master key, decrypt store (only when `locked`) |
+| `/api/secrets/lock` | POST | Token | Clear master key from OS credential store (only when `unlocked`) |
+| `/api/secrets/rotate` | POST | Token | Rotate master key, re-encrypt all secrets (only when `unlocked`) |
+| `/api/secrets/export` | POST | Token | Export backup (encrypted if encryption enabled, plaintext otherwise) |
+| `/api/secrets/import` | POST | Token | Import from backup |
+
+Read-only endpoints (`GET /api/secrets`, `GET /api/secrets/:name/info`, `GET /api/secrets/status`) work in all states — secret names and categories are unencrypted metadata. Mutation endpoints (`PUT /api/secrets/:name`, `DELETE /api/secrets/:name`) work when `unencrypted` or `unlocked` but return `423 Locked` when locked (can't encrypt new values without the key). The encryption/unlock/lock/rotate endpoints only apply to encrypted stores.
+
+Authentication uses the same bearer token as the rest of the control API. On hosted instances, the dashboard proxy handles auth transparently. Self-hosted users authenticate via their configured API token.
+
+### CLI Subcommand Structure
+
+```
+spacebot secrets
+  status              Show store state and secret counts
+  list                List all secrets (name + category)
+  set <name>          Add or update a secret (interactive or --stdin)
+  delete <name>       Delete a secret
+  info <name>         Show secret metadata and config references
+  migrate             Auto-migrate plaintext keys from config.toml
+  encrypt             Enable encryption (generate master key, encrypt all secrets)
+  unlock              Unlock encrypted store (interactive or --stdin)
+  lock                Lock encrypted store (clear key from OS credential store)
+  rotate              Rotate master key (encrypted mode only)
+  export              Export backup
+  import              Import from backup
+```
+
+All subcommands communicate with the running Spacebot instance via the control API (`localhost:19898`). They don't access the secret store directly — this ensures the same locking/unlocking semantics apply regardless of whether the user uses the dashboard or CLI.
diff --git a/docs/design-docs/stereos-integration.md b/docs/design-docs/stereos-integration.md
new file mode 100644
index 000000000..5512c2e87
--- /dev/null
+++ b/docs/design-docs/stereos-integration.md
@@ -0,0 +1,162 @@
+# stereOS Integration
+
+Research into [stereOS](https://github.com/papercomputeco/stereos) — a NixOS-based Linux distro purpose-built for running AI agents in hardened VMs — and how it maps to Spacebot's architecture.
+
+## What stereOS Is
+
+stereOS produces bootable machine images called **mixtapes** that bundle a minimal, security-hardened Linux system with a specific AI agent binary. It boots in under 3 seconds, runs the agent in a sandboxed user account with a restricted PATH, and is controlled by two system daemons that handle lifecycle management, secret injection, and session introspection.
+
+**Key properties:**
+
+- NixOS-based, fully declarative — the entire OS is defined in Nix modules
+- Targets lightweight VMs: QEMU/KVM, Apple Virtualization.framework
+- Three image formats: raw EFI, QCOW2, direct-kernel boot artifacts
+- Host-guest control plane over virtio-vsock (CID 3, port 1024) with TCP fallback
+- Two orchestration daemons: `stereosd` (system lifecycle) and `agentd` (agent session management)
+- Currently aarch64-linux only
+
+**Existing mixtapes:** OpenCode, Claude Code, Gemini CLI, and a "full" variant bundling all three.
+
+## Security Model
+
+stereOS implements defense-in-depth across six layers:
+
+1. **Restricted shell + PATH** — agent user gets a custom login shell that sets PATH to only a curated set of approved binaries. Nix tooling is never included. All Nix-related env vars are unset.
+2. **Nix daemon ACL** — only root and wheel can talk to the Nix daemon. The agent user is in `agent` group, not `wheel`.
+3. **Explicit sudo denial** — `agent ALL=(ALL:ALL) !ALL` before any permissive rules.
+4. **Kernel hardening** — ptrace blocked (`yama.ptrace_scope=2`), kernel pointers hidden, dmesg restricted, core dumps disabled, ICMP redirects disabled.
+5. **Immutable users, no passwords** — SSH keys injected ephemerally at boot by `stereosd` over vsock.
+6. **VM boundary** — the VM itself is the primary isolation mechanism.
+
+**Secret handling:** `stereosd` receives secrets from the host over vsock, writes them to `/run/stereos/secrets/` on tmpfs with root-only permissions (0700). Never touches disk.
+
+## How It Maps to Spacebot
+
+### 1. Hosted Platform Instance Runtime (High Value)
+
+`spacebot-platform` currently provisions Fly Machines for customer instances. stereOS could serve as the instance runtime:
+
+- Build a `spacebot-mixtape` containing the Spacebot binary
+- `stereosd` handles lifecycle (start/stop/health) and secret injection (API keys, config) — replaces direct Fly Machine API calls for some operations
+- Sub-3-second boot means near-instant instance provisioning
+- `agentd` provides tmux session introspection — admins can attach to debug customer instances
+- `mixtape.toml` manifest with SHA-256 checksums enables reproducible, verifiable deploys
+- The NixOS declarative model means every instance runs an identical, auditable system
+
+**Gap:** Fly uses Firecracker, not QEMU. Firecracker expects its own rootfs + kernel format, not raw EFI or QCOW2. stereOS already produces kernel artifacts (bzImage + initrd + cmdline) which is close to what Firecracker needs, but the rootfs extraction would require a new image format in stereOS. This is the main blocker for hosted platform use.
+
+### 2. Worker Sandbox Environment (High Value, Longer Term)
+
+Spacebot workers execute arbitrary shell commands via `ShellTool` and `ExecTool`. Since 0.2.0, sandboxing uses bubblewrap (Linux) and `sandbox-exec` (macOS) — see `docs/design-docs/sandbox.md`. stereOS offers a stronger primitive: **run worker processes inside a purpose-built VM**.
+
+What this would look like:
+
+- Spawn one stereOS VM per agent at agent boot time
+- All workers for that agent execute inside the same VM
+- Worker tools (shell, file, exec) execute inside the VM via a thin RPC layer over vsock
+- The VM boundary replaces bubblewrap's mount namespace — kernel-level isolation instead of namespace-level
+- stereOS's restricted PATH and sudo denial apply on top of the VM boundary
+- Workers can't escape because they're in a different kernel
+
+**Per-agent, not per-worker.** The VM boots once when the agent starts and stays up for the agent's lifetime. Workers spawn and die inside it. This is the right granularity because:
+
+1. **Startup latency** — 2-3 seconds per VM is fine once at agent boot, but unacceptable if every fire-and-forget worker pays that cost. Workers spawn constantly; agents don't.
+2. **Shared workspace** — all workers for an agent already share the same workspace and data directory. One VM matches the existing isolation boundary.
+3. **Resource overhead** — one VM per agent (~128-256MB) is manageable. One per worker would balloon memory on instances with many concurrent workers.
+4. **Matches bubblewrap** — the current sandbox design creates one `Sandbox` per agent at startup and shares it via `Arc` across all workers. Same logical boundary, stronger isolation.
+
+**Tradeoffs vs bubblewrap:**
+
+|                        | bubblewrap (current)                                              | stereOS VM (per-agent)                                                     |
+| ---------------------- | ----------------------------------------------------------------- | -------------------------------------------------------------------------- |
+| **Startup latency**    | ~0ms per worker                                                   | ~2-3 seconds once at agent boot, then ~0ms per worker                      |
+| **Isolation strength** | Namespace-level (shared kernel)                                   | VM-level (separate kernel)                                                 |
+| **Resource overhead**  | Minimal                                                           | ~128-256MB RAM per agent                                                   |
+| **Network isolation**  | Not included (bwrap --unshare-net possible but breaks most tasks) | Controllable at VM level                                                   |
+| **Complexity**         | Low (single bwrap call)                                           | High (VM lifecycle, vsock RPC, image distribution)                         |
+
+**Verdict:** This is the right direction for high-security or multi-tenant scenarios (hosted platform), but overkill for self-hosted single-user instances. The bubblewrap sandbox should remain the default; VM isolation would be an opt-in upgrade for hosted deployments.
+
+### 3. OpenCode Worker Backend (Medium Value)
+
+Spacebot already supports OpenCode as a worker backend. stereOS ships an `opencode-mixtape`. There's a natural alignment — Spacebot could spawn OpenCode workers inside stereOS VMs for maximum isolation during coding sessions, especially for untrusted workloads. The plumbing already exists on both sides; it's mainly an integration question.
+
+### 4. Self-Hosted Deployment (Medium Value)
+
+For users who want to self-host Spacebot with maximum isolation, a `spacebot-mixtape` is the simplest path:
+
+- `nix build .#spacebot-mixtape` produces a bootable image
+- User launches it in QEMU/KVM or on Apple Silicon via `run-vm.sh`
+- Secrets injected at boot, workspace mounted via virtio-fs
+- No Docker, no container runtime, no host dependencies beyond QEMU
+
+This is a clean alternative to the current Docker deployment path for security-conscious users.
+
+## What a `spacebot-mixtape` Would Look Like
+
+Adding a new mixtape to stereOS is minimal. Based on the existing patterns:
+
+```nix
+# mixtapes/spacebot/base.nix
+{ config, lib, pkgs, ... }:
+{
+  stereos.agent.extraPackages = [ pkgs.spacebot ];
+
+  # Seed a minimal config.toml — secrets come via stereosd at boot
+  environment.etc."skel/.config/spacebot/config.toml".text = ''
+    [llm]
+    anthropic_key = "file:/run/stereos/secrets/ANTHROPIC_API_KEY"
+
+    [[agents]]
+    id = "main"
+  '';
+}
+```
+
+Then register in `flake.nix`:
+
+```nix
+spacebot-mixtape = stereos-lib.mkMixtape {
+  name = "spacebot-mixtape";
+  features = [ ./mixtapes/spacebot/base.nix ];
+};
+```
+
+The main prerequisite is packaging the Spacebot binary as a Nix derivation. Since it's a single Rust binary with no runtime dependencies, this is straightforward — `crane` or `naersk` for the Nix build, with SQLite and OpenSSL as build inputs.
+
+## Blockers and Open Questions
+
+### Fly/Firecracker Compatibility
+
+stereOS produces three image formats (raw EFI, QCOW2, kernel artifacts). Firecracker needs an ext4 rootfs and a kernel binary. stereOS's kernel artifacts output (bzImage + initrd) gets partway there, but Firecracker doesn't use initrd the same way — it expects a pre-mounted rootfs, not an initramfs that pivots. This would require either:
+
+1. A new `formats/firecracker.nix` in stereOS that extracts the NixOS system closure into a flat ext4 image
+2. Running QEMU/KVM on Fly instead of Firecracker (possible via Fly GPU machines or custom builders, but non-standard)
+
+### Architecture Support
+
+stereOS is aarch64-linux only. Fly Machines are predominantly x86_64. Cross-compilation in Nix is well-supported, so adding `x86_64-linux` is likely straightforward but untested.
+
+### Control Plane Protocol
+
+`stereosd` speaks a custom protocol over vsock. For `spacebot-platform` to manage stereOS instances, it would need a Rust client for this protocol (or stereOS would need an HTTP API). The protocol is not yet documented publicly — would need to inspect the `stereosd` source.
+
+### Workspace Persistence
+
+stereOS VMs are ephemeral by design. Spacebot instances need persistent storage (SQLite databases, LanceDB, workspace files). This would require virtio-fs mounts to a persistent volume, which stereOS supports but the Fly integration path would need to map to Fly volumes.
+
+## Recommendation
+
+**Near term (low effort, high signal):**
+
+- Create a `spacebot-mixtape` in stereOS for self-hosted deployment. This is 2-3 files of Nix config + a Nix derivation for the Spacebot binary. Gives us a hardened, bootable deployment option with zero Docker dependency.
+
+**Medium term (moderate effort):**
+
+- Investigate Firecracker compatibility by looking at `stereosd`'s source and the Firecracker rootfs format. If the gap is small, stereOS becomes a candidate for the hosted platform runtime.
+
+**Long term (high effort, high value):**
+
+- Per-agent VM isolation for the hosted platform. One stereOS VM per agent, all workers execute inside it. This is the most architecturally interesting use case but requires solving vsock RPC, VM lifecycle management, and workspace mounting.
+
+The bubblewrap sandbox (shipped in 0.2.0) remains the right default for most deployments. stereOS VM isolation is a complementary layer for high-security hosted scenarios, not a replacement.
diff --git a/docs/design-docs/tool-nudging.md b/docs/design-docs/tool-nudging.md
new file mode 100644
index 000000000..106d9ed86
--- /dev/null
+++ b/docs/design-docs/tool-nudging.md
@@ -0,0 +1,120 @@
+# Tool Nudging
+
+Automatic retry mechanism that prevents workers from exiting with text-only responses before signaling a terminal outcome.
+
+## Problem
+
+Workers sometimes respond with text like "I'll help you with that" or "Let me create the email now..." without actually calling any tools. This is common:
+- At the start of a worker loop when the LLM is "thinking out loud"
+- When the task description is vague and the LLM wants clarification
+- With certain models that have a conversational tendency
+- **Mid-task**, after making a few tool calls (e.g. `read_skill`, `set_status`), the model returns narration instead of continuing with tools
+
+Without intervention, the worker silently reaches `Done` state with no useful output. In Rig's agent loop, any text-only response (no tool calls) terminates the loop — the worker exits as if it completed successfully.
+
+## Solution
+
+Workers must explicitly signal a terminal outcome via `set_status(kind: "outcome")` before they can exit with a text-only response. Until that signal is received, any text-only response triggers a nudge that sends the worker back to work.
+
+### How It Works
+
+```
+Worker loop starts
+  → LLM completion
+  → If response includes tool calls → continue normally
+  → If text-only response:
+    → Has outcome been signaled via set_status(kind: "outcome")? → allow exit
+    → No outcome signal? → Terminate with "tool_nudge" reason → retry with nudge prompt
+    → Max 2 retries per prompt request
+    → If retries exhausted → worker fails (PromptCancelled)
+```
+
+### Outcome Signaling
+
+The `set_status` tool has a `kind` field:
+
+- `kind: "progress"` (default) — intermediate status update, does not unlock exit
+- `kind: "outcome"` — terminal result signal, allows text-only exit
+
+Workers are instructed to call `set_status(kind: "outcome")` with a result summary before finishing. The hook marks `outcome_signaled` only after a successful `set_status` tool result is observed in `on_tool_result` (`success: true` and `kind: "outcome"`), so failed status calls do not unlock text-only exit.
+
+### Policy Scoping
+
+Tool nudging is scoped by process type:
+
+| Process Type | Default Policy | Reason |
+|--------------|----------------|--------|
+| Worker | Enabled | Workers must complete tasks before exiting |
+| Branch | Disabled | Branches are for thinking, not doing |
+| Channel | Disabled | Channels should be conversational |
+
+The policy can be overridden per-hook:
+
+```rust
+let hook = SpacebotHook::new(...)
+    .with_tool_nudge_policy(ToolNudgePolicy::Disabled);
+```
+
+### Implementation Details
+
+**Outcome detection** (`src/hooks/spacebot.rs:on_tool_result`):
+- After a successful `set_status` tool execution with `kind: "outcome"`, `outcome_signaled` is set to `true`
+- The flag persists for the rest of the prompt request
+
+**Nudge decision** (`src/hooks/spacebot.rs:should_nudge_tool_usage`):
+- Returns `true` when: policy enabled, nudge active, no outcome signaled, response is text-only
+- Returns `false` when: outcome signaled, response has tool calls, policy disabled
+
+**Retry flow** (`prompt_with_tool_nudge_retry`):
+1. Reset nudge state at start of prompt (clears `outcome_signaled`)
+2. On text-only response without outcome: terminate with `TOOL_NUDGE_REASON`
+3. Catch termination in retry loop, prune history, retry with nudge prompt
+4. On success: prune the nudge prompt from history to keep context clean
+5. After `TOOL_NUDGE_MAX_RETRIES` (2) exhausted: `PromptCancelled` propagates to worker → `WorkerState::Failed`
+
+**History hygiene**:
+- Synthetic nudge prompts are removed from history on both success and retry
+- Failed assistant turns are pruned but user prompts are preserved
+- Prevents accumulation of nudge noise in context
+
+### Configuration
+
+There is no user-facing configuration for tool nudging. The behavior is:
+- Always enabled for workers
+- Always disabled for branches and channels
+- Cannot be configured per-agent or per-task
+
+If you need to disable nudging for a specific worker scenario, override the policy when creating the hook:
+
+```rust
+// In worker follow-up handling (already disabled)
+let follow_up_hook = hook
+    .clone()
+    .with_tool_nudge_policy(ToolNudgePolicy::Disabled);
+```
+
+### Testing
+
+The nudging behavior has comprehensive test coverage:
+
+- **Unit tests** (`src/hooks/spacebot.rs`):
+  - `nudges_on_every_text_only_response_without_outcome` — nudge fires on every text-only response
+  - `nudges_after_tool_calls_without_outcome` — the exact bug case (read_skill + progress status + text exit)
+  - `outcome_signal_allows_text_only_completion` — outcome signal unlocks exit
+  - `progress_status_does_not_signal_outcome` — explicit progress kind doesn't unlock
+  - `default_status_kind_does_not_signal_outcome` — omitted kind doesn't unlock
+  - `does_not_nudge_when_completion_contains_tool_call`
+  - `process_scoped_policy_*` variants for Branch/Channel/Worker
+  - `tool_nudge_retry_history_hygiene_*` for history pruning
+
+- **Integration tests** (`tests/tool_nudge.rs`):
+  - Public API surface tests (constants, policy enum, hook creation)
+  - Event emission verification
+  - Process-type scoping
+
+### Future Considerations
+
+1. **Per-model tuning**: Some models may need more/fewer nudge retries
+2. **Adaptive nudging**: Detect when nudging isn't working and escalate
+3. **User-visible indicator**: Show in UI when a worker was nudged
+4. **Metric**: Dedicated counter for nudge events
diff --git a/docs/docker.md b/docs/docker.md
index 88cc3a8f8..d14e4769c 100644
--- a/docs/docker.md
+++ b/docs/docker.md
@@ -197,6 +197,31 @@ healthcheck:
 - Graceful shutdown on `SIGTERM` (what `docker stop` sends). Drains active channels, closes database connections.
 - The PID file and Unix socket (used in daemon mode) are not created.
 
+## Updates
+
+Spacebot checks for new releases on startup and every hour. When a new version is available, a banner appears in the web UI.
+
+The web dashboard also includes **Settings → Updates** with status details, one-click controls (Docker), and manual command snippets.
+
+`latest` is supported and continues to receive updates (it tracks the rolling `full` image). Use explicit version tags only when you want controlled rollouts.
+
+### Manual Update
+
+```bash
+docker compose pull spacebot
+docker compose up -d --force-recreate spacebot
+```
+
+### One-Click Update
+
+Mount `/var/run/docker.sock` into the Spacebot container to enable the **Update now** button in the UI. Without the socket mount, update checks still work but apply is manual.
+
+One-click updates are intended for containers running Spacebot release tags. If you're running a custom/self-built image, rebuild your image and recreate the container.
+
+### Native / Source Builds
+
+If Spacebot is installed from source (`cargo install --path .` or a local release build), updates are manual: pull latest source, rebuild/reinstall, then restart.
+
 ## CI / Releases
 
 Images are built and pushed to `ghcr.io/spacedriveapp/spacebot` via GitHub Actions (`.github/workflows/release.yml`).
diff --git a/fly.staging.toml b/fly.staging.toml
index 97da79dce..d0af60450 100644
--- a/fly.staging.toml
+++ b/fly.staging.toml
@@ -3,7 +3,6 @@ primary_region = "iad"
 
 [build]
   dockerfile = "Dockerfile"
-  target = "full"
 
 [env]
   SPACEBOT_DIR = "/data"
diff --git a/fly.toml b/fly.toml
index 7e5fee5c6..fd64ec6f9 100644
--- a/fly.toml
+++ b/fly.toml
@@ -3,7 +3,6 @@ primary_region = "iad"
 
 [build]
   dockerfile = "Dockerfile"
-  target = "full"
 
 [env]
   SPACEBOT_DIR = "/data"
diff --git a/interface/bun.lock b/interface/bun.lock
index 0349bffde..13c16389b 100644
--- a/interface/bun.lock
+++ b/interface/bun.lock
@@ -34,6 +34,7 @@
         "@radix-ui/react-tooltip": "^1.2.8",
         "@react-sigma/core": "^5.0.6",
         "@tanstack/react-query": "^5.62.0",
+        "@tanstack/react-query-devtools": "^5.91.3",
         "@tanstack/react-router": "^1.159.5",
         "@tanstack/react-virtual": "^3.13.18",
         "@tanstack/router-devtools": "^1.159.5",
@@ -487,8 +488,12 @@
 
     "@tanstack/query-core": ["@tanstack/query-core@5.90.20", "", {}, ""],
 
+    "@tanstack/query-devtools": ["@tanstack/query-devtools@5.93.0", "", {}, "sha512-+kpsx1NQnOFTZsw6HAFCW3HkKg0+2cepGtAWXjiiSOJJ1CtQpt72EE2nyZb+AjAbLRPoeRmPJ8MtQd8r8gsPdg=="],
+
     "@tanstack/react-query": ["@tanstack/react-query@5.90.21", "", { "dependencies": { "@tanstack/query-core": "5.90.20" }, "peerDependencies": { "react": "^18 || ^19" } }, ""],
 
+    "@tanstack/react-query-devtools": ["@tanstack/react-query-devtools@5.91.3", "", { "dependencies": { "@tanstack/query-devtools": "5.93.0" }, "peerDependencies": { "@tanstack/react-query": "^5.90.20", "react": "^18 || ^19" } }, "sha512-nlahjMtd/J1h7IzOOfqeyDh5LNfG0eULwlltPEonYy0QL+nqrBB+nyzJfULV+moL7sZyxc2sHdNJki+vLA9BSA=="],
+
     "@tanstack/react-router": ["@tanstack/react-router@1.159.5", "", { "dependencies": { "@tanstack/history": "1.154.14", "@tanstack/react-store": "^0.8.0", "@tanstack/router-core": "1.159.4", "isbot": "^5.1.22", "tiny-invariant": "^1.3.3", "tiny-warning": "^1.0.3" }, "peerDependencies": { "react": ">=18.0.0 || >=19.0.0", "react-dom": ">=18.0.0 || >=19.0.0" } }, ""],
 
     "@tanstack/react-router-devtools": ["@tanstack/react-router-devtools@1.159.5", "", { "dependencies": { "@tanstack/router-devtools-core": "1.159.4" }, "peerDependencies": { "@tanstack/react-router": "^1.159.5", "@tanstack/router-core": "^1.159.4", "react": ">=18.0.0 || >=19.0.0", "react-dom": ">=18.0.0 || >=19.0.0" } }, ""],
diff --git a/interface/package-lock.json b/interface/package-lock.json
deleted file mode 100644
index 8a6cc8497..000000000
--- a/interface/package-lock.json
+++ /dev/null
@@ -1,10640 +0,0 @@
-{
-	"name": "spacebot-interface",
-	"version": "0.1.0",
-	"lockfileVersion": 3,
-	"requires": true,
-	"packages": {
-		"": {
-			"name": "spacebot-interface",
-			"version": "0.1.0",
-			"dependencies": {
-				"@codemirror/language": "^6.12.1",
-				"@codemirror/legacy-modes": "^6.5.2",
-				"@codemirror/state": "^6.5.4",
-				"@codemirror/theme-one-dark": "^6.1.3",
-				"@codemirror/view": "^6.39.14",
-				"@dnd-kit/core": "^6.3.1",
-				"@dnd-kit/sortable": "^10.0.0",
-				"@dnd-kit/utilities": "^3.2.2",
-				"@fontsource/ibm-plex-sans": "^5.1.0",
-				"@fortawesome/fontawesome-svg-core": "^7.2.0",
-				"@fortawesome/free-brands-svg-icons": "^7.2.0",
-				"@fortawesome/free-solid-svg-icons": "^7.2.0",
-				"@fortawesome/react-fontawesome": "^3.0.0",
-				"@hookform/resolvers": "^5.2.2",
-				"@hugeicons/core-free-icons": "^3.1.1",
-				"@hugeicons/react": "^1.1.5",
-				"@lobehub/icons": "^4.6.0",
-				"@radix-ui/react-checkbox": "^1.3.3",
-				"@radix-ui/react-dialog": "^1.1.15",
-				"@radix-ui/react-dropdown-menu": "^2.1.16",
-				"@radix-ui/react-popover": "^1.1.15",
-				"@radix-ui/react-radio-group": "^1.3.8",
-				"@radix-ui/react-select": "^2.2.6",
-				"@radix-ui/react-slider": "^1.3.6",
-				"@radix-ui/react-switch": "^1.2.6",
-				"@radix-ui/react-tabs": "^1.1.13",
-				"@radix-ui/react-tooltip": "^1.2.8",
-				"@react-sigma/core": "^5.0.6",
-				"@tanstack/react-query": "^5.62.0",
-				"@tanstack/react-router": "^1.159.5",
-				"@tanstack/react-virtual": "^3.13.18",
-				"@tanstack/router-devtools": "^1.159.5",
-				"@xyflow/react": "^12.10.1",
-				"class-variance-authority": "^0.7.1",
-				"clsx": "^2.1.1",
-				"codemirror": "^6.0.2",
-				"framer-motion": "^12.34.0",
-				"graphology": "^0.26.0",
-				"graphology-layout-forceatlas2": "^0.10.1",
-				"graphology-types": "^0.24.8",
-				"react": "^19.0.0",
-				"react-dom": "^19.0.0",
-				"react-hook-form": "^7.71.1",
-				"react-markdown": "^10.1.0",
-				"recharts": "^3.7.0",
-				"remark-gfm": "^4.0.1",
-				"sigma": "^3.0.2",
-				"smol-toml": "^1.6.0",
-				"sonner": "^2.0.7",
-				"zod": "^4.3.6"
-			},
-			"devDependencies": {
-				"@types/react": "^19.0.0",
-				"@types/react-dom": "^19.0.0",
-				"@vitejs/plugin-react": "^4.3.4",
-				"autoprefixer": "^10.4.18",
-				"postcss": "^8.4.36",
-				"sass": "^1.72.0",
-				"tailwindcss": "^3.4.1",
-				"tailwindcss-animate": "^1.0.7",
-				"typescript": "^5.6.2",
-				"vite": "^6.0.0"
-			}
-		},
-		"node_modules/@alloc/quick-lru": {
-			"version": "5.2.0",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=10"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
-		"node_modules/@ant-design/colors": {
-			"version": "8.0.1",
-			"resolved": "https://registry.npmjs.org/@ant-design/colors/-/colors-8.0.1.tgz",
-			"integrity": "sha512-foPVl0+SWIslGUtD/xBr1p9U4AKzPhNYEseXYRRo5QSzGACYZrQbe11AYJbYfAWnWSpGBx6JjBmSeugUsD9vqQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@ant-design/fast-color": "^3.0.0"
-			}
-		},
-		"node_modules/@ant-design/cssinjs": {
-			"version": "2.1.0",
-			"resolved": "https://registry.npmjs.org/@ant-design/cssinjs/-/cssinjs-2.1.0.tgz",
-			"integrity": "sha512-eZFrPCnrYrF3XtL7qA4L75P0qA3TtZta8H3Yggy7UYFh8gZgu5bSMNF+v4UVCzGxzYmx8ZvPdgOce0BJ6PsW9g==",
-			"license": "MIT",
-			"dependencies": {
-				"@babel/runtime": "^7.11.1",
-				"@emotion/hash": "^0.8.0",
-				"@emotion/unitless": "^0.7.5",
-				"@rc-component/util": "^1.4.0",
-				"clsx": "^2.1.1",
-				"csstype": "^3.1.3",
-				"stylis": "^4.3.4"
-			},
-			"peerDependencies": {
-				"react": ">=16.0.0",
-				"react-dom": ">=16.0.0"
-			}
-		},
-		"node_modules/@ant-design/cssinjs-utils": {
-			"version": "2.1.1",
-			"resolved": "https://registry.npmjs.org/@ant-design/cssinjs-utils/-/cssinjs-utils-2.1.1.tgz",
-			"integrity": "sha512-RKxkj5pGFB+FkPJ5NGhoX3DK3xsv0pMltha7Ei1AnY3tILeq38L7tuhaWDPQI/5nlPxOog44wvqpNyyGcUsNMg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@ant-design/cssinjs": "^2.1.0",
-				"@babel/runtime": "^7.23.2",
-				"@rc-component/util": "^1.4.0"
-			},
-			"peerDependencies": {
-				"react": ">=18",
-				"react-dom": ">=18"
-			}
-		},
-		"node_modules/@ant-design/fast-color": {
-			"version": "3.0.1",
-			"resolved": "https://registry.npmjs.org/@ant-design/fast-color/-/fast-color-3.0.1.tgz",
-			"integrity": "sha512-esKJegpW4nckh0o6kV3Tkb7NPIZYbPnnFxmQDUmL08ukXZAvV85TZBr70eGuke/CIArLaP6aw8lt9KILjnWuOw==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=8.x"
-			}
-		},
-		"node_modules/@ant-design/icons": {
-			"version": "6.1.0",
-			"resolved": "https://registry.npmjs.org/@ant-design/icons/-/icons-6.1.0.tgz",
-			"integrity": "sha512-KrWMu1fIg3w/1F2zfn+JlfNDU8dDqILfA5Tg85iqs1lf8ooyGlbkA+TkwfOKKgqpUmAiRY1PTFpuOU2DAIgSUg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@ant-design/colors": "^8.0.0",
-				"@ant-design/icons-svg": "^4.4.0",
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=8"
-			},
-			"peerDependencies": {
-				"react": ">=16.0.0",
-				"react-dom": ">=16.0.0"
-			}
-		},
-		"node_modules/@ant-design/icons-svg": {
-			"version": "4.4.2",
-			"resolved": "https://registry.npmjs.org/@ant-design/icons-svg/-/icons-svg-4.4.2.tgz",
-			"integrity": "sha512-vHbT+zJEVzllwP+CM+ul7reTEfBR0vgxFe7+lREAsAA7YGsYpboiq2sQNeQeRvh09GfQgs/GyFEvZpJ9cLXpXA==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@ant-design/react-slick": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/@ant-design/react-slick/-/react-slick-2.0.0.tgz",
-			"integrity": "sha512-HMS9sRoEmZey8LsE/Yo6+klhlzU12PisjrVcydW3So7RdklyEd2qehyU6a7Yp+OYN72mgsYs3NFCyP2lCPFVqg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.28.4",
-				"clsx": "^2.1.1",
-				"json2mq": "^0.2.0",
-				"throttle-debounce": "^5.0.0"
-			},
-			"peerDependencies": {
-				"react": "^0.14.0 || ^15.0.1 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-				"react-dom": "^0.14.0 || ^15.0.1 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-			}
-		},
-		"node_modules/@antfu/install-pkg": {
-			"version": "1.1.0",
-			"resolved": "https://registry.npmjs.org/@antfu/install-pkg/-/install-pkg-1.1.0.tgz",
-			"integrity": "sha512-MGQsmw10ZyI+EJo45CdSER4zEb+p31LpDAFp2Z3gkSd1yqVZGi0Ebx++YTEMonJy4oChEMLsxZ64j8FH6sSqtQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"package-manager-detector": "^1.3.0",
-				"tinyexec": "^1.0.1"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/antfu"
-			}
-		},
-		"node_modules/@babel/code-frame": {
-			"version": "7.29.0",
-			"license": "MIT",
-			"dependencies": {
-				"@babel/helper-validator-identifier": "^7.28.5",
-				"js-tokens": "^4.0.0",
-				"picocolors": "^1.1.1"
-			},
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/@babel/compat-data": {
-			"version": "7.29.0",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/@babel/core": {
-			"version": "7.29.0",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@babel/code-frame": "^7.29.0",
-				"@babel/generator": "^7.29.0",
-				"@babel/helper-compilation-targets": "^7.28.6",
-				"@babel/helper-module-transforms": "^7.28.6",
-				"@babel/helpers": "^7.28.6",
-				"@babel/parser": "^7.29.0",
-				"@babel/template": "^7.28.6",
-				"@babel/traverse": "^7.29.0",
-				"@babel/types": "^7.29.0",
-				"@jridgewell/remapping": "^2.3.5",
-				"convert-source-map": "^2.0.0",
-				"debug": "^4.1.0",
-				"gensync": "^1.0.0-beta.2",
-				"json5": "^2.2.3",
-				"semver": "^6.3.1"
-			},
-			"engines": {
-				"node": ">=6.9.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/babel"
-			}
-		},
-		"node_modules/@babel/generator": {
-			"version": "7.29.1",
-			"license": "MIT",
-			"dependencies": {
-				"@babel/parser": "^7.29.0",
-				"@babel/types": "^7.29.0",
-				"@jridgewell/gen-mapping": "^0.3.12",
-				"@jridgewell/trace-mapping": "^0.3.28",
-				"jsesc": "^3.0.2"
-			},
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/@babel/helper-compilation-targets": {
-			"version": "7.28.6",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@babel/compat-data": "^7.28.6",
-				"@babel/helper-validator-option": "^7.27.1",
-				"browserslist": "^4.24.0",
-				"lru-cache": "^5.1.1",
-				"semver": "^6.3.1"
-			},
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/@babel/helper-globals": {
-			"version": "7.28.0",
-			"license": "MIT",
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/@babel/helper-module-imports": {
-			"version": "7.28.6",
-			"license": "MIT",
-			"dependencies": {
-				"@babel/traverse": "^7.28.6",
-				"@babel/types": "^7.28.6"
-			},
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/@babel/helper-module-transforms": {
-			"version": "7.28.6",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@babel/helper-module-imports": "^7.28.6",
-				"@babel/helper-validator-identifier": "^7.28.5",
-				"@babel/traverse": "^7.28.6"
-			},
-			"engines": {
-				"node": ">=6.9.0"
-			},
-			"peerDependencies": {
-				"@babel/core": "^7.0.0"
-			}
-		},
-		"node_modules/@babel/helper-plugin-utils": {
-			"version": "7.28.6",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/@babel/helper-string-parser": {
-			"version": "7.27.1",
-			"license": "MIT",
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/@babel/helper-validator-identifier": {
-			"version": "7.28.5",
-			"license": "MIT",
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/@babel/helper-validator-option": {
-			"version": "7.27.1",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/@babel/helpers": {
-			"version": "7.28.6",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@babel/template": "^7.28.6",
-				"@babel/types": "^7.28.6"
-			},
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/@babel/parser": {
-			"version": "7.29.0",
-			"license": "MIT",
-			"dependencies": {
-				"@babel/types": "^7.29.0"
-			},
-			"bin": {
-				"parser": "bin/babel-parser.js"
-			},
-			"engines": {
-				"node": ">=6.0.0"
-			}
-		},
-		"node_modules/@babel/plugin-transform-react-jsx-self": {
-			"version": "7.27.1",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@babel/helper-plugin-utils": "^7.27.1"
-			},
-			"engines": {
-				"node": ">=6.9.0"
-			},
-			"peerDependencies": {
-				"@babel/core": "^7.0.0-0"
-			}
-		},
-		"node_modules/@babel/plugin-transform-react-jsx-source": {
-			"version": "7.27.1",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@babel/helper-plugin-utils": "^7.27.1"
-			},
-			"engines": {
-				"node": ">=6.9.0"
-			},
-			"peerDependencies": {
-				"@babel/core": "^7.0.0-0"
-			}
-		},
-		"node_modules/@babel/runtime": {
-			"version": "7.28.6",
-			"resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.6.tgz",
-			"integrity": "sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==",
-			"license": "MIT",
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/@babel/template": {
-			"version": "7.28.6",
-			"license": "MIT",
-			"dependencies": {
-				"@babel/code-frame": "^7.28.6",
-				"@babel/parser": "^7.28.6",
-				"@babel/types": "^7.28.6"
-			},
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/@babel/traverse": {
-			"version": "7.29.0",
-			"license": "MIT",
-			"dependencies": {
-				"@babel/code-frame": "^7.29.0",
-				"@babel/generator": "^7.29.0",
-				"@babel/helper-globals": "^7.28.0",
-				"@babel/parser": "^7.29.0",
-				"@babel/template": "^7.28.6",
-				"@babel/types": "^7.29.0",
-				"debug": "^4.3.1"
-			},
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/@babel/types": {
-			"version": "7.29.0",
-			"license": "MIT",
-			"dependencies": {
-				"@babel/helper-string-parser": "^7.27.1",
-				"@babel/helper-validator-identifier": "^7.28.5"
-			},
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/@base-ui/react": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/@base-ui/react/-/react-1.0.0.tgz",
-			"integrity": "sha512-4USBWz++DUSLTuIYpbYkSgy1F9ZmNG9S/lXvlUN6qMK0P0RlW+6eQmDUB4DgZ7HVvtXl4pvi4z5J2fv6Z3+9hg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.28.4",
-				"@base-ui/utils": "0.2.3",
-				"@floating-ui/react-dom": "^2.1.6",
-				"@floating-ui/utils": "^0.2.10",
-				"reselect": "^5.1.1",
-				"tabbable": "^6.3.0",
-				"use-sync-external-store": "^1.6.0"
-			},
-			"engines": {
-				"node": ">=14.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/mui-org"
-			},
-			"peerDependencies": {
-				"@types/react": "^17 || ^18 || ^19",
-				"react": "^17 || ^18 || ^19",
-				"react-dom": "^17 || ^18 || ^19"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@base-ui/utils": {
-			"version": "0.2.3",
-			"resolved": "https://registry.npmjs.org/@base-ui/utils/-/utils-0.2.3.tgz",
-			"integrity": "sha512-/CguQ2PDaOzeVOkllQR8nocJ0FFIDqsWIcURsVmm53QGo8NhFNpePjNlyPIB41luxfOqnG7PU0xicMEw3ls7XQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.28.4",
-				"@floating-ui/utils": "^0.2.10",
-				"reselect": "^5.1.1",
-				"use-sync-external-store": "^1.6.0"
-			},
-			"peerDependencies": {
-				"@types/react": "^17 || ^18 || ^19",
-				"react": "^17 || ^18 || ^19",
-				"react-dom": "^17 || ^18 || ^19"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@braintree/sanitize-url": {
-			"version": "7.1.2",
-			"resolved": "https://registry.npmjs.org/@braintree/sanitize-url/-/sanitize-url-7.1.2.tgz",
-			"integrity": "sha512-jigsZK+sMF/cuiB7sERuo9V7N9jx+dhmHHnQyDSVdpZwVutaBu7WvNYqMDLSgFgfB30n452TP3vjDAvFC973mA==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@chevrotain/cst-dts-gen": {
-			"version": "11.1.1",
-			"resolved": "https://registry.npmjs.org/@chevrotain/cst-dts-gen/-/cst-dts-gen-11.1.1.tgz",
-			"integrity": "sha512-fRHyv6/f542qQqiRGalrfJl/evD39mAvbJLCekPazhiextEatq1Jx1K/i9gSd5NNO0ds03ek0Cbo/4uVKmOBcw==",
-			"license": "Apache-2.0",
-			"peer": true,
-			"dependencies": {
-				"@chevrotain/gast": "11.1.1",
-				"@chevrotain/types": "11.1.1",
-				"lodash-es": "4.17.23"
-			}
-		},
-		"node_modules/@chevrotain/gast": {
-			"version": "11.1.1",
-			"resolved": "https://registry.npmjs.org/@chevrotain/gast/-/gast-11.1.1.tgz",
-			"integrity": "sha512-Ko/5vPEYy1vn5CbCjjvnSO4U7GgxyGm+dfUZZJIWTlQFkXkyym0jFYrWEU10hyCjrA7rQtiHtBr0EaZqvHFZvg==",
-			"license": "Apache-2.0",
-			"peer": true,
-			"dependencies": {
-				"@chevrotain/types": "11.1.1",
-				"lodash-es": "4.17.23"
-			}
-		},
-		"node_modules/@chevrotain/regexp-to-ast": {
-			"version": "11.1.1",
-			"resolved": "https://registry.npmjs.org/@chevrotain/regexp-to-ast/-/regexp-to-ast-11.1.1.tgz",
-			"integrity": "sha512-ctRw1OKSXkOrR8VTvOxrQ5USEc4sNrfwXHa1NuTcR7wre4YbjPcKw+82C2uylg/TEwFRgwLmbhlln4qkmDyteg==",
-			"license": "Apache-2.0",
-			"peer": true
-		},
-		"node_modules/@chevrotain/types": {
-			"version": "11.1.1",
-			"resolved": "https://registry.npmjs.org/@chevrotain/types/-/types-11.1.1.tgz",
-			"integrity": "sha512-wb2ToxG8LkgPYnKe9FH8oGn3TMCBdnwiuNC5l5y+CtlaVRbCytU0kbVsk6CGrqTL4ZN4ksJa0TXOYbxpbthtqw==",
-			"license": "Apache-2.0",
-			"peer": true
-		},
-		"node_modules/@chevrotain/utils": {
-			"version": "11.1.1",
-			"resolved": "https://registry.npmjs.org/@chevrotain/utils/-/utils-11.1.1.tgz",
-			"integrity": "sha512-71eTYMzYXYSFPrbg/ZwftSaSDld7UYlS8OQa3lNnn9jzNtpFbaReRRyghzqS7rI3CDaorqpPJJcXGHK+FE1TVQ==",
-			"license": "Apache-2.0",
-			"peer": true
-		},
-		"node_modules/@codemirror/autocomplete": {
-			"version": "6.20.0",
-			"resolved": "https://registry.npmjs.org/@codemirror/autocomplete/-/autocomplete-6.20.0.tgz",
-			"integrity": "sha512-bOwvTOIJcG5FVo5gUUupiwYh8MioPLQ4UcqbcRf7UQ98X90tCa9E1kZ3Z7tqwpZxYyOvh1YTYbmZE9RTfTp5hg==",
-			"license": "MIT",
-			"dependencies": {
-				"@codemirror/language": "^6.0.0",
-				"@codemirror/state": "^6.0.0",
-				"@codemirror/view": "^6.17.0",
-				"@lezer/common": "^1.0.0"
-			}
-		},
-		"node_modules/@codemirror/commands": {
-			"version": "6.10.2",
-			"resolved": "https://registry.npmjs.org/@codemirror/commands/-/commands-6.10.2.tgz",
-			"integrity": "sha512-vvX1fsih9HledO1c9zdotZYUZnE4xV0m6i3m25s5DIfXofuprk6cRcLUZvSk3CASUbwjQX21tOGbkY2BH8TpnQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@codemirror/language": "^6.0.0",
-				"@codemirror/state": "^6.4.0",
-				"@codemirror/view": "^6.27.0",
-				"@lezer/common": "^1.1.0"
-			}
-		},
-		"node_modules/@codemirror/language": {
-			"version": "6.12.1",
-			"resolved": "https://registry.npmjs.org/@codemirror/language/-/language-6.12.1.tgz",
-			"integrity": "sha512-Fa6xkSiuGKc8XC8Cn96T+TQHYj4ZZ7RdFmXA3i9xe/3hLHfwPZdM+dqfX0Cp0zQklBKhVD8Yzc8LS45rkqcwpQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@codemirror/state": "^6.0.0",
-				"@codemirror/view": "^6.23.0",
-				"@lezer/common": "^1.5.0",
-				"@lezer/highlight": "^1.0.0",
-				"@lezer/lr": "^1.0.0",
-				"style-mod": "^4.0.0"
-			}
-		},
-		"node_modules/@codemirror/legacy-modes": {
-			"version": "6.5.2",
-			"resolved": "https://registry.npmjs.org/@codemirror/legacy-modes/-/legacy-modes-6.5.2.tgz",
-			"integrity": "sha512-/jJbwSTazlQEDOQw2FJ8LEEKVS72pU0lx6oM54kGpL8t/NJ2Jda3CZ4pcltiKTdqYSRk3ug1B3pil1gsjA6+8Q==",
-			"license": "MIT",
-			"dependencies": {
-				"@codemirror/language": "^6.0.0"
-			}
-		},
-		"node_modules/@codemirror/lint": {
-			"version": "6.9.4",
-			"resolved": "https://registry.npmjs.org/@codemirror/lint/-/lint-6.9.4.tgz",
-			"integrity": "sha512-ABc9vJ8DEmvOWuH26P3i8FpMWPQkduD9Rvba5iwb6O3hxASgclm3T3krGo8NASXkHCidz6b++LWlzWIUfEPSWw==",
-			"license": "MIT",
-			"dependencies": {
-				"@codemirror/state": "^6.0.0",
-				"@codemirror/view": "^6.35.0",
-				"crelt": "^1.0.5"
-			}
-		},
-		"node_modules/@codemirror/search": {
-			"version": "6.6.0",
-			"resolved": "https://registry.npmjs.org/@codemirror/search/-/search-6.6.0.tgz",
-			"integrity": "sha512-koFuNXcDvyyotWcgOnZGmY7LZqEOXZaaxD/j6n18TCLx2/9HieZJ5H6hs1g8FiRxBD0DNfs0nXn17g872RmYdw==",
-			"license": "MIT",
-			"dependencies": {
-				"@codemirror/state": "^6.0.0",
-				"@codemirror/view": "^6.37.0",
-				"crelt": "^1.0.5"
-			}
-		},
-		"node_modules/@codemirror/state": {
-			"version": "6.5.4",
-			"resolved": "https://registry.npmjs.org/@codemirror/state/-/state-6.5.4.tgz",
-			"integrity": "sha512-8y7xqG/hpB53l25CIoit9/ngxdfoG+fx+V3SHBrinnhOtLvKHRyAJJuHzkWrR4YXXLX8eXBsejgAAxHUOdW1yw==",
-			"license": "MIT",
-			"dependencies": {
-				"@marijn/find-cluster-break": "^1.0.0"
-			}
-		},
-		"node_modules/@codemirror/theme-one-dark": {
-			"version": "6.1.3",
-			"resolved": "https://registry.npmjs.org/@codemirror/theme-one-dark/-/theme-one-dark-6.1.3.tgz",
-			"integrity": "sha512-NzBdIvEJmx6fjeremiGp3t/okrLPYT0d9orIc7AFun8oZcRk58aejkqhv6spnz4MLAevrKNPMQYXEWMg4s+sKA==",
-			"license": "MIT",
-			"dependencies": {
-				"@codemirror/language": "^6.0.0",
-				"@codemirror/state": "^6.0.0",
-				"@codemirror/view": "^6.0.0",
-				"@lezer/highlight": "^1.0.0"
-			}
-		},
-		"node_modules/@codemirror/view": {
-			"version": "6.39.15",
-			"resolved": "https://registry.npmjs.org/@codemirror/view/-/view-6.39.15.tgz",
-			"integrity": "sha512-aCWjgweIIXLBHh7bY6cACvXuyrZ0xGafjQ2VInjp4RM4gMfscK5uESiNdrH0pE+e1lZr2B4ONGsjchl2KsKZzg==",
-			"license": "MIT",
-			"dependencies": {
-				"@codemirror/state": "^6.5.0",
-				"crelt": "^1.0.6",
-				"style-mod": "^4.1.0",
-				"w3c-keyname": "^2.2.4"
-			}
-		},
-		"node_modules/@dnd-kit/accessibility": {
-			"version": "3.1.1",
-			"resolved": "https://registry.npmjs.org/@dnd-kit/accessibility/-/accessibility-3.1.1.tgz",
-			"integrity": "sha512-2P+YgaXF+gRsIihwwY1gCsQSYnu9Zyj2py8kY5fFvUM1qm2WA2u639R6YNVfU4GWr+ZM5mqEsfHZZLoRONbemw==",
-			"license": "MIT",
-			"dependencies": {
-				"tslib": "^2.0.0"
-			},
-			"peerDependencies": {
-				"react": ">=16.8.0"
-			}
-		},
-		"node_modules/@dnd-kit/core": {
-			"version": "6.3.1",
-			"resolved": "https://registry.npmjs.org/@dnd-kit/core/-/core-6.3.1.tgz",
-			"integrity": "sha512-xkGBRQQab4RLwgXxoqETICr6S5JlogafbhNsidmrkVv2YRs5MLwpjoF2qpiGjQt8S9AoxtIV603s0GIUpY5eYQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@dnd-kit/accessibility": "^3.1.1",
-				"@dnd-kit/utilities": "^3.2.2",
-				"tslib": "^2.0.0"
-			},
-			"peerDependencies": {
-				"react": ">=16.8.0",
-				"react-dom": ">=16.8.0"
-			}
-		},
-		"node_modules/@dnd-kit/modifiers": {
-			"version": "9.0.0",
-			"resolved": "https://registry.npmjs.org/@dnd-kit/modifiers/-/modifiers-9.0.0.tgz",
-			"integrity": "sha512-ybiLc66qRGuZoC20wdSSG6pDXFikui/dCNGthxv4Ndy8ylErY0N3KVxY2bgo7AWwIbxDmXDg3ylAFmnrjcbVvw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@dnd-kit/utilities": "^3.2.2",
-				"tslib": "^2.0.0"
-			},
-			"peerDependencies": {
-				"@dnd-kit/core": "^6.3.0",
-				"react": ">=16.8.0"
-			}
-		},
-		"node_modules/@dnd-kit/sortable": {
-			"version": "10.0.0",
-			"resolved": "https://registry.npmjs.org/@dnd-kit/sortable/-/sortable-10.0.0.tgz",
-			"integrity": "sha512-+xqhmIIzvAYMGfBYYnbKuNicfSsk4RksY2XdmJhT+HAC01nix6fHCztU68jooFiMUB01Ky3F0FyOvhG/BZrWkg==",
-			"license": "MIT",
-			"dependencies": {
-				"@dnd-kit/utilities": "^3.2.2",
-				"tslib": "^2.0.0"
-			},
-			"peerDependencies": {
-				"@dnd-kit/core": "^6.3.0",
-				"react": ">=16.8.0"
-			}
-		},
-		"node_modules/@dnd-kit/utilities": {
-			"version": "3.2.2",
-			"resolved": "https://registry.npmjs.org/@dnd-kit/utilities/-/utilities-3.2.2.tgz",
-			"integrity": "sha512-+MKAJEOfaBe5SmV6t34p80MMKhjvUz0vRrvVJbPT0WElzaOJ/1xs+D+KDv+tD/NE5ujfrChEcshd4fLn0wpiqg==",
-			"license": "MIT",
-			"dependencies": {
-				"tslib": "^2.0.0"
-			},
-			"peerDependencies": {
-				"react": ">=16.8.0"
-			}
-		},
-		"node_modules/@emoji-mart/data": {
-			"version": "1.2.1",
-			"resolved": "https://registry.npmjs.org/@emoji-mart/data/-/data-1.2.1.tgz",
-			"integrity": "sha512-no2pQMWiBy6gpBEiqGeU77/bFejDqUTRY7KX+0+iur13op3bqUsXdnwoZs6Xb1zbv0gAj5VvS1PWoUUckSr5Dw==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@emoji-mart/react": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/@emoji-mart/react/-/react-1.1.1.tgz",
-			"integrity": "sha512-NMlFNeWgv1//uPsvLxvGQoIerPuVdXwK/EUek8OOkJ6wVOWPUizRBJU0hDqWZCOROVpfBgCemaC3m6jDOXi03g==",
-			"license": "MIT",
-			"peer": true,
-			"peerDependencies": {
-				"emoji-mart": "^5.2",
-				"react": "^16.8 || ^17 || ^18"
-			}
-		},
-		"node_modules/@emotion/babel-plugin": {
-			"version": "11.13.5",
-			"resolved": "https://registry.npmjs.org/@emotion/babel-plugin/-/babel-plugin-11.13.5.tgz",
-			"integrity": "sha512-pxHCpT2ex+0q+HH91/zsdHkw/lXd468DIN2zvfvLtPKLLMo6gQj7oLObq8PhkrxOZb/gGCq03S3Z7PDhS8pduQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@babel/helper-module-imports": "^7.16.7",
-				"@babel/runtime": "^7.18.3",
-				"@emotion/hash": "^0.9.2",
-				"@emotion/memoize": "^0.9.0",
-				"@emotion/serialize": "^1.3.3",
-				"babel-plugin-macros": "^3.1.0",
-				"convert-source-map": "^1.5.0",
-				"escape-string-regexp": "^4.0.0",
-				"find-root": "^1.1.0",
-				"source-map": "^0.5.7",
-				"stylis": "4.2.0"
-			}
-		},
-		"node_modules/@emotion/babel-plugin/node_modules/@emotion/hash": {
-			"version": "0.9.2",
-			"resolved": "https://registry.npmjs.org/@emotion/hash/-/hash-0.9.2.tgz",
-			"integrity": "sha512-MyqliTZGuOm3+5ZRSaaBGP3USLw6+EGykkwZns2EPC5g8jJ4z9OrdZY9apkl3+UP9+sdz76YYkwCKP5gh8iY3g==",
-			"license": "MIT"
-		},
-		"node_modules/@emotion/babel-plugin/node_modules/convert-source-map": {
-			"version": "1.9.0",
-			"resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz",
-			"integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==",
-			"license": "MIT"
-		},
-		"node_modules/@emotion/babel-plugin/node_modules/escape-string-regexp": {
-			"version": "4.0.0",
-			"resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
-			"integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
-			"license": "MIT",
-			"engines": {
-				"node": ">=10"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
-		"node_modules/@emotion/babel-plugin/node_modules/source-map": {
-			"version": "0.5.7",
-			"resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
-			"integrity": "sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==",
-			"license": "BSD-3-Clause",
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/@emotion/babel-plugin/node_modules/stylis": {
-			"version": "4.2.0",
-			"resolved": "https://registry.npmjs.org/stylis/-/stylis-4.2.0.tgz",
-			"integrity": "sha512-Orov6g6BB1sDfYgzWfTHDOxamtX1bE/zo104Dh9e6fqJ3PooipYyfJ0pUmrZO2wAvO8YbEyeFrkV91XTsGMSrw==",
-			"license": "MIT"
-		},
-		"node_modules/@emotion/cache": {
-			"version": "11.14.0",
-			"resolved": "https://registry.npmjs.org/@emotion/cache/-/cache-11.14.0.tgz",
-			"integrity": "sha512-L/B1lc/TViYk4DcpGxtAVbx0ZyiKM5ktoIyafGkH6zg/tj+mA+NE//aPYKG0k8kCHSHVJrpLpcAlOBEXQ3SavA==",
-			"license": "MIT",
-			"dependencies": {
-				"@emotion/memoize": "^0.9.0",
-				"@emotion/sheet": "^1.4.0",
-				"@emotion/utils": "^1.4.2",
-				"@emotion/weak-memoize": "^0.4.0",
-				"stylis": "4.2.0"
-			}
-		},
-		"node_modules/@emotion/cache/node_modules/stylis": {
-			"version": "4.2.0",
-			"resolved": "https://registry.npmjs.org/stylis/-/stylis-4.2.0.tgz",
-			"integrity": "sha512-Orov6g6BB1sDfYgzWfTHDOxamtX1bE/zo104Dh9e6fqJ3PooipYyfJ0pUmrZO2wAvO8YbEyeFrkV91XTsGMSrw==",
-			"license": "MIT"
-		},
-		"node_modules/@emotion/css": {
-			"version": "11.13.5",
-			"resolved": "https://registry.npmjs.org/@emotion/css/-/css-11.13.5.tgz",
-			"integrity": "sha512-wQdD0Xhkn3Qy2VNcIzbLP9MR8TafI0MJb7BEAXKp+w4+XqErksWR4OXomuDzPsN4InLdGhVe6EYcn2ZIUCpB8w==",
-			"license": "MIT",
-			"dependencies": {
-				"@emotion/babel-plugin": "^11.13.5",
-				"@emotion/cache": "^11.13.5",
-				"@emotion/serialize": "^1.3.3",
-				"@emotion/sheet": "^1.4.0",
-				"@emotion/utils": "^1.4.2"
-			}
-		},
-		"node_modules/@emotion/hash": {
-			"version": "0.8.0",
-			"resolved": "https://registry.npmjs.org/@emotion/hash/-/hash-0.8.0.tgz",
-			"integrity": "sha512-kBJtf7PH6aWwZ6fka3zQ0p6SBYzx4fl1LoZXE2RrnYST9Xljm7WfKJrU4g/Xr3Beg72MLrp1AWNUmuYJTL7Cow==",
-			"license": "MIT"
-		},
-		"node_modules/@emotion/is-prop-valid": {
-			"version": "1.4.0",
-			"resolved": "https://registry.npmjs.org/@emotion/is-prop-valid/-/is-prop-valid-1.4.0.tgz",
-			"integrity": "sha512-QgD4fyscGcbbKwJmqNvUMSE02OsHUa+lAWKdEUIJKgqe5IwRSKd7+KhibEWdaKwgjLj0DRSHA9biAIqGBk05lw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@emotion/memoize": "^0.9.0"
-			}
-		},
-		"node_modules/@emotion/memoize": {
-			"version": "0.9.0",
-			"resolved": "https://registry.npmjs.org/@emotion/memoize/-/memoize-0.9.0.tgz",
-			"integrity": "sha512-30FAj7/EoJ5mwVPOWhAyCX+FPfMDrVecJAM+Iw9NRoSl4BBAQeqj4cApHHUXOVvIPgLVDsCFoz/hGD+5QQD1GQ==",
-			"license": "MIT"
-		},
-		"node_modules/@emotion/react": {
-			"version": "11.14.0",
-			"resolved": "https://registry.npmjs.org/@emotion/react/-/react-11.14.0.tgz",
-			"integrity": "sha512-O000MLDBDdk/EohJPFUqvnp4qnHeYkVP5B0xEG0D/L7cOKP9kefu2DXn8dj74cQfsEzUqh+sr1RzFqiL1o+PpA==",
-			"license": "MIT",
-			"dependencies": {
-				"@babel/runtime": "^7.18.3",
-				"@emotion/babel-plugin": "^11.13.5",
-				"@emotion/cache": "^11.14.0",
-				"@emotion/serialize": "^1.3.3",
-				"@emotion/use-insertion-effect-with-fallbacks": "^1.2.0",
-				"@emotion/utils": "^1.4.2",
-				"@emotion/weak-memoize": "^0.4.0",
-				"hoist-non-react-statics": "^3.3.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.8.0"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@emotion/serialize": {
-			"version": "1.3.3",
-			"resolved": "https://registry.npmjs.org/@emotion/serialize/-/serialize-1.3.3.tgz",
-			"integrity": "sha512-EISGqt7sSNWHGI76hC7x1CksiXPahbxEOrC5RjmFRJTqLyEK9/9hZvBbiYn70dw4wuwMKiEMCUlR6ZXTSWQqxA==",
-			"license": "MIT",
-			"dependencies": {
-				"@emotion/hash": "^0.9.2",
-				"@emotion/memoize": "^0.9.0",
-				"@emotion/unitless": "^0.10.0",
-				"@emotion/utils": "^1.4.2",
-				"csstype": "^3.0.2"
-			}
-		},
-		"node_modules/@emotion/serialize/node_modules/@emotion/hash": {
-			"version": "0.9.2",
-			"resolved": "https://registry.npmjs.org/@emotion/hash/-/hash-0.9.2.tgz",
-			"integrity": "sha512-MyqliTZGuOm3+5ZRSaaBGP3USLw6+EGykkwZns2EPC5g8jJ4z9OrdZY9apkl3+UP9+sdz76YYkwCKP5gh8iY3g==",
-			"license": "MIT"
-		},
-		"node_modules/@emotion/serialize/node_modules/@emotion/unitless": {
-			"version": "0.10.0",
-			"resolved": "https://registry.npmjs.org/@emotion/unitless/-/unitless-0.10.0.tgz",
-			"integrity": "sha512-dFoMUuQA20zvtVTuxZww6OHoJYgrzfKM1t52mVySDJnMSEa08ruEvdYQbhvyu6soU+NeLVd3yKfTfT0NeV6qGg==",
-			"license": "MIT"
-		},
-		"node_modules/@emotion/sheet": {
-			"version": "1.4.0",
-			"resolved": "https://registry.npmjs.org/@emotion/sheet/-/sheet-1.4.0.tgz",
-			"integrity": "sha512-fTBW9/8r2w3dXWYM4HCB1Rdp8NLibOw2+XELH5m5+AkWiL/KqYX6dc0kKYlaYyKjrQ6ds33MCdMPEwgs2z1rqg==",
-			"license": "MIT"
-		},
-		"node_modules/@emotion/unitless": {
-			"version": "0.7.5",
-			"resolved": "https://registry.npmjs.org/@emotion/unitless/-/unitless-0.7.5.tgz",
-			"integrity": "sha512-OWORNpfjMsSSUBVrRBVGECkhWcULOAJz9ZW8uK9qgxD+87M7jHRcvh/A96XXNhXTLmKcoYSQtBEX7lHMO7YRwg==",
-			"license": "MIT"
-		},
-		"node_modules/@emotion/use-insertion-effect-with-fallbacks": {
-			"version": "1.2.0",
-			"resolved": "https://registry.npmjs.org/@emotion/use-insertion-effect-with-fallbacks/-/use-insertion-effect-with-fallbacks-1.2.0.tgz",
-			"integrity": "sha512-yJMtVdH59sxi/aVJBpk9FQq+OR8ll5GT8oWd57UpeaKEVGab41JWaCFA7FRLoMLloOZF/c/wsPoe+bfGmRKgDg==",
-			"license": "MIT",
-			"peerDependencies": {
-				"react": ">=16.8.0"
-			}
-		},
-		"node_modules/@emotion/utils": {
-			"version": "1.4.2",
-			"resolved": "https://registry.npmjs.org/@emotion/utils/-/utils-1.4.2.tgz",
-			"integrity": "sha512-3vLclRofFziIa3J2wDh9jjbkUz9qk5Vi3IZ/FSTKViB0k+ef0fPV7dYrUIugbgupYDx7v9ud/SjrtEP8Y4xLoA==",
-			"license": "MIT"
-		},
-		"node_modules/@emotion/weak-memoize": {
-			"version": "0.4.0",
-			"resolved": "https://registry.npmjs.org/@emotion/weak-memoize/-/weak-memoize-0.4.0.tgz",
-			"integrity": "sha512-snKqtPW01tN0ui7yu9rGv69aJXr/a/Ywvl11sUjNtEcRc+ng/mQriFL0wLXMef74iHa/EkftbDzU9F8iFbH+zg==",
-			"license": "MIT"
-		},
-		"node_modules/@esbuild/darwin-arm64": {
-			"version": "0.25.12",
-			"cpu": [
-				"arm64"
-			],
-			"dev": true,
-			"license": "MIT",
-			"optional": true,
-			"os": [
-				"darwin"
-			],
-			"engines": {
-				"node": ">=18"
-			}
-		},
-		"node_modules/@floating-ui/core": {
-			"version": "1.7.4",
-			"resolved": "https://registry.npmjs.org/@floating-ui/core/-/core-1.7.4.tgz",
-			"integrity": "sha512-C3HlIdsBxszvm5McXlB8PeOEWfBhcGBTZGkGlWc2U0KFY5IwG5OQEuQ8rq52DZmcHDlPLd+YFBK+cZcytwIFWg==",
-			"license": "MIT",
-			"dependencies": {
-				"@floating-ui/utils": "^0.2.10"
-			}
-		},
-		"node_modules/@floating-ui/dom": {
-			"version": "1.7.5",
-			"resolved": "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.7.5.tgz",
-			"integrity": "sha512-N0bD2kIPInNHUHehXhMke1rBGs1dwqvC9O9KYMyyjK7iXt7GAhnro7UlcuYcGdS/yYOlq0MAVgrow8IbWJwyqg==",
-			"license": "MIT",
-			"dependencies": {
-				"@floating-ui/core": "^1.7.4",
-				"@floating-ui/utils": "^0.2.10"
-			}
-		},
-		"node_modules/@floating-ui/react": {
-			"version": "0.27.18",
-			"resolved": "https://registry.npmjs.org/@floating-ui/react/-/react-0.27.18.tgz",
-			"integrity": "sha512-xJWJxvmy3a05j643gQt+pRbht5XnTlGpsEsAPnMi5F5YTOEEJymA90uZKBD8OvIv5XvZ1qi4GcccSlqT3Bq44Q==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@floating-ui/react-dom": "^2.1.7",
-				"@floating-ui/utils": "^0.2.10",
-				"tabbable": "^6.0.0"
-			},
-			"peerDependencies": {
-				"react": ">=17.0.0",
-				"react-dom": ">=17.0.0"
-			}
-		},
-		"node_modules/@floating-ui/react-dom": {
-			"version": "2.1.7",
-			"resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.7.tgz",
-			"integrity": "sha512-0tLRojf/1Go2JgEVm+3Frg9A3IW8bJgKgdO0BN5RkF//ufuz2joZM63Npau2ff3J6lUVYgDSNzNkR+aH3IVfjg==",
-			"license": "MIT",
-			"dependencies": {
-				"@floating-ui/dom": "^1.7.5"
-			},
-			"peerDependencies": {
-				"react": ">=16.8.0",
-				"react-dom": ">=16.8.0"
-			}
-		},
-		"node_modules/@floating-ui/utils": {
-			"version": "0.2.10",
-			"resolved": "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.10.tgz",
-			"integrity": "sha512-aGTxbpbg8/b5JfU1HXSrbH3wXZuLPJcNEcZQFMxLs3oSzgtVu6nFPkbbGGUvBcUjKV2YyB9Wxxabo+HEH9tcRQ==",
-			"license": "MIT"
-		},
-		"node_modules/@fontsource/ibm-plex-sans": {
-			"version": "5.2.8",
-			"license": "OFL-1.1",
-			"funding": {
-				"url": "https://github.com/sponsors/ayuhito"
-			}
-		},
-		"node_modules/@fortawesome/fontawesome-common-types": {
-			"version": "7.2.0",
-			"resolved": "https://registry.npmjs.org/@fortawesome/fontawesome-common-types/-/fontawesome-common-types-7.2.0.tgz",
-			"integrity": "sha512-IpR0bER9FY25p+e7BmFH25MZKEwFHTfRAfhOyJubgiDnoJNsSvJ7nigLraHtp4VOG/cy8D7uiV0dLkHOne5Fhw==",
-			"license": "MIT",
-			"engines": {
-				"node": ">=6"
-			}
-		},
-		"node_modules/@fortawesome/fontawesome-svg-core": {
-			"version": "7.2.0",
-			"resolved": "https://registry.npmjs.org/@fortawesome/fontawesome-svg-core/-/fontawesome-svg-core-7.2.0.tgz",
-			"integrity": "sha512-6639htZMjEkwskf3J+e6/iar+4cTNM9qhoWuRfj9F3eJD6r7iCzV1SWnQr2Mdv0QT0suuqU8BoJCZUyCtP9R4Q==",
-			"license": "MIT",
-			"dependencies": {
-				"@fortawesome/fontawesome-common-types": "7.2.0"
-			},
-			"engines": {
-				"node": ">=6"
-			}
-		},
-		"node_modules/@fortawesome/free-brands-svg-icons": {
-			"version": "7.2.0",
-			"resolved": "https://registry.npmjs.org/@fortawesome/free-brands-svg-icons/-/free-brands-svg-icons-7.2.0.tgz",
-			"integrity": "sha512-VNG8xqOip1JuJcC3zsVsKRQ60oXG9+oYNDCosjoU/H9pgYmLTEwWw8pE0jhPz/JWdHeUuK6+NQ3qsM4gIbdbYQ==",
-			"license": "(CC-BY-4.0 AND MIT)",
-			"dependencies": {
-				"@fortawesome/fontawesome-common-types": "7.2.0"
-			},
-			"engines": {
-				"node": ">=6"
-			}
-		},
-		"node_modules/@fortawesome/free-solid-svg-icons": {
-			"version": "7.2.0",
-			"resolved": "https://registry.npmjs.org/@fortawesome/free-solid-svg-icons/-/free-solid-svg-icons-7.2.0.tgz",
-			"integrity": "sha512-YTVITFGN0/24PxzXrwqCgnyd7njDuzp5ZvaCx5nq/jg55kUYd94Nj8UTchBdBofi/L0nwRfjGOg0E41d2u9T1w==",
-			"license": "(CC-BY-4.0 AND MIT)",
-			"dependencies": {
-				"@fortawesome/fontawesome-common-types": "7.2.0"
-			},
-			"engines": {
-				"node": ">=6"
-			}
-		},
-		"node_modules/@fortawesome/react-fontawesome": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/@fortawesome/react-fontawesome/-/react-fontawesome-3.0.0.tgz",
-			"integrity": "sha512-x6boc1RLEjf/QPrMS20VJcabTZeGCb1hbwNybPPLjJohGPowXfjOpwQlVK6aH6MVKfCq2JXeHRIlx+tYpS18FA==",
-			"license": "MIT",
-			"dependencies": {
-				"semver": "^7.7.2"
-			},
-			"peerDependencies": {
-				"@fortawesome/fontawesome-svg-core": "~6 || ~7",
-				"react": "^18.0.0 || ^19.0.0"
-			}
-		},
-		"node_modules/@fortawesome/react-fontawesome/node_modules/semver": {
-			"version": "7.7.4",
-			"resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
-			"integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
-			"license": "ISC",
-			"bin": {
-				"semver": "bin/semver.js"
-			},
-			"engines": {
-				"node": ">=10"
-			}
-		},
-		"node_modules/@giscus/react": {
-			"version": "3.1.0",
-			"resolved": "https://registry.npmjs.org/@giscus/react/-/react-3.1.0.tgz",
-			"integrity": "sha512-0TCO2TvL43+oOdyVVGHDItwxD1UMKP2ZYpT6gXmhFOqfAJtZxTzJ9hkn34iAF/b6YzyJ4Um89QIt9z/ajmAEeg==",
-			"peer": true,
-			"dependencies": {
-				"giscus": "^1.6.0"
-			},
-			"peerDependencies": {
-				"react": "^16 || ^17 || ^18 || ^19",
-				"react-dom": "^16 || ^17 || ^18 || ^19"
-			}
-		},
-		"node_modules/@hookform/resolvers": {
-			"version": "5.2.2",
-			"resolved": "https://registry.npmjs.org/@hookform/resolvers/-/resolvers-5.2.2.tgz",
-			"integrity": "sha512-A/IxlMLShx3KjV/HeTcTfaMxdwy690+L/ZADoeaTltLx+CVuzkeVIPuybK3jrRfw7YZnmdKsVVHAlEPIAEUNlA==",
-			"license": "MIT",
-			"dependencies": {
-				"@standard-schema/utils": "^0.3.0"
-			},
-			"peerDependencies": {
-				"react-hook-form": "^7.55.0"
-			}
-		},
-		"node_modules/@hugeicons/core-free-icons": {
-			"version": "3.1.1",
-			"resolved": "https://registry.npmjs.org/@hugeicons/core-free-icons/-/core-free-icons-3.1.1.tgz",
-			"integrity": "sha512-UpS2lUQFi5sKyJSWwM6rO+BnPLvVz1gsyCpPHeZyVuZqi89YH8ksliza4cwaODqKOZyeXmG8juo1ty4QtQofkg==",
-			"license": "MIT"
-		},
-		"node_modules/@hugeicons/react": {
-			"version": "1.1.5",
-			"resolved": "https://registry.npmjs.org/@hugeicons/react/-/react-1.1.5.tgz",
-			"integrity": "sha512-JX/iDz3oO7hWdVqbjwFwRrAjHk8h2vI+mBkNzp4JcXG3t4idoupfjon73nLOA7cr27m0M8hrRC1Q2h6nEBGKVA==",
-			"license": "MIT",
-			"peerDependencies": {
-				"react": ">=16.0.0"
-			}
-		},
-		"node_modules/@iconify/types": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/@iconify/types/-/types-2.0.0.tgz",
-			"integrity": "sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@iconify/utils": {
-			"version": "3.1.0",
-			"resolved": "https://registry.npmjs.org/@iconify/utils/-/utils-3.1.0.tgz",
-			"integrity": "sha512-Zlzem1ZXhI1iHeeERabLNzBHdOa4VhQbqAcOQaMKuTuyZCpwKbC2R4Dd0Zo3g9EAc+Y4fiarO8HIHRAth7+skw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@antfu/install-pkg": "^1.1.0",
-				"@iconify/types": "^2.0.0",
-				"mlly": "^1.8.0"
-			}
-		},
-		"node_modules/@jridgewell/gen-mapping": {
-			"version": "0.3.13",
-			"license": "MIT",
-			"dependencies": {
-				"@jridgewell/sourcemap-codec": "^1.5.0",
-				"@jridgewell/trace-mapping": "^0.3.24"
-			}
-		},
-		"node_modules/@jridgewell/remapping": {
-			"version": "2.3.5",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@jridgewell/gen-mapping": "^0.3.5",
-				"@jridgewell/trace-mapping": "^0.3.24"
-			}
-		},
-		"node_modules/@jridgewell/resolve-uri": {
-			"version": "3.1.2",
-			"license": "MIT",
-			"engines": {
-				"node": ">=6.0.0"
-			}
-		},
-		"node_modules/@jridgewell/sourcemap-codec": {
-			"version": "1.5.5",
-			"license": "MIT"
-		},
-		"node_modules/@jridgewell/trace-mapping": {
-			"version": "0.3.31",
-			"license": "MIT",
-			"dependencies": {
-				"@jridgewell/resolve-uri": "^3.1.0",
-				"@jridgewell/sourcemap-codec": "^1.4.14"
-			}
-		},
-		"node_modules/@lezer/common": {
-			"version": "1.5.1",
-			"resolved": "https://registry.npmjs.org/@lezer/common/-/common-1.5.1.tgz",
-			"integrity": "sha512-6YRVG9vBkaY7p1IVxL4s44n5nUnaNnGM2/AckNgYOnxTG2kWh1vR8BMxPseWPjRNpb5VtXnMpeYAEAADoRV1Iw==",
-			"license": "MIT"
-		},
-		"node_modules/@lezer/highlight": {
-			"version": "1.2.3",
-			"resolved": "https://registry.npmjs.org/@lezer/highlight/-/highlight-1.2.3.tgz",
-			"integrity": "sha512-qXdH7UqTvGfdVBINrgKhDsVTJTxactNNxLk7+UMwZhU13lMHaOBlJe9Vqp907ya56Y3+ed2tlqzys7jDkTmW0g==",
-			"license": "MIT",
-			"dependencies": {
-				"@lezer/common": "^1.3.0"
-			}
-		},
-		"node_modules/@lezer/lr": {
-			"version": "1.4.8",
-			"resolved": "https://registry.npmjs.org/@lezer/lr/-/lr-1.4.8.tgz",
-			"integrity": "sha512-bPWa0Pgx69ylNlMlPvBPryqeLYQjyJjqPx+Aupm5zydLIF3NE+6MMLT8Yi23Bd9cif9VS00aUebn+6fDIGBcDA==",
-			"license": "MIT",
-			"dependencies": {
-				"@lezer/common": "^1.0.0"
-			}
-		},
-		"node_modules/@lit-labs/ssr-dom-shim": {
-			"version": "1.5.1",
-			"resolved": "https://registry.npmjs.org/@lit-labs/ssr-dom-shim/-/ssr-dom-shim-1.5.1.tgz",
-			"integrity": "sha512-Aou5UdlSpr5whQe8AA/bZG0jMj96CoJIWbGfZ91qieWu5AWUMKw8VR/pAkQkJYvBNhmCcWnZlyyk5oze8JIqYA==",
-			"license": "BSD-3-Clause",
-			"peer": true
-		},
-		"node_modules/@lit/reactive-element": {
-			"version": "2.1.2",
-			"resolved": "https://registry.npmjs.org/@lit/reactive-element/-/reactive-element-2.1.2.tgz",
-			"integrity": "sha512-pbCDiVMnne1lYUIaYNN5wrwQXDtHaYtg7YEFPeW+hws6U47WeFvISGUWekPGKWOP1ygrs0ef0o1VJMk1exos5A==",
-			"license": "BSD-3-Clause",
-			"peer": true,
-			"dependencies": {
-				"@lit-labs/ssr-dom-shim": "^1.5.0"
-			}
-		},
-		"node_modules/@lobehub/emojilib": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/@lobehub/emojilib/-/emojilib-1.0.0.tgz",
-			"integrity": "sha512-s9KnjaPjsEefaNv150G3aifvB+J3P4eEKG+epY9zDPS2BeB6+V2jELWqAZll+nkogMaVovjEE813z3V751QwGw==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@lobehub/fluent-emoji": {
-			"version": "4.1.0",
-			"resolved": "https://registry.npmjs.org/@lobehub/fluent-emoji/-/fluent-emoji-4.1.0.tgz",
-			"integrity": "sha512-R1MB2lfUkDvB7XAQdRzY75c1dx/tB7gEvBPaEEMarzKfCJWmXm7rheS6caVzmgwAlq5sfmTbxPL+un99sp//Yw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@lobehub/emojilib": "^1.0.0",
-				"antd-style": "^4.1.0",
-				"emoji-regex": "^10.6.0",
-				"es-toolkit": "^1.43.0",
-				"lucide-react": "^0.562.0",
-				"url-join": "^5.0.0"
-			},
-			"peerDependencies": {
-				"react": "^19.0.0",
-				"react-dom": "^19.0.0"
-			}
-		},
-		"node_modules/@lobehub/icons": {
-			"version": "4.6.0",
-			"resolved": "https://registry.npmjs.org/@lobehub/icons/-/icons-4.6.0.tgz",
-			"integrity": "sha512-TuU0837kalurxQfGwfyd6UODwKtPluhvuT8XrgqHo/D0B/ggbYWrLF1pwIYG+p9ccA6oz6HeaEQhmNH2eQl2sw==",
-			"license": "MIT",
-			"workspaces": [
-				"packages/*"
-			],
-			"dependencies": {
-				"antd-style": "^4.1.0",
-				"lucide-react": "^0.469.0",
-				"polished": "^4.3.1"
-			},
-			"peerDependencies": {
-				"@lobehub/ui": "^4.3.3",
-				"antd": "^6.1.1",
-				"react": "^19.0.0",
-				"react-dom": "^19.0.0"
-			}
-		},
-		"node_modules/@lobehub/icons/node_modules/lucide-react": {
-			"version": "0.469.0",
-			"resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.469.0.tgz",
-			"integrity": "sha512-28vvUnnKQ/dBwiCQtwJw7QauYnE7yd2Cyp4tTTJpvglX4EMpbflcdBgrgToX2j71B3YvugK/NH3BGUk+E/p/Fw==",
-			"license": "ISC",
-			"peerDependencies": {
-				"react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-			}
-		},
-		"node_modules/@lobehub/ui": {
-			"version": "4.38.4",
-			"resolved": "https://registry.npmjs.org/@lobehub/ui/-/ui-4.38.4.tgz",
-			"integrity": "sha512-FYQeWkR0CoZCaPqEX9AUGrhaIfkYeuacW2KtV+1GS7eGVjREFNNOAgY5PLk20ZMYV/cRFsn9fNG0rqn9PxChxw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@ant-design/cssinjs": "^2.0.3",
-				"@base-ui/react": "1.0.0",
-				"@dnd-kit/core": "^6.3.1",
-				"@dnd-kit/modifiers": "^9.0.0",
-				"@dnd-kit/sortable": "^10.0.0",
-				"@dnd-kit/utilities": "^3.2.2",
-				"@emoji-mart/data": "^1.2.1",
-				"@emoji-mart/react": "^1.1.1",
-				"@emotion/is-prop-valid": "^1.4.0",
-				"@floating-ui/react": "^0.27.17",
-				"@giscus/react": "^3.1.0",
-				"@mdx-js/mdx": "^3.1.1",
-				"@mdx-js/react": "^3.1.1",
-				"@pierre/diffs": "^1.0.10",
-				"@radix-ui/react-slot": "^1.2.4",
-				"@shikijs/core": "^3.22.0",
-				"@shikijs/transformers": "^3.22.0",
-				"@splinetool/runtime": "0.9.526",
-				"ahooks": "^3.9.6",
-				"antd-style": "^4.1.0",
-				"chroma-js": "^3.2.0",
-				"class-variance-authority": "^0.7.1",
-				"clsx": "^2.1.1",
-				"dayjs": "^1.11.19",
-				"emoji-mart": "^5.6.0",
-				"es-toolkit": "^1.44.0",
-				"fast-deep-equal": "^3.1.3",
-				"immer": "^11.1.3",
-				"katex": "^0.16.28",
-				"leva": "^0.10.1",
-				"lucide-react": "^0.563.0",
-				"marked": "^17.0.1",
-				"mermaid": "^11.12.2",
-				"motion": "^12.30.0",
-				"numeral": "^2.0.6",
-				"polished": "^4.3.1",
-				"query-string": "^9.3.1",
-				"rc-collapse": "^4.0.0",
-				"rc-footer": "^0.6.8",
-				"rc-image": "^7.12.0",
-				"rc-input-number": "^9.5.0",
-				"rc-menu": "^9.16.1",
-				"re-resizable": "^6.11.2",
-				"react-avatar-editor": "^14.0.0",
-				"react-error-boundary": "^6.1.0",
-				"react-hotkeys-hook": "^5.2.4",
-				"react-markdown": "^10.1.0",
-				"react-merge-refs": "^3.0.2",
-				"react-rnd": "^10.5.2",
-				"react-zoom-pan-pinch": "^3.7.0",
-				"rehype-github-alerts": "^4.2.0",
-				"rehype-katex": "^7.0.1",
-				"rehype-raw": "^7.0.0",
-				"remark-breaks": "^4.0.0",
-				"remark-cjk-friendly": "^1.2.3",
-				"remark-gfm": "^4.0.1",
-				"remark-github": "^12.0.0",
-				"remark-math": "^6.0.0",
-				"remend": "^1.2.0",
-				"shiki": "^3.22.0",
-				"shiki-stream": "^0.1.4",
-				"swr": "^2.4.0",
-				"ts-md5": "^2.0.1",
-				"unified": "^11.0.5",
-				"url-join": "^5.0.0",
-				"use-merge-value": "^1.2.0",
-				"uuid": "^13.0.0",
-				"virtua": "^0.48.5"
-			},
-			"peerDependencies": {
-				"@lobehub/fluent-emoji": "^4.0.0",
-				"@lobehub/icons": "^4.0.0",
-				"antd": "^6.1.1",
-				"motion": "^12.0.0",
-				"react": "^19.0.0",
-				"react-dom": "^19.0.0"
-			}
-		},
-		"node_modules/@lobehub/ui/node_modules/@radix-ui/react-slot": {
-			"version": "1.2.4",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.4.tgz",
-			"integrity": "sha512-Jl+bCv8HxKnlTLVrcDE8zTMJ09R9/ukw4qBs/oZClOfoQk/cOTbDn+NceXfV7j09YPVQUryJPHurafcSg6EVKA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@radix-ui/react-compose-refs": "1.1.2"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@lobehub/ui/node_modules/immer": {
-			"version": "11.1.4",
-			"resolved": "https://registry.npmjs.org/immer/-/immer-11.1.4.tgz",
-			"integrity": "sha512-XREFCPo6ksxVzP4E0ekD5aMdf8WMwmdNaz6vuvxgI40UaEiu6q3p8X52aU6GdyvLY3XXX/8R7JOTXStz/nBbRw==",
-			"license": "MIT",
-			"peer": true,
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/immer"
-			}
-		},
-		"node_modules/@lobehub/ui/node_modules/lucide-react": {
-			"version": "0.563.0",
-			"resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.563.0.tgz",
-			"integrity": "sha512-8dXPB2GI4dI8jV4MgUDGBeLdGk8ekfqVZ0BdLcrRzocGgG75ltNEmWS+gE7uokKF/0oSUuczNDT+g9hFJ23FkA==",
-			"license": "ISC",
-			"peer": true,
-			"peerDependencies": {
-				"react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-			}
-		},
-		"node_modules/@marijn/find-cluster-break": {
-			"version": "1.0.2",
-			"resolved": "https://registry.npmjs.org/@marijn/find-cluster-break/-/find-cluster-break-1.0.2.tgz",
-			"integrity": "sha512-l0h88YhZFyKdXIFNfSWpyjStDjGHwZ/U7iobcK1cQQD8sejsONdQtTVU+1wVN1PBw40PiiHB1vA5S7VTfQiP9g==",
-			"license": "MIT"
-		},
-		"node_modules/@mdx-js/mdx": {
-			"version": "3.1.1",
-			"resolved": "https://registry.npmjs.org/@mdx-js/mdx/-/mdx-3.1.1.tgz",
-			"integrity": "sha512-f6ZO2ifpwAQIpzGWaBQT2TXxPv6z3RBzQKpVftEWN78Vl/YweF1uwussDx8ECAXVtr3Rs89fKyG9YlzUs9DyGQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree": "^1.0.0",
-				"@types/estree-jsx": "^1.0.0",
-				"@types/hast": "^3.0.0",
-				"@types/mdx": "^2.0.0",
-				"acorn": "^8.0.0",
-				"collapse-white-space": "^2.0.0",
-				"devlop": "^1.0.0",
-				"estree-util-is-identifier-name": "^3.0.0",
-				"estree-util-scope": "^1.0.0",
-				"estree-walker": "^3.0.0",
-				"hast-util-to-jsx-runtime": "^2.0.0",
-				"markdown-extensions": "^2.0.0",
-				"recma-build-jsx": "^1.0.0",
-				"recma-jsx": "^1.0.0",
-				"recma-stringify": "^1.0.0",
-				"rehype-recma": "^1.0.0",
-				"remark-mdx": "^3.0.0",
-				"remark-parse": "^11.0.0",
-				"remark-rehype": "^11.0.0",
-				"source-map": "^0.7.0",
-				"unified": "^11.0.0",
-				"unist-util-position-from-estree": "^2.0.0",
-				"unist-util-stringify-position": "^4.0.0",
-				"unist-util-visit": "^5.0.0",
-				"vfile": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/@mdx-js/react": {
-			"version": "3.1.1",
-			"resolved": "https://registry.npmjs.org/@mdx-js/react/-/react-3.1.1.tgz",
-			"integrity": "sha512-f++rKLQgUVYDAtECQ6fn/is15GkEH9+nZPM3MS0RcxVqoTfawHvDlSCH7JbMhAM6uJ32v3eXLvLmLvjGu7PTQw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/mdx": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			},
-			"peerDependencies": {
-				"@types/react": ">=16",
-				"react": ">=16"
-			}
-		},
-		"node_modules/@mermaid-js/parser": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/@mermaid-js/parser/-/parser-1.0.0.tgz",
-			"integrity": "sha512-vvK0Hi/VWndxoh03Mmz6wa1KDriSPjS2XMZL/1l19HFwygiObEEoEwSDxOqyLzzAI6J2PU3261JjTMTO7x+BPw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"langium": "^4.0.0"
-			}
-		},
-		"node_modules/@nodelib/fs.scandir": {
-			"version": "2.1.5",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@nodelib/fs.stat": "2.0.5",
-				"run-parallel": "^1.1.9"
-			},
-			"engines": {
-				"node": ">= 8"
-			}
-		},
-		"node_modules/@nodelib/fs.stat": {
-			"version": "2.0.5",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">= 8"
-			}
-		},
-		"node_modules/@nodelib/fs.walk": {
-			"version": "1.2.8",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@nodelib/fs.scandir": "2.1.5",
-				"fastq": "^1.6.0"
-			},
-			"engines": {
-				"node": ">= 8"
-			}
-		},
-		"node_modules/@parcel/watcher": {
-			"version": "2.5.6",
-			"dev": true,
-			"hasInstallScript": true,
-			"license": "MIT",
-			"optional": true,
-			"dependencies": {
-				"detect-libc": "^2.0.3",
-				"is-glob": "^4.0.3",
-				"node-addon-api": "^7.0.0",
-				"picomatch": "^4.0.3"
-			},
-			"engines": {
-				"node": ">= 10.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/parcel"
-			},
-			"optionalDependencies": {
-				"@parcel/watcher-android-arm64": "2.5.6",
-				"@parcel/watcher-darwin-arm64": "2.5.6",
-				"@parcel/watcher-darwin-x64": "2.5.6",
-				"@parcel/watcher-freebsd-x64": "2.5.6",
-				"@parcel/watcher-linux-arm-glibc": "2.5.6",
-				"@parcel/watcher-linux-arm-musl": "2.5.6",
-				"@parcel/watcher-linux-arm64-glibc": "2.5.6",
-				"@parcel/watcher-linux-arm64-musl": "2.5.6",
-				"@parcel/watcher-linux-x64-glibc": "2.5.6",
-				"@parcel/watcher-linux-x64-musl": "2.5.6",
-				"@parcel/watcher-win32-arm64": "2.5.6",
-				"@parcel/watcher-win32-ia32": "2.5.6",
-				"@parcel/watcher-win32-x64": "2.5.6"
-			}
-		},
-		"node_modules/@parcel/watcher-darwin-arm64": {
-			"version": "2.5.6",
-			"cpu": [
-				"arm64"
-			],
-			"dev": true,
-			"license": "MIT",
-			"optional": true,
-			"os": [
-				"darwin"
-			],
-			"engines": {
-				"node": ">= 10.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/parcel"
-			}
-		},
-		"node_modules/@pierre/diffs": {
-			"version": "1.0.11",
-			"resolved": "https://registry.npmjs.org/@pierre/diffs/-/diffs-1.0.11.tgz",
-			"integrity": "sha512-j6zIEoyImQy1HfcJqbrDwP0O5I7V2VNXAaw53FqQ+SykRfaNwABeZHs9uibXO4supaXPmTx6LEH9Lffr03e1Tw==",
-			"license": "apache-2.0",
-			"peer": true,
-			"dependencies": {
-				"@shikijs/core": "^3.0.0",
-				"@shikijs/engine-javascript": "^3.0.0",
-				"@shikijs/transformers": "^3.0.0",
-				"diff": "8.0.3",
-				"hast-util-to-html": "9.0.5",
-				"lru_map": "0.4.1",
-				"shiki": "^3.0.0"
-			},
-			"peerDependencies": {
-				"react": "^18.3.1 || ^19.0.0",
-				"react-dom": "^18.3.1 || ^19.0.0"
-			}
-		},
-		"node_modules/@primer/octicons": {
-			"version": "19.22.0",
-			"resolved": "https://registry.npmjs.org/@primer/octicons/-/octicons-19.22.0.tgz",
-			"integrity": "sha512-nWoh9PlE6u7xbiZF3KcUm3ktLpN2rQPt11trwp/t4EsKuYRNVWVbBp1LkCBsvZq7ScckNKUURLigIU0wS1FQdw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"object-assign": "^4.1.1"
-			}
-		},
-		"node_modules/@radix-ui/number": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/@radix-ui/number/-/number-1.1.1.tgz",
-			"integrity": "sha512-MkKCwxlXTgz6CFoJx3pCwn07GKp36+aZyu/u2Ln2VrA5DcdyCZkASEDBTd8x5whTQQL5CiYf4prXKLcgQdv29g==",
-			"license": "MIT"
-		},
-		"node_modules/@radix-ui/primitive": {
-			"version": "1.1.3",
-			"resolved": "https://registry.npmjs.org/@radix-ui/primitive/-/primitive-1.1.3.tgz",
-			"integrity": "sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==",
-			"license": "MIT"
-		},
-		"node_modules/@radix-ui/react-arrow": {
-			"version": "1.1.7",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-arrow/-/react-arrow-1.1.7.tgz",
-			"integrity": "sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/react-primitive": "2.1.3"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-checkbox": {
-			"version": "1.3.3",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-checkbox/-/react-checkbox-1.3.3.tgz",
-			"integrity": "sha512-wBbpv+NQftHDdG86Qc0pIyXk5IR3tM8Vd0nWLKDcX8nNn4nXFOFwsKuqw2okA/1D/mpaAkmuyndrPJTYDNZtFw==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/primitive": "1.1.3",
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-context": "1.1.2",
-				"@radix-ui/react-presence": "1.1.5",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-use-controllable-state": "1.2.2",
-				"@radix-ui/react-use-previous": "1.1.1",
-				"@radix-ui/react-use-size": "1.1.1"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-collection": {
-			"version": "1.1.7",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-collection/-/react-collection-1.1.7.tgz",
-			"integrity": "sha512-Fh9rGN0MoI4ZFUNyfFVNU4y9LUz93u9/0K+yLgA2bwRojxM8JU1DyvvMBabnZPBgMWREAJvU2jjVzq+LrFUglw==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-context": "1.1.2",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-slot": "1.2.3"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-compose-refs": {
-			"version": "1.1.2",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-compose-refs/-/react-compose-refs-1.1.2.tgz",
-			"integrity": "sha512-z4eqJvfiNnFMHIIvXP3CY57y2WJs5g2v3X0zm9mEJkrkNv4rDxu+sg9Jh8EkXyeqBkB7SOcboo9dMVqhyrACIg==",
-			"license": "MIT",
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-context": {
-			"version": "1.1.2",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-context/-/react-context-1.1.2.tgz",
-			"integrity": "sha512-jCi/QKUM2r1Ju5a3J64TH2A5SpKAgh0LpknyqdQ4m6DCV0xJ2HG1xARRwNGPQfi1SLdLWZ1OJz6F4OMBBNiGJA==",
-			"license": "MIT",
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-dialog": {
-			"version": "1.1.15",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-dialog/-/react-dialog-1.1.15.tgz",
-			"integrity": "sha512-TCglVRtzlffRNxRMEyR36DGBLJpeusFcgMVD9PZEzAKnUs1lKCgX5u9BmC2Yg+LL9MgZDugFFs1Vl+Jp4t/PGw==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/primitive": "1.1.3",
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-context": "1.1.2",
-				"@radix-ui/react-dismissable-layer": "1.1.11",
-				"@radix-ui/react-focus-guards": "1.1.3",
-				"@radix-ui/react-focus-scope": "1.1.7",
-				"@radix-ui/react-id": "1.1.1",
-				"@radix-ui/react-portal": "1.1.9",
-				"@radix-ui/react-presence": "1.1.5",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-slot": "1.2.3",
-				"@radix-ui/react-use-controllable-state": "1.2.2",
-				"aria-hidden": "^1.2.4",
-				"react-remove-scroll": "^2.6.3"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-direction": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-direction/-/react-direction-1.1.1.tgz",
-			"integrity": "sha512-1UEWRX6jnOA2y4H5WczZ44gOOjTEmlqv1uNW4GAJEO5+bauCBhv8snY65Iw5/VOS/ghKN9gr2KjnLKxrsvoMVw==",
-			"license": "MIT",
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-dismissable-layer": {
-			"version": "1.1.11",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.11.tgz",
-			"integrity": "sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/primitive": "1.1.3",
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-use-callback-ref": "1.1.1",
-				"@radix-ui/react-use-escape-keydown": "1.1.1"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-dropdown-menu": {
-			"version": "2.1.16",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-dropdown-menu/-/react-dropdown-menu-2.1.16.tgz",
-			"integrity": "sha512-1PLGQEynI/3OX/ftV54COn+3Sud/Mn8vALg2rWnBLnRaGtJDduNW/22XjlGgPdpcIbiQxjKtb7BkcjP00nqfJw==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/primitive": "1.1.3",
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-context": "1.1.2",
-				"@radix-ui/react-id": "1.1.1",
-				"@radix-ui/react-menu": "2.1.16",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-use-controllable-state": "1.2.2"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-focus-guards": {
-			"version": "1.1.3",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-focus-guards/-/react-focus-guards-1.1.3.tgz",
-			"integrity": "sha512-0rFg/Rj2Q62NCm62jZw0QX7a3sz6QCQU0LpZdNrJX8byRGaGVTqbrW9jAoIAHyMQqsNpeZ81YgSizOt5WXq0Pw==",
-			"license": "MIT",
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-focus-scope": {
-			"version": "1.1.7",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-focus-scope/-/react-focus-scope-1.1.7.tgz",
-			"integrity": "sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-use-callback-ref": "1.1.1"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-id": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-id/-/react-id-1.1.1.tgz",
-			"integrity": "sha512-kGkGegYIdQsOb4XjsfM97rXsiHaBwco+hFI66oO4s9LU+PLAC5oJ7khdOVFxkhsmlbpUqDAvXw11CluXP+jkHg==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/react-use-layout-effect": "1.1.1"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-menu": {
-			"version": "2.1.16",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-menu/-/react-menu-2.1.16.tgz",
-			"integrity": "sha512-72F2T+PLlphrqLcAotYPp0uJMr5SjP5SL01wfEspJbru5Zs5vQaSHb4VB3ZMJPimgHHCHG7gMOeOB9H3Hdmtxg==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/primitive": "1.1.3",
-				"@radix-ui/react-collection": "1.1.7",
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-context": "1.1.2",
-				"@radix-ui/react-direction": "1.1.1",
-				"@radix-ui/react-dismissable-layer": "1.1.11",
-				"@radix-ui/react-focus-guards": "1.1.3",
-				"@radix-ui/react-focus-scope": "1.1.7",
-				"@radix-ui/react-id": "1.1.1",
-				"@radix-ui/react-popper": "1.2.8",
-				"@radix-ui/react-portal": "1.1.9",
-				"@radix-ui/react-presence": "1.1.5",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-roving-focus": "1.1.11",
-				"@radix-ui/react-slot": "1.2.3",
-				"@radix-ui/react-use-callback-ref": "1.1.1",
-				"aria-hidden": "^1.2.4",
-				"react-remove-scroll": "^2.6.3"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-popover": {
-			"version": "1.1.15",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-popover/-/react-popover-1.1.15.tgz",
-			"integrity": "sha512-kr0X2+6Yy/vJzLYJUPCZEc8SfQcf+1COFoAqauJm74umQhta9M7lNJHP7QQS3vkvcGLQUbWpMzwrXYwrYztHKA==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/primitive": "1.1.3",
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-context": "1.1.2",
-				"@radix-ui/react-dismissable-layer": "1.1.11",
-				"@radix-ui/react-focus-guards": "1.1.3",
-				"@radix-ui/react-focus-scope": "1.1.7",
-				"@radix-ui/react-id": "1.1.1",
-				"@radix-ui/react-popper": "1.2.8",
-				"@radix-ui/react-portal": "1.1.9",
-				"@radix-ui/react-presence": "1.1.5",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-slot": "1.2.3",
-				"@radix-ui/react-use-controllable-state": "1.2.2",
-				"aria-hidden": "^1.2.4",
-				"react-remove-scroll": "^2.6.3"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-popper": {
-			"version": "1.2.8",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-popper/-/react-popper-1.2.8.tgz",
-			"integrity": "sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==",
-			"license": "MIT",
-			"dependencies": {
-				"@floating-ui/react-dom": "^2.0.0",
-				"@radix-ui/react-arrow": "1.1.7",
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-context": "1.1.2",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-use-callback-ref": "1.1.1",
-				"@radix-ui/react-use-layout-effect": "1.1.1",
-				"@radix-ui/react-use-rect": "1.1.1",
-				"@radix-ui/react-use-size": "1.1.1",
-				"@radix-ui/rect": "1.1.1"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-portal": {
-			"version": "1.1.9",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-portal/-/react-portal-1.1.9.tgz",
-			"integrity": "sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-use-layout-effect": "1.1.1"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-presence": {
-			"version": "1.1.5",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-presence/-/react-presence-1.1.5.tgz",
-			"integrity": "sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-use-layout-effect": "1.1.1"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-primitive": {
-			"version": "2.1.3",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.3.tgz",
-			"integrity": "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/react-slot": "1.2.3"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-radio-group": {
-			"version": "1.3.8",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-radio-group/-/react-radio-group-1.3.8.tgz",
-			"integrity": "sha512-VBKYIYImA5zsxACdisNQ3BjCBfmbGH3kQlnFVqlWU4tXwjy7cGX8ta80BcrO+WJXIn5iBylEH3K6ZTlee//lgQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/primitive": "1.1.3",
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-context": "1.1.2",
-				"@radix-ui/react-direction": "1.1.1",
-				"@radix-ui/react-presence": "1.1.5",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-roving-focus": "1.1.11",
-				"@radix-ui/react-use-controllable-state": "1.2.2",
-				"@radix-ui/react-use-previous": "1.1.1",
-				"@radix-ui/react-use-size": "1.1.1"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-roving-focus": {
-			"version": "1.1.11",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-roving-focus/-/react-roving-focus-1.1.11.tgz",
-			"integrity": "sha512-7A6S9jSgm/S+7MdtNDSb+IU859vQqJ/QAtcYQcfFC6W8RS4IxIZDldLR0xqCFZ6DCyrQLjLPsxtTNch5jVA4lA==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/primitive": "1.1.3",
-				"@radix-ui/react-collection": "1.1.7",
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-context": "1.1.2",
-				"@radix-ui/react-direction": "1.1.1",
-				"@radix-ui/react-id": "1.1.1",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-use-callback-ref": "1.1.1",
-				"@radix-ui/react-use-controllable-state": "1.2.2"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-select": {
-			"version": "2.2.6",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-select/-/react-select-2.2.6.tgz",
-			"integrity": "sha512-I30RydO+bnn2PQztvo25tswPH+wFBjehVGtmagkU78yMdwTwVf12wnAOF+AeP8S2N8xD+5UPbGhkUfPyvT+mwQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/number": "1.1.1",
-				"@radix-ui/primitive": "1.1.3",
-				"@radix-ui/react-collection": "1.1.7",
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-context": "1.1.2",
-				"@radix-ui/react-direction": "1.1.1",
-				"@radix-ui/react-dismissable-layer": "1.1.11",
-				"@radix-ui/react-focus-guards": "1.1.3",
-				"@radix-ui/react-focus-scope": "1.1.7",
-				"@radix-ui/react-id": "1.1.1",
-				"@radix-ui/react-popper": "1.2.8",
-				"@radix-ui/react-portal": "1.1.9",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-slot": "1.2.3",
-				"@radix-ui/react-use-callback-ref": "1.1.1",
-				"@radix-ui/react-use-controllable-state": "1.2.2",
-				"@radix-ui/react-use-layout-effect": "1.1.1",
-				"@radix-ui/react-use-previous": "1.1.1",
-				"@radix-ui/react-visually-hidden": "1.2.3",
-				"aria-hidden": "^1.2.4",
-				"react-remove-scroll": "^2.6.3"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-slider": {
-			"version": "1.3.6",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-slider/-/react-slider-1.3.6.tgz",
-			"integrity": "sha512-JPYb1GuM1bxfjMRlNLE+BcmBC8onfCi60Blk7OBqi2MLTFdS+8401U4uFjnwkOr49BLmXxLC6JHkvAsx5OJvHw==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/number": "1.1.1",
-				"@radix-ui/primitive": "1.1.3",
-				"@radix-ui/react-collection": "1.1.7",
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-context": "1.1.2",
-				"@radix-ui/react-direction": "1.1.1",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-use-controllable-state": "1.2.2",
-				"@radix-ui/react-use-layout-effect": "1.1.1",
-				"@radix-ui/react-use-previous": "1.1.1",
-				"@radix-ui/react-use-size": "1.1.1"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-slot": {
-			"version": "1.2.3",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz",
-			"integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/react-compose-refs": "1.1.2"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-switch": {
-			"version": "1.2.6",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-switch/-/react-switch-1.2.6.tgz",
-			"integrity": "sha512-bByzr1+ep1zk4VubeEVViV592vu2lHE2BZY5OnzehZqOOgogN80+mNtCqPkhn2gklJqOpxWgPoYTSnhBCqpOXQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/primitive": "1.1.3",
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-context": "1.1.2",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-use-controllable-state": "1.2.2",
-				"@radix-ui/react-use-previous": "1.1.1",
-				"@radix-ui/react-use-size": "1.1.1"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-tabs": {
-			"version": "1.1.13",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-tabs/-/react-tabs-1.1.13.tgz",
-			"integrity": "sha512-7xdcatg7/U+7+Udyoj2zodtI9H/IIopqo+YOIcZOq1nJwXWBZ9p8xiu5llXlekDbZkca79a/fozEYQXIA4sW6A==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/primitive": "1.1.3",
-				"@radix-ui/react-context": "1.1.2",
-				"@radix-ui/react-direction": "1.1.1",
-				"@radix-ui/react-id": "1.1.1",
-				"@radix-ui/react-presence": "1.1.5",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-roving-focus": "1.1.11",
-				"@radix-ui/react-use-controllable-state": "1.2.2"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-tooltip": {
-			"version": "1.2.8",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-tooltip/-/react-tooltip-1.2.8.tgz",
-			"integrity": "sha512-tY7sVt1yL9ozIxvmbtN5qtmH2krXcBCfjEiCgKGLqunJHvgvZG2Pcl2oQ3kbcZARb1BGEHdkLzcYGO8ynVlieg==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/primitive": "1.1.3",
-				"@radix-ui/react-compose-refs": "1.1.2",
-				"@radix-ui/react-context": "1.1.2",
-				"@radix-ui/react-dismissable-layer": "1.1.11",
-				"@radix-ui/react-id": "1.1.1",
-				"@radix-ui/react-popper": "1.2.8",
-				"@radix-ui/react-portal": "1.1.9",
-				"@radix-ui/react-presence": "1.1.5",
-				"@radix-ui/react-primitive": "2.1.3",
-				"@radix-ui/react-slot": "1.2.3",
-				"@radix-ui/react-use-controllable-state": "1.2.2",
-				"@radix-ui/react-visually-hidden": "1.2.3"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-use-callback-ref": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-callback-ref/-/react-use-callback-ref-1.1.1.tgz",
-			"integrity": "sha512-FkBMwD+qbGQeMu1cOHnuGB6x4yzPjho8ap5WtbEJ26umhgqVXbhekKUQO+hZEL1vU92a3wHwdp0HAcqAUF5iDg==",
-			"license": "MIT",
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-use-controllable-state": {
-			"version": "1.2.2",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-controllable-state/-/react-use-controllable-state-1.2.2.tgz",
-			"integrity": "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/react-use-effect-event": "0.0.2",
-				"@radix-ui/react-use-layout-effect": "1.1.1"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-use-effect-event": {
-			"version": "0.0.2",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-effect-event/-/react-use-effect-event-0.0.2.tgz",
-			"integrity": "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/react-use-layout-effect": "1.1.1"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-use-escape-keydown": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-escape-keydown/-/react-use-escape-keydown-1.1.1.tgz",
-			"integrity": "sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/react-use-callback-ref": "1.1.1"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-use-layout-effect": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-layout-effect/-/react-use-layout-effect-1.1.1.tgz",
-			"integrity": "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ==",
-			"license": "MIT",
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-use-previous": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-previous/-/react-use-previous-1.1.1.tgz",
-			"integrity": "sha512-2dHfToCj/pzca2Ck724OZ5L0EVrr3eHRNsG/b3xQJLA2hZpVCS99bLAX+hm1IHXDEnzU6by5z/5MIY794/a8NQ==",
-			"license": "MIT",
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-use-rect": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-rect/-/react-use-rect-1.1.1.tgz",
-			"integrity": "sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/rect": "1.1.1"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-use-size": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-size/-/react-use-size-1.1.1.tgz",
-			"integrity": "sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/react-use-layout-effect": "1.1.1"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/react-visually-hidden": {
-			"version": "1.2.3",
-			"resolved": "https://registry.npmjs.org/@radix-ui/react-visually-hidden/-/react-visually-hidden-1.2.3.tgz",
-			"integrity": "sha512-pzJq12tEaaIhqjbzpCuv/OypJY/BPavOofm+dbab+MHLajy277+1lLm6JFcGgF5eskJ6mquGirhXY2GD/8u8Ug==",
-			"license": "MIT",
-			"dependencies": {
-				"@radix-ui/react-primitive": "2.1.3"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"@types/react-dom": "*",
-				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-				"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"@types/react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@radix-ui/rect": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/@radix-ui/rect/-/rect-1.1.1.tgz",
-			"integrity": "sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw==",
-			"license": "MIT"
-		},
-		"node_modules/@rc-component/async-validator": {
-			"version": "5.1.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/async-validator/-/async-validator-5.1.0.tgz",
-			"integrity": "sha512-n4HcR5siNUXRX23nDizbZBQPO0ZM/5oTtmKZ6/eqL0L2bo747cklFdZGRN2f+c9qWGICwDzrhW0H7tE9PptdcA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.24.4"
-			},
-			"engines": {
-				"node": ">=14.x"
-			}
-		},
-		"node_modules/@rc-component/cascader": {
-			"version": "1.14.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/cascader/-/cascader-1.14.0.tgz",
-			"integrity": "sha512-Ip9356xwZUR2nbW5PRVGif4B/bDve4pLa/N+PGbvBaTnjbvmN4PFMBGQSmlDlzKP1ovxaYMvwF/dI9lXNLT4iQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/select": "~1.6.0",
-				"@rc-component/tree": "~1.2.0",
-				"@rc-component/util": "^1.4.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=18.0.0",
-				"react-dom": ">=18.0.0"
-			}
-		},
-		"node_modules/@rc-component/checkbox": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/checkbox/-/checkbox-2.0.0.tgz",
-			"integrity": "sha512-3CXGPpAR9gsPKeO2N78HAPOzU30UdemD6HGJoWVJOpa6WleaGB5kzZj3v6bdTZab31YuWgY/RxV3VKPctn0DwQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/collapse": {
-			"version": "1.2.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/collapse/-/collapse-1.2.0.tgz",
-			"integrity": "sha512-ZRYSKSS39qsFx93p26bde7JUZJshsUBEQRlRXPuJYlAiNX0vyYlF5TsAm8JZN3LcF8XvKikdzPbgAtXSbkLUkw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.10.1",
-				"@rc-component/motion": "^1.1.4",
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=18.0.0",
-				"react-dom": ">=18.0.0"
-			}
-		},
-		"node_modules/@rc-component/color-picker": {
-			"version": "3.1.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/color-picker/-/color-picker-3.1.0.tgz",
-			"integrity": "sha512-o7Vavj7yyfVxFmeynXf0fCHVlC0UTE9al74c6nYuLck+gjuVdQNWSVXR8Efq/mmWFy7891SCOsfaPq6Eqe1s/g==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@ant-design/fast-color": "^3.0.0",
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/context": {
-			"version": "2.0.1",
-			"resolved": "https://registry.npmjs.org/@rc-component/context/-/context-2.0.1.tgz",
-			"integrity": "sha512-HyZbYm47s/YqtP6pKXNMjPEMaukyg7P0qVfgMLzr7YiFNMHbK2fKTAGzms9ykfGHSfyf75nBbgWw+hHkp+VImw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/util": "^1.3.0"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/dialog": {
-			"version": "1.8.4",
-			"resolved": "https://registry.npmjs.org/@rc-component/dialog/-/dialog-1.8.4.tgz",
-			"integrity": "sha512-Ay6PM7phkTkquplG8fWfUGFZ2GTLx9diTl4f0d8Eqxd7W1u1KjE9AQooFQHOHnhZf0Ya3z51+5EKCWHmt/dNEw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/motion": "^1.1.3",
-				"@rc-component/portal": "^2.1.0",
-				"@rc-component/util": "^1.9.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=18.0.0",
-				"react-dom": ">=18.0.0"
-			}
-		},
-		"node_modules/@rc-component/drawer": {
-			"version": "1.4.2",
-			"resolved": "https://registry.npmjs.org/@rc-component/drawer/-/drawer-1.4.2.tgz",
-			"integrity": "sha512-1ib+fZEp6FBu+YvcIktm+nCQ+Q+qIpwpoaJH6opGr4ofh2QMq+qdr5DLC4oCf5qf3pcWX9lUWPYX652k4ini8Q==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/motion": "^1.1.4",
-				"@rc-component/portal": "^2.1.3",
-				"@rc-component/util": "^1.9.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=18.0.0",
-				"react-dom": ">=18.0.0"
-			}
-		},
-		"node_modules/@rc-component/dropdown": {
-			"version": "1.0.2",
-			"resolved": "https://registry.npmjs.org/@rc-component/dropdown/-/dropdown-1.0.2.tgz",
-			"integrity": "sha512-6PY2ecUSYhDPhkNHHb4wfeAya04WhpmUSKzdR60G+kMNVUCX2vjT/AgTS0Lz0I/K6xrPMJ3enQbwVpeN3sHCgg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/trigger": "^3.0.0",
-				"@rc-component/util": "^1.2.1",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.11.0",
-				"react-dom": ">=16.11.0"
-			}
-		},
-		"node_modules/@rc-component/form": {
-			"version": "1.6.2",
-			"resolved": "https://registry.npmjs.org/@rc-component/form/-/form-1.6.2.tgz",
-			"integrity": "sha512-OgIn2RAoaSBqaIgzJf/X6iflIa9LpTozci1lagLBdURDFhGA370v0+T0tXxOi8YShMjTha531sFhwtnrv+EJaQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/async-validator": "^5.1.0",
-				"@rc-component/util": "^1.6.2",
-				"clsx": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/image": {
-			"version": "1.6.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/image/-/image-1.6.0.tgz",
-			"integrity": "sha512-tSfn2ZE/oP082g4QIOxeehkmgnXB7R+5AFj/lIFr4k7pEuxHBdyGIq9axoCY9qea8NN0DY6p4IB/F07tLqaT5A==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/motion": "^1.0.0",
-				"@rc-component/portal": "^2.1.2",
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/input": {
-			"version": "1.1.2",
-			"resolved": "https://registry.npmjs.org/@rc-component/input/-/input-1.1.2.tgz",
-			"integrity": "sha512-Q61IMR47piUBudgixJ30CciKIy9b1H95qe7GgEKOmSJVJXvFRWJllJfQry9tif+MX2cWFXWJf/RXz4kaCeq/Fg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/util": "^1.4.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.0.0",
-				"react-dom": ">=16.0.0"
-			}
-		},
-		"node_modules/@rc-component/input-number": {
-			"version": "1.6.2",
-			"resolved": "https://registry.npmjs.org/@rc-component/input-number/-/input-number-1.6.2.tgz",
-			"integrity": "sha512-Gjcq7meZlCOiWN1t1xCC+7/s85humHVokTBI7PJgTfoyw5OWF74y3e6P8PHX104g9+b54jsodFIzyaj6p8LI9w==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/mini-decimal": "^1.0.1",
-				"@rc-component/util": "^1.4.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/mentions": {
-			"version": "1.6.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/mentions/-/mentions-1.6.0.tgz",
-			"integrity": "sha512-KIkQNP6habNuTsLhUv0UGEOwG67tlmE7KNIJoQZZNggEZl5lQJTytFDb69sl5CK3TDdISCTjKP3nGEBKgT61CQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/input": "~1.1.0",
-				"@rc-component/menu": "~1.2.0",
-				"@rc-component/textarea": "~1.1.0",
-				"@rc-component/trigger": "^3.0.0",
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/menu": {
-			"version": "1.2.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/menu/-/menu-1.2.0.tgz",
-			"integrity": "sha512-VWwDuhvYHSnTGj4n6bV3ISrLACcPAzdPOq3d0BzkeiM5cve8BEYfvkEhNoM0PLzv51jpcejeyrLXeMVIJ+QJlg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/motion": "^1.1.4",
-				"@rc-component/overflow": "^1.0.0",
-				"@rc-component/trigger": "^3.0.0",
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/mini-decimal": {
-			"version": "1.1.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/mini-decimal/-/mini-decimal-1.1.0.tgz",
-			"integrity": "sha512-jS4E7T9Li2GuYwI6PyiVXmxTiM6b07rlD9Ge8uGZSCz3WlzcG5ZK7g5bbuKNeZ9pgUuPK/5guV781ujdVpm4HQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.18.0"
-			},
-			"engines": {
-				"node": ">=8.x"
-			}
-		},
-		"node_modules/@rc-component/motion": {
-			"version": "1.1.6",
-			"resolved": "https://registry.npmjs.org/@rc-component/motion/-/motion-1.1.6.tgz",
-			"integrity": "sha512-aEQobs/YA0kqRvHIPjQvOytdtdRVyhf/uXAal4chBjxDu6odHckExJzjn2D+Ju1aKK6hx3pAs6BXdV9+86xkgQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/util": "^1.2.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/mutate-observer": {
-			"version": "2.0.1",
-			"resolved": "https://registry.npmjs.org/@rc-component/mutate-observer/-/mutate-observer-2.0.1.tgz",
-			"integrity": "sha512-AyarjoLU5YlxuValRi+w8JRH2Z84TBbFO2RoGWz9d8bSu0FqT8DtugH3xC3BV7mUwlmROFauyWuXFuq4IFbH+w==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/util": "^1.2.0"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/notification": {
-			"version": "1.2.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/notification/-/notification-1.2.0.tgz",
-			"integrity": "sha512-OX3J+zVU7rvoJCikjrfW7qOUp7zlDeFBK2eA3SFbGSkDqo63Sl4Ss8A04kFP+fxHSxMDIS9jYVEZtU1FNCFuBA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/motion": "^1.1.4",
-				"@rc-component/util": "^1.2.1",
-				"clsx": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/overflow": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/overflow/-/overflow-1.0.0.tgz",
-			"integrity": "sha512-GSlBeoE0XTBi5cf3zl8Qh7Uqhn7v8RrlJ8ajeVpEkNe94HWy5l5BQ0Mwn2TVUq9gdgbfEMUmTX7tJFAg7mz0Rw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.11.1",
-				"@rc-component/resize-observer": "^1.0.1",
-				"@rc-component/util": "^1.4.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/pagination": {
-			"version": "1.2.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/pagination/-/pagination-1.2.0.tgz",
-			"integrity": "sha512-YcpUFE8dMLfSo6OARJlK6DbHHvrxz7pMGPGmC/caZSJJz6HRKHC1RPP001PRHCvG9Z/veD039uOQmazVuLJzlw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/picker": {
-			"version": "1.9.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/picker/-/picker-1.9.0.tgz",
-			"integrity": "sha512-OLisdk8AWVCG9goBU1dWzuH5QlBQk8jktmQ6p0/IyBFwdKGwyIZOSjnBYo8hooHiTdl0lU+wGf/OfMtVBw02KQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/overflow": "^1.0.0",
-				"@rc-component/resize-observer": "^1.0.0",
-				"@rc-component/trigger": "^3.6.15",
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=12.x"
-			},
-			"peerDependencies": {
-				"date-fns": ">= 2.x",
-				"dayjs": ">= 1.x",
-				"luxon": ">= 3.x",
-				"moment": ">= 2.x",
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			},
-			"peerDependenciesMeta": {
-				"date-fns": {
-					"optional": true
-				},
-				"dayjs": {
-					"optional": true
-				},
-				"luxon": {
-					"optional": true
-				},
-				"moment": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@rc-component/portal": {
-			"version": "2.2.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/portal/-/portal-2.2.0.tgz",
-			"integrity": "sha512-oc6FlA+uXCMiwArHsJyHcIkX4q6uKyndrPol2eWX8YPkAnztHOPsFIRtmWG4BMlGE5h7YIRE3NiaJ5VS8Lb1QQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/util": "^1.2.1",
-				"clsx": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=12.x"
-			},
-			"peerDependencies": {
-				"react": ">=18.0.0",
-				"react-dom": ">=18.0.0"
-			}
-		},
-		"node_modules/@rc-component/progress": {
-			"version": "1.0.2",
-			"resolved": "https://registry.npmjs.org/@rc-component/progress/-/progress-1.0.2.tgz",
-			"integrity": "sha512-WZUnH9eGxH1+xodZKqdrHke59uyGZSWgj5HBM5Kwk5BrTMuAORO7VJ2IP5Qbm9aH3n9x3IcesqHHR0NWPBC7fQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/util": "^1.2.1",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/qrcode": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/@rc-component/qrcode/-/qrcode-1.1.1.tgz",
-			"integrity": "sha512-LfLGNymzKdUPjXUbRP+xOhIWY4jQ+YMj5MmWAcgcAq1Ij8XP7tRmAXqyuv96XvLUBE/5cA8hLFl9eO1JQMujrA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.24.7"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/rate": {
-			"version": "1.0.1",
-			"resolved": "https://registry.npmjs.org/@rc-component/rate/-/rate-1.0.1.tgz",
-			"integrity": "sha512-bkXxeBqDpl5IOC7yL7GcSYjQx9G8H+6kLYQnNZWeBYq2OYIv1MONd6mqKTjnnJYpV0cQIU2z3atdW0j1kttpTw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/resize-observer": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/@rc-component/resize-observer/-/resize-observer-1.1.1.tgz",
-			"integrity": "sha512-NfXXMmiR+SmUuKE1NwJESzEUYUFWIDUn2uXpxCTOLwiRUUakd62DRNFjRJArgzyFW8S5rsL4aX5XlyIXyC/vRA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/util": "^1.2.0"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/segmented": {
-			"version": "1.3.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/segmented/-/segmented-1.3.0.tgz",
-			"integrity": "sha512-5J/bJ01mbDnoA6P/FW8SxUvKn+OgUSTZJPzCNnTBntG50tzoP7DydGhqxp7ggZXZls7me3mc2EQDXakU3iTVFg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.11.1",
-				"@rc-component/motion": "^1.1.4",
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.0.0",
-				"react-dom": ">=16.0.0"
-			}
-		},
-		"node_modules/@rc-component/select": {
-			"version": "1.6.10",
-			"resolved": "https://registry.npmjs.org/@rc-component/select/-/select-1.6.10.tgz",
-			"integrity": "sha512-y4+2LnyGZrAorIBwflk78PmFVUWcSc9pcljiH72oHj7K1YY/BFUmj224pD7P4o7J+tbIFES45Z7LIpjVmvYlNA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/overflow": "^1.0.0",
-				"@rc-component/trigger": "^3.0.0",
-				"@rc-component/util": "^1.3.0",
-				"@rc-component/virtual-list": "^1.0.1",
-				"clsx": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": "*",
-				"react-dom": "*"
-			}
-		},
-		"node_modules/@rc-component/slider": {
-			"version": "1.0.1",
-			"resolved": "https://registry.npmjs.org/@rc-component/slider/-/slider-1.0.1.tgz",
-			"integrity": "sha512-uDhEPU1z3WDfCJhaL9jfd2ha/Eqpdfxsn0Zb0Xcq1NGQAman0TWaR37OWp2vVXEOdV2y0njSILTMpTfPV1454g==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/steps": {
-			"version": "1.2.2",
-			"resolved": "https://registry.npmjs.org/@rc-component/steps/-/steps-1.2.2.tgz",
-			"integrity": "sha512-/yVIZ00gDYYPHSY0JP+M+s3ZvuXLu2f9rEjQqiUDs7EcYsUYrpJ/1bLj9aI9R7MBR3fu/NGh6RM9u2qGfqp+Nw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/util": "^1.2.1",
-				"clsx": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/switch": {
-			"version": "1.0.3",
-			"resolved": "https://registry.npmjs.org/@rc-component/switch/-/switch-1.0.3.tgz",
-			"integrity": "sha512-Jgi+EbOBquje/XNdofr7xbJQZPYJP+BlPfR0h+WN4zFkdtB2EWqEfvkXJWeipflwjWip0/17rNbxEAqs8hVHfw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/table": {
-			"version": "1.9.1",
-			"resolved": "https://registry.npmjs.org/@rc-component/table/-/table-1.9.1.tgz",
-			"integrity": "sha512-FVI5ZS/GdB3BcgexfCYKi3iHhZS3Fr59EtsxORszYGrfpH1eWr33eDNSYkVfLI6tfJ7vftJDd9D5apfFWqkdJg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/context": "^2.0.1",
-				"@rc-component/resize-observer": "^1.0.0",
-				"@rc-component/util": "^1.1.0",
-				"@rc-component/virtual-list": "^1.0.1",
-				"clsx": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=18.0.0",
-				"react-dom": ">=18.0.0"
-			}
-		},
-		"node_modules/@rc-component/tabs": {
-			"version": "1.7.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/tabs/-/tabs-1.7.0.tgz",
-			"integrity": "sha512-J48cs2iBi7Ho3nptBxxIqizEliUC+ExE23faspUQKGQ550vaBlv3aGF8Epv/UB1vFWeoJDTW/dNzgIU0Qj5i/w==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/dropdown": "~1.0.0",
-				"@rc-component/menu": "~1.2.0",
-				"@rc-component/motion": "^1.1.3",
-				"@rc-component/resize-observer": "^1.0.0",
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/textarea": {
-			"version": "1.1.2",
-			"resolved": "https://registry.npmjs.org/@rc-component/textarea/-/textarea-1.1.2.tgz",
-			"integrity": "sha512-9rMUEODWZDMovfScIEHXWlVZuPljZ2pd1LKNjslJVitn4SldEzq5vO1CL3yy3Dnib6zZal2r2DPtjy84VVpF6A==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/input": "~1.1.0",
-				"@rc-component/resize-observer": "^1.0.0",
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/tooltip": {
-			"version": "1.4.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/tooltip/-/tooltip-1.4.0.tgz",
-			"integrity": "sha512-8Rx5DCctIlLI4raR0I0xHjVTf1aF48+gKCNeAAo5bmF5VoR5YED+A/XEqzXv9KKqrJDRcd3Wndpxh2hyzrTtSg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/trigger": "^3.7.1",
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=18.0.0",
-				"react-dom": ">=18.0.0"
-			}
-		},
-		"node_modules/@rc-component/tour": {
-			"version": "2.3.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/tour/-/tour-2.3.0.tgz",
-			"integrity": "sha512-K04K9r32kUC+auBSQfr+Fss4SpSIS9JGe56oq/ALAX0p+i2ylYOI1MgR83yBY7v96eO6ZFXcM/igCQmubps0Ow==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/portal": "^2.2.0",
-				"@rc-component/trigger": "^3.0.0",
-				"@rc-component/util": "^1.7.0",
-				"clsx": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/tree": {
-			"version": "1.2.3",
-			"resolved": "https://registry.npmjs.org/@rc-component/tree/-/tree-1.2.3.tgz",
-			"integrity": "sha512-mG8hF2ogQcKaEpfyxzPvMWqqkptofd7Sf+YiXOpPzuXLTLwNKfLDJtysc1/oybopbnzxNqWh2Vgwi+GYwNIb7w==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/motion": "^1.0.0",
-				"@rc-component/util": "^1.8.1",
-				"@rc-component/virtual-list": "^1.0.1",
-				"clsx": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=10.x"
-			},
-			"peerDependencies": {
-				"react": "*",
-				"react-dom": "*"
-			}
-		},
-		"node_modules/@rc-component/tree-select": {
-			"version": "1.8.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/tree-select/-/tree-select-1.8.0.tgz",
-			"integrity": "sha512-iYsPq3nuLYvGqdvFAW+l+I9ASRIOVbMXyA8FGZg2lGym/GwkaWeJGzI4eJ7c9IOEhRj0oyfIN4S92Fl3J05mjQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/select": "~1.6.0",
-				"@rc-component/tree": "~1.2.0",
-				"@rc-component/util": "^1.4.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": "*",
-				"react-dom": "*"
-			}
-		},
-		"node_modules/@rc-component/trigger": {
-			"version": "3.9.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/trigger/-/trigger-3.9.0.tgz",
-			"integrity": "sha512-X8btpwfrT27AgrZVOz4swclhEHTZcqaHeQMXXBgveagOiakTa36uObXbdwerXffgV8G9dH1fAAE0DHtVQs8EHg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/motion": "^1.1.4",
-				"@rc-component/portal": "^2.2.0",
-				"@rc-component/resize-observer": "^1.1.1",
-				"@rc-component/util": "^1.2.1",
-				"clsx": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=18.0.0",
-				"react-dom": ">=18.0.0"
-			}
-		},
-		"node_modules/@rc-component/upload": {
-			"version": "1.1.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/upload/-/upload-1.1.0.tgz",
-			"integrity": "sha512-LIBV90mAnUE6VK5N4QvForoxZc4XqEYZimcp7fk+lkE4XwHHyJWxpIXQQwMU8hJM+YwBbsoZkGksL1sISWHQxw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@rc-component/util": "^1.3.0",
-				"clsx": "^2.1.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@rc-component/util": {
-			"version": "1.9.0",
-			"resolved": "https://registry.npmjs.org/@rc-component/util/-/util-1.9.0.tgz",
-			"integrity": "sha512-5uW6AfhIigCWeEQDthTozlxiT4Prn6xYQWeO0xokjcaa186OtwPRHBZJ2o0T0FhbjGhZ3vXdbkv0sx3gAYW7Vg==",
-			"license": "MIT",
-			"dependencies": {
-				"is-mobile": "^5.0.0",
-				"react-is": "^18.2.0"
-			},
-			"peerDependencies": {
-				"react": ">=18.0.0",
-				"react-dom": ">=18.0.0"
-			}
-		},
-		"node_modules/@rc-component/util/node_modules/react-is": {
-			"version": "18.3.1",
-			"resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
-			"integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
-			"license": "MIT"
-		},
-		"node_modules/@rc-component/virtual-list": {
-			"version": "1.0.2",
-			"resolved": "https://registry.npmjs.org/@rc-component/virtual-list/-/virtual-list-1.0.2.tgz",
-			"integrity": "sha512-uvTol/mH74FYsn5loDGJxo+7kjkO4i+y4j87Re1pxJBs0FaeuMuLRzQRGaXwnMcV1CxpZLi2Z56Rerj2M00fjQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.20.0",
-				"@rc-component/resize-observer": "^1.0.1",
-				"@rc-component/util": "^1.4.0",
-				"clsx": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/@react-sigma/core": {
-			"version": "5.0.6",
-			"resolved": "https://registry.npmjs.org/@react-sigma/core/-/core-5.0.6.tgz",
-			"integrity": "sha512-Xu2qXyvDZIhmvGC1n8d7Kcxm5Ntcz4HbPIM7CPDD2e4h3s/oxVpVPX7wtsNreJRRPj9mK+3oqB6SWXNI4mTqVg==",
-			"license": "MIT",
-			"peerDependencies": {
-				"graphology": "^0.26.0",
-				"react": "^18.0.0 || ^19.0.0",
-				"sigma": "^3.0.2"
-			}
-		},
-		"node_modules/@reduxjs/toolkit": {
-			"version": "2.11.2",
-			"license": "MIT",
-			"dependencies": {
-				"@standard-schema/spec": "^1.0.0",
-				"@standard-schema/utils": "^0.3.0",
-				"immer": "^11.0.0",
-				"redux": "^5.0.1",
-				"redux-thunk": "^3.1.0",
-				"reselect": "^5.1.0"
-			},
-			"peerDependencies": {
-				"react": "^16.9.0 || ^17.0.0 || ^18 || ^19",
-				"react-redux": "^7.2.1 || ^8.1.3 || ^9.0.0"
-			},
-			"peerDependenciesMeta": {
-				"react": {
-					"optional": true
-				},
-				"react-redux": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@reduxjs/toolkit/node_modules/immer": {
-			"version": "11.1.4",
-			"license": "MIT",
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/immer"
-			}
-		},
-		"node_modules/@rolldown/pluginutils": {
-			"version": "1.0.0-beta.27",
-			"dev": true,
-			"license": "MIT"
-		},
-		"node_modules/@rollup/rollup-darwin-arm64": {
-			"version": "4.57.1",
-			"cpu": [
-				"arm64"
-			],
-			"dev": true,
-			"license": "MIT",
-			"optional": true,
-			"os": [
-				"darwin"
-			]
-		},
-		"node_modules/@shikijs/core": {
-			"version": "3.22.0",
-			"resolved": "https://registry.npmjs.org/@shikijs/core/-/core-3.22.0.tgz",
-			"integrity": "sha512-iAlTtSDDbJiRpvgL5ugKEATDtHdUVkqgHDm/gbD2ZS9c88mx7G1zSYjjOxp5Qa0eaW0MAQosFRmJSk354PRoQA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@shikijs/types": "3.22.0",
-				"@shikijs/vscode-textmate": "^10.0.2",
-				"@types/hast": "^3.0.4",
-				"hast-util-to-html": "^9.0.5"
-			}
-		},
-		"node_modules/@shikijs/engine-javascript": {
-			"version": "3.22.0",
-			"resolved": "https://registry.npmjs.org/@shikijs/engine-javascript/-/engine-javascript-3.22.0.tgz",
-			"integrity": "sha512-jdKhfgW9CRtj3Tor0L7+yPwdG3CgP7W+ZEqSsojrMzCjD1e0IxIbwUMDDpYlVBlC08TACg4puwFGkZfLS+56Tw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@shikijs/types": "3.22.0",
-				"@shikijs/vscode-textmate": "^10.0.2",
-				"oniguruma-to-es": "^4.3.4"
-			}
-		},
-		"node_modules/@shikijs/engine-oniguruma": {
-			"version": "3.22.0",
-			"resolved": "https://registry.npmjs.org/@shikijs/engine-oniguruma/-/engine-oniguruma-3.22.0.tgz",
-			"integrity": "sha512-DyXsOG0vGtNtl7ygvabHd7Mt5EY8gCNqR9Y7Lpbbd/PbJvgWrqaKzH1JW6H6qFkuUa8aCxoiYVv8/YfFljiQxA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@shikijs/types": "3.22.0",
-				"@shikijs/vscode-textmate": "^10.0.2"
-			}
-		},
-		"node_modules/@shikijs/langs": {
-			"version": "3.22.0",
-			"resolved": "https://registry.npmjs.org/@shikijs/langs/-/langs-3.22.0.tgz",
-			"integrity": "sha512-x/42TfhWmp6H00T6uwVrdTJGKgNdFbrEdhaDwSR5fd5zhQ1Q46bHq9EO61SCEWJR0HY7z2HNDMaBZp8JRmKiIA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@shikijs/types": "3.22.0"
-			}
-		},
-		"node_modules/@shikijs/themes": {
-			"version": "3.22.0",
-			"resolved": "https://registry.npmjs.org/@shikijs/themes/-/themes-3.22.0.tgz",
-			"integrity": "sha512-o+tlOKqsr6FE4+mYJG08tfCFDS+3CG20HbldXeVoyP+cYSUxDhrFf3GPjE60U55iOkkjbpY2uC3It/eeja35/g==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@shikijs/types": "3.22.0"
-			}
-		},
-		"node_modules/@shikijs/transformers": {
-			"version": "3.22.0",
-			"resolved": "https://registry.npmjs.org/@shikijs/transformers/-/transformers-3.22.0.tgz",
-			"integrity": "sha512-E7eRV7mwDBjueLF6852n2oYeJYxBq3NSsDk+uyruYAXONv4U8holGmIrT+mPRJQ1J1SNOH6L8G19KRzmBawrFw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@shikijs/core": "3.22.0",
-				"@shikijs/types": "3.22.0"
-			}
-		},
-		"node_modules/@shikijs/types": {
-			"version": "3.22.0",
-			"resolved": "https://registry.npmjs.org/@shikijs/types/-/types-3.22.0.tgz",
-			"integrity": "sha512-491iAekgKDBFE67z70Ok5a8KBMsQ2IJwOWw3us/7ffQkIBCyOQfm/aNwVMBUriP02QshIfgHCBSIYAl3u2eWjg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@shikijs/vscode-textmate": "^10.0.2",
-				"@types/hast": "^3.0.4"
-			}
-		},
-		"node_modules/@shikijs/vscode-textmate": {
-			"version": "10.0.2",
-			"resolved": "https://registry.npmjs.org/@shikijs/vscode-textmate/-/vscode-textmate-10.0.2.tgz",
-			"integrity": "sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@splinetool/runtime": {
-			"version": "0.9.526",
-			"resolved": "https://registry.npmjs.org/@splinetool/runtime/-/runtime-0.9.526.tgz",
-			"integrity": "sha512-qznHbXA5aKwDbCgESAothCNm1IeEZcmNWG145p5aXj4w5uoqR1TZ9qkTHTKLTsUbHeitCwdhzmRqan1kxboLgQ==",
-			"peer": true,
-			"dependencies": {
-				"on-change": "^4.0.0",
-				"semver-compare": "^1.0.0"
-			}
-		},
-		"node_modules/@standard-schema/spec": {
-			"version": "1.1.0",
-			"license": "MIT"
-		},
-		"node_modules/@standard-schema/utils": {
-			"version": "0.3.0",
-			"license": "MIT"
-		},
-		"node_modules/@stitches/react": {
-			"version": "1.2.8",
-			"resolved": "https://registry.npmjs.org/@stitches/react/-/react-1.2.8.tgz",
-			"integrity": "sha512-9g9dWI4gsSVe8bNLlb+lMkBYsnIKCZTmvqvDG+Avnn69XfmHZKiaMrx7cgTaddq7aTPPmXiTsbFcUy0xgI4+wA==",
-			"license": "MIT",
-			"peer": true,
-			"peerDependencies": {
-				"react": ">= 16.3.0"
-			}
-		},
-		"node_modules/@tanstack/history": {
-			"version": "1.154.14",
-			"license": "MIT",
-			"engines": {
-				"node": ">=12"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/tannerlinsley"
-			}
-		},
-		"node_modules/@tanstack/query-core": {
-			"version": "5.90.20",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/tannerlinsley"
-			}
-		},
-		"node_modules/@tanstack/react-query": {
-			"version": "5.90.21",
-			"license": "MIT",
-			"dependencies": {
-				"@tanstack/query-core": "5.90.20"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/tannerlinsley"
-			},
-			"peerDependencies": {
-				"react": "^18 || ^19"
-			}
-		},
-		"node_modules/@tanstack/react-router": {
-			"version": "1.159.5",
-			"license": "MIT",
-			"dependencies": {
-				"@tanstack/history": "1.154.14",
-				"@tanstack/react-store": "^0.8.0",
-				"@tanstack/router-core": "1.159.4",
-				"isbot": "^5.1.22",
-				"tiny-invariant": "^1.3.3",
-				"tiny-warning": "^1.0.3"
-			},
-			"engines": {
-				"node": ">=12"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/tannerlinsley"
-			},
-			"peerDependencies": {
-				"react": ">=18.0.0 || >=19.0.0",
-				"react-dom": ">=18.0.0 || >=19.0.0"
-			}
-		},
-		"node_modules/@tanstack/react-router-devtools": {
-			"version": "1.159.5",
-			"license": "MIT",
-			"dependencies": {
-				"@tanstack/router-devtools-core": "1.159.4"
-			},
-			"engines": {
-				"node": ">=12"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/tannerlinsley"
-			},
-			"peerDependencies": {
-				"@tanstack/react-router": "^1.159.5",
-				"@tanstack/router-core": "^1.159.4",
-				"react": ">=18.0.0 || >=19.0.0",
-				"react-dom": ">=18.0.0 || >=19.0.0"
-			},
-			"peerDependenciesMeta": {
-				"@tanstack/router-core": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@tanstack/react-store": {
-			"version": "0.8.0",
-			"license": "MIT",
-			"dependencies": {
-				"@tanstack/store": "0.8.0",
-				"use-sync-external-store": "^1.6.0"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/tannerlinsley"
-			},
-			"peerDependencies": {
-				"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-				"react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-			}
-		},
-		"node_modules/@tanstack/react-virtual": {
-			"version": "3.13.18",
-			"license": "MIT",
-			"dependencies": {
-				"@tanstack/virtual-core": "3.13.18"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/tannerlinsley"
-			},
-			"peerDependencies": {
-				"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-				"react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-			}
-		},
-		"node_modules/@tanstack/router-core": {
-			"version": "1.159.4",
-			"license": "MIT",
-			"dependencies": {
-				"@tanstack/history": "1.154.14",
-				"@tanstack/store": "^0.8.0",
-				"cookie-es": "^2.0.0",
-				"seroval": "^1.4.2",
-				"seroval-plugins": "^1.4.2",
-				"tiny-invariant": "^1.3.3",
-				"tiny-warning": "^1.0.3"
-			},
-			"engines": {
-				"node": ">=12"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/tannerlinsley"
-			}
-		},
-		"node_modules/@tanstack/router-devtools": {
-			"version": "1.159.5",
-			"license": "MIT",
-			"dependencies": {
-				"@tanstack/react-router-devtools": "1.159.5",
-				"clsx": "^2.1.1",
-				"goober": "^2.1.16"
-			},
-			"engines": {
-				"node": ">=12"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/tannerlinsley"
-			},
-			"peerDependencies": {
-				"@tanstack/react-router": "^1.159.5",
-				"csstype": "^3.0.10",
-				"react": ">=18.0.0 || >=19.0.0",
-				"react-dom": ">=18.0.0 || >=19.0.0"
-			},
-			"peerDependenciesMeta": {
-				"csstype": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@tanstack/router-devtools-core": {
-			"version": "1.159.4",
-			"license": "MIT",
-			"dependencies": {
-				"clsx": "^2.1.1",
-				"goober": "^2.1.16",
-				"tiny-invariant": "^1.3.3"
-			},
-			"engines": {
-				"node": ">=12"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/tannerlinsley"
-			},
-			"peerDependencies": {
-				"@tanstack/router-core": "^1.159.4",
-				"csstype": "^3.0.10"
-			},
-			"peerDependenciesMeta": {
-				"csstype": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/@tanstack/store": {
-			"version": "0.8.0",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/tannerlinsley"
-			}
-		},
-		"node_modules/@tanstack/virtual-core": {
-			"version": "3.13.18",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/tannerlinsley"
-			}
-		},
-		"node_modules/@types/babel__core": {
-			"version": "7.20.5",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@babel/parser": "^7.20.7",
-				"@babel/types": "^7.20.7",
-				"@types/babel__generator": "*",
-				"@types/babel__template": "*",
-				"@types/babel__traverse": "*"
-			}
-		},
-		"node_modules/@types/babel__generator": {
-			"version": "7.27.0",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@babel/types": "^7.0.0"
-			}
-		},
-		"node_modules/@types/babel__template": {
-			"version": "7.4.4",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@babel/parser": "^7.1.0",
-				"@babel/types": "^7.0.0"
-			}
-		},
-		"node_modules/@types/babel__traverse": {
-			"version": "7.28.0",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@babel/types": "^7.28.2"
-			}
-		},
-		"node_modules/@types/d3": {
-			"version": "7.4.3",
-			"resolved": "https://registry.npmjs.org/@types/d3/-/d3-7.4.3.tgz",
-			"integrity": "sha512-lZXZ9ckh5R8uiFVt8ogUNf+pIrK4EsWrx2Np75WvF/eTpJ0FMHNhjXk8CKEx/+gpHbNQyJWehbFaTvqmHWB3ww==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/d3-array": "*",
-				"@types/d3-axis": "*",
-				"@types/d3-brush": "*",
-				"@types/d3-chord": "*",
-				"@types/d3-color": "*",
-				"@types/d3-contour": "*",
-				"@types/d3-delaunay": "*",
-				"@types/d3-dispatch": "*",
-				"@types/d3-drag": "*",
-				"@types/d3-dsv": "*",
-				"@types/d3-ease": "*",
-				"@types/d3-fetch": "*",
-				"@types/d3-force": "*",
-				"@types/d3-format": "*",
-				"@types/d3-geo": "*",
-				"@types/d3-hierarchy": "*",
-				"@types/d3-interpolate": "*",
-				"@types/d3-path": "*",
-				"@types/d3-polygon": "*",
-				"@types/d3-quadtree": "*",
-				"@types/d3-random": "*",
-				"@types/d3-scale": "*",
-				"@types/d3-scale-chromatic": "*",
-				"@types/d3-selection": "*",
-				"@types/d3-shape": "*",
-				"@types/d3-time": "*",
-				"@types/d3-time-format": "*",
-				"@types/d3-timer": "*",
-				"@types/d3-transition": "*",
-				"@types/d3-zoom": "*"
-			}
-		},
-		"node_modules/@types/d3-array": {
-			"version": "3.2.2",
-			"license": "MIT"
-		},
-		"node_modules/@types/d3-axis": {
-			"version": "3.0.6",
-			"resolved": "https://registry.npmjs.org/@types/d3-axis/-/d3-axis-3.0.6.tgz",
-			"integrity": "sha512-pYeijfZuBd87T0hGn0FO1vQ/cgLk6E1ALJjfkC0oJ8cbwkZl3TpgS8bVBLZN+2jjGgg38epgxb2zmoGtSfvgMw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/d3-selection": "*"
-			}
-		},
-		"node_modules/@types/d3-brush": {
-			"version": "3.0.6",
-			"resolved": "https://registry.npmjs.org/@types/d3-brush/-/d3-brush-3.0.6.tgz",
-			"integrity": "sha512-nH60IZNNxEcrh6L1ZSMNA28rj27ut/2ZmI3r96Zd+1jrZD++zD3LsMIjWlvg4AYrHn/Pqz4CF3veCxGjtbqt7A==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/d3-selection": "*"
-			}
-		},
-		"node_modules/@types/d3-chord": {
-			"version": "3.0.6",
-			"resolved": "https://registry.npmjs.org/@types/d3-chord/-/d3-chord-3.0.6.tgz",
-			"integrity": "sha512-LFYWWd8nwfwEmTZG9PfQxd17HbNPksHBiJHaKuY1XeqscXacsS2tyoo6OdRsjf+NQYeB6XrNL3a25E3gH69lcg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/d3-color": {
-			"version": "3.1.3",
-			"license": "MIT"
-		},
-		"node_modules/@types/d3-contour": {
-			"version": "3.0.6",
-			"resolved": "https://registry.npmjs.org/@types/d3-contour/-/d3-contour-3.0.6.tgz",
-			"integrity": "sha512-BjzLgXGnCWjUSYGfH1cpdo41/hgdWETu4YxpezoztawmqsvCeep+8QGfiY6YbDvfgHz/DkjeIkkZVJavB4a3rg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/d3-array": "*",
-				"@types/geojson": "*"
-			}
-		},
-		"node_modules/@types/d3-delaunay": {
-			"version": "6.0.4",
-			"resolved": "https://registry.npmjs.org/@types/d3-delaunay/-/d3-delaunay-6.0.4.tgz",
-			"integrity": "sha512-ZMaSKu4THYCU6sV64Lhg6qjf1orxBthaC161plr5KuPHo3CNm8DTHiLw/5Eq2b6TsNP0W0iJrUOFscY6Q450Hw==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/d3-dispatch": {
-			"version": "3.0.7",
-			"resolved": "https://registry.npmjs.org/@types/d3-dispatch/-/d3-dispatch-3.0.7.tgz",
-			"integrity": "sha512-5o9OIAdKkhN1QItV2oqaE5KMIiXAvDWBDPrD85e58Qlz1c1kI/J0NcqbEG88CoTwJrYe7ntUCVfeUl2UJKbWgA==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/d3-drag": {
-			"version": "3.0.7",
-			"resolved": "https://registry.npmjs.org/@types/d3-drag/-/d3-drag-3.0.7.tgz",
-			"integrity": "sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@types/d3-selection": "*"
-			}
-		},
-		"node_modules/@types/d3-dsv": {
-			"version": "3.0.7",
-			"resolved": "https://registry.npmjs.org/@types/d3-dsv/-/d3-dsv-3.0.7.tgz",
-			"integrity": "sha512-n6QBF9/+XASqcKK6waudgL0pf/S5XHPPI8APyMLLUHd8NqouBGLsU8MgtO7NINGtPBtk9Kko/W4ea0oAspwh9g==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/d3-ease": {
-			"version": "3.0.2",
-			"license": "MIT"
-		},
-		"node_modules/@types/d3-fetch": {
-			"version": "3.0.7",
-			"resolved": "https://registry.npmjs.org/@types/d3-fetch/-/d3-fetch-3.0.7.tgz",
-			"integrity": "sha512-fTAfNmxSb9SOWNB9IoG5c8Hg6R+AzUHDRlsXsDZsNp6sxAEOP0tkP3gKkNSO/qmHPoBFTxNrjDprVHDQDvo5aA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/d3-dsv": "*"
-			}
-		},
-		"node_modules/@types/d3-force": {
-			"version": "3.0.10",
-			"resolved": "https://registry.npmjs.org/@types/d3-force/-/d3-force-3.0.10.tgz",
-			"integrity": "sha512-ZYeSaCF3p73RdOKcjj+swRlZfnYpK1EbaDiYICEEp5Q6sUiqFaFQ9qgoshp5CzIyyb/yD09kD9o2zEltCexlgw==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/d3-format": {
-			"version": "3.0.4",
-			"resolved": "https://registry.npmjs.org/@types/d3-format/-/d3-format-3.0.4.tgz",
-			"integrity": "sha512-fALi2aI6shfg7vM5KiR1wNJnZ7r6UuggVqtDA+xiEdPZQwy/trcQaHnwShLuLdta2rTymCNpxYTiMZX/e09F4g==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/d3-geo": {
-			"version": "3.1.0",
-			"resolved": "https://registry.npmjs.org/@types/d3-geo/-/d3-geo-3.1.0.tgz",
-			"integrity": "sha512-856sckF0oP/diXtS4jNsiQw/UuK5fQG8l/a9VVLeSouf1/PPbBE1i1W852zVwKwYCBkFJJB7nCFTbk6UMEXBOQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/geojson": "*"
-			}
-		},
-		"node_modules/@types/d3-hierarchy": {
-			"version": "3.1.7",
-			"resolved": "https://registry.npmjs.org/@types/d3-hierarchy/-/d3-hierarchy-3.1.7.tgz",
-			"integrity": "sha512-tJFtNoYBtRtkNysX1Xq4sxtjK8YgoWUNpIiUee0/jHGRwqvzYxkq0hGVbbOGSz+JgFxxRu4K8nb3YpG3CMARtg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/d3-interpolate": {
-			"version": "3.0.4",
-			"license": "MIT",
-			"dependencies": {
-				"@types/d3-color": "*"
-			}
-		},
-		"node_modules/@types/d3-path": {
-			"version": "3.1.1",
-			"license": "MIT"
-		},
-		"node_modules/@types/d3-polygon": {
-			"version": "3.0.2",
-			"resolved": "https://registry.npmjs.org/@types/d3-polygon/-/d3-polygon-3.0.2.tgz",
-			"integrity": "sha512-ZuWOtMaHCkN9xoeEMr1ubW2nGWsp4nIql+OPQRstu4ypeZ+zk3YKqQT0CXVe/PYqrKpZAi+J9mTs05TKwjXSRA==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/d3-quadtree": {
-			"version": "3.0.6",
-			"resolved": "https://registry.npmjs.org/@types/d3-quadtree/-/d3-quadtree-3.0.6.tgz",
-			"integrity": "sha512-oUzyO1/Zm6rsxKRHA1vH0NEDG58HrT5icx/azi9MF1TWdtttWl0UIUsjEQBBh+SIkrpd21ZjEv7ptxWys1ncsg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/d3-random": {
-			"version": "3.0.3",
-			"resolved": "https://registry.npmjs.org/@types/d3-random/-/d3-random-3.0.3.tgz",
-			"integrity": "sha512-Imagg1vJ3y76Y2ea0871wpabqp613+8/r0mCLEBfdtqC7xMSfj9idOnmBYyMoULfHePJyxMAw3nWhJxzc+LFwQ==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/d3-scale": {
-			"version": "4.0.9",
-			"license": "MIT",
-			"dependencies": {
-				"@types/d3-time": "*"
-			}
-		},
-		"node_modules/@types/d3-scale-chromatic": {
-			"version": "3.1.0",
-			"resolved": "https://registry.npmjs.org/@types/d3-scale-chromatic/-/d3-scale-chromatic-3.1.0.tgz",
-			"integrity": "sha512-iWMJgwkK7yTRmWqRB5plb1kadXyQ5Sj8V/zYlFGMUBbIPKQScw+Dku9cAAMgJG+z5GYDoMjWGLVOvjghDEFnKQ==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/d3-selection": {
-			"version": "3.0.11",
-			"resolved": "https://registry.npmjs.org/@types/d3-selection/-/d3-selection-3.0.11.tgz",
-			"integrity": "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w==",
-			"license": "MIT"
-		},
-		"node_modules/@types/d3-shape": {
-			"version": "3.1.8",
-			"license": "MIT",
-			"dependencies": {
-				"@types/d3-path": "*"
-			}
-		},
-		"node_modules/@types/d3-time": {
-			"version": "3.0.4",
-			"license": "MIT"
-		},
-		"node_modules/@types/d3-time-format": {
-			"version": "4.0.3",
-			"resolved": "https://registry.npmjs.org/@types/d3-time-format/-/d3-time-format-4.0.3.tgz",
-			"integrity": "sha512-5xg9rC+wWL8kdDj153qZcsJ0FWiFt0J5RB6LYUNZjwSnesfblqrI/bJ1wBdJ8OQfncgbJG5+2F+qfqnqyzYxyg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/d3-timer": {
-			"version": "3.0.2",
-			"license": "MIT"
-		},
-		"node_modules/@types/d3-transition": {
-			"version": "3.0.9",
-			"resolved": "https://registry.npmjs.org/@types/d3-transition/-/d3-transition-3.0.9.tgz",
-			"integrity": "sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg==",
-			"license": "MIT",
-			"dependencies": {
-				"@types/d3-selection": "*"
-			}
-		},
-		"node_modules/@types/d3-zoom": {
-			"version": "3.0.8",
-			"resolved": "https://registry.npmjs.org/@types/d3-zoom/-/d3-zoom-3.0.8.tgz",
-			"integrity": "sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw==",
-			"license": "MIT",
-			"dependencies": {
-				"@types/d3-interpolate": "*",
-				"@types/d3-selection": "*"
-			}
-		},
-		"node_modules/@types/debug": {
-			"version": "4.1.12",
-			"license": "MIT",
-			"dependencies": {
-				"@types/ms": "*"
-			}
-		},
-		"node_modules/@types/estree": {
-			"version": "1.0.8",
-			"license": "MIT"
-		},
-		"node_modules/@types/estree-jsx": {
-			"version": "1.0.5",
-			"license": "MIT",
-			"dependencies": {
-				"@types/estree": "*"
-			}
-		},
-		"node_modules/@types/geojson": {
-			"version": "7946.0.16",
-			"resolved": "https://registry.npmjs.org/@types/geojson/-/geojson-7946.0.16.tgz",
-			"integrity": "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/hast": {
-			"version": "3.0.4",
-			"license": "MIT",
-			"dependencies": {
-				"@types/unist": "*"
-			}
-		},
-		"node_modules/@types/js-cookie": {
-			"version": "3.0.6",
-			"resolved": "https://registry.npmjs.org/@types/js-cookie/-/js-cookie-3.0.6.tgz",
-			"integrity": "sha512-wkw9yd1kEXOPnvEeEV1Go1MmxtBJL0RR79aOTAApecWFVu7w0NNXNqhcWgvw2YgZDYadliXkl14pa3WXw5jlCQ==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/katex": {
-			"version": "0.16.8",
-			"resolved": "https://registry.npmjs.org/@types/katex/-/katex-0.16.8.tgz",
-			"integrity": "sha512-trgaNyfU+Xh2Tc+ABIb44a5AYUpicB3uwirOioeOkNPPbmgRNtcWyDeeFRzjPZENO9Vq8gvVqfhaaXWLlevVwg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/mdast": {
-			"version": "4.0.4",
-			"license": "MIT",
-			"dependencies": {
-				"@types/unist": "*"
-			}
-		},
-		"node_modules/@types/mdx": {
-			"version": "2.0.13",
-			"resolved": "https://registry.npmjs.org/@types/mdx/-/mdx-2.0.13.tgz",
-			"integrity": "sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/ms": {
-			"version": "2.1.0",
-			"license": "MIT"
-		},
-		"node_modules/@types/parse-json": {
-			"version": "4.0.2",
-			"resolved": "https://registry.npmjs.org/@types/parse-json/-/parse-json-4.0.2.tgz",
-			"integrity": "sha512-dISoDXWWQwUquiKsyZ4Ng+HX2KsPL7LyHKHQwgGFEA3IaKac4Obd+h2a/a6waisAoepJlBcx9paWqjA8/HVjCw==",
-			"license": "MIT"
-		},
-		"node_modules/@types/react": {
-			"version": "19.2.14",
-			"license": "MIT",
-			"dependencies": {
-				"csstype": "^3.2.2"
-			}
-		},
-		"node_modules/@types/react-dom": {
-			"version": "19.2.3",
-			"devOptional": true,
-			"license": "MIT",
-			"peerDependencies": {
-				"@types/react": "^19.2.0"
-			}
-		},
-		"node_modules/@types/trusted-types": {
-			"version": "2.0.7",
-			"resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz",
-			"integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@types/unist": {
-			"version": "3.0.3",
-			"license": "MIT"
-		},
-		"node_modules/@types/use-sync-external-store": {
-			"version": "0.0.6",
-			"license": "MIT"
-		},
-		"node_modules/@ungap/structured-clone": {
-			"version": "1.3.0",
-			"license": "ISC"
-		},
-		"node_modules/@use-gesture/core": {
-			"version": "10.3.1",
-			"resolved": "https://registry.npmjs.org/@use-gesture/core/-/core-10.3.1.tgz",
-			"integrity": "sha512-WcINiDt8WjqBdUXye25anHiNxPc0VOrlT8F6LLkU6cycrOGUDyY/yyFmsg3k8i5OLvv25llc0QC45GhR/C8llw==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/@use-gesture/react": {
-			"version": "10.3.1",
-			"resolved": "https://registry.npmjs.org/@use-gesture/react/-/react-10.3.1.tgz",
-			"integrity": "sha512-Yy19y6O2GJq8f7CHf7L0nxL8bf4PZCPaVOCgJrusOeFHY1LvHgYXnmnXg6N5iwAnbgbZCDjo60SiM6IPJi9C5g==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@use-gesture/core": "10.3.1"
-			},
-			"peerDependencies": {
-				"react": ">= 16.8.0"
-			}
-		},
-		"node_modules/@vitejs/plugin-react": {
-			"version": "4.7.0",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@babel/core": "^7.28.0",
-				"@babel/plugin-transform-react-jsx-self": "^7.27.1",
-				"@babel/plugin-transform-react-jsx-source": "^7.27.1",
-				"@rolldown/pluginutils": "1.0.0-beta.27",
-				"@types/babel__core": "^7.20.5",
-				"react-refresh": "^0.17.0"
-			},
-			"engines": {
-				"node": "^14.18.0 || >=16.0.0"
-			},
-			"peerDependencies": {
-				"vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
-			}
-		},
-		"node_modules/@xyflow/react": {
-			"version": "12.10.1",
-			"resolved": "https://registry.npmjs.org/@xyflow/react/-/react-12.10.1.tgz",
-			"integrity": "sha512-5eSWtIK/+rkldOuFbOOz44CRgQRjtS9v5nufk77DV+XBnfCGL9HAQ8PG00o2ZYKqkEU/Ak6wrKC95Tu+2zuK3Q==",
-			"license": "MIT",
-			"dependencies": {
-				"@xyflow/system": "0.0.75",
-				"classcat": "^5.0.3",
-				"zustand": "^4.4.0"
-			},
-			"peerDependencies": {
-				"react": ">=17",
-				"react-dom": ">=17"
-			}
-		},
-		"node_modules/@xyflow/system": {
-			"version": "0.0.75",
-			"resolved": "https://registry.npmjs.org/@xyflow/system/-/system-0.0.75.tgz",
-			"integrity": "sha512-iXs+AGFLi8w/VlAoc/iSxk+CxfT6o64Uw/k0CKASOPqjqz6E0rb5jFZgJtXGZCpfQI6OQpu5EnumP5fGxQheaQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@types/d3-drag": "^3.0.7",
-				"@types/d3-interpolate": "^3.0.4",
-				"@types/d3-selection": "^3.0.10",
-				"@types/d3-transition": "^3.0.8",
-				"@types/d3-zoom": "^3.0.8",
-				"d3-drag": "^3.0.0",
-				"d3-interpolate": "^3.0.1",
-				"d3-selection": "^3.0.0",
-				"d3-zoom": "^3.0.0"
-			}
-		},
-		"node_modules/acorn": {
-			"version": "8.16.0",
-			"resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
-			"integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
-			"license": "MIT",
-			"peer": true,
-			"bin": {
-				"acorn": "bin/acorn"
-			},
-			"engines": {
-				"node": ">=0.4.0"
-			}
-		},
-		"node_modules/acorn-jsx": {
-			"version": "5.3.2",
-			"resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
-			"integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
-			"license": "MIT",
-			"peer": true,
-			"peerDependencies": {
-				"acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
-			}
-		},
-		"node_modules/ahooks": {
-			"version": "3.9.6",
-			"resolved": "https://registry.npmjs.org/ahooks/-/ahooks-3.9.6.tgz",
-			"integrity": "sha512-Mr7f05swd5SmKlR9SZo5U6M0LsL4ErweLzpdgXjA1JPmnZ78Vr6wzx0jUtvoxrcqGKYnX0Yjc02iEASVxHFPjQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.21.0",
-				"@types/js-cookie": "^3.0.6",
-				"dayjs": "^1.9.1",
-				"intersection-observer": "^0.12.0",
-				"js-cookie": "^3.0.5",
-				"lodash": "^4.17.21",
-				"react-fast-compare": "^3.2.2",
-				"resize-observer-polyfill": "^1.5.1",
-				"screenfull": "^5.0.0",
-				"tslib": "^2.4.1"
-			},
-			"peerDependencies": {
-				"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-				"react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-			}
-		},
-		"node_modules/antd": {
-			"version": "6.3.0",
-			"resolved": "https://registry.npmjs.org/antd/-/antd-6.3.0.tgz",
-			"integrity": "sha512-bbHJcASrRHp02wTpr940KtUHlTT6tvmaD4OAjqgOJXNmTQ/+qBDdBVWY/yeDV41p/WbWjTLlaqRGVbL3UEVpNw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@ant-design/colors": "^8.0.1",
-				"@ant-design/cssinjs": "^2.1.0",
-				"@ant-design/cssinjs-utils": "^2.1.1",
-				"@ant-design/fast-color": "^3.0.1",
-				"@ant-design/icons": "^6.1.0",
-				"@ant-design/react-slick": "~2.0.0",
-				"@babel/runtime": "^7.28.4",
-				"@rc-component/cascader": "~1.14.0",
-				"@rc-component/checkbox": "~2.0.0",
-				"@rc-component/collapse": "~1.2.0",
-				"@rc-component/color-picker": "~3.1.0",
-				"@rc-component/dialog": "~1.8.4",
-				"@rc-component/drawer": "~1.4.2",
-				"@rc-component/dropdown": "~1.0.2",
-				"@rc-component/form": "~1.6.2",
-				"@rc-component/image": "~1.6.0",
-				"@rc-component/input": "~1.1.2",
-				"@rc-component/input-number": "~1.6.2",
-				"@rc-component/mentions": "~1.6.0",
-				"@rc-component/menu": "~1.2.0",
-				"@rc-component/motion": "~1.1.6",
-				"@rc-component/mutate-observer": "^2.0.1",
-				"@rc-component/notification": "~1.2.0",
-				"@rc-component/pagination": "~1.2.0",
-				"@rc-component/picker": "~1.9.0",
-				"@rc-component/progress": "~1.0.2",
-				"@rc-component/qrcode": "~1.1.1",
-				"@rc-component/rate": "~1.0.1",
-				"@rc-component/resize-observer": "^1.1.1",
-				"@rc-component/segmented": "~1.3.0",
-				"@rc-component/select": "~1.6.5",
-				"@rc-component/slider": "~1.0.1",
-				"@rc-component/steps": "~1.2.2",
-				"@rc-component/switch": "~1.0.3",
-				"@rc-component/table": "~1.9.1",
-				"@rc-component/tabs": "~1.7.0",
-				"@rc-component/textarea": "~1.1.2",
-				"@rc-component/tooltip": "~1.4.0",
-				"@rc-component/tour": "~2.3.0",
-				"@rc-component/tree": "~1.2.3",
-				"@rc-component/tree-select": "~1.8.0",
-				"@rc-component/trigger": "^3.9.0",
-				"@rc-component/upload": "~1.1.0",
-				"@rc-component/util": "^1.9.0",
-				"clsx": "^2.1.1",
-				"dayjs": "^1.11.11",
-				"scroll-into-view-if-needed": "^3.1.0",
-				"throttle-debounce": "^5.0.2"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/ant-design"
-			},
-			"peerDependencies": {
-				"react": ">=18.0.0",
-				"react-dom": ">=18.0.0"
-			}
-		},
-		"node_modules/antd-style": {
-			"version": "4.1.0",
-			"resolved": "https://registry.npmjs.org/antd-style/-/antd-style-4.1.0.tgz",
-			"integrity": "sha512-vnPBGg0OVlSz90KRYZhxd89aZiOImTiesF+9MQqN8jsLGZUQTjbP04X9jTdEfsztKUuMbBWg/RmB/wHTakbtMQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@ant-design/cssinjs": "^2.0.0",
-				"@babel/runtime": "^7.24.1",
-				"@emotion/cache": "^11.11.0",
-				"@emotion/css": "^11.11.2",
-				"@emotion/react": "^11.11.4",
-				"@emotion/serialize": "^1.1.3",
-				"@emotion/utils": "^1.2.1",
-				"use-merge-value": "^1.2.0"
-			},
-			"peerDependencies": {
-				"antd": ">=6.0.0",
-				"react": ">=18"
-			}
-		},
-		"node_modules/any-promise": {
-			"version": "1.3.0",
-			"dev": true,
-			"license": "MIT"
-		},
-		"node_modules/anymatch": {
-			"version": "3.1.3",
-			"dev": true,
-			"license": "ISC",
-			"dependencies": {
-				"normalize-path": "^3.0.0",
-				"picomatch": "^2.0.4"
-			},
-			"engines": {
-				"node": ">= 8"
-			}
-		},
-		"node_modules/anymatch/node_modules/picomatch": {
-			"version": "2.3.1",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=8.6"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/jonschlinkert"
-			}
-		},
-		"node_modules/arg": {
-			"version": "5.0.2",
-			"dev": true,
-			"license": "MIT"
-		},
-		"node_modules/aria-hidden": {
-			"version": "1.2.6",
-			"resolved": "https://registry.npmjs.org/aria-hidden/-/aria-hidden-1.2.6.tgz",
-			"integrity": "sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==",
-			"license": "MIT",
-			"dependencies": {
-				"tslib": "^2.0.0"
-			},
-			"engines": {
-				"node": ">=10"
-			}
-		},
-		"node_modules/assign-symbols": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz",
-			"integrity": "sha512-Q+JC7Whu8HhmTdBph/Tq59IoRtoy6KAm5zzPv00WdujX82lbAL8K7WVjne7vdCsAmbF4AYaDOPyO3k0kl8qIrw==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/astring": {
-			"version": "1.9.0",
-			"resolved": "https://registry.npmjs.org/astring/-/astring-1.9.0.tgz",
-			"integrity": "sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==",
-			"license": "MIT",
-			"peer": true,
-			"bin": {
-				"astring": "bin/astring"
-			}
-		},
-		"node_modules/attr-accept": {
-			"version": "2.2.5",
-			"resolved": "https://registry.npmjs.org/attr-accept/-/attr-accept-2.2.5.tgz",
-			"integrity": "sha512-0bDNnY/u6pPwHDMoF0FieU354oBi0a8rD9FcsLwzcGWbc8KS8KPIi7y+s13OlVY+gMWc/9xEMUgNE6Qm8ZllYQ==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=4"
-			}
-		},
-		"node_modules/autoprefixer": {
-			"version": "10.4.24",
-			"dev": true,
-			"funding": [
-				{
-					"type": "opencollective",
-					"url": "https://opencollective.com/postcss/"
-				},
-				{
-					"type": "tidelift",
-					"url": "https://tidelift.com/funding/github/npm/autoprefixer"
-				},
-				{
-					"type": "github",
-					"url": "https://github.com/sponsors/ai"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"browserslist": "^4.28.1",
-				"caniuse-lite": "^1.0.30001766",
-				"fraction.js": "^5.3.4",
-				"picocolors": "^1.1.1",
-				"postcss-value-parser": "^4.2.0"
-			},
-			"bin": {
-				"autoprefixer": "bin/autoprefixer"
-			},
-			"engines": {
-				"node": "^10 || ^12 || >=14"
-			},
-			"peerDependencies": {
-				"postcss": "^8.1.0"
-			}
-		},
-		"node_modules/babel-plugin-macros": {
-			"version": "3.1.0",
-			"resolved": "https://registry.npmjs.org/babel-plugin-macros/-/babel-plugin-macros-3.1.0.tgz",
-			"integrity": "sha512-Cg7TFGpIr01vOQNODXOOaGz2NpCU5gl8x1qJFbb6hbZxR7XrcE2vtbAsTAbJ7/xwJtUuJEw8K8Zr/AE0LHlesg==",
-			"license": "MIT",
-			"dependencies": {
-				"@babel/runtime": "^7.12.5",
-				"cosmiconfig": "^7.0.0",
-				"resolve": "^1.19.0"
-			},
-			"engines": {
-				"node": ">=10",
-				"npm": ">=6"
-			}
-		},
-		"node_modules/bail": {
-			"version": "2.0.2",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/baseline-browser-mapping": {
-			"version": "2.9.19",
-			"dev": true,
-			"license": "Apache-2.0",
-			"bin": {
-				"baseline-browser-mapping": "dist/cli.js"
-			}
-		},
-		"node_modules/binary-extensions": {
-			"version": "2.3.0",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=8"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
-		"node_modules/braces": {
-			"version": "3.0.3",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"fill-range": "^7.1.1"
-			},
-			"engines": {
-				"node": ">=8"
-			}
-		},
-		"node_modules/browserslist": {
-			"version": "4.28.1",
-			"dev": true,
-			"funding": [
-				{
-					"type": "opencollective",
-					"url": "https://opencollective.com/browserslist"
-				},
-				{
-					"type": "tidelift",
-					"url": "https://tidelift.com/funding/github/npm/browserslist"
-				},
-				{
-					"type": "github",
-					"url": "https://github.com/sponsors/ai"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"baseline-browser-mapping": "^2.9.0",
-				"caniuse-lite": "^1.0.30001759",
-				"electron-to-chromium": "^1.5.263",
-				"node-releases": "^2.0.27",
-				"update-browserslist-db": "^1.2.0"
-			},
-			"bin": {
-				"browserslist": "cli.js"
-			},
-			"engines": {
-				"node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
-			}
-		},
-		"node_modules/callsites": {
-			"version": "3.1.0",
-			"resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
-			"integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
-			"license": "MIT",
-			"engines": {
-				"node": ">=6"
-			}
-		},
-		"node_modules/camelcase-css": {
-			"version": "2.0.1",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">= 6"
-			}
-		},
-		"node_modules/caniuse-lite": {
-			"version": "1.0.30001769",
-			"dev": true,
-			"funding": [
-				{
-					"type": "opencollective",
-					"url": "https://opencollective.com/browserslist"
-				},
-				{
-					"type": "tidelift",
-					"url": "https://tidelift.com/funding/github/npm/caniuse-lite"
-				},
-				{
-					"type": "github",
-					"url": "https://github.com/sponsors/ai"
-				}
-			],
-			"license": "CC-BY-4.0"
-		},
-		"node_modules/ccount": {
-			"version": "2.0.1",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/character-entities": {
-			"version": "2.0.2",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/character-entities-html4": {
-			"version": "2.1.0",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/character-entities-legacy": {
-			"version": "3.0.0",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/character-reference-invalid": {
-			"version": "2.0.1",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/chevrotain": {
-			"version": "11.1.1",
-			"resolved": "https://registry.npmjs.org/chevrotain/-/chevrotain-11.1.1.tgz",
-			"integrity": "sha512-f0yv5CPKaFxfsPTBzX7vGuim4oIC1/gcS7LUGdBSwl2dU6+FON6LVUksdOo1qJjoUvXNn45urgh8C+0a24pACQ==",
-			"license": "Apache-2.0",
-			"peer": true,
-			"dependencies": {
-				"@chevrotain/cst-dts-gen": "11.1.1",
-				"@chevrotain/gast": "11.1.1",
-				"@chevrotain/regexp-to-ast": "11.1.1",
-				"@chevrotain/types": "11.1.1",
-				"@chevrotain/utils": "11.1.1",
-				"lodash-es": "4.17.23"
-			}
-		},
-		"node_modules/chevrotain-allstar": {
-			"version": "0.3.1",
-			"resolved": "https://registry.npmjs.org/chevrotain-allstar/-/chevrotain-allstar-0.3.1.tgz",
-			"integrity": "sha512-b7g+y9A0v4mxCW1qUhf3BSVPg+/NvGErk/dOkrDaHA0nQIQGAtrOjlX//9OQtRlSCy+x9rfB5N8yC71lH1nvMw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"lodash-es": "^4.17.21"
-			},
-			"peerDependencies": {
-				"chevrotain": "^11.0.0"
-			}
-		},
-		"node_modules/chokidar": {
-			"version": "4.0.3",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"readdirp": "^4.0.1"
-			},
-			"engines": {
-				"node": ">= 14.16.0"
-			},
-			"funding": {
-				"url": "https://paulmillr.com/funding/"
-			}
-		},
-		"node_modules/chroma-js": {
-			"version": "3.2.0",
-			"resolved": "https://registry.npmjs.org/chroma-js/-/chroma-js-3.2.0.tgz",
-			"integrity": "sha512-os/OippSlX1RlWWr+QDPcGUZs0uoqr32urfxESG9U93lhUfbnlyckte84Q8P1UQY/qth983AS1JONKmLS4T0nw==",
-			"license": "(BSD-3-Clause AND Apache-2.0)",
-			"peer": true
-		},
-		"node_modules/class-variance-authority": {
-			"version": "0.7.1",
-			"resolved": "https://registry.npmjs.org/class-variance-authority/-/class-variance-authority-0.7.1.tgz",
-			"integrity": "sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg==",
-			"license": "Apache-2.0",
-			"dependencies": {
-				"clsx": "^2.1.1"
-			},
-			"funding": {
-				"url": "https://polar.sh/cva"
-			}
-		},
-		"node_modules/classcat": {
-			"version": "5.0.5",
-			"resolved": "https://registry.npmjs.org/classcat/-/classcat-5.0.5.tgz",
-			"integrity": "sha512-JhZUT7JFcQy/EzW605k/ktHtncoo9vnyW/2GspNYwFlN1C/WmjuV/xtS04e9SOkL2sTdw0VAZ2UGCcQ9lR6p6w==",
-			"license": "MIT"
-		},
-		"node_modules/classnames": {
-			"version": "2.5.1",
-			"resolved": "https://registry.npmjs.org/classnames/-/classnames-2.5.1.tgz",
-			"integrity": "sha512-saHYOzhIQs6wy2sVxTM6bUDsQO4F50V9RQ22qBpEdCW+I+/Wmke2HOl6lS6dTpdxVhb88/I6+Hs+438c3lfUow==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/clsx": {
-			"version": "2.1.1",
-			"license": "MIT",
-			"engines": {
-				"node": ">=6"
-			}
-		},
-		"node_modules/codemirror": {
-			"version": "6.0.2",
-			"resolved": "https://registry.npmjs.org/codemirror/-/codemirror-6.0.2.tgz",
-			"integrity": "sha512-VhydHotNW5w1UGK0Qj96BwSk/Zqbp9WbnyK2W/eVMv4QyF41INRGpjUhFJY7/uDNuudSc33a/PKr4iDqRduvHw==",
-			"license": "MIT",
-			"dependencies": {
-				"@codemirror/autocomplete": "^6.0.0",
-				"@codemirror/commands": "^6.0.0",
-				"@codemirror/language": "^6.0.0",
-				"@codemirror/lint": "^6.0.0",
-				"@codemirror/search": "^6.0.0",
-				"@codemirror/state": "^6.0.0",
-				"@codemirror/view": "^6.0.0"
-			}
-		},
-		"node_modules/collapse-white-space": {
-			"version": "2.1.0",
-			"resolved": "https://registry.npmjs.org/collapse-white-space/-/collapse-white-space-2.1.0.tgz",
-			"integrity": "sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw==",
-			"license": "MIT",
-			"peer": true,
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/colord": {
-			"version": "2.9.3",
-			"resolved": "https://registry.npmjs.org/colord/-/colord-2.9.3.tgz",
-			"integrity": "sha512-jeC1axXpnb0/2nn/Y1LPuLdgXBLH7aDcHu4KEKfqw3CUhX7ZpfBSlPKyqXE6btIgEzfWtrX3/tyBCaCvXvMkOw==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/comma-separated-tokens": {
-			"version": "2.0.3",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/commander": {
-			"version": "4.1.1",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">= 6"
-			}
-		},
-		"node_modules/compute-scroll-into-view": {
-			"version": "3.1.1",
-			"resolved": "https://registry.npmjs.org/compute-scroll-into-view/-/compute-scroll-into-view-3.1.1.tgz",
-			"integrity": "sha512-VRhuHOLoKYOy4UbilLbUzbYg93XLjv2PncJC50EuTWPA3gaja1UjBsUP/D/9/juV3vQFr6XBEzn9KCAHdUvOHw==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/confbox": {
-			"version": "0.1.8",
-			"resolved": "https://registry.npmjs.org/confbox/-/confbox-0.1.8.tgz",
-			"integrity": "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/convert-source-map": {
-			"version": "2.0.0",
-			"dev": true,
-			"license": "MIT"
-		},
-		"node_modules/cookie-es": {
-			"version": "2.0.0",
-			"license": "MIT"
-		},
-		"node_modules/cose-base": {
-			"version": "1.0.3",
-			"resolved": "https://registry.npmjs.org/cose-base/-/cose-base-1.0.3.tgz",
-			"integrity": "sha512-s9whTXInMSgAp/NVXVNuVxVKzGH2qck3aQlVHxDCdAEPgtMKwc4Wq6/QKhgdEdgbLSi9rBTAcPoRa6JpiG4ksg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"layout-base": "^1.0.0"
-			}
-		},
-		"node_modules/cosmiconfig": {
-			"version": "7.1.0",
-			"resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-7.1.0.tgz",
-			"integrity": "sha512-AdmX6xUzdNASswsFtmwSt7Vj8po9IuqXm0UXz7QKPuEUmPB4XyjGfaAr2PSuELMwkRMVH1EpIkX5bTZGRB3eCA==",
-			"license": "MIT",
-			"dependencies": {
-				"@types/parse-json": "^4.0.0",
-				"import-fresh": "^3.2.1",
-				"parse-json": "^5.0.0",
-				"path-type": "^4.0.0",
-				"yaml": "^1.10.0"
-			},
-			"engines": {
-				"node": ">=10"
-			}
-		},
-		"node_modules/cosmiconfig/node_modules/yaml": {
-			"version": "1.10.2",
-			"resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz",
-			"integrity": "sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==",
-			"license": "ISC",
-			"engines": {
-				"node": ">= 6"
-			}
-		},
-		"node_modules/crelt": {
-			"version": "1.0.6",
-			"resolved": "https://registry.npmjs.org/crelt/-/crelt-1.0.6.tgz",
-			"integrity": "sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g==",
-			"license": "MIT"
-		},
-		"node_modules/cssesc": {
-			"version": "3.0.0",
-			"dev": true,
-			"license": "MIT",
-			"bin": {
-				"cssesc": "bin/cssesc"
-			},
-			"engines": {
-				"node": ">=4"
-			}
-		},
-		"node_modules/csstype": {
-			"version": "3.2.3",
-			"license": "MIT"
-		},
-		"node_modules/cytoscape": {
-			"version": "3.33.1",
-			"resolved": "https://registry.npmjs.org/cytoscape/-/cytoscape-3.33.1.tgz",
-			"integrity": "sha512-iJc4TwyANnOGR1OmWhsS9ayRS3s+XQ185FmuHObThD+5AeJCakAAbWv8KimMTt08xCCLNgneQwFp+JRJOr9qGQ==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=0.10"
-			}
-		},
-		"node_modules/cytoscape-cose-bilkent": {
-			"version": "4.1.0",
-			"resolved": "https://registry.npmjs.org/cytoscape-cose-bilkent/-/cytoscape-cose-bilkent-4.1.0.tgz",
-			"integrity": "sha512-wgQlVIUJF13Quxiv5e1gstZ08rnZj2XaLHGoFMYXz7SkNfCDOOteKBE6SYRfA9WxxI/iBc3ajfDoc6hb/MRAHQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"cose-base": "^1.0.0"
-			},
-			"peerDependencies": {
-				"cytoscape": "^3.2.0"
-			}
-		},
-		"node_modules/cytoscape-fcose": {
-			"version": "2.2.0",
-			"resolved": "https://registry.npmjs.org/cytoscape-fcose/-/cytoscape-fcose-2.2.0.tgz",
-			"integrity": "sha512-ki1/VuRIHFCzxWNrsshHYPs6L7TvLu3DL+TyIGEsRcvVERmxokbf5Gdk7mFxZnTdiGtnA4cfSmjZJMviqSuZrQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"cose-base": "^2.2.0"
-			},
-			"peerDependencies": {
-				"cytoscape": "^3.2.0"
-			}
-		},
-		"node_modules/cytoscape-fcose/node_modules/cose-base": {
-			"version": "2.2.0",
-			"resolved": "https://registry.npmjs.org/cose-base/-/cose-base-2.2.0.tgz",
-			"integrity": "sha512-AzlgcsCbUMymkADOJtQm3wO9S3ltPfYOFD5033keQn9NJzIbtnZj+UdBJe7DYml/8TdbtHJW3j58SOnKhWY/5g==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"layout-base": "^2.0.0"
-			}
-		},
-		"node_modules/cytoscape-fcose/node_modules/layout-base": {
-			"version": "2.0.1",
-			"resolved": "https://registry.npmjs.org/layout-base/-/layout-base-2.0.1.tgz",
-			"integrity": "sha512-dp3s92+uNI1hWIpPGH3jK2kxE2lMjdXdr+DH8ynZHpd6PUlH6x6cbuXnoMmiNumznqaNO31xu9e79F0uuZ0JFg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/d3": {
-			"version": "7.9.0",
-			"resolved": "https://registry.npmjs.org/d3/-/d3-7.9.0.tgz",
-			"integrity": "sha512-e1U46jVP+w7Iut8Jt8ri1YsPOvFpg46k+K8TpCb0P+zjCkjkPnV7WzfDJzMHy1LnA+wj5pLT1wjO901gLXeEhA==",
-			"license": "ISC",
-			"peer": true,
-			"dependencies": {
-				"d3-array": "3",
-				"d3-axis": "3",
-				"d3-brush": "3",
-				"d3-chord": "3",
-				"d3-color": "3",
-				"d3-contour": "4",
-				"d3-delaunay": "6",
-				"d3-dispatch": "3",
-				"d3-drag": "3",
-				"d3-dsv": "3",
-				"d3-ease": "3",
-				"d3-fetch": "3",
-				"d3-force": "3",
-				"d3-format": "3",
-				"d3-geo": "3",
-				"d3-hierarchy": "3",
-				"d3-interpolate": "3",
-				"d3-path": "3",
-				"d3-polygon": "3",
-				"d3-quadtree": "3",
-				"d3-random": "3",
-				"d3-scale": "4",
-				"d3-scale-chromatic": "3",
-				"d3-selection": "3",
-				"d3-shape": "3",
-				"d3-time": "3",
-				"d3-time-format": "4",
-				"d3-timer": "3",
-				"d3-transition": "3",
-				"d3-zoom": "3"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-array": {
-			"version": "3.2.4",
-			"license": "ISC",
-			"dependencies": {
-				"internmap": "1 - 2"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-axis": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/d3-axis/-/d3-axis-3.0.0.tgz",
-			"integrity": "sha512-IH5tgjV4jE/GhHkRV0HiVYPDtvfjHQlQfJHs0usq7M30XcSBvOotpmH1IgkcXsO/5gEQZD43B//fc7SRT5S+xw==",
-			"license": "ISC",
-			"peer": true,
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-brush": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/d3-brush/-/d3-brush-3.0.0.tgz",
-			"integrity": "sha512-ALnjWlVYkXsVIGlOsuWH1+3udkYFI48Ljihfnh8FZPF2QS9o+PzGLBslO0PjzVoHLZ2KCVgAM8NVkXPJB2aNnQ==",
-			"license": "ISC",
-			"peer": true,
-			"dependencies": {
-				"d3-dispatch": "1 - 3",
-				"d3-drag": "2 - 3",
-				"d3-interpolate": "1 - 3",
-				"d3-selection": "3",
-				"d3-transition": "3"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-chord": {
-			"version": "3.0.1",
-			"resolved": "https://registry.npmjs.org/d3-chord/-/d3-chord-3.0.1.tgz",
-			"integrity": "sha512-VE5S6TNa+j8msksl7HwjxMHDM2yNK3XCkusIlpX5kwauBfXuyLAtNg9jCp/iHH61tgI4sb6R/EIMWCqEIdjT/g==",
-			"license": "ISC",
-			"peer": true,
-			"dependencies": {
-				"d3-path": "1 - 3"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-color": {
-			"version": "3.1.0",
-			"license": "ISC",
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-contour": {
-			"version": "4.0.2",
-			"resolved": "https://registry.npmjs.org/d3-contour/-/d3-contour-4.0.2.tgz",
-			"integrity": "sha512-4EzFTRIikzs47RGmdxbeUvLWtGedDUNkTcmzoeyg4sP/dvCexO47AaQL7VKy/gul85TOxw+IBgA8US2xwbToNA==",
-			"license": "ISC",
-			"peer": true,
-			"dependencies": {
-				"d3-array": "^3.2.0"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-delaunay": {
-			"version": "6.0.4",
-			"resolved": "https://registry.npmjs.org/d3-delaunay/-/d3-delaunay-6.0.4.tgz",
-			"integrity": "sha512-mdjtIZ1XLAM8bm/hx3WwjfHt6Sggek7qH043O8KEjDXN40xi3vx/6pYSVTwLjEgiXQTbvaouWKynLBiUZ6SK6A==",
-			"license": "ISC",
-			"peer": true,
-			"dependencies": {
-				"delaunator": "5"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-dispatch": {
-			"version": "3.0.1",
-			"resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-3.0.1.tgz",
-			"integrity": "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==",
-			"license": "ISC",
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-drag": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/d3-drag/-/d3-drag-3.0.0.tgz",
-			"integrity": "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==",
-			"license": "ISC",
-			"dependencies": {
-				"d3-dispatch": "1 - 3",
-				"d3-selection": "3"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-dsv": {
-			"version": "3.0.1",
-			"resolved": "https://registry.npmjs.org/d3-dsv/-/d3-dsv-3.0.1.tgz",
-			"integrity": "sha512-UG6OvdI5afDIFP9w4G0mNq50dSOsXHJaRE8arAS5o9ApWnIElp8GZw1Dun8vP8OyHOZ/QJUKUJwxiiCCnUwm+Q==",
-			"license": "ISC",
-			"peer": true,
-			"dependencies": {
-				"commander": "7",
-				"iconv-lite": "0.6",
-				"rw": "1"
-			},
-			"bin": {
-				"csv2json": "bin/dsv2json.js",
-				"csv2tsv": "bin/dsv2dsv.js",
-				"dsv2dsv": "bin/dsv2dsv.js",
-				"dsv2json": "bin/dsv2json.js",
-				"json2csv": "bin/json2dsv.js",
-				"json2dsv": "bin/json2dsv.js",
-				"json2tsv": "bin/json2dsv.js",
-				"tsv2csv": "bin/dsv2dsv.js",
-				"tsv2json": "bin/dsv2json.js"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-dsv/node_modules/commander": {
-			"version": "7.2.0",
-			"resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz",
-			"integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">= 10"
-			}
-		},
-		"node_modules/d3-ease": {
-			"version": "3.0.1",
-			"license": "BSD-3-Clause",
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-fetch": {
-			"version": "3.0.1",
-			"resolved": "https://registry.npmjs.org/d3-fetch/-/d3-fetch-3.0.1.tgz",
-			"integrity": "sha512-kpkQIM20n3oLVBKGg6oHrUchHM3xODkTzjMoj7aWQFq5QEM+R6E4WkzT5+tojDY7yjez8KgCBRoj4aEr99Fdqw==",
-			"license": "ISC",
-			"peer": true,
-			"dependencies": {
-				"d3-dsv": "1 - 3"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-force": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/d3-force/-/d3-force-3.0.0.tgz",
-			"integrity": "sha512-zxV/SsA+U4yte8051P4ECydjD/S+qeYtnaIyAs9tgHCqfguma/aAQDjo85A9Z6EKhBirHRJHXIgJUlffT4wdLg==",
-			"license": "ISC",
-			"peer": true,
-			"dependencies": {
-				"d3-dispatch": "1 - 3",
-				"d3-quadtree": "1 - 3",
-				"d3-timer": "1 - 3"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-format": {
-			"version": "3.1.2",
-			"license": "ISC",
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-geo": {
-			"version": "3.1.1",
-			"resolved": "https://registry.npmjs.org/d3-geo/-/d3-geo-3.1.1.tgz",
-			"integrity": "sha512-637ln3gXKXOwhalDzinUgY83KzNWZRKbYubaG+fGVuc/dxO64RRljtCTnf5ecMyE1RIdtqpkVcq0IbtU2S8j2Q==",
-			"license": "ISC",
-			"peer": true,
-			"dependencies": {
-				"d3-array": "2.5.0 - 3"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-hierarchy": {
-			"version": "3.1.2",
-			"resolved": "https://registry.npmjs.org/d3-hierarchy/-/d3-hierarchy-3.1.2.tgz",
-			"integrity": "sha512-FX/9frcub54beBdugHjDCdikxThEqjnR93Qt7PvQTOHxyiNCAlvMrHhclk3cD5VeAaq9fxmfRp+CnWw9rEMBuA==",
-			"license": "ISC",
-			"peer": true,
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-interpolate": {
-			"version": "3.0.1",
-			"license": "ISC",
-			"dependencies": {
-				"d3-color": "1 - 3"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-path": {
-			"version": "3.1.0",
-			"license": "ISC",
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-polygon": {
-			"version": "3.0.1",
-			"resolved": "https://registry.npmjs.org/d3-polygon/-/d3-polygon-3.0.1.tgz",
-			"integrity": "sha512-3vbA7vXYwfe1SYhED++fPUQlWSYTTGmFmQiany/gdbiWgU/iEyQzyymwL9SkJjFFuCS4902BSzewVGsHHmHtXg==",
-			"license": "ISC",
-			"peer": true,
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-quadtree": {
-			"version": "3.0.1",
-			"resolved": "https://registry.npmjs.org/d3-quadtree/-/d3-quadtree-3.0.1.tgz",
-			"integrity": "sha512-04xDrxQTDTCFwP5H6hRhsRcb9xxv2RzkcsygFzmkSIOJy3PeRJP7sNk3VRIbKXcog561P9oU0/rVH6vDROAgUw==",
-			"license": "ISC",
-			"peer": true,
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-random": {
-			"version": "3.0.1",
-			"resolved": "https://registry.npmjs.org/d3-random/-/d3-random-3.0.1.tgz",
-			"integrity": "sha512-FXMe9GfxTxqd5D6jFsQ+DJ8BJS4E/fT5mqqdjovykEB2oFbTMDVdg1MGFxfQW+FBOGoB++k8swBrgwSHT1cUXQ==",
-			"license": "ISC",
-			"peer": true,
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-sankey": {
-			"version": "0.12.3",
-			"resolved": "https://registry.npmjs.org/d3-sankey/-/d3-sankey-0.12.3.tgz",
-			"integrity": "sha512-nQhsBRmM19Ax5xEIPLMY9ZmJ/cDvd1BG3UVvt5h3WRxKg5zGRbvnteTyWAbzeSvlh3tW7ZEmq4VwR5mB3tutmQ==",
-			"license": "BSD-3-Clause",
-			"peer": true,
-			"dependencies": {
-				"d3-array": "1 - 2",
-				"d3-shape": "^1.2.0"
-			}
-		},
-		"node_modules/d3-sankey/node_modules/d3-array": {
-			"version": "2.12.1",
-			"resolved": "https://registry.npmjs.org/d3-array/-/d3-array-2.12.1.tgz",
-			"integrity": "sha512-B0ErZK/66mHtEsR1TkPEEkwdy+WDesimkM5gpZr5Dsg54BiTA5RXtYW5qTLIAcekaS9xfZrzBLF/OAkB3Qn1YQ==",
-			"license": "BSD-3-Clause",
-			"peer": true,
-			"dependencies": {
-				"internmap": "^1.0.0"
-			}
-		},
-		"node_modules/d3-sankey/node_modules/d3-path": {
-			"version": "1.0.9",
-			"resolved": "https://registry.npmjs.org/d3-path/-/d3-path-1.0.9.tgz",
-			"integrity": "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg==",
-			"license": "BSD-3-Clause",
-			"peer": true
-		},
-		"node_modules/d3-sankey/node_modules/d3-shape": {
-			"version": "1.3.7",
-			"resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-1.3.7.tgz",
-			"integrity": "sha512-EUkvKjqPFUAZyOlhY5gzCxCeI0Aep04LwIRpsZ/mLFelJiUfnK56jo5JMDSE7yyP2kLSb6LtF+S5chMk7uqPqw==",
-			"license": "BSD-3-Clause",
-			"peer": true,
-			"dependencies": {
-				"d3-path": "1"
-			}
-		},
-		"node_modules/d3-sankey/node_modules/internmap": {
-			"version": "1.0.1",
-			"resolved": "https://registry.npmjs.org/internmap/-/internmap-1.0.1.tgz",
-			"integrity": "sha512-lDB5YccMydFBtasVtxnZ3MRBHuaoE8GKsppq+EchKL2U4nK/DmEpPHNH8MZe5HkMtpSiTSOZwfN0tzYjO/lJEw==",
-			"license": "ISC",
-			"peer": true
-		},
-		"node_modules/d3-scale": {
-			"version": "4.0.2",
-			"license": "ISC",
-			"dependencies": {
-				"d3-array": "2.10.0 - 3",
-				"d3-format": "1 - 3",
-				"d3-interpolate": "1.2.0 - 3",
-				"d3-time": "2.1.1 - 3",
-				"d3-time-format": "2 - 4"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-scale-chromatic": {
-			"version": "3.1.0",
-			"resolved": "https://registry.npmjs.org/d3-scale-chromatic/-/d3-scale-chromatic-3.1.0.tgz",
-			"integrity": "sha512-A3s5PWiZ9YCXFye1o246KoscMWqf8BsD9eRiJ3He7C9OBaxKhAd5TFCdEx/7VbKtxxTsu//1mMJFrEt572cEyQ==",
-			"license": "ISC",
-			"peer": true,
-			"dependencies": {
-				"d3-color": "1 - 3",
-				"d3-interpolate": "1 - 3"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-selection": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz",
-			"integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==",
-			"license": "ISC",
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-shape": {
-			"version": "3.2.0",
-			"license": "ISC",
-			"dependencies": {
-				"d3-path": "^3.1.0"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-time": {
-			"version": "3.1.0",
-			"license": "ISC",
-			"dependencies": {
-				"d3-array": "2 - 3"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-time-format": {
-			"version": "4.1.0",
-			"license": "ISC",
-			"dependencies": {
-				"d3-time": "1 - 3"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-timer": {
-			"version": "3.0.1",
-			"license": "ISC",
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/d3-transition": {
-			"version": "3.0.1",
-			"resolved": "https://registry.npmjs.org/d3-transition/-/d3-transition-3.0.1.tgz",
-			"integrity": "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w==",
-			"license": "ISC",
-			"dependencies": {
-				"d3-color": "1 - 3",
-				"d3-dispatch": "1 - 3",
-				"d3-ease": "1 - 3",
-				"d3-interpolate": "1 - 3",
-				"d3-timer": "1 - 3"
-			},
-			"engines": {
-				"node": ">=12"
-			},
-			"peerDependencies": {
-				"d3-selection": "2 - 3"
-			}
-		},
-		"node_modules/d3-zoom": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/d3-zoom/-/d3-zoom-3.0.0.tgz",
-			"integrity": "sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw==",
-			"license": "ISC",
-			"dependencies": {
-				"d3-dispatch": "1 - 3",
-				"d3-drag": "2 - 3",
-				"d3-interpolate": "1 - 3",
-				"d3-selection": "2 - 3",
-				"d3-transition": "2 - 3"
-			},
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/dagre-d3-es": {
-			"version": "7.0.13",
-			"resolved": "https://registry.npmjs.org/dagre-d3-es/-/dagre-d3-es-7.0.13.tgz",
-			"integrity": "sha512-efEhnxpSuwpYOKRm/L5KbqoZmNNukHa/Flty4Wp62JRvgH2ojwVgPgdYyr4twpieZnyRDdIH7PY2mopX26+j2Q==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"d3": "^7.9.0",
-				"lodash-es": "^4.17.21"
-			}
-		},
-		"node_modules/dayjs": {
-			"version": "1.11.19",
-			"resolved": "https://registry.npmjs.org/dayjs/-/dayjs-1.11.19.tgz",
-			"integrity": "sha512-t5EcLVS6QPBNqM2z8fakk/NKel+Xzshgt8FFKAn+qwlD1pzZWxh0nVCrvFK7ZDb6XucZeF9z8C7CBWTRIVApAw==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/debug": {
-			"version": "4.4.3",
-			"license": "MIT",
-			"dependencies": {
-				"ms": "^2.1.3"
-			},
-			"engines": {
-				"node": ">=6.0"
-			},
-			"peerDependenciesMeta": {
-				"supports-color": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/decimal.js-light": {
-			"version": "2.5.1",
-			"license": "MIT"
-		},
-		"node_modules/decode-named-character-reference": {
-			"version": "1.3.0",
-			"license": "MIT",
-			"dependencies": {
-				"character-entities": "^2.0.0"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/decode-uri-component": {
-			"version": "0.4.1",
-			"resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.4.1.tgz",
-			"integrity": "sha512-+8VxcR21HhTy8nOt6jf20w0c9CADrw1O8d+VZ/YzzCt4bJ3uBjw+D1q2osAB8RnpwwaeYBxy0HyKQxD5JBMuuQ==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=14.16"
-			}
-		},
-		"node_modules/delaunator": {
-			"version": "5.0.1",
-			"resolved": "https://registry.npmjs.org/delaunator/-/delaunator-5.0.1.tgz",
-			"integrity": "sha512-8nvh+XBe96aCESrGOqMp/84b13H9cdKbG5P2ejQCh4d4sK9RL4371qou9drQjMhvnPmhWl5hnmqbEE0fXr9Xnw==",
-			"license": "ISC",
-			"peer": true,
-			"dependencies": {
-				"robust-predicates": "^3.0.2"
-			}
-		},
-		"node_modules/dequal": {
-			"version": "2.0.3",
-			"license": "MIT",
-			"engines": {
-				"node": ">=6"
-			}
-		},
-		"node_modules/detect-libc": {
-			"version": "2.1.2",
-			"dev": true,
-			"license": "Apache-2.0",
-			"optional": true,
-			"engines": {
-				"node": ">=8"
-			}
-		},
-		"node_modules/detect-node-es": {
-			"version": "1.1.0",
-			"resolved": "https://registry.npmjs.org/detect-node-es/-/detect-node-es-1.1.0.tgz",
-			"integrity": "sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==",
-			"license": "MIT"
-		},
-		"node_modules/devlop": {
-			"version": "1.1.0",
-			"license": "MIT",
-			"dependencies": {
-				"dequal": "^2.0.0"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/didyoumean": {
-			"version": "1.2.2",
-			"dev": true,
-			"license": "Apache-2.0"
-		},
-		"node_modules/diff": {
-			"version": "8.0.3",
-			"resolved": "https://registry.npmjs.org/diff/-/diff-8.0.3.tgz",
-			"integrity": "sha512-qejHi7bcSD4hQAZE0tNAawRK1ZtafHDmMTMkrrIGgSLl7hTnQHmKCeB45xAcbfTqK2zowkM3j3bHt/4b/ARbYQ==",
-			"license": "BSD-3-Clause",
-			"peer": true,
-			"engines": {
-				"node": ">=0.3.1"
-			}
-		},
-		"node_modules/dlv": {
-			"version": "1.1.3",
-			"dev": true,
-			"license": "MIT"
-		},
-		"node_modules/dompurify": {
-			"version": "3.3.1",
-			"resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.3.1.tgz",
-			"integrity": "sha512-qkdCKzLNtrgPFP1Vo+98FRzJnBRGe4ffyCea9IwHB1fyxPOeNTHpLKYGd4Uk9xvNoH0ZoOjwZxNptyMwqrId1Q==",
-			"license": "(MPL-2.0 OR Apache-2.0)",
-			"peer": true,
-			"optionalDependencies": {
-				"@types/trusted-types": "^2.0.7"
-			}
-		},
-		"node_modules/electron-to-chromium": {
-			"version": "1.5.286",
-			"dev": true,
-			"license": "ISC"
-		},
-		"node_modules/emoji-mart": {
-			"version": "5.6.0",
-			"resolved": "https://registry.npmjs.org/emoji-mart/-/emoji-mart-5.6.0.tgz",
-			"integrity": "sha512-eJp3QRe79pjwa+duv+n7+5YsNhRcMl812EcFVwrnRvYKoNPoQb5qxU8DG6Bgwji0akHdp6D4Ln6tYLG58MFSow==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/emoji-regex": {
-			"version": "10.6.0",
-			"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.6.0.tgz",
-			"integrity": "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/entities": {
-			"version": "6.0.1",
-			"resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
-			"integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
-			"license": "BSD-2-Clause",
-			"peer": true,
-			"engines": {
-				"node": ">=0.12"
-			},
-			"funding": {
-				"url": "https://github.com/fb55/entities?sponsor=1"
-			}
-		},
-		"node_modules/error-ex": {
-			"version": "1.3.4",
-			"resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.4.tgz",
-			"integrity": "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==",
-			"license": "MIT",
-			"dependencies": {
-				"is-arrayish": "^0.2.1"
-			}
-		},
-		"node_modules/es-toolkit": {
-			"version": "1.44.0",
-			"license": "MIT",
-			"workspaces": [
-				"docs",
-				"benchmarks"
-			]
-		},
-		"node_modules/esast-util-from-estree": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/esast-util-from-estree/-/esast-util-from-estree-2.0.0.tgz",
-			"integrity": "sha512-4CyanoAudUSBAn5K13H4JhsMH6L9ZP7XbLVe/dKybkxMO7eDyLsT8UHl9TRNrU2Gr9nz+FovfSIjuXWJ81uVwQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree-jsx": "^1.0.0",
-				"devlop": "^1.0.0",
-				"estree-util-visit": "^2.0.0",
-				"unist-util-position-from-estree": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/esast-util-from-js": {
-			"version": "2.0.1",
-			"resolved": "https://registry.npmjs.org/esast-util-from-js/-/esast-util-from-js-2.0.1.tgz",
-			"integrity": "sha512-8Ja+rNJ0Lt56Pcf3TAmpBZjmx8ZcK5Ts4cAzIOjsjevg9oSXJnl6SUQ2EevU8tv3h6ZLWmoKL5H4fgWvdvfETw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree-jsx": "^1.0.0",
-				"acorn": "^8.0.0",
-				"esast-util-from-estree": "^2.0.0",
-				"vfile-message": "^4.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/esbuild": {
-			"version": "0.25.12",
-			"dev": true,
-			"hasInstallScript": true,
-			"license": "MIT",
-			"bin": {
-				"esbuild": "bin/esbuild"
-			},
-			"engines": {
-				"node": ">=18"
-			},
-			"optionalDependencies": {
-				"@esbuild/aix-ppc64": "0.25.12",
-				"@esbuild/android-arm": "0.25.12",
-				"@esbuild/android-arm64": "0.25.12",
-				"@esbuild/android-x64": "0.25.12",
-				"@esbuild/darwin-arm64": "0.25.12",
-				"@esbuild/darwin-x64": "0.25.12",
-				"@esbuild/freebsd-arm64": "0.25.12",
-				"@esbuild/freebsd-x64": "0.25.12",
-				"@esbuild/linux-arm": "0.25.12",
-				"@esbuild/linux-arm64": "0.25.12",
-				"@esbuild/linux-ia32": "0.25.12",
-				"@esbuild/linux-loong64": "0.25.12",
-				"@esbuild/linux-mips64el": "0.25.12",
-				"@esbuild/linux-ppc64": "0.25.12",
-				"@esbuild/linux-riscv64": "0.25.12",
-				"@esbuild/linux-s390x": "0.25.12",
-				"@esbuild/linux-x64": "0.25.12",
-				"@esbuild/netbsd-arm64": "0.25.12",
-				"@esbuild/netbsd-x64": "0.25.12",
-				"@esbuild/openbsd-arm64": "0.25.12",
-				"@esbuild/openbsd-x64": "0.25.12",
-				"@esbuild/openharmony-arm64": "0.25.12",
-				"@esbuild/sunos-x64": "0.25.12",
-				"@esbuild/win32-arm64": "0.25.12",
-				"@esbuild/win32-ia32": "0.25.12",
-				"@esbuild/win32-x64": "0.25.12"
-			}
-		},
-		"node_modules/escalade": {
-			"version": "3.2.0",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=6"
-			}
-		},
-		"node_modules/escape-string-regexp": {
-			"version": "5.0.0",
-			"license": "MIT",
-			"engines": {
-				"node": ">=12"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
-		"node_modules/estree-util-attach-comments": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/estree-util-attach-comments/-/estree-util-attach-comments-3.0.0.tgz",
-			"integrity": "sha512-cKUwm/HUcTDsYh/9FgnuFqpfquUbwIqwKM26BVCGDPVgvaCl/nDCCjUfiLlx6lsEZ3Z4RFxNbOQ60pkaEwFxGw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree": "^1.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/estree-util-build-jsx": {
-			"version": "3.0.1",
-			"resolved": "https://registry.npmjs.org/estree-util-build-jsx/-/estree-util-build-jsx-3.0.1.tgz",
-			"integrity": "sha512-8U5eiL6BTrPxp/CHbs2yMgP8ftMhR5ww1eIKoWRMlqvltHF8fZn5LRDvTKuxD3DUn+shRbLGqXemcP51oFCsGQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree-jsx": "^1.0.0",
-				"devlop": "^1.0.0",
-				"estree-util-is-identifier-name": "^3.0.0",
-				"estree-walker": "^3.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/estree-util-is-identifier-name": {
-			"version": "3.0.0",
-			"license": "MIT",
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/estree-util-scope": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/estree-util-scope/-/estree-util-scope-1.0.0.tgz",
-			"integrity": "sha512-2CAASclonf+JFWBNJPndcOpA8EMJwa0Q8LUFJEKqXLW6+qBvbFZuF5gItbQOs/umBUkjviCSDCbBwU2cXbmrhQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree": "^1.0.0",
-				"devlop": "^1.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/estree-util-to-js": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/estree-util-to-js/-/estree-util-to-js-2.0.0.tgz",
-			"integrity": "sha512-WDF+xj5rRWmD5tj6bIqRi6CkLIXbbNQUcxQHzGysQzvHmdYG2G7p/Tf0J0gpxGgkeMZNTIjT/AoSvC9Xehcgdg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree-jsx": "^1.0.0",
-				"astring": "^1.8.0",
-				"source-map": "^0.7.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/estree-util-visit": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/estree-util-visit/-/estree-util-visit-2.0.0.tgz",
-			"integrity": "sha512-m5KgiH85xAhhW8Wta0vShLcUvOsh3LLPI2YVwcbio1l7E09NTLL1EyMZFM1OyWowoH0skScNbhOPl4kcBgzTww==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree-jsx": "^1.0.0",
-				"@types/unist": "^3.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/estree-walker": {
-			"version": "3.0.3",
-			"resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
-			"integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree": "^1.0.0"
-			}
-		},
-		"node_modules/eventemitter3": {
-			"version": "5.0.4",
-			"license": "MIT"
-		},
-		"node_modules/events": {
-			"version": "3.3.0",
-			"resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz",
-			"integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==",
-			"license": "MIT",
-			"engines": {
-				"node": ">=0.8.x"
-			}
-		},
-		"node_modules/extend": {
-			"version": "3.0.2",
-			"license": "MIT"
-		},
-		"node_modules/extend-shallow": {
-			"version": "2.0.1",
-			"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
-			"integrity": "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"is-extendable": "^0.1.0"
-			},
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/extend-shallow/node_modules/is-extendable": {
-			"version": "0.1.1",
-			"resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz",
-			"integrity": "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/fast-deep-equal": {
-			"version": "3.1.3",
-			"resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
-			"integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/fast-glob": {
-			"version": "3.3.3",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@nodelib/fs.stat": "^2.0.2",
-				"@nodelib/fs.walk": "^1.2.3",
-				"glob-parent": "^5.1.2",
-				"merge2": "^1.3.0",
-				"micromatch": "^4.0.8"
-			},
-			"engines": {
-				"node": ">=8.6.0"
-			}
-		},
-		"node_modules/fast-glob/node_modules/glob-parent": {
-			"version": "5.1.2",
-			"dev": true,
-			"license": "ISC",
-			"dependencies": {
-				"is-glob": "^4.0.1"
-			},
-			"engines": {
-				"node": ">= 6"
-			}
-		},
-		"node_modules/fastq": {
-			"version": "1.20.1",
-			"dev": true,
-			"license": "ISC",
-			"dependencies": {
-				"reusify": "^1.0.4"
-			}
-		},
-		"node_modules/fdir": {
-			"version": "6.5.0",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=12.0.0"
-			},
-			"peerDependencies": {
-				"picomatch": "^3 || ^4"
-			},
-			"peerDependenciesMeta": {
-				"picomatch": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/file-selector": {
-			"version": "0.5.0",
-			"resolved": "https://registry.npmjs.org/file-selector/-/file-selector-0.5.0.tgz",
-			"integrity": "sha512-s8KNnmIDTBoD0p9uJ9uD0XY38SCeBOtj0UMXyQSLg1Ypfrfj8+dAvwsLjYQkQ2GjhVtp2HrnF5cJzMhBjfD8HA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"tslib": "^2.0.3"
-			},
-			"engines": {
-				"node": ">= 10"
-			}
-		},
-		"node_modules/fill-range": {
-			"version": "7.1.1",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"to-regex-range": "^5.0.1"
-			},
-			"engines": {
-				"node": ">=8"
-			}
-		},
-		"node_modules/filter-obj": {
-			"version": "5.1.0",
-			"resolved": "https://registry.npmjs.org/filter-obj/-/filter-obj-5.1.0.tgz",
-			"integrity": "sha512-qWeTREPoT7I0bifpPUXtxkZJ1XJzxWtfoWWkdVGqa+eCr3SHW/Ocp89o8vLvbUuQnadybJpjOKu4V+RwO6sGng==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=14.16"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
-		"node_modules/find-root": {
-			"version": "1.1.0",
-			"resolved": "https://registry.npmjs.org/find-root/-/find-root-1.1.0.tgz",
-			"integrity": "sha512-NKfW6bec6GfKc0SGx1e07QZY9PE99u0Bft/0rzSD5k3sO/vwkVUpDUKVm5Gpp5Ue3YfShPFTX2070tDs5kB9Ng==",
-			"license": "MIT"
-		},
-		"node_modules/for-in": {
-			"version": "1.0.2",
-			"resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz",
-			"integrity": "sha512-7EwmXrOjyL+ChxMhmG5lnW9MPt1aIeZEwKhQzoBUdTV0N3zuwWDZYVJatDvZ2OyzPUvdIAZDsCetk3coyMfcnQ==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/fraction.js": {
-			"version": "5.3.4",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": "*"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/rawify"
-			}
-		},
-		"node_modules/framer-motion": {
-			"version": "12.34.3",
-			"resolved": "https://registry.npmjs.org/framer-motion/-/framer-motion-12.34.3.tgz",
-			"integrity": "sha512-v81ecyZKYO/DfpTwHivqkxSUBzvceOpoI+wLfgCgoUIKxlFKEXdg0oR9imxwXumT4SFy8vRk9xzJ5l3/Du/55Q==",
-			"license": "MIT",
-			"dependencies": {
-				"motion-dom": "^12.34.3",
-				"motion-utils": "^12.29.2",
-				"tslib": "^2.4.0"
-			},
-			"peerDependencies": {
-				"@emotion/is-prop-valid": "*",
-				"react": "^18.0.0 || ^19.0.0",
-				"react-dom": "^18.0.0 || ^19.0.0"
-			},
-			"peerDependenciesMeta": {
-				"@emotion/is-prop-valid": {
-					"optional": true
-				},
-				"react": {
-					"optional": true
-				},
-				"react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/fsevents": {
-			"version": "2.3.3",
-			"dev": true,
-			"license": "MIT",
-			"optional": true,
-			"os": [
-				"darwin"
-			],
-			"engines": {
-				"node": "^8.16.0 || ^10.6.0 || >=11.0.0"
-			}
-		},
-		"node_modules/function-bind": {
-			"version": "1.1.2",
-			"license": "MIT",
-			"funding": {
-				"url": "https://github.com/sponsors/ljharb"
-			}
-		},
-		"node_modules/gensync": {
-			"version": "1.0.0-beta.2",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=6.9.0"
-			}
-		},
-		"node_modules/get-east-asian-width": {
-			"version": "1.5.0",
-			"resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.5.0.tgz",
-			"integrity": "sha512-CQ+bEO+Tva/qlmw24dCejulK5pMzVnUOFOijVogd3KQs07HnRIgp8TGipvCCRT06xeYEbpbgwaCxglFyiuIcmA==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=18"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
-		"node_modules/get-nonce": {
-			"version": "1.0.1",
-			"resolved": "https://registry.npmjs.org/get-nonce/-/get-nonce-1.0.1.tgz",
-			"integrity": "sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q==",
-			"license": "MIT",
-			"engines": {
-				"node": ">=6"
-			}
-		},
-		"node_modules/get-value": {
-			"version": "2.0.6",
-			"resolved": "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz",
-			"integrity": "sha512-Ln0UQDlxH1BapMu3GPtf7CuYNwRZf2gwCuPqbyG6pB8WfmFpzqcy4xtAaAMUhnNqjMKTiCPZG2oMT3YSx8U2NA==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/giscus": {
-			"version": "1.6.0",
-			"resolved": "https://registry.npmjs.org/giscus/-/giscus-1.6.0.tgz",
-			"integrity": "sha512-Zrsi8r4t1LVW950keaWcsURuZUQwUaMKjvJgTCY125vkW6OiEBkatE7ScJDbpqKHdZwb///7FVC21SE3iFK3PQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"lit": "^3.2.1"
-			}
-		},
-		"node_modules/glob-parent": {
-			"version": "6.0.2",
-			"dev": true,
-			"license": "ISC",
-			"dependencies": {
-				"is-glob": "^4.0.3"
-			},
-			"engines": {
-				"node": ">=10.13.0"
-			}
-		},
-		"node_modules/goober": {
-			"version": "2.1.18",
-			"license": "MIT",
-			"peerDependencies": {
-				"csstype": "^3.0.10"
-			}
-		},
-		"node_modules/graphology": {
-			"version": "0.26.0",
-			"resolved": "https://registry.npmjs.org/graphology/-/graphology-0.26.0.tgz",
-			"integrity": "sha512-8SSImzgUUYC89Z042s+0r/vMibY7GX/Emz4LDO5e7jYXhuoWfHISPFJYjpRLUSJGq6UQ6xlenvX1p/hJdfXuXg==",
-			"license": "MIT",
-			"dependencies": {
-				"events": "^3.3.0"
-			},
-			"peerDependencies": {
-				"graphology-types": ">=0.24.0"
-			}
-		},
-		"node_modules/graphology-layout-forceatlas2": {
-			"version": "0.10.1",
-			"resolved": "https://registry.npmjs.org/graphology-layout-forceatlas2/-/graphology-layout-forceatlas2-0.10.1.tgz",
-			"integrity": "sha512-ogzBeF1FvWzjkikrIFwxhlZXvD2+wlY54lqhsrWprcdPjopM2J9HoMweUmIgwaTvY4bUYVimpSsOdvDv1gPRFQ==",
-			"license": "MIT",
-			"dependencies": {
-				"graphology-utils": "^2.1.0"
-			},
-			"peerDependencies": {
-				"graphology-types": ">=0.19.0"
-			}
-		},
-		"node_modules/graphology-types": {
-			"version": "0.24.8",
-			"resolved": "https://registry.npmjs.org/graphology-types/-/graphology-types-0.24.8.tgz",
-			"integrity": "sha512-hDRKYXa8TsoZHjgEaysSRyPdT6uB78Ci8WnjgbStlQysz7xR52PInxNsmnB7IBOM1BhikxkNyCVEFgmPKnpx3Q==",
-			"license": "MIT"
-		},
-		"node_modules/graphology-utils": {
-			"version": "2.5.2",
-			"resolved": "https://registry.npmjs.org/graphology-utils/-/graphology-utils-2.5.2.tgz",
-			"integrity": "sha512-ckHg8MXrXJkOARk56ZaSCM1g1Wihe2d6iTmz1enGOz4W/l831MBCKSayeFQfowgF8wd+PQ4rlch/56Vs/VZLDQ==",
-			"license": "MIT",
-			"peerDependencies": {
-				"graphology-types": ">=0.23.0"
-			}
-		},
-		"node_modules/hachure-fill": {
-			"version": "0.5.2",
-			"resolved": "https://registry.npmjs.org/hachure-fill/-/hachure-fill-0.5.2.tgz",
-			"integrity": "sha512-3GKBOn+m2LX9iq+JC1064cSFprJY4jL1jCXTcpnfER5HYE2l/4EfWSGzkPa/ZDBmYI0ZOEj5VHV/eKnPGkHuOg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/hasown": {
-			"version": "2.0.2",
-			"license": "MIT",
-			"dependencies": {
-				"function-bind": "^1.1.2"
-			},
-			"engines": {
-				"node": ">= 0.4"
-			}
-		},
-		"node_modules/hast-util-from-dom": {
-			"version": "5.0.1",
-			"resolved": "https://registry.npmjs.org/hast-util-from-dom/-/hast-util-from-dom-5.0.1.tgz",
-			"integrity": "sha512-N+LqofjR2zuzTjCPzyDUdSshy4Ma6li7p/c3pA78uTwzFgENbgbUrm2ugwsOdcjI1muO+o6Dgzp9p8WHtn/39Q==",
-			"license": "ISC",
-			"peer": true,
-			"dependencies": {
-				"@types/hast": "^3.0.0",
-				"hastscript": "^9.0.0",
-				"web-namespaces": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/hast-util-from-html": {
-			"version": "2.0.3",
-			"resolved": "https://registry.npmjs.org/hast-util-from-html/-/hast-util-from-html-2.0.3.tgz",
-			"integrity": "sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/hast": "^3.0.0",
-				"devlop": "^1.1.0",
-				"hast-util-from-parse5": "^8.0.0",
-				"parse5": "^7.0.0",
-				"vfile": "^6.0.0",
-				"vfile-message": "^4.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/hast-util-from-html-isomorphic": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/hast-util-from-html-isomorphic/-/hast-util-from-html-isomorphic-2.0.0.tgz",
-			"integrity": "sha512-zJfpXq44yff2hmE0XmwEOzdWin5xwH+QIhMLOScpX91e/NSGPsAzNCvLQDIEPyO2TXi+lBmU6hjLIhV8MwP2kw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/hast": "^3.0.0",
-				"hast-util-from-dom": "^5.0.0",
-				"hast-util-from-html": "^2.0.0",
-				"unist-util-remove-position": "^5.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/hast-util-from-parse5": {
-			"version": "8.0.3",
-			"resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-8.0.3.tgz",
-			"integrity": "sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/hast": "^3.0.0",
-				"@types/unist": "^3.0.0",
-				"devlop": "^1.0.0",
-				"hastscript": "^9.0.0",
-				"property-information": "^7.0.0",
-				"vfile": "^6.0.0",
-				"vfile-location": "^5.0.0",
-				"web-namespaces": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/hast-util-is-element": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/hast-util-is-element/-/hast-util-is-element-3.0.0.tgz",
-			"integrity": "sha512-Val9mnv2IWpLbNPqc/pUem+a7Ipj2aHacCwgNfTiK0vJKl0LF+4Ba4+v1oPHFpf3bLYmreq0/l3Gud9S5OH42g==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/hast": "^3.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/hast-util-parse-selector": {
-			"version": "4.0.0",
-			"resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz",
-			"integrity": "sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/hast": "^3.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/hast-util-raw": {
-			"version": "9.1.0",
-			"resolved": "https://registry.npmjs.org/hast-util-raw/-/hast-util-raw-9.1.0.tgz",
-			"integrity": "sha512-Y8/SBAHkZGoNkpzqqfCldijcuUKh7/su31kEBp67cFY09Wy0mTRgtsLYsiIxMJxlu0f6AA5SUTbDR8K0rxnbUw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/hast": "^3.0.0",
-				"@types/unist": "^3.0.0",
-				"@ungap/structured-clone": "^1.0.0",
-				"hast-util-from-parse5": "^8.0.0",
-				"hast-util-to-parse5": "^8.0.0",
-				"html-void-elements": "^3.0.0",
-				"mdast-util-to-hast": "^13.0.0",
-				"parse5": "^7.0.0",
-				"unist-util-position": "^5.0.0",
-				"unist-util-visit": "^5.0.0",
-				"vfile": "^6.0.0",
-				"web-namespaces": "^2.0.0",
-				"zwitch": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/hast-util-to-estree": {
-			"version": "3.1.3",
-			"resolved": "https://registry.npmjs.org/hast-util-to-estree/-/hast-util-to-estree-3.1.3.tgz",
-			"integrity": "sha512-48+B/rJWAp0jamNbAAf9M7Uf//UVqAoMmgXhBdxTDJLGKY+LRnZ99qcG+Qjl5HfMpYNzS5v4EAwVEF34LeAj7w==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree": "^1.0.0",
-				"@types/estree-jsx": "^1.0.0",
-				"@types/hast": "^3.0.0",
-				"comma-separated-tokens": "^2.0.0",
-				"devlop": "^1.0.0",
-				"estree-util-attach-comments": "^3.0.0",
-				"estree-util-is-identifier-name": "^3.0.0",
-				"hast-util-whitespace": "^3.0.0",
-				"mdast-util-mdx-expression": "^2.0.0",
-				"mdast-util-mdx-jsx": "^3.0.0",
-				"mdast-util-mdxjs-esm": "^2.0.0",
-				"property-information": "^7.0.0",
-				"space-separated-tokens": "^2.0.0",
-				"style-to-js": "^1.0.0",
-				"unist-util-position": "^5.0.0",
-				"zwitch": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/hast-util-to-html": {
-			"version": "9.0.5",
-			"resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-9.0.5.tgz",
-			"integrity": "sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/hast": "^3.0.0",
-				"@types/unist": "^3.0.0",
-				"ccount": "^2.0.0",
-				"comma-separated-tokens": "^2.0.0",
-				"hast-util-whitespace": "^3.0.0",
-				"html-void-elements": "^3.0.0",
-				"mdast-util-to-hast": "^13.0.0",
-				"property-information": "^7.0.0",
-				"space-separated-tokens": "^2.0.0",
-				"stringify-entities": "^4.0.0",
-				"zwitch": "^2.0.4"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/hast-util-to-jsx-runtime": {
-			"version": "2.3.6",
-			"license": "MIT",
-			"dependencies": {
-				"@types/estree": "^1.0.0",
-				"@types/hast": "^3.0.0",
-				"@types/unist": "^3.0.0",
-				"comma-separated-tokens": "^2.0.0",
-				"devlop": "^1.0.0",
-				"estree-util-is-identifier-name": "^3.0.0",
-				"hast-util-whitespace": "^3.0.0",
-				"mdast-util-mdx-expression": "^2.0.0",
-				"mdast-util-mdx-jsx": "^3.0.0",
-				"mdast-util-mdxjs-esm": "^2.0.0",
-				"property-information": "^7.0.0",
-				"space-separated-tokens": "^2.0.0",
-				"style-to-js": "^1.0.0",
-				"unist-util-position": "^5.0.0",
-				"vfile-message": "^4.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/hast-util-to-parse5": {
-			"version": "8.0.1",
-			"resolved": "https://registry.npmjs.org/hast-util-to-parse5/-/hast-util-to-parse5-8.0.1.tgz",
-			"integrity": "sha512-MlWT6Pjt4CG9lFCjiz4BH7l9wmrMkfkJYCxFwKQic8+RTZgWPuWxwAfjJElsXkex7DJjfSJsQIt931ilUgmwdA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/hast": "^3.0.0",
-				"comma-separated-tokens": "^2.0.0",
-				"devlop": "^1.0.0",
-				"property-information": "^7.0.0",
-				"space-separated-tokens": "^2.0.0",
-				"web-namespaces": "^2.0.0",
-				"zwitch": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/hast-util-to-text": {
-			"version": "4.0.2",
-			"resolved": "https://registry.npmjs.org/hast-util-to-text/-/hast-util-to-text-4.0.2.tgz",
-			"integrity": "sha512-KK6y/BN8lbaq654j7JgBydev7wuNMcID54lkRav1P0CaE1e47P72AWWPiGKXTJU271ooYzcvTAn/Zt0REnvc7A==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/hast": "^3.0.0",
-				"@types/unist": "^3.0.0",
-				"hast-util-is-element": "^3.0.0",
-				"unist-util-find-after": "^5.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/hast-util-whitespace": {
-			"version": "3.0.0",
-			"license": "MIT",
-			"dependencies": {
-				"@types/hast": "^3.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/hastscript": {
-			"version": "9.0.1",
-			"resolved": "https://registry.npmjs.org/hastscript/-/hastscript-9.0.1.tgz",
-			"integrity": "sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/hast": "^3.0.0",
-				"comma-separated-tokens": "^2.0.0",
-				"hast-util-parse-selector": "^4.0.0",
-				"property-information": "^7.0.0",
-				"space-separated-tokens": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/hoist-non-react-statics": {
-			"version": "3.3.2",
-			"resolved": "https://registry.npmjs.org/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz",
-			"integrity": "sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==",
-			"license": "BSD-3-Clause",
-			"dependencies": {
-				"react-is": "^16.7.0"
-			}
-		},
-		"node_modules/hoist-non-react-statics/node_modules/react-is": {
-			"version": "16.13.1",
-			"resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
-			"integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
-			"license": "MIT"
-		},
-		"node_modules/html-url-attributes": {
-			"version": "3.0.1",
-			"license": "MIT",
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/html-void-elements": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-3.0.0.tgz",
-			"integrity": "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==",
-			"license": "MIT",
-			"peer": true,
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/iconv-lite": {
-			"version": "0.6.3",
-			"resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
-			"integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"safer-buffer": ">= 2.1.2 < 3.0.0"
-			},
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/immer": {
-			"version": "10.2.0",
-			"license": "MIT",
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/immer"
-			}
-		},
-		"node_modules/immutable": {
-			"version": "5.1.4",
-			"dev": true,
-			"license": "MIT"
-		},
-		"node_modules/import-fresh": {
-			"version": "3.3.1",
-			"resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
-			"integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
-			"license": "MIT",
-			"dependencies": {
-				"parent-module": "^1.0.0",
-				"resolve-from": "^4.0.0"
-			},
-			"engines": {
-				"node": ">=6"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
-		"node_modules/inline-style-parser": {
-			"version": "0.2.7",
-			"license": "MIT"
-		},
-		"node_modules/internmap": {
-			"version": "2.0.3",
-			"license": "ISC",
-			"engines": {
-				"node": ">=12"
-			}
-		},
-		"node_modules/intersection-observer": {
-			"version": "0.12.2",
-			"resolved": "https://registry.npmjs.org/intersection-observer/-/intersection-observer-0.12.2.tgz",
-			"integrity": "sha512-7m1vEcPCxXYI8HqnL8CKI6siDyD+eIWSwgB3DZA+ZTogxk9I4CDnj4wilt9x/+/QbHI4YG5YZNmC6458/e9Ktg==",
-			"deprecated": "The Intersection Observer polyfill is no longer needed and can safely be removed. Intersection Observer has been Baseline since 2019.",
-			"license": "Apache-2.0",
-			"peer": true
-		},
-		"node_modules/is-alphabetical": {
-			"version": "2.0.1",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/is-alphanumerical": {
-			"version": "2.0.1",
-			"license": "MIT",
-			"dependencies": {
-				"is-alphabetical": "^2.0.0",
-				"is-decimal": "^2.0.0"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/is-arrayish": {
-			"version": "0.2.1",
-			"resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
-			"integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==",
-			"license": "MIT"
-		},
-		"node_modules/is-binary-path": {
-			"version": "2.1.0",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"binary-extensions": "^2.0.0"
-			},
-			"engines": {
-				"node": ">=8"
-			}
-		},
-		"node_modules/is-core-module": {
-			"version": "2.16.1",
-			"license": "MIT",
-			"dependencies": {
-				"hasown": "^2.0.2"
-			},
-			"engines": {
-				"node": ">= 0.4"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/ljharb"
-			}
-		},
-		"node_modules/is-decimal": {
-			"version": "2.0.1",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/is-extendable": {
-			"version": "1.0.1",
-			"resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
-			"integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"is-plain-object": "^2.0.4"
-			},
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/is-extglob": {
-			"version": "2.1.1",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/is-glob": {
-			"version": "4.0.3",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"is-extglob": "^2.1.1"
-			},
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/is-hexadecimal": {
-			"version": "2.0.1",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/is-mobile": {
-			"version": "5.0.0",
-			"resolved": "https://registry.npmjs.org/is-mobile/-/is-mobile-5.0.0.tgz",
-			"integrity": "sha512-Tz/yndySvLAEXh+Uk8liFCxOwVH6YutuR74utvOcu7I9Di+DwM0mtdPVZNaVvvBUM2OXxne/NhOs1zAO7riusQ==",
-			"license": "MIT"
-		},
-		"node_modules/is-number": {
-			"version": "7.0.0",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=0.12.0"
-			}
-		},
-		"node_modules/is-plain-obj": {
-			"version": "4.1.0",
-			"license": "MIT",
-			"engines": {
-				"node": ">=12"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
-		"node_modules/is-plain-object": {
-			"version": "2.0.4",
-			"resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz",
-			"integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"isobject": "^3.0.1"
-			},
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/isbot": {
-			"version": "5.1.35",
-			"license": "Unlicense",
-			"engines": {
-				"node": ">=18"
-			}
-		},
-		"node_modules/isobject": {
-			"version": "3.0.1",
-			"resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
-			"integrity": "sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/jiti": {
-			"version": "1.21.7",
-			"dev": true,
-			"license": "MIT",
-			"bin": {
-				"jiti": "bin/jiti.js"
-			}
-		},
-		"node_modules/js-cookie": {
-			"version": "3.0.5",
-			"resolved": "https://registry.npmjs.org/js-cookie/-/js-cookie-3.0.5.tgz",
-			"integrity": "sha512-cEiJEAEoIbWfCZYKWhVwFuvPX1gETRYPw6LlaTKoxD3s2AkXzkCjnp6h0V77ozyqj0jakteJ4YqDJT830+lVGw==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=14"
-			}
-		},
-		"node_modules/js-tokens": {
-			"version": "4.0.0",
-			"license": "MIT"
-		},
-		"node_modules/jsesc": {
-			"version": "3.1.0",
-			"license": "MIT",
-			"bin": {
-				"jsesc": "bin/jsesc"
-			},
-			"engines": {
-				"node": ">=6"
-			}
-		},
-		"node_modules/json-parse-even-better-errors": {
-			"version": "2.3.1",
-			"resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
-			"integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
-			"license": "MIT"
-		},
-		"node_modules/json2mq": {
-			"version": "0.2.0",
-			"resolved": "https://registry.npmjs.org/json2mq/-/json2mq-0.2.0.tgz",
-			"integrity": "sha512-SzoRg7ux5DWTII9J2qkrZrqV1gt+rTaoufMxEzXbS26Uid0NwaJd123HcoB80TgubEppxxIGdNxCx50fEoEWQA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"string-convert": "^0.2.0"
-			}
-		},
-		"node_modules/json5": {
-			"version": "2.2.3",
-			"dev": true,
-			"license": "MIT",
-			"bin": {
-				"json5": "lib/cli.js"
-			},
-			"engines": {
-				"node": ">=6"
-			}
-		},
-		"node_modules/katex": {
-			"version": "0.16.32",
-			"resolved": "https://registry.npmjs.org/katex/-/katex-0.16.32.tgz",
-			"integrity": "sha512-ac0FzkRJlpw4WyH3Zu/OgU9LmPKqjHr6O2BxfSrBt8uJ1BhvH2YK3oJ4ut/K+O+6qQt2MGpdbn0MrffVEnnUDQ==",
-			"funding": [
-				"https://opencollective.com/katex",
-				"https://github.com/sponsors/katex"
-			],
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"commander": "^8.3.0"
-			},
-			"bin": {
-				"katex": "cli.js"
-			}
-		},
-		"node_modules/katex/node_modules/commander": {
-			"version": "8.3.0",
-			"resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz",
-			"integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">= 12"
-			}
-		},
-		"node_modules/khroma": {
-			"version": "2.1.0",
-			"resolved": "https://registry.npmjs.org/khroma/-/khroma-2.1.0.tgz",
-			"integrity": "sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw==",
-			"peer": true
-		},
-		"node_modules/langium": {
-			"version": "4.2.1",
-			"resolved": "https://registry.npmjs.org/langium/-/langium-4.2.1.tgz",
-			"integrity": "sha512-zu9QWmjpzJcomzdJQAHgDVhLGq5bLosVak1KVa40NzQHXfqr4eAHupvnPOVXEoLkg6Ocefvf/93d//SB7du4YQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"chevrotain": "~11.1.1",
-				"chevrotain-allstar": "~0.3.1",
-				"vscode-languageserver": "~9.0.1",
-				"vscode-languageserver-textdocument": "~1.0.11",
-				"vscode-uri": "~3.1.0"
-			},
-			"engines": {
-				"node": ">=20.10.0",
-				"npm": ">=10.2.3"
-			}
-		},
-		"node_modules/layout-base": {
-			"version": "1.0.2",
-			"resolved": "https://registry.npmjs.org/layout-base/-/layout-base-1.0.2.tgz",
-			"integrity": "sha512-8h2oVEZNktL4BH2JCOI90iD1yXwL6iNW7KcCKT2QZgQJR2vbqDsldCTPRU9NifTCqHZci57XvQQ15YTu+sTYPg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/leva": {
-			"version": "0.10.1",
-			"resolved": "https://registry.npmjs.org/leva/-/leva-0.10.1.tgz",
-			"integrity": "sha512-BcjnfUX8jpmwZUz2L7AfBtF9vn4ggTH33hmeufDULbP3YgNZ/C+ss/oO3stbrqRQyaOmRwy70y7BGTGO81S3rA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@radix-ui/react-portal": "^1.1.4",
-				"@radix-ui/react-tooltip": "^1.1.8",
-				"@stitches/react": "^1.2.8",
-				"@use-gesture/react": "^10.2.5",
-				"colord": "^2.9.2",
-				"dequal": "^2.0.2",
-				"merge-value": "^1.0.0",
-				"react-colorful": "^5.5.1",
-				"react-dropzone": "^12.0.0",
-				"v8n": "^1.3.3",
-				"zustand": "^3.6.9"
-			},
-			"peerDependencies": {
-				"react": "^18.0.0 || ^19.0.0",
-				"react-dom": "^18.0.0 || ^19.0.0"
-			}
-		},
-		"node_modules/leva/node_modules/zustand": {
-			"version": "3.7.2",
-			"resolved": "https://registry.npmjs.org/zustand/-/zustand-3.7.2.tgz",
-			"integrity": "sha512-PIJDIZKtokhof+9+60cpockVOq05sJzHCriyvaLBmEJixseQ1a5Kdov6fWZfWOu5SK9c+FhH1jU0tntLxRJYMA==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=12.7.0"
-			},
-			"peerDependencies": {
-				"react": ">=16.8"
-			},
-			"peerDependenciesMeta": {
-				"react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/lilconfig": {
-			"version": "3.1.3",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=14"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/antonk52"
-			}
-		},
-		"node_modules/lines-and-columns": {
-			"version": "1.2.4",
-			"license": "MIT"
-		},
-		"node_modules/lit": {
-			"version": "3.3.2",
-			"resolved": "https://registry.npmjs.org/lit/-/lit-3.3.2.tgz",
-			"integrity": "sha512-NF9zbsP79l4ao2SNrH3NkfmFgN/hBYSQo90saIVI1o5GpjAdCPVstVzO1MrLOakHoEhYkrtRjPK6Ob521aoYWQ==",
-			"license": "BSD-3-Clause",
-			"peer": true,
-			"dependencies": {
-				"@lit/reactive-element": "^2.1.0",
-				"lit-element": "^4.2.0",
-				"lit-html": "^3.3.0"
-			}
-		},
-		"node_modules/lit-element": {
-			"version": "4.2.2",
-			"resolved": "https://registry.npmjs.org/lit-element/-/lit-element-4.2.2.tgz",
-			"integrity": "sha512-aFKhNToWxoyhkNDmWZwEva2SlQia+jfG0fjIWV//YeTaWrVnOxD89dPKfigCUspXFmjzOEUQpOkejH5Ly6sG0w==",
-			"license": "BSD-3-Clause",
-			"peer": true,
-			"dependencies": {
-				"@lit-labs/ssr-dom-shim": "^1.5.0",
-				"@lit/reactive-element": "^2.1.0",
-				"lit-html": "^3.3.0"
-			}
-		},
-		"node_modules/lit-html": {
-			"version": "3.3.2",
-			"resolved": "https://registry.npmjs.org/lit-html/-/lit-html-3.3.2.tgz",
-			"integrity": "sha512-Qy9hU88zcmaxBXcc10ZpdK7cOLXvXpRoBxERdtqV9QOrfpMZZ6pSYP91LhpPtap3sFMUiL7Tw2RImbe0Al2/kw==",
-			"license": "BSD-3-Clause",
-			"peer": true,
-			"dependencies": {
-				"@types/trusted-types": "^2.0.2"
-			}
-		},
-		"node_modules/lodash": {
-			"version": "4.17.23",
-			"resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz",
-			"integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/lodash-es": {
-			"version": "4.17.23",
-			"resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.17.23.tgz",
-			"integrity": "sha512-kVI48u3PZr38HdYz98UmfPnXl2DXrpdctLrFLCd3kOx1xUkOmpFPx7gCWWM5MPkL/fD8zb+Ph0QzjGFs4+hHWg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/longest-streak": {
-			"version": "3.1.0",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/loose-envify": {
-			"version": "1.4.0",
-			"resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
-			"integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"js-tokens": "^3.0.0 || ^4.0.0"
-			},
-			"bin": {
-				"loose-envify": "cli.js"
-			}
-		},
-		"node_modules/lru_map": {
-			"version": "0.4.1",
-			"resolved": "https://registry.npmjs.org/lru_map/-/lru_map-0.4.1.tgz",
-			"integrity": "sha512-I+lBvqMMFfqaV8CJCISjI3wbjmwVu/VyOoU7+qtu9d7ioW5klMgsTTiUOUp+DJvfTTzKXoPbyC6YfgkNcyPSOg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/lru-cache": {
-			"version": "5.1.1",
-			"dev": true,
-			"license": "ISC",
-			"dependencies": {
-				"yallist": "^3.0.2"
-			}
-		},
-		"node_modules/lucide-react": {
-			"version": "0.562.0",
-			"resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.562.0.tgz",
-			"integrity": "sha512-82hOAu7y0dbVuFfmO4bYF1XEwYk/mEbM5E+b1jgci/udUBEE/R7LF5Ip0CCEmXe8AybRM8L+04eP+LGZeDvkiw==",
-			"license": "ISC",
-			"peer": true,
-			"peerDependencies": {
-				"react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-			}
-		},
-		"node_modules/markdown-extensions": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/markdown-extensions/-/markdown-extensions-2.0.0.tgz",
-			"integrity": "sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=16"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
-		"node_modules/markdown-table": {
-			"version": "3.0.4",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/marked": {
-			"version": "17.0.3",
-			"resolved": "https://registry.npmjs.org/marked/-/marked-17.0.3.tgz",
-			"integrity": "sha512-jt1v2ObpyOKR8p4XaUJVk3YWRJ5n+i4+rjQopxvV32rSndTJXvIzuUdWWIy/1pFQMkQmvTXawzDNqOH/CUmx6A==",
-			"license": "MIT",
-			"peer": true,
-			"bin": {
-				"marked": "bin/marked.js"
-			},
-			"engines": {
-				"node": ">= 20"
-			}
-		},
-		"node_modules/mdast-util-find-and-replace": {
-			"version": "3.0.2",
-			"license": "MIT",
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"escape-string-regexp": "^5.0.0",
-				"unist-util-is": "^6.0.0",
-				"unist-util-visit-parents": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-from-markdown": {
-			"version": "2.0.2",
-			"license": "MIT",
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"@types/unist": "^3.0.0",
-				"decode-named-character-reference": "^1.0.0",
-				"devlop": "^1.0.0",
-				"mdast-util-to-string": "^4.0.0",
-				"micromark": "^4.0.0",
-				"micromark-util-decode-numeric-character-reference": "^2.0.0",
-				"micromark-util-decode-string": "^2.0.0",
-				"micromark-util-normalize-identifier": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0",
-				"unist-util-stringify-position": "^4.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-gfm": {
-			"version": "3.1.0",
-			"license": "MIT",
-			"dependencies": {
-				"mdast-util-from-markdown": "^2.0.0",
-				"mdast-util-gfm-autolink-literal": "^2.0.0",
-				"mdast-util-gfm-footnote": "^2.0.0",
-				"mdast-util-gfm-strikethrough": "^2.0.0",
-				"mdast-util-gfm-table": "^2.0.0",
-				"mdast-util-gfm-task-list-item": "^2.0.0",
-				"mdast-util-to-markdown": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-gfm-autolink-literal": {
-			"version": "2.0.1",
-			"license": "MIT",
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"ccount": "^2.0.0",
-				"devlop": "^1.0.0",
-				"mdast-util-find-and-replace": "^3.0.0",
-				"micromark-util-character": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-gfm-footnote": {
-			"version": "2.1.0",
-			"license": "MIT",
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"devlop": "^1.1.0",
-				"mdast-util-from-markdown": "^2.0.0",
-				"mdast-util-to-markdown": "^2.0.0",
-				"micromark-util-normalize-identifier": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-gfm-strikethrough": {
-			"version": "2.0.0",
-			"license": "MIT",
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"mdast-util-from-markdown": "^2.0.0",
-				"mdast-util-to-markdown": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-gfm-table": {
-			"version": "2.0.0",
-			"license": "MIT",
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"devlop": "^1.0.0",
-				"markdown-table": "^3.0.0",
-				"mdast-util-from-markdown": "^2.0.0",
-				"mdast-util-to-markdown": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-gfm-task-list-item": {
-			"version": "2.0.0",
-			"license": "MIT",
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"devlop": "^1.0.0",
-				"mdast-util-from-markdown": "^2.0.0",
-				"mdast-util-to-markdown": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-math": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/mdast-util-math/-/mdast-util-math-3.0.0.tgz",
-			"integrity": "sha512-Tl9GBNeG/AhJnQM221bJR2HPvLOSnLE/T9cJI9tlc6zwQk2nPk/4f0cHkOdEixQPC/j8UtKDdITswvLAy1OZ1w==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/hast": "^3.0.0",
-				"@types/mdast": "^4.0.0",
-				"devlop": "^1.0.0",
-				"longest-streak": "^3.0.0",
-				"mdast-util-from-markdown": "^2.0.0",
-				"mdast-util-to-markdown": "^2.1.0",
-				"unist-util-remove-position": "^5.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-mdx": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/mdast-util-mdx/-/mdast-util-mdx-3.0.0.tgz",
-			"integrity": "sha512-JfbYLAW7XnYTTbUsmpu0kdBUVe+yKVJZBItEjwyYJiDJuZ9w4eeaqks4HQO+R7objWgS2ymV60GYpI14Ug554w==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"mdast-util-from-markdown": "^2.0.0",
-				"mdast-util-mdx-expression": "^2.0.0",
-				"mdast-util-mdx-jsx": "^3.0.0",
-				"mdast-util-mdxjs-esm": "^2.0.0",
-				"mdast-util-to-markdown": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-mdx-expression": {
-			"version": "2.0.1",
-			"license": "MIT",
-			"dependencies": {
-				"@types/estree-jsx": "^1.0.0",
-				"@types/hast": "^3.0.0",
-				"@types/mdast": "^4.0.0",
-				"devlop": "^1.0.0",
-				"mdast-util-from-markdown": "^2.0.0",
-				"mdast-util-to-markdown": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-mdx-jsx": {
-			"version": "3.2.0",
-			"license": "MIT",
-			"dependencies": {
-				"@types/estree-jsx": "^1.0.0",
-				"@types/hast": "^3.0.0",
-				"@types/mdast": "^4.0.0",
-				"@types/unist": "^3.0.0",
-				"ccount": "^2.0.0",
-				"devlop": "^1.1.0",
-				"mdast-util-from-markdown": "^2.0.0",
-				"mdast-util-to-markdown": "^2.0.0",
-				"parse-entities": "^4.0.0",
-				"stringify-entities": "^4.0.0",
-				"unist-util-stringify-position": "^4.0.0",
-				"vfile-message": "^4.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-mdxjs-esm": {
-			"version": "2.0.1",
-			"license": "MIT",
-			"dependencies": {
-				"@types/estree-jsx": "^1.0.0",
-				"@types/hast": "^3.0.0",
-				"@types/mdast": "^4.0.0",
-				"devlop": "^1.0.0",
-				"mdast-util-from-markdown": "^2.0.0",
-				"mdast-util-to-markdown": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-newline-to-break": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/mdast-util-newline-to-break/-/mdast-util-newline-to-break-2.0.0.tgz",
-			"integrity": "sha512-MbgeFca0hLYIEx/2zGsszCSEJJ1JSCdiY5xQxRcLDDGa8EPvlLPupJ4DSajbMPAnC0je8jfb9TiUATnxxrHUog==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"mdast-util-find-and-replace": "^3.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-phrasing": {
-			"version": "4.1.0",
-			"license": "MIT",
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"unist-util-is": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-to-hast": {
-			"version": "13.2.1",
-			"license": "MIT",
-			"dependencies": {
-				"@types/hast": "^3.0.0",
-				"@types/mdast": "^4.0.0",
-				"@ungap/structured-clone": "^1.0.0",
-				"devlop": "^1.0.0",
-				"micromark-util-sanitize-uri": "^2.0.0",
-				"trim-lines": "^3.0.0",
-				"unist-util-position": "^5.0.0",
-				"unist-util-visit": "^5.0.0",
-				"vfile": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-to-markdown": {
-			"version": "2.1.2",
-			"license": "MIT",
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"@types/unist": "^3.0.0",
-				"longest-streak": "^3.0.0",
-				"mdast-util-phrasing": "^4.0.0",
-				"mdast-util-to-string": "^4.0.0",
-				"micromark-util-classify-character": "^2.0.0",
-				"micromark-util-decode-string": "^2.0.0",
-				"unist-util-visit": "^5.0.0",
-				"zwitch": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/mdast-util-to-string": {
-			"version": "4.0.0",
-			"license": "MIT",
-			"dependencies": {
-				"@types/mdast": "^4.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/merge-value": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/merge-value/-/merge-value-1.0.0.tgz",
-			"integrity": "sha512-fJMmvat4NeKz63Uv9iHWcPDjCWcCkoiRoajRTEO8hlhUC6rwaHg0QCF9hBOTjZmm4JuglPckPSTtcuJL5kp0TQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"get-value": "^2.0.6",
-				"is-extendable": "^1.0.0",
-				"mixin-deep": "^1.2.0",
-				"set-value": "^2.0.0"
-			},
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/merge2": {
-			"version": "1.4.1",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">= 8"
-			}
-		},
-		"node_modules/mermaid": {
-			"version": "11.12.3",
-			"resolved": "https://registry.npmjs.org/mermaid/-/mermaid-11.12.3.tgz",
-			"integrity": "sha512-wN5ZSgJQIC+CHJut9xaKWsknLxaFBwCPwPkGTSUYrTiHORWvpT8RxGk849HPnpUAQ+/9BPRqYb80jTpearrHzQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@braintree/sanitize-url": "^7.1.1",
-				"@iconify/utils": "^3.0.1",
-				"@mermaid-js/parser": "^1.0.0",
-				"@types/d3": "^7.4.3",
-				"cytoscape": "^3.29.3",
-				"cytoscape-cose-bilkent": "^4.1.0",
-				"cytoscape-fcose": "^2.2.0",
-				"d3": "^7.9.0",
-				"d3-sankey": "^0.12.3",
-				"dagre-d3-es": "7.0.13",
-				"dayjs": "^1.11.18",
-				"dompurify": "^3.2.5",
-				"katex": "^0.16.22",
-				"khroma": "^2.1.0",
-				"lodash-es": "^4.17.23",
-				"marked": "^16.2.1",
-				"roughjs": "^4.6.6",
-				"stylis": "^4.3.6",
-				"ts-dedent": "^2.2.0",
-				"uuid": "^11.1.0"
-			}
-		},
-		"node_modules/mermaid/node_modules/marked": {
-			"version": "16.4.2",
-			"resolved": "https://registry.npmjs.org/marked/-/marked-16.4.2.tgz",
-			"integrity": "sha512-TI3V8YYWvkVf3KJe1dRkpnjs68JUPyEa5vjKrp1XEEJUAOaQc+Qj+L1qWbPd0SJuAdQkFU0h73sXXqwDYxsiDA==",
-			"license": "MIT",
-			"peer": true,
-			"bin": {
-				"marked": "bin/marked.js"
-			},
-			"engines": {
-				"node": ">= 20"
-			}
-		},
-		"node_modules/mermaid/node_modules/uuid": {
-			"version": "11.1.0",
-			"resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz",
-			"integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==",
-			"funding": [
-				"https://github.com/sponsors/broofa",
-				"https://github.com/sponsors/ctavan"
-			],
-			"license": "MIT",
-			"peer": true,
-			"bin": {
-				"uuid": "dist/esm/bin/uuid"
-			}
-		},
-		"node_modules/micromark": {
-			"version": "4.0.2",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"@types/debug": "^4.0.0",
-				"debug": "^4.0.0",
-				"decode-named-character-reference": "^1.0.0",
-				"devlop": "^1.0.0",
-				"micromark-core-commonmark": "^2.0.0",
-				"micromark-factory-space": "^2.0.0",
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-chunked": "^2.0.0",
-				"micromark-util-combine-extensions": "^2.0.0",
-				"micromark-util-decode-numeric-character-reference": "^2.0.0",
-				"micromark-util-encode": "^2.0.0",
-				"micromark-util-normalize-identifier": "^2.0.0",
-				"micromark-util-resolve-all": "^2.0.0",
-				"micromark-util-sanitize-uri": "^2.0.0",
-				"micromark-util-subtokenize": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-core-commonmark": {
-			"version": "2.0.3",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"decode-named-character-reference": "^1.0.0",
-				"devlop": "^1.0.0",
-				"micromark-factory-destination": "^2.0.0",
-				"micromark-factory-label": "^2.0.0",
-				"micromark-factory-space": "^2.0.0",
-				"micromark-factory-title": "^2.0.0",
-				"micromark-factory-whitespace": "^2.0.0",
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-chunked": "^2.0.0",
-				"micromark-util-classify-character": "^2.0.0",
-				"micromark-util-html-tag-name": "^2.0.0",
-				"micromark-util-normalize-identifier": "^2.0.0",
-				"micromark-util-resolve-all": "^2.0.0",
-				"micromark-util-subtokenize": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-extension-cjk-friendly": {
-			"version": "1.2.3",
-			"resolved": "https://registry.npmjs.org/micromark-extension-cjk-friendly/-/micromark-extension-cjk-friendly-1.2.3.tgz",
-			"integrity": "sha512-gRzVLUdjXBLX6zNPSnHGDoo+ZTp5zy+MZm0g3sv+3chPXY7l9gW+DnrcHcZh/jiPR6MjPKO4AEJNp4Aw6V9z5Q==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"devlop": "^1.1.0",
-				"micromark-extension-cjk-friendly-util": "2.1.1",
-				"micromark-util-chunked": "^2.0.1",
-				"micromark-util-resolve-all": "^2.0.1",
-				"micromark-util-symbol": "^2.0.1"
-			},
-			"engines": {
-				"node": ">=16"
-			},
-			"peerDependencies": {
-				"micromark": "^4.0.0",
-				"micromark-util-types": "^2.0.0"
-			},
-			"peerDependenciesMeta": {
-				"micromark-util-types": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/micromark-extension-cjk-friendly-util": {
-			"version": "2.1.1",
-			"resolved": "https://registry.npmjs.org/micromark-extension-cjk-friendly-util/-/micromark-extension-cjk-friendly-util-2.1.1.tgz",
-			"integrity": "sha512-egs6+12JU2yutskHY55FyR48ZiEcFOJFyk9rsiyIhcJ6IvWB6ABBqVrBw8IobqJTDZ/wdSr9eoXDPb5S2nW1bg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"get-east-asian-width": "^1.3.0",
-				"micromark-util-character": "^2.1.1",
-				"micromark-util-symbol": "^2.0.1"
-			},
-			"engines": {
-				"node": ">=16"
-			},
-			"peerDependenciesMeta": {
-				"micromark-util-types": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/micromark-extension-gfm": {
-			"version": "3.0.0",
-			"license": "MIT",
-			"dependencies": {
-				"micromark-extension-gfm-autolink-literal": "^2.0.0",
-				"micromark-extension-gfm-footnote": "^2.0.0",
-				"micromark-extension-gfm-strikethrough": "^2.0.0",
-				"micromark-extension-gfm-table": "^2.0.0",
-				"micromark-extension-gfm-tagfilter": "^2.0.0",
-				"micromark-extension-gfm-task-list-item": "^2.0.0",
-				"micromark-util-combine-extensions": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/micromark-extension-gfm-autolink-literal": {
-			"version": "2.1.0",
-			"license": "MIT",
-			"dependencies": {
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-sanitize-uri": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/micromark-extension-gfm-footnote": {
-			"version": "2.1.0",
-			"license": "MIT",
-			"dependencies": {
-				"devlop": "^1.0.0",
-				"micromark-core-commonmark": "^2.0.0",
-				"micromark-factory-space": "^2.0.0",
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-normalize-identifier": "^2.0.0",
-				"micromark-util-sanitize-uri": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/micromark-extension-gfm-strikethrough": {
-			"version": "2.1.0",
-			"license": "MIT",
-			"dependencies": {
-				"devlop": "^1.0.0",
-				"micromark-util-chunked": "^2.0.0",
-				"micromark-util-classify-character": "^2.0.0",
-				"micromark-util-resolve-all": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/micromark-extension-gfm-table": {
-			"version": "2.1.1",
-			"license": "MIT",
-			"dependencies": {
-				"devlop": "^1.0.0",
-				"micromark-factory-space": "^2.0.0",
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/micromark-extension-gfm-tagfilter": {
-			"version": "2.0.0",
-			"license": "MIT",
-			"dependencies": {
-				"micromark-util-types": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/micromark-extension-gfm-task-list-item": {
-			"version": "2.1.0",
-			"license": "MIT",
-			"dependencies": {
-				"devlop": "^1.0.0",
-				"micromark-factory-space": "^2.0.0",
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/micromark-extension-math": {
-			"version": "3.1.0",
-			"resolved": "https://registry.npmjs.org/micromark-extension-math/-/micromark-extension-math-3.1.0.tgz",
-			"integrity": "sha512-lvEqd+fHjATVs+2v/8kg9i5Q0AP2k85H0WUOwpIVvUML8BapsMvh1XAogmQjOCsLpoKRCVQqEkQBB3NhVBcsOg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/katex": "^0.16.0",
-				"devlop": "^1.0.0",
-				"katex": "^0.16.0",
-				"micromark-factory-space": "^2.0.0",
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/micromark-extension-mdx-expression": {
-			"version": "3.0.1",
-			"resolved": "https://registry.npmjs.org/micromark-extension-mdx-expression/-/micromark-extension-mdx-expression-3.0.1.tgz",
-			"integrity": "sha512-dD/ADLJ1AeMvSAKBwO22zG22N4ybhe7kFIZ3LsDI0GlsNr2A3KYxb0LdC1u5rj4Nw+CHKY0RVdnHX8vj8ejm4Q==",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree": "^1.0.0",
-				"devlop": "^1.0.0",
-				"micromark-factory-mdx-expression": "^2.0.0",
-				"micromark-factory-space": "^2.0.0",
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-events-to-acorn": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-extension-mdx-jsx": {
-			"version": "3.0.2",
-			"resolved": "https://registry.npmjs.org/micromark-extension-mdx-jsx/-/micromark-extension-mdx-jsx-3.0.2.tgz",
-			"integrity": "sha512-e5+q1DjMh62LZAJOnDraSSbDMvGJ8x3cbjygy2qFEi7HCeUT4BDKCvMozPozcD6WmOt6sVvYDNBKhFSz3kjOVQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree": "^1.0.0",
-				"devlop": "^1.0.0",
-				"estree-util-is-identifier-name": "^3.0.0",
-				"micromark-factory-mdx-expression": "^2.0.0",
-				"micromark-factory-space": "^2.0.0",
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-events-to-acorn": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0",
-				"vfile-message": "^4.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/micromark-extension-mdx-md": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/micromark-extension-mdx-md/-/micromark-extension-mdx-md-2.0.0.tgz",
-			"integrity": "sha512-EpAiszsB3blw4Rpba7xTOUptcFeBFi+6PY8VnJ2hhimH+vCQDirWgsMpz7w1XcZE7LVrSAUGb9VJpG9ghlYvYQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"micromark-util-types": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/micromark-extension-mdxjs": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/micromark-extension-mdxjs/-/micromark-extension-mdxjs-3.0.0.tgz",
-			"integrity": "sha512-A873fJfhnJ2siZyUrJ31l34Uqwy4xIFmvPY1oj+Ean5PHcPBYzEsvqvWGaWcfEIr11O5Dlw3p2y0tZWpKHDejQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"acorn": "^8.0.0",
-				"acorn-jsx": "^5.0.0",
-				"micromark-extension-mdx-expression": "^3.0.0",
-				"micromark-extension-mdx-jsx": "^3.0.0",
-				"micromark-extension-mdx-md": "^2.0.0",
-				"micromark-extension-mdxjs-esm": "^3.0.0",
-				"micromark-util-combine-extensions": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/micromark-extension-mdxjs-esm": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/micromark-extension-mdxjs-esm/-/micromark-extension-mdxjs-esm-3.0.0.tgz",
-			"integrity": "sha512-DJFl4ZqkErRpq/dAPyeWp15tGrcrrJho1hKK5uBS70BCtfrIFg81sqcTVu3Ta+KD1Tk5vAtBNElWxtAa+m8K9A==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree": "^1.0.0",
-				"devlop": "^1.0.0",
-				"micromark-core-commonmark": "^2.0.0",
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-events-to-acorn": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0",
-				"unist-util-position-from-estree": "^2.0.0",
-				"vfile-message": "^4.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/micromark-factory-destination": {
-			"version": "2.0.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-factory-label": {
-			"version": "2.0.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"devlop": "^1.0.0",
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-factory-mdx-expression": {
-			"version": "2.0.3",
-			"resolved": "https://registry.npmjs.org/micromark-factory-mdx-expression/-/micromark-factory-mdx-expression-2.0.3.tgz",
-			"integrity": "sha512-kQnEtA3vzucU2BkrIa8/VaSAsP+EJ3CKOvhMuJgOEGg9KDC6OAY6nSnNDVRiVNRqj7Y4SlSzcStaH/5jge8JdQ==",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree": "^1.0.0",
-				"devlop": "^1.0.0",
-				"micromark-factory-space": "^2.0.0",
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-events-to-acorn": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0",
-				"unist-util-position-from-estree": "^2.0.0",
-				"vfile-message": "^4.0.0"
-			}
-		},
-		"node_modules/micromark-factory-space": {
-			"version": "2.0.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-factory-title": {
-			"version": "2.0.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"micromark-factory-space": "^2.0.0",
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-factory-whitespace": {
-			"version": "2.0.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"micromark-factory-space": "^2.0.0",
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-util-character": {
-			"version": "2.1.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-util-chunked": {
-			"version": "2.0.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"micromark-util-symbol": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-util-classify-character": {
-			"version": "2.0.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-util-combine-extensions": {
-			"version": "2.0.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"micromark-util-chunked": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-util-decode-numeric-character-reference": {
-			"version": "2.0.2",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"micromark-util-symbol": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-util-decode-string": {
-			"version": "2.0.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"decode-named-character-reference": "^1.0.0",
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-decode-numeric-character-reference": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-util-encode": {
-			"version": "2.0.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT"
-		},
-		"node_modules/micromark-util-events-to-acorn": {
-			"version": "2.0.3",
-			"resolved": "https://registry.npmjs.org/micromark-util-events-to-acorn/-/micromark-util-events-to-acorn-2.0.3.tgz",
-			"integrity": "sha512-jmsiEIiZ1n7X1Rr5k8wVExBQCg5jy4UXVADItHmNk1zkwEVhBuIUKRu3fqv+hs4nxLISi2DQGlqIOGiFxgbfHg==",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree": "^1.0.0",
-				"@types/unist": "^3.0.0",
-				"devlop": "^1.0.0",
-				"estree-util-visit": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0",
-				"vfile-message": "^4.0.0"
-			}
-		},
-		"node_modules/micromark-util-html-tag-name": {
-			"version": "2.0.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT"
-		},
-		"node_modules/micromark-util-normalize-identifier": {
-			"version": "2.0.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"micromark-util-symbol": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-util-resolve-all": {
-			"version": "2.0.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"micromark-util-types": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-util-sanitize-uri": {
-			"version": "2.0.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"micromark-util-character": "^2.0.0",
-				"micromark-util-encode": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-util-subtokenize": {
-			"version": "2.1.0",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"devlop": "^1.0.0",
-				"micromark-util-chunked": "^2.0.0",
-				"micromark-util-symbol": "^2.0.0",
-				"micromark-util-types": "^2.0.0"
-			}
-		},
-		"node_modules/micromark-util-symbol": {
-			"version": "2.0.1",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT"
-		},
-		"node_modules/micromark-util-types": {
-			"version": "2.0.2",
-			"funding": [
-				{
-					"type": "GitHub Sponsors",
-					"url": "https://github.com/sponsors/unifiedjs"
-				},
-				{
-					"type": "OpenCollective",
-					"url": "https://opencollective.com/unified"
-				}
-			],
-			"license": "MIT"
-		},
-		"node_modules/micromatch": {
-			"version": "4.0.8",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"braces": "^3.0.3",
-				"picomatch": "^2.3.1"
-			},
-			"engines": {
-				"node": ">=8.6"
-			}
-		},
-		"node_modules/micromatch/node_modules/picomatch": {
-			"version": "2.3.1",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=8.6"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/jonschlinkert"
-			}
-		},
-		"node_modules/mixin-deep": {
-			"version": "1.3.2",
-			"resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz",
-			"integrity": "sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"for-in": "^1.0.2",
-				"is-extendable": "^1.0.1"
-			},
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/mlly": {
-			"version": "1.8.0",
-			"resolved": "https://registry.npmjs.org/mlly/-/mlly-1.8.0.tgz",
-			"integrity": "sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"acorn": "^8.15.0",
-				"pathe": "^2.0.3",
-				"pkg-types": "^1.3.1",
-				"ufo": "^1.6.1"
-			}
-		},
-		"node_modules/motion": {
-			"version": "12.34.3",
-			"resolved": "https://registry.npmjs.org/motion/-/motion-12.34.3.tgz",
-			"integrity": "sha512-xZIkBGO7v/Uvm+EyaqYd+9IpXu0sZqLywVlGdCFrrMiaO9JI4Kx51mO9KlHSWwll+gZUVY5OJsWgYI5FywJ/tw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"framer-motion": "^12.34.3",
-				"tslib": "^2.4.0"
-			},
-			"peerDependencies": {
-				"@emotion/is-prop-valid": "*",
-				"react": "^18.0.0 || ^19.0.0",
-				"react-dom": "^18.0.0 || ^19.0.0"
-			},
-			"peerDependenciesMeta": {
-				"@emotion/is-prop-valid": {
-					"optional": true
-				},
-				"react": {
-					"optional": true
-				},
-				"react-dom": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/motion-dom": {
-			"version": "12.34.3",
-			"resolved": "https://registry.npmjs.org/motion-dom/-/motion-dom-12.34.3.tgz",
-			"integrity": "sha512-sYgFe+pR9aIM7o4fhs2aXtOI+oqlUd33N9Yoxcgo1Fv7M20sRkHtCmzE/VRNIcq7uNJ+qio+Xubt1FXH3pQ+eQ==",
-			"license": "MIT",
-			"dependencies": {
-				"motion-utils": "^12.29.2"
-			}
-		},
-		"node_modules/motion-utils": {
-			"version": "12.29.2",
-			"resolved": "https://registry.npmjs.org/motion-utils/-/motion-utils-12.29.2.tgz",
-			"integrity": "sha512-G3kc34H2cX2gI63RqU+cZq+zWRRPSsNIOjpdl9TN4AQwC4sgwYPl/Q/Obf/d53nOm569T0fYK+tcoSV50BWx8A==",
-			"license": "MIT"
-		},
-		"node_modules/ms": {
-			"version": "2.1.3",
-			"license": "MIT"
-		},
-		"node_modules/mz": {
-			"version": "2.7.0",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"any-promise": "^1.0.0",
-				"object-assign": "^4.0.1",
-				"thenify-all": "^1.0.0"
-			}
-		},
-		"node_modules/nanoid": {
-			"version": "3.3.11",
-			"dev": true,
-			"funding": [
-				{
-					"type": "github",
-					"url": "https://github.com/sponsors/ai"
-				}
-			],
-			"license": "MIT",
-			"bin": {
-				"nanoid": "bin/nanoid.cjs"
-			},
-			"engines": {
-				"node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
-			}
-		},
-		"node_modules/node-addon-api": {
-			"version": "7.1.1",
-			"dev": true,
-			"license": "MIT",
-			"optional": true
-		},
-		"node_modules/node-releases": {
-			"version": "2.0.27",
-			"dev": true,
-			"license": "MIT"
-		},
-		"node_modules/normalize-path": {
-			"version": "3.0.0",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/numeral": {
-			"version": "2.0.6",
-			"resolved": "https://registry.npmjs.org/numeral/-/numeral-2.0.6.tgz",
-			"integrity": "sha512-qaKRmtYPZ5qdw4jWJD6bxEf1FJEqllJrwxCLIm0sQU/A7v2/czigzOb+C2uSiFsa9lBUzeH7M1oK+Q+OLxL3kA==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": "*"
-			}
-		},
-		"node_modules/object-assign": {
-			"version": "4.1.1",
-			"license": "MIT",
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/object-hash": {
-			"version": "3.0.0",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">= 6"
-			}
-		},
-		"node_modules/on-change": {
-			"version": "4.0.2",
-			"resolved": "https://registry.npmjs.org/on-change/-/on-change-4.0.2.tgz",
-			"integrity": "sha512-cMtCyuJmTx/bg2HCpHo3ZLeF7FZnBOapLqZHr2AlLeJ5Ul0Zu2mUJJz051Fdwu/Et2YW04ZD+TtU+gVy0ACNCA==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-			},
-			"funding": {
-				"url": "https://github.com/sindresorhus/on-change?sponsor=1"
-			}
-		},
-		"node_modules/oniguruma-parser": {
-			"version": "0.12.1",
-			"resolved": "https://registry.npmjs.org/oniguruma-parser/-/oniguruma-parser-0.12.1.tgz",
-			"integrity": "sha512-8Unqkvk1RYc6yq2WBYRj4hdnsAxVze8i7iPfQr8e4uSP3tRv0rpZcbGUDvxfQQcdwHt/e9PrMvGCsa8OqG9X3w==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/oniguruma-to-es": {
-			"version": "4.3.4",
-			"resolved": "https://registry.npmjs.org/oniguruma-to-es/-/oniguruma-to-es-4.3.4.tgz",
-			"integrity": "sha512-3VhUGN3w2eYxnTzHn+ikMI+fp/96KoRSVK9/kMTcFqj1NRDh2IhQCKvYxDnWePKRXY/AqH+Fuiyb7VHSzBjHfA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"oniguruma-parser": "^0.12.1",
-				"regex": "^6.0.1",
-				"regex-recursion": "^6.0.2"
-			}
-		},
-		"node_modules/package-manager-detector": {
-			"version": "1.6.0",
-			"resolved": "https://registry.npmjs.org/package-manager-detector/-/package-manager-detector-1.6.0.tgz",
-			"integrity": "sha512-61A5ThoTiDG/C8s8UMZwSorAGwMJ0ERVGj2OjoW5pAalsNOg15+iQiPzrLJ4jhZ1HJzmC2PIHT2oEiH3R5fzNA==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/parent-module": {
-			"version": "1.0.1",
-			"resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
-			"integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
-			"license": "MIT",
-			"dependencies": {
-				"callsites": "^3.0.0"
-			},
-			"engines": {
-				"node": ">=6"
-			}
-		},
-		"node_modules/parse-entities": {
-			"version": "4.0.2",
-			"license": "MIT",
-			"dependencies": {
-				"@types/unist": "^2.0.0",
-				"character-entities-legacy": "^3.0.0",
-				"character-reference-invalid": "^2.0.0",
-				"decode-named-character-reference": "^1.0.0",
-				"is-alphanumerical": "^2.0.0",
-				"is-decimal": "^2.0.0",
-				"is-hexadecimal": "^2.0.0"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/parse-entities/node_modules/@types/unist": {
-			"version": "2.0.11",
-			"license": "MIT"
-		},
-		"node_modules/parse-json": {
-			"version": "5.2.0",
-			"resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
-			"integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
-			"license": "MIT",
-			"dependencies": {
-				"@babel/code-frame": "^7.0.0",
-				"error-ex": "^1.3.1",
-				"json-parse-even-better-errors": "^2.3.0",
-				"lines-and-columns": "^1.1.6"
-			},
-			"engines": {
-				"node": ">=8"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
-		"node_modules/parse5": {
-			"version": "7.3.0",
-			"resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
-			"integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"entities": "^6.0.0"
-			},
-			"funding": {
-				"url": "https://github.com/inikulin/parse5?sponsor=1"
-			}
-		},
-		"node_modules/path-data-parser": {
-			"version": "0.1.0",
-			"resolved": "https://registry.npmjs.org/path-data-parser/-/path-data-parser-0.1.0.tgz",
-			"integrity": "sha512-NOnmBpt5Y2RWbuv0LMzsayp3lVylAHLPUTut412ZA3l+C4uw4ZVkQbjShYCQ8TCpUMdPapr4YjUqLYD6v68j+w==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/path-parse": {
-			"version": "1.0.7",
-			"license": "MIT"
-		},
-		"node_modules/path-type": {
-			"version": "4.0.0",
-			"resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
-			"integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
-			"license": "MIT",
-			"engines": {
-				"node": ">=8"
-			}
-		},
-		"node_modules/pathe": {
-			"version": "2.0.3",
-			"resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
-			"integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/picocolors": {
-			"version": "1.1.1",
-			"license": "ISC"
-		},
-		"node_modules/picomatch": {
-			"version": "4.0.3",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=12"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/jonschlinkert"
-			}
-		},
-		"node_modules/pify": {
-			"version": "2.3.0",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/pirates": {
-			"version": "4.0.7",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">= 6"
-			}
-		},
-		"node_modules/pkg-types": {
-			"version": "1.3.1",
-			"resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-1.3.1.tgz",
-			"integrity": "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"confbox": "^0.1.8",
-				"mlly": "^1.7.4",
-				"pathe": "^2.0.1"
-			}
-		},
-		"node_modules/points-on-curve": {
-			"version": "0.2.0",
-			"resolved": "https://registry.npmjs.org/points-on-curve/-/points-on-curve-0.2.0.tgz",
-			"integrity": "sha512-0mYKnYYe9ZcqMCWhUjItv/oHjvgEsfKvnUTg8sAtnHr3GVy7rGkXCb6d5cSyqrWqL4k81b9CPg3urd+T7aop3A==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/points-on-path": {
-			"version": "0.2.1",
-			"resolved": "https://registry.npmjs.org/points-on-path/-/points-on-path-0.2.1.tgz",
-			"integrity": "sha512-25ClnWWuw7JbWZcgqY/gJ4FQWadKxGWk+3kR/7kD0tCaDtPPMj7oHu2ToLaVhfpnHrZzYby2w6tUA0eOIuUg8g==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"path-data-parser": "0.1.0",
-				"points-on-curve": "0.2.0"
-			}
-		},
-		"node_modules/polished": {
-			"version": "4.3.1",
-			"resolved": "https://registry.npmjs.org/polished/-/polished-4.3.1.tgz",
-			"integrity": "sha512-OBatVyC/N7SCW/FaDHrSd+vn0o5cS855TOmYi4OkdWUMSJCET/xip//ch8xGUvtr3i44X9LVyWwQlRMTN3pwSA==",
-			"license": "MIT",
-			"dependencies": {
-				"@babel/runtime": "^7.17.8"
-			},
-			"engines": {
-				"node": ">=10"
-			}
-		},
-		"node_modules/postcss": {
-			"version": "8.5.6",
-			"dev": true,
-			"funding": [
-				{
-					"type": "opencollective",
-					"url": "https://opencollective.com/postcss/"
-				},
-				{
-					"type": "tidelift",
-					"url": "https://tidelift.com/funding/github/npm/postcss"
-				},
-				{
-					"type": "github",
-					"url": "https://github.com/sponsors/ai"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"nanoid": "^3.3.11",
-				"picocolors": "^1.1.1",
-				"source-map-js": "^1.2.1"
-			},
-			"engines": {
-				"node": "^10 || ^12 || >=14"
-			}
-		},
-		"node_modules/postcss-import": {
-			"version": "15.1.0",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"postcss-value-parser": "^4.0.0",
-				"read-cache": "^1.0.0",
-				"resolve": "^1.1.7"
-			},
-			"engines": {
-				"node": ">=14.0.0"
-			},
-			"peerDependencies": {
-				"postcss": "^8.0.0"
-			}
-		},
-		"node_modules/postcss-js": {
-			"version": "4.1.0",
-			"dev": true,
-			"funding": [
-				{
-					"type": "opencollective",
-					"url": "https://opencollective.com/postcss/"
-				},
-				{
-					"type": "github",
-					"url": "https://github.com/sponsors/ai"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"camelcase-css": "^2.0.1"
-			},
-			"engines": {
-				"node": "^12 || ^14 || >= 16"
-			},
-			"peerDependencies": {
-				"postcss": "^8.4.21"
-			}
-		},
-		"node_modules/postcss-load-config": {
-			"version": "6.0.1",
-			"dev": true,
-			"funding": [
-				{
-					"type": "opencollective",
-					"url": "https://opencollective.com/postcss/"
-				},
-				{
-					"type": "github",
-					"url": "https://github.com/sponsors/ai"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"lilconfig": "^3.1.1"
-			},
-			"engines": {
-				"node": ">= 18"
-			},
-			"peerDependencies": {
-				"jiti": ">=1.21.0",
-				"postcss": ">=8.0.9",
-				"tsx": "^4.8.1",
-				"yaml": "^2.4.2"
-			},
-			"peerDependenciesMeta": {
-				"jiti": {
-					"optional": true
-				},
-				"postcss": {
-					"optional": true
-				},
-				"tsx": {
-					"optional": true
-				},
-				"yaml": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/postcss-nested": {
-			"version": "6.2.0",
-			"dev": true,
-			"funding": [
-				{
-					"type": "opencollective",
-					"url": "https://opencollective.com/postcss/"
-				},
-				{
-					"type": "github",
-					"url": "https://github.com/sponsors/ai"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"postcss-selector-parser": "^6.1.1"
-			},
-			"engines": {
-				"node": ">=12.0"
-			},
-			"peerDependencies": {
-				"postcss": "^8.2.14"
-			}
-		},
-		"node_modules/postcss-nested/node_modules/postcss-selector-parser": {
-			"version": "6.1.2",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"cssesc": "^3.0.0",
-				"util-deprecate": "^1.0.2"
-			},
-			"engines": {
-				"node": ">=4"
-			}
-		},
-		"node_modules/postcss-value-parser": {
-			"version": "4.2.0",
-			"dev": true,
-			"license": "MIT"
-		},
-		"node_modules/prop-types": {
-			"version": "15.8.1",
-			"resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
-			"integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"loose-envify": "^1.4.0",
-				"object-assign": "^4.1.1",
-				"react-is": "^16.13.1"
-			}
-		},
-		"node_modules/prop-types/node_modules/react-is": {
-			"version": "16.13.1",
-			"resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
-			"integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/property-information": {
-			"version": "7.1.0",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/query-string": {
-			"version": "9.3.1",
-			"resolved": "https://registry.npmjs.org/query-string/-/query-string-9.3.1.tgz",
-			"integrity": "sha512-5fBfMOcDi5SA9qj5jZhWAcTtDfKF5WFdd2uD9nVNlbxVv1baq65aALy6qofpNEGELHvisjjasxQp7BlM9gvMzw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"decode-uri-component": "^0.4.1",
-				"filter-obj": "^5.1.0",
-				"split-on-first": "^3.0.0"
-			},
-			"engines": {
-				"node": ">=18"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
-		"node_modules/queue-microtask": {
-			"version": "1.2.3",
-			"dev": true,
-			"funding": [
-				{
-					"type": "github",
-					"url": "https://github.com/sponsors/feross"
-				},
-				{
-					"type": "patreon",
-					"url": "https://www.patreon.com/feross"
-				},
-				{
-					"type": "consulting",
-					"url": "https://feross.org/support"
-				}
-			],
-			"license": "MIT"
-		},
-		"node_modules/rc-collapse": {
-			"version": "4.0.0",
-			"resolved": "https://registry.npmjs.org/rc-collapse/-/rc-collapse-4.0.0.tgz",
-			"integrity": "sha512-SwoOByE39/3oIokDs/BnkqI+ltwirZbP8HZdq1/3SkPSBi7xDdvWHTp7cpNI9ullozkR6mwTWQi6/E/9huQVrA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.10.1",
-				"classnames": "2.x",
-				"rc-motion": "^2.3.4",
-				"rc-util": "^5.27.0"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/rc-dialog": {
-			"version": "9.6.0",
-			"resolved": "https://registry.npmjs.org/rc-dialog/-/rc-dialog-9.6.0.tgz",
-			"integrity": "sha512-ApoVi9Z8PaCQg6FsUzS8yvBEQy0ZL2PkuvAgrmohPkN3okps5WZ5WQWPc1RNuiOKaAYv8B97ACdsFU5LizzCqg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.10.1",
-				"@rc-component/portal": "^1.0.0-8",
-				"classnames": "^2.2.6",
-				"rc-motion": "^2.3.0",
-				"rc-util": "^5.21.0"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/rc-dialog/node_modules/@rc-component/portal": {
-			"version": "1.1.2",
-			"resolved": "https://registry.npmjs.org/@rc-component/portal/-/portal-1.1.2.tgz",
-			"integrity": "sha512-6f813C0IsasTZms08kfA8kPAGxbbkYToa8ALaiDIGGECU4i9hj8Plgbx0sNJDrey3EtHO30hmdaxtT0138xZcg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.18.0",
-				"classnames": "^2.3.2",
-				"rc-util": "^5.24.4"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/rc-footer": {
-			"version": "0.6.8",
-			"resolved": "https://registry.npmjs.org/rc-footer/-/rc-footer-0.6.8.tgz",
-			"integrity": "sha512-JBZ+xcb6kkex8XnBd4VHw1ZxjV6kmcwUumSHaIFdka2qzMCo7Klcy4sI6G0XtUpG/vtpislQCc+S9Bc+NLHYMg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.11.1",
-				"classnames": "^2.2.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.0.0",
-				"react-dom": ">=16.0.0"
-			}
-		},
-		"node_modules/rc-image": {
-			"version": "7.12.0",
-			"resolved": "https://registry.npmjs.org/rc-image/-/rc-image-7.12.0.tgz",
-			"integrity": "sha512-cZ3HTyyckPnNnUb9/DRqduqzLfrQRyi+CdHjdqgsyDpI3Ln5UX1kXnAhPBSJj9pVRzwRFgqkN7p9b6HBDjmu/Q==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.11.2",
-				"@rc-component/portal": "^1.0.2",
-				"classnames": "^2.2.6",
-				"rc-dialog": "~9.6.0",
-				"rc-motion": "^2.6.2",
-				"rc-util": "^5.34.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/rc-image/node_modules/@rc-component/portal": {
-			"version": "1.1.2",
-			"resolved": "https://registry.npmjs.org/@rc-component/portal/-/portal-1.1.2.tgz",
-			"integrity": "sha512-6f813C0IsasTZms08kfA8kPAGxbbkYToa8ALaiDIGGECU4i9hj8Plgbx0sNJDrey3EtHO30hmdaxtT0138xZcg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.18.0",
-				"classnames": "^2.3.2",
-				"rc-util": "^5.24.4"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/rc-input": {
-			"version": "1.8.0",
-			"resolved": "https://registry.npmjs.org/rc-input/-/rc-input-1.8.0.tgz",
-			"integrity": "sha512-KXvaTbX+7ha8a/k+eg6SYRVERK0NddX8QX7a7AnRvUa/rEH0CNMlpcBzBkhI0wp2C8C4HlMoYl8TImSN+fuHKA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.11.1",
-				"classnames": "^2.2.1",
-				"rc-util": "^5.18.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.0.0",
-				"react-dom": ">=16.0.0"
-			}
-		},
-		"node_modules/rc-input-number": {
-			"version": "9.5.0",
-			"resolved": "https://registry.npmjs.org/rc-input-number/-/rc-input-number-9.5.0.tgz",
-			"integrity": "sha512-bKaEvB5tHebUURAEXw35LDcnRZLq3x1k7GxfAqBMzmpHkDGzjAtnUL8y4y5N15rIFIg5IJgwr211jInl3cipag==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.10.1",
-				"@rc-component/mini-decimal": "^1.0.1",
-				"classnames": "^2.2.5",
-				"rc-input": "~1.8.0",
-				"rc-util": "^5.40.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/rc-menu": {
-			"version": "9.16.1",
-			"resolved": "https://registry.npmjs.org/rc-menu/-/rc-menu-9.16.1.tgz",
-			"integrity": "sha512-ghHx6/6Dvp+fw8CJhDUHFHDJ84hJE3BXNCzSgLdmNiFErWSOaZNsihDAsKq9ByTALo/xkNIwtDFGIl6r+RPXBg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.10.1",
-				"@rc-component/trigger": "^2.0.0",
-				"classnames": "2.x",
-				"rc-motion": "^2.4.3",
-				"rc-overflow": "^1.3.1",
-				"rc-util": "^5.27.0"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/rc-menu/node_modules/@rc-component/portal": {
-			"version": "1.1.2",
-			"resolved": "https://registry.npmjs.org/@rc-component/portal/-/portal-1.1.2.tgz",
-			"integrity": "sha512-6f813C0IsasTZms08kfA8kPAGxbbkYToa8ALaiDIGGECU4i9hj8Plgbx0sNJDrey3EtHO30hmdaxtT0138xZcg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.18.0",
-				"classnames": "^2.3.2",
-				"rc-util": "^5.24.4"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/rc-menu/node_modules/@rc-component/trigger": {
-			"version": "2.3.1",
-			"resolved": "https://registry.npmjs.org/@rc-component/trigger/-/trigger-2.3.1.tgz",
-			"integrity": "sha512-ORENF39PeXTzM+gQEshuk460Z8N4+6DkjpxlpE7Q3gYy1iBpLrx0FOJz3h62ryrJZ/3zCAUIkT1Pb/8hHWpb3A==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.23.2",
-				"@rc-component/portal": "^1.1.0",
-				"classnames": "^2.3.2",
-				"rc-motion": "^2.0.0",
-				"rc-resize-observer": "^1.3.1",
-				"rc-util": "^5.44.0"
-			},
-			"engines": {
-				"node": ">=8.x"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/rc-motion": {
-			"version": "2.9.5",
-			"resolved": "https://registry.npmjs.org/rc-motion/-/rc-motion-2.9.5.tgz",
-			"integrity": "sha512-w+XTUrfh7ArbYEd2582uDrEhmBHwK1ZENJiSJVb7uRxdE7qJSYjbO2eksRXmndqyKqKoYPc9ClpPh5242mV1vA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.11.1",
-				"classnames": "^2.2.1",
-				"rc-util": "^5.44.0"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/rc-overflow": {
-			"version": "1.5.0",
-			"resolved": "https://registry.npmjs.org/rc-overflow/-/rc-overflow-1.5.0.tgz",
-			"integrity": "sha512-Lm/v9h0LymeUYJf0x39OveU52InkdRXqnn2aYXfWmo8WdOonIKB2kfau+GF0fWq6jPgtdO9yMqveGcK6aIhJmg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.11.1",
-				"classnames": "^2.2.1",
-				"rc-resize-observer": "^1.0.0",
-				"rc-util": "^5.37.0"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/rc-resize-observer": {
-			"version": "1.4.3",
-			"resolved": "https://registry.npmjs.org/rc-resize-observer/-/rc-resize-observer-1.4.3.tgz",
-			"integrity": "sha512-YZLjUbyIWox8E9i9C3Tm7ia+W7euPItNWSPX5sCcQTYbnwDb5uNpnLHQCG1f22oZWUhLw4Mv2tFmeWe68CDQRQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.20.7",
-				"classnames": "^2.2.1",
-				"rc-util": "^5.44.1",
-				"resize-observer-polyfill": "^1.5.1"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/rc-util": {
-			"version": "5.44.4",
-			"resolved": "https://registry.npmjs.org/rc-util/-/rc-util-5.44.4.tgz",
-			"integrity": "sha512-resueRJzmHG9Q6rI/DfK6Kdv9/Lfls05vzMs1Sk3M2P+3cJa+MakaZyWY8IPfehVuhPJFKrIY1IK4GqbiaiY5w==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@babel/runtime": "^7.18.3",
-				"react-is": "^18.2.0"
-			},
-			"peerDependencies": {
-				"react": ">=16.9.0",
-				"react-dom": ">=16.9.0"
-			}
-		},
-		"node_modules/rc-util/node_modules/react-is": {
-			"version": "18.3.1",
-			"resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
-			"integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/re-resizable": {
-			"version": "6.11.2",
-			"resolved": "https://registry.npmjs.org/re-resizable/-/re-resizable-6.11.2.tgz",
-			"integrity": "sha512-2xI2P3OHs5qw7K0Ud1aLILK6MQxW50TcO+DetD9eIV58j84TqYeHoZcL9H4GXFXXIh7afhH8mv5iUCXII7OW7A==",
-			"license": "MIT",
-			"peer": true,
-			"peerDependencies": {
-				"react": "^16.13.1 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-				"react-dom": "^16.13.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-			}
-		},
-		"node_modules/react": {
-			"version": "19.2.4",
-			"license": "MIT",
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/react-avatar-editor": {
-			"version": "14.0.0",
-			"resolved": "https://registry.npmjs.org/react-avatar-editor/-/react-avatar-editor-14.0.0.tgz",
-			"integrity": "sha512-NaQM3oo4u0a1/Njjutc2FjwKX35vQV+t6S8hovsbAlMpBN1ntIwP/g+Yr9eDIIfaNtRXL0AqboTnPmRxhD/i8A==",
-			"license": "MIT",
-			"peer": true,
-			"peerDependencies": {
-				"react": "^0.14.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-				"react-dom": "^0.14.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-			}
-		},
-		"node_modules/react-colorful": {
-			"version": "5.6.1",
-			"resolved": "https://registry.npmjs.org/react-colorful/-/react-colorful-5.6.1.tgz",
-			"integrity": "sha512-1exovf0uGTGyq5mXQT0zgQ80uvj2PCwvF8zY1RN9/vbJVSjSo3fsB/4L3ObbF7u70NduSiK4xu4Y6q1MHoUGEw==",
-			"license": "MIT",
-			"peer": true,
-			"peerDependencies": {
-				"react": ">=16.8.0",
-				"react-dom": ">=16.8.0"
-			}
-		},
-		"node_modules/react-dom": {
-			"version": "19.2.4",
-			"license": "MIT",
-			"dependencies": {
-				"scheduler": "^0.27.0"
-			},
-			"peerDependencies": {
-				"react": "^19.2.4"
-			}
-		},
-		"node_modules/react-draggable": {
-			"version": "4.4.6",
-			"resolved": "https://registry.npmjs.org/react-draggable/-/react-draggable-4.4.6.tgz",
-			"integrity": "sha512-LtY5Xw1zTPqHkVmtM3X8MUOxNDOUhv/khTgBgrUvwaS064bwVvxT+q5El0uUFNx5IEPKXuRejr7UqLwBIg5pdw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"clsx": "^1.1.1",
-				"prop-types": "^15.8.1"
-			},
-			"peerDependencies": {
-				"react": ">= 16.3.0",
-				"react-dom": ">= 16.3.0"
-			}
-		},
-		"node_modules/react-draggable/node_modules/clsx": {
-			"version": "1.2.1",
-			"resolved": "https://registry.npmjs.org/clsx/-/clsx-1.2.1.tgz",
-			"integrity": "sha512-EcR6r5a8bj6pu3ycsa/E/cKVGuTgZJZdsyUYHOksG/UHIiKfjxzRxYJpyVBwYaQeOvghal9fcc4PidlgzugAQg==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=6"
-			}
-		},
-		"node_modules/react-dropzone": {
-			"version": "12.1.0",
-			"resolved": "https://registry.npmjs.org/react-dropzone/-/react-dropzone-12.1.0.tgz",
-			"integrity": "sha512-iBYHA1rbopIvtzokEX4QubO6qk5IF/x3BtKGu74rF2JkQDXnwC4uO/lHKpaw4PJIV6iIAYOlwLv2FpiGyqHNog==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"attr-accept": "^2.2.2",
-				"file-selector": "^0.5.0",
-				"prop-types": "^15.8.1"
-			},
-			"engines": {
-				"node": ">= 10.13"
-			},
-			"peerDependencies": {
-				"react": ">= 16.8"
-			}
-		},
-		"node_modules/react-error-boundary": {
-			"version": "6.1.1",
-			"resolved": "https://registry.npmjs.org/react-error-boundary/-/react-error-boundary-6.1.1.tgz",
-			"integrity": "sha512-BrYwPOdXi5mqkk5lw+Uvt0ThHx32rCt3BkukS4X23A2AIWDPSGX6iaWTc0y9TU/mHDA/6qOSGel+B2ERkOvD1w==",
-			"license": "MIT",
-			"peer": true,
-			"peerDependencies": {
-				"react": "^18.0.0 || ^19.0.0"
-			}
-		},
-		"node_modules/react-fast-compare": {
-			"version": "3.2.2",
-			"resolved": "https://registry.npmjs.org/react-fast-compare/-/react-fast-compare-3.2.2.tgz",
-			"integrity": "sha512-nsO+KSNgo1SbJqJEYRE9ERzo7YtYbou/OqjSQKxV7jcKox7+usiUVZOAC+XnDOABXggQTno0Y1CpVnuWEc1boQ==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/react-hook-form": {
-			"version": "7.71.1",
-			"resolved": "https://registry.npmjs.org/react-hook-form/-/react-hook-form-7.71.1.tgz",
-			"integrity": "sha512-9SUJKCGKo8HUSsCO+y0CtqkqI5nNuaDqTxyqPsZPqIwudpj4rCrAz/jZV+jn57bx5gtZKOh3neQu94DXMc+w5w==",
-			"license": "MIT",
-			"engines": {
-				"node": ">=18.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/react-hook-form"
-			},
-			"peerDependencies": {
-				"react": "^16.8.0 || ^17 || ^18 || ^19"
-			}
-		},
-		"node_modules/react-hotkeys-hook": {
-			"version": "5.2.4",
-			"resolved": "https://registry.npmjs.org/react-hotkeys-hook/-/react-hotkeys-hook-5.2.4.tgz",
-			"integrity": "sha512-BgKg+A1+TawkYluh5Bo4cTmcgMN5L29uhJbDUQdHwPX+qgXRjIPYU5kIDHyxnAwCkCBiu9V5OpB2mpyeluVF2A==",
-			"license": "MIT",
-			"peer": true,
-			"peerDependencies": {
-				"react": ">=16.8.0",
-				"react-dom": ">=16.8.0"
-			}
-		},
-		"node_modules/react-is": {
-			"version": "19.2.4",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/react-markdown": {
-			"version": "10.1.0",
-			"license": "MIT",
-			"dependencies": {
-				"@types/hast": "^3.0.0",
-				"@types/mdast": "^4.0.0",
-				"devlop": "^1.0.0",
-				"hast-util-to-jsx-runtime": "^2.0.0",
-				"html-url-attributes": "^3.0.0",
-				"mdast-util-to-hast": "^13.0.0",
-				"remark-parse": "^11.0.0",
-				"remark-rehype": "^11.0.0",
-				"unified": "^11.0.0",
-				"unist-util-visit": "^5.0.0",
-				"vfile": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			},
-			"peerDependencies": {
-				"@types/react": ">=18",
-				"react": ">=18"
-			}
-		},
-		"node_modules/react-merge-refs": {
-			"version": "3.0.2",
-			"resolved": "https://registry.npmjs.org/react-merge-refs/-/react-merge-refs-3.0.2.tgz",
-			"integrity": "sha512-MSZAfwFfdbEvwkKWP5EI5chuLYnNUxNS7vyS0i1Jp+wtd8J4Ga2ddzhaE68aMol2Z4vCnRM/oGOo1a3V75UPlw==",
-			"license": "MIT",
-			"peer": true,
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/gregberge"
-			},
-			"peerDependencies": {
-				"react": ">=16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-			},
-			"peerDependenciesMeta": {
-				"react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/react-redux": {
-			"version": "9.2.0",
-			"license": "MIT",
-			"dependencies": {
-				"@types/use-sync-external-store": "^0.0.6",
-				"use-sync-external-store": "^1.4.0"
-			},
-			"peerDependencies": {
-				"@types/react": "^18.2.25 || ^19",
-				"react": "^18.0 || ^19",
-				"redux": "^5.0.0"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"redux": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/react-refresh": {
-			"version": "0.17.0",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/react-remove-scroll": {
-			"version": "2.7.2",
-			"resolved": "https://registry.npmjs.org/react-remove-scroll/-/react-remove-scroll-2.7.2.tgz",
-			"integrity": "sha512-Iqb9NjCCTt6Hf+vOdNIZGdTiH1QSqr27H/Ek9sv/a97gfueI/5h1s3yRi1nngzMUaOOToin5dI1dXKdXiF+u0Q==",
-			"license": "MIT",
-			"dependencies": {
-				"react-remove-scroll-bar": "^2.3.7",
-				"react-style-singleton": "^2.2.3",
-				"tslib": "^2.1.0",
-				"use-callback-ref": "^1.3.3",
-				"use-sidecar": "^1.1.3"
-			},
-			"engines": {
-				"node": ">=10"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/react-remove-scroll-bar": {
-			"version": "2.3.8",
-			"resolved": "https://registry.npmjs.org/react-remove-scroll-bar/-/react-remove-scroll-bar-2.3.8.tgz",
-			"integrity": "sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q==",
-			"license": "MIT",
-			"dependencies": {
-				"react-style-singleton": "^2.2.2",
-				"tslib": "^2.0.0"
-			},
-			"engines": {
-				"node": ">=10"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/react-rnd": {
-			"version": "10.5.2",
-			"resolved": "https://registry.npmjs.org/react-rnd/-/react-rnd-10.5.2.tgz",
-			"integrity": "sha512-0Tm4x7k7pfHf2snewJA8x7Nwgt3LV+58MVEWOVsFjk51eYruFEa6Wy7BNdxt4/lH0wIRsu7Gm3KjSXY2w7YaNw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"re-resizable": "6.11.2",
-				"react-draggable": "4.4.6",
-				"tslib": "2.6.2"
-			},
-			"peerDependencies": {
-				"react": ">=16.3.0",
-				"react-dom": ">=16.3.0"
-			}
-		},
-		"node_modules/react-rnd/node_modules/tslib": {
-			"version": "2.6.2",
-			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz",
-			"integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==",
-			"license": "0BSD",
-			"peer": true
-		},
-		"node_modules/react-style-singleton": {
-			"version": "2.2.3",
-			"resolved": "https://registry.npmjs.org/react-style-singleton/-/react-style-singleton-2.2.3.tgz",
-			"integrity": "sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ==",
-			"license": "MIT",
-			"dependencies": {
-				"get-nonce": "^1.0.0",
-				"tslib": "^2.0.0"
-			},
-			"engines": {
-				"node": ">=10"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/react-zoom-pan-pinch": {
-			"version": "3.7.0",
-			"resolved": "https://registry.npmjs.org/react-zoom-pan-pinch/-/react-zoom-pan-pinch-3.7.0.tgz",
-			"integrity": "sha512-UmReVZ0TxlKzxSbYiAj+LeGRW8s8LraAFTXRAxzMYnNRgGPsxCudwZKVkjvGmjtx7SW/hZamt69NUmGf4xrkXA==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=8",
-				"npm": ">=5"
-			},
-			"peerDependencies": {
-				"react": "*",
-				"react-dom": "*"
-			}
-		},
-		"node_modules/read-cache": {
-			"version": "1.0.0",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"pify": "^2.3.0"
-			}
-		},
-		"node_modules/readdirp": {
-			"version": "4.1.2",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">= 14.18.0"
-			},
-			"funding": {
-				"type": "individual",
-				"url": "https://paulmillr.com/funding/"
-			}
-		},
-		"node_modules/recharts": {
-			"version": "3.7.0",
-			"license": "MIT",
-			"workspaces": [
-				"www"
-			],
-			"dependencies": {
-				"@reduxjs/toolkit": "1.x.x || 2.x.x",
-				"clsx": "^2.1.1",
-				"decimal.js-light": "^2.5.1",
-				"es-toolkit": "^1.39.3",
-				"eventemitter3": "^5.0.1",
-				"immer": "^10.1.1",
-				"react-redux": "8.x.x || 9.x.x",
-				"reselect": "5.1.1",
-				"tiny-invariant": "^1.3.3",
-				"use-sync-external-store": "^1.2.2",
-				"victory-vendor": "^37.0.2"
-			},
-			"engines": {
-				"node": ">=18"
-			},
-			"peerDependencies": {
-				"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-				"react-dom": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
-				"react-is": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-			}
-		},
-		"node_modules/recma-build-jsx": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/recma-build-jsx/-/recma-build-jsx-1.0.0.tgz",
-			"integrity": "sha512-8GtdyqaBcDfva+GUKDr3nev3VpKAhup1+RvkMvUxURHpW7QyIvk9F5wz7Vzo06CEMSilw6uArgRqhpiUcWp8ew==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree": "^1.0.0",
-				"estree-util-build-jsx": "^3.0.0",
-				"vfile": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/recma-jsx": {
-			"version": "1.0.1",
-			"resolved": "https://registry.npmjs.org/recma-jsx/-/recma-jsx-1.0.1.tgz",
-			"integrity": "sha512-huSIy7VU2Z5OLv6oFLosQGGDqPqdO1iq6bWNAdhzMxSJP7RAso4fCZ1cKu8j9YHCZf3TPrq4dw3okhrylgcd7w==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"acorn-jsx": "^5.0.0",
-				"estree-util-to-js": "^2.0.0",
-				"recma-parse": "^1.0.0",
-				"recma-stringify": "^1.0.0",
-				"unified": "^11.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			},
-			"peerDependencies": {
-				"acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
-			}
-		},
-		"node_modules/recma-parse": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/recma-parse/-/recma-parse-1.0.0.tgz",
-			"integrity": "sha512-OYLsIGBB5Y5wjnSnQW6t3Xg7q3fQ7FWbw/vcXtORTnyaSFscOtABg+7Pnz6YZ6c27fG1/aN8CjfwoUEUIdwqWQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree": "^1.0.0",
-				"esast-util-from-js": "^2.0.0",
-				"unified": "^11.0.0",
-				"vfile": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/recma-stringify": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/recma-stringify/-/recma-stringify-1.0.0.tgz",
-			"integrity": "sha512-cjwII1MdIIVloKvC9ErQ+OgAtwHBmcZ0Bg4ciz78FtbT8In39aAYbaA7zvxQ61xVMSPE8WxhLwLbhif4Js2C+g==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree": "^1.0.0",
-				"estree-util-to-js": "^2.0.0",
-				"unified": "^11.0.0",
-				"vfile": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/redux": {
-			"version": "5.0.1",
-			"license": "MIT"
-		},
-		"node_modules/redux-thunk": {
-			"version": "3.1.0",
-			"license": "MIT",
-			"peerDependencies": {
-				"redux": "^5.0.0"
-			}
-		},
-		"node_modules/regex": {
-			"version": "6.1.0",
-			"resolved": "https://registry.npmjs.org/regex/-/regex-6.1.0.tgz",
-			"integrity": "sha512-6VwtthbV4o/7+OaAF9I5L5V3llLEsoPyq9P1JVXkedTP33c7MfCG0/5NOPcSJn0TzXcG9YUrR0gQSWioew3LDg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"regex-utilities": "^2.3.0"
-			}
-		},
-		"node_modules/regex-recursion": {
-			"version": "6.0.2",
-			"resolved": "https://registry.npmjs.org/regex-recursion/-/regex-recursion-6.0.2.tgz",
-			"integrity": "sha512-0YCaSCq2VRIebiaUviZNs0cBz1kg5kVS2UKUfNIx8YVs1cN3AV7NTctO5FOKBA+UT2BPJIWZauYHPqJODG50cg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"regex-utilities": "^2.3.0"
-			}
-		},
-		"node_modules/regex-utilities": {
-			"version": "2.3.0",
-			"resolved": "https://registry.npmjs.org/regex-utilities/-/regex-utilities-2.3.0.tgz",
-			"integrity": "sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/rehype-github-alerts": {
-			"version": "4.2.0",
-			"resolved": "https://registry.npmjs.org/rehype-github-alerts/-/rehype-github-alerts-4.2.0.tgz",
-			"integrity": "sha512-6di6kEu9WUHKLKrkKG2xX6AOuaCMGghg0Wq7MEuM/jBYUPVIq6PJpMe00dxMfU+/YSBtDXhffpDimgDi+BObIQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@primer/octicons": "^19.20.0",
-				"hast-util-from-html": "^2.0.3",
-				"hast-util-is-element": "^3.0.0",
-				"unist-util-visit": "^5.0.0"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/chrisweb"
-			}
-		},
-		"node_modules/rehype-katex": {
-			"version": "7.0.1",
-			"resolved": "https://registry.npmjs.org/rehype-katex/-/rehype-katex-7.0.1.tgz",
-			"integrity": "sha512-OiM2wrZ/wuhKkigASodFoo8wimG3H12LWQaH8qSPVJn9apWKFSH3YOCtbKpBorTVw/eI7cuT21XBbvwEswbIOA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/hast": "^3.0.0",
-				"@types/katex": "^0.16.0",
-				"hast-util-from-html-isomorphic": "^2.0.0",
-				"hast-util-to-text": "^4.0.0",
-				"katex": "^0.16.0",
-				"unist-util-visit-parents": "^6.0.0",
-				"vfile": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/rehype-raw": {
-			"version": "7.0.0",
-			"resolved": "https://registry.npmjs.org/rehype-raw/-/rehype-raw-7.0.0.tgz",
-			"integrity": "sha512-/aE8hCfKlQeA8LmyeyQvQF3eBiLRGNlfBJEvWH7ivp9sBqs7TNqBL5X3v157rM4IFETqDnIOO+z5M/biZbo9Ww==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/hast": "^3.0.0",
-				"hast-util-raw": "^9.0.0",
-				"vfile": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/rehype-recma": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/rehype-recma/-/rehype-recma-1.0.0.tgz",
-			"integrity": "sha512-lqA4rGUf1JmacCNWWZx0Wv1dHqMwxzsDWYMTowuplHF3xH0N/MmrZ/G3BDZnzAkRmxDadujCjaKM2hqYdCBOGw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/estree": "^1.0.0",
-				"@types/hast": "^3.0.0",
-				"hast-util-to-estree": "^3.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/remark-breaks": {
-			"version": "4.0.0",
-			"resolved": "https://registry.npmjs.org/remark-breaks/-/remark-breaks-4.0.0.tgz",
-			"integrity": "sha512-IjEjJOkH4FuJvHZVIW0QCDWxcG96kCq7An/KVH2NfJe6rKZU2AsHeB3OEjPNRxi4QC34Xdx7I2KGYn6IpT7gxQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"mdast-util-newline-to-break": "^2.0.0",
-				"unified": "^11.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/remark-cjk-friendly": {
-			"version": "1.2.3",
-			"resolved": "https://registry.npmjs.org/remark-cjk-friendly/-/remark-cjk-friendly-1.2.3.tgz",
-			"integrity": "sha512-UvAgxwlNk+l9Oqgl/9MWK2eWRS7zgBW/nXX9AthV7nd/3lNejF138E7Xbmk9Zs4WjTJGs721r7fAEc7tNFoH7g==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"micromark-extension-cjk-friendly": "1.2.3"
-			},
-			"engines": {
-				"node": ">=16"
-			},
-			"peerDependencies": {
-				"@types/mdast": "^4.0.0",
-				"unified": "^11.0.0"
-			},
-			"peerDependenciesMeta": {
-				"@types/mdast": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/remark-gfm": {
-			"version": "4.0.1",
-			"license": "MIT",
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"mdast-util-gfm": "^3.0.0",
-				"micromark-extension-gfm": "^3.0.0",
-				"remark-parse": "^11.0.0",
-				"remark-stringify": "^11.0.0",
-				"unified": "^11.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/remark-github": {
-			"version": "12.0.0",
-			"resolved": "https://registry.npmjs.org/remark-github/-/remark-github-12.0.0.tgz",
-			"integrity": "sha512-ByefQKFN184LeiGRCabfl7zUJsdlMYWEhiLX1gpmQ11yFg6xSuOTW7LVCv0oc1x+YvUMJW23NU36sJX2RWGgvg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"mdast-util-find-and-replace": "^3.0.0",
-				"mdast-util-to-string": "^4.0.0",
-				"to-vfile": "^8.0.0",
-				"unist-util-visit": "^5.0.0",
-				"vfile": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/remark-math": {
-			"version": "6.0.0",
-			"resolved": "https://registry.npmjs.org/remark-math/-/remark-math-6.0.0.tgz",
-			"integrity": "sha512-MMqgnP74Igy+S3WwnhQ7kqGlEerTETXMvJhrUzDikVZ2/uogJCb+WHUg97hK9/jcfc0dkD73s3LN8zU49cTEtA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"mdast-util-math": "^3.0.0",
-				"micromark-extension-math": "^3.0.0",
-				"unified": "^11.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/remark-mdx": {
-			"version": "3.1.1",
-			"resolved": "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.1.1.tgz",
-			"integrity": "sha512-Pjj2IYlUY3+D8x00UJsIOg5BEvfMyeI+2uLPn9VO9Wg4MEtN/VTIq2NEJQfde9PnX15KgtHyl9S0BcTnWrIuWg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"mdast-util-mdx": "^3.0.0",
-				"micromark-extension-mdxjs": "^3.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/remark-parse": {
-			"version": "11.0.0",
-			"license": "MIT",
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"mdast-util-from-markdown": "^2.0.0",
-				"micromark-util-types": "^2.0.0",
-				"unified": "^11.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/remark-rehype": {
-			"version": "11.1.2",
-			"license": "MIT",
-			"dependencies": {
-				"@types/hast": "^3.0.0",
-				"@types/mdast": "^4.0.0",
-				"mdast-util-to-hast": "^13.0.0",
-				"unified": "^11.0.0",
-				"vfile": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/remark-stringify": {
-			"version": "11.0.0",
-			"license": "MIT",
-			"dependencies": {
-				"@types/mdast": "^4.0.0",
-				"mdast-util-to-markdown": "^2.0.0",
-				"unified": "^11.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/remend": {
-			"version": "1.2.1",
-			"resolved": "https://registry.npmjs.org/remend/-/remend-1.2.1.tgz",
-			"integrity": "sha512-4wC12bgXsfKAjF1ewwkNIQz5sqewz/z1xgIgjEMb3r1pEytQ37F0Cm6i+OhbTWEvguJD7lhOUJhK5fSasw9f0w==",
-			"license": "Apache-2.0",
-			"peer": true
-		},
-		"node_modules/reselect": {
-			"version": "5.1.1",
-			"license": "MIT"
-		},
-		"node_modules/resize-observer-polyfill": {
-			"version": "1.5.1",
-			"resolved": "https://registry.npmjs.org/resize-observer-polyfill/-/resize-observer-polyfill-1.5.1.tgz",
-			"integrity": "sha512-LwZrotdHOo12nQuZlHEmtuXdqGoOD0OhaxopaNFxWzInpEgaLWoVuAMbTzixuosCx2nEG58ngzW3vxdWoxIgdg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/resolve": {
-			"version": "1.22.11",
-			"license": "MIT",
-			"dependencies": {
-				"is-core-module": "^2.16.1",
-				"path-parse": "^1.0.7",
-				"supports-preserve-symlinks-flag": "^1.0.0"
-			},
-			"bin": {
-				"resolve": "bin/resolve"
-			},
-			"engines": {
-				"node": ">= 0.4"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/ljharb"
-			}
-		},
-		"node_modules/resolve-from": {
-			"version": "4.0.0",
-			"resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
-			"integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
-			"license": "MIT",
-			"engines": {
-				"node": ">=4"
-			}
-		},
-		"node_modules/reusify": {
-			"version": "1.1.0",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"iojs": ">=1.0.0",
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/robust-predicates": {
-			"version": "3.0.2",
-			"resolved": "https://registry.npmjs.org/robust-predicates/-/robust-predicates-3.0.2.tgz",
-			"integrity": "sha512-IXgzBWvWQwE6PrDI05OvmXUIruQTcoMDzRsOd5CDvHCVLcLHMTSYvOK5Cm46kWqlV3yAbuSpBZdJ5oP5OUoStg==",
-			"license": "Unlicense",
-			"peer": true
-		},
-		"node_modules/rollup": {
-			"version": "4.57.1",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@types/estree": "1.0.8"
-			},
-			"bin": {
-				"rollup": "dist/bin/rollup"
-			},
-			"engines": {
-				"node": ">=18.0.0",
-				"npm": ">=8.0.0"
-			},
-			"optionalDependencies": {
-				"@rollup/rollup-android-arm-eabi": "4.57.1",
-				"@rollup/rollup-android-arm64": "4.57.1",
-				"@rollup/rollup-darwin-arm64": "4.57.1",
-				"@rollup/rollup-darwin-x64": "4.57.1",
-				"@rollup/rollup-freebsd-arm64": "4.57.1",
-				"@rollup/rollup-freebsd-x64": "4.57.1",
-				"@rollup/rollup-linux-arm-gnueabihf": "4.57.1",
-				"@rollup/rollup-linux-arm-musleabihf": "4.57.1",
-				"@rollup/rollup-linux-arm64-gnu": "4.57.1",
-				"@rollup/rollup-linux-arm64-musl": "4.57.1",
-				"@rollup/rollup-linux-loong64-gnu": "4.57.1",
-				"@rollup/rollup-linux-loong64-musl": "4.57.1",
-				"@rollup/rollup-linux-ppc64-gnu": "4.57.1",
-				"@rollup/rollup-linux-ppc64-musl": "4.57.1",
-				"@rollup/rollup-linux-riscv64-gnu": "4.57.1",
-				"@rollup/rollup-linux-riscv64-musl": "4.57.1",
-				"@rollup/rollup-linux-s390x-gnu": "4.57.1",
-				"@rollup/rollup-linux-x64-gnu": "4.57.1",
-				"@rollup/rollup-linux-x64-musl": "4.57.1",
-				"@rollup/rollup-openbsd-x64": "4.57.1",
-				"@rollup/rollup-openharmony-arm64": "4.57.1",
-				"@rollup/rollup-win32-arm64-msvc": "4.57.1",
-				"@rollup/rollup-win32-ia32-msvc": "4.57.1",
-				"@rollup/rollup-win32-x64-gnu": "4.57.1",
-				"@rollup/rollup-win32-x64-msvc": "4.57.1",
-				"fsevents": "~2.3.2"
-			}
-		},
-		"node_modules/roughjs": {
-			"version": "4.6.6",
-			"resolved": "https://registry.npmjs.org/roughjs/-/roughjs-4.6.6.tgz",
-			"integrity": "sha512-ZUz/69+SYpFN/g/lUlo2FXcIjRkSu3nDarreVdGGndHEBJ6cXPdKguS8JGxwj5HA5xIbVKSmLgr5b3AWxtRfvQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"hachure-fill": "^0.5.2",
-				"path-data-parser": "^0.1.0",
-				"points-on-curve": "^0.2.0",
-				"points-on-path": "^0.2.1"
-			}
-		},
-		"node_modules/run-parallel": {
-			"version": "1.2.0",
-			"dev": true,
-			"funding": [
-				{
-					"type": "github",
-					"url": "https://github.com/sponsors/feross"
-				},
-				{
-					"type": "patreon",
-					"url": "https://www.patreon.com/feross"
-				},
-				{
-					"type": "consulting",
-					"url": "https://feross.org/support"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"queue-microtask": "^1.2.2"
-			}
-		},
-		"node_modules/rw": {
-			"version": "1.3.3",
-			"resolved": "https://registry.npmjs.org/rw/-/rw-1.3.3.tgz",
-			"integrity": "sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ==",
-			"license": "BSD-3-Clause",
-			"peer": true
-		},
-		"node_modules/safer-buffer": {
-			"version": "2.1.2",
-			"resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
-			"integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/sass": {
-			"version": "1.97.3",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"chokidar": "^4.0.0",
-				"immutable": "^5.0.2",
-				"source-map-js": ">=0.6.2 <2.0.0"
-			},
-			"bin": {
-				"sass": "sass.js"
-			},
-			"engines": {
-				"node": ">=14.0.0"
-			},
-			"optionalDependencies": {
-				"@parcel/watcher": "^2.4.1"
-			}
-		},
-		"node_modules/scheduler": {
-			"version": "0.27.0",
-			"license": "MIT"
-		},
-		"node_modules/screenfull": {
-			"version": "5.2.0",
-			"resolved": "https://registry.npmjs.org/screenfull/-/screenfull-5.2.0.tgz",
-			"integrity": "sha512-9BakfsO2aUQN2K9Fdbj87RJIEZ82Q9IGim7FqM5OsebfoFC6ZHXgDq/KvniuLTPdeM8wY2o6Dj3WQ7KeQCj3cA==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=0.10.0"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
-		"node_modules/scroll-into-view-if-needed": {
-			"version": "3.1.0",
-			"resolved": "https://registry.npmjs.org/scroll-into-view-if-needed/-/scroll-into-view-if-needed-3.1.0.tgz",
-			"integrity": "sha512-49oNpRjWRvnU8NyGVmUaYG4jtTkNonFZI86MmGRDqBphEK2EXT9gdEUoQPZhuBM8yWHxCWbobltqYO5M4XrUvQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"compute-scroll-into-view": "^3.0.2"
-			}
-		},
-		"node_modules/semver": {
-			"version": "6.3.1",
-			"dev": true,
-			"license": "ISC",
-			"bin": {
-				"semver": "bin/semver.js"
-			}
-		},
-		"node_modules/semver-compare": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/semver-compare/-/semver-compare-1.0.0.tgz",
-			"integrity": "sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/seroval": {
-			"version": "1.5.0",
-			"license": "MIT",
-			"engines": {
-				"node": ">=10"
-			}
-		},
-		"node_modules/seroval-plugins": {
-			"version": "1.5.0",
-			"license": "MIT",
-			"engines": {
-				"node": ">=10"
-			},
-			"peerDependencies": {
-				"seroval": "^1.0"
-			}
-		},
-		"node_modules/set-value": {
-			"version": "2.0.1",
-			"resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz",
-			"integrity": "sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"extend-shallow": "^2.0.1",
-				"is-extendable": "^0.1.1",
-				"is-plain-object": "^2.0.3",
-				"split-string": "^3.0.1"
-			},
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/set-value/node_modules/is-extendable": {
-			"version": "0.1.1",
-			"resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz",
-			"integrity": "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/shiki": {
-			"version": "3.22.0",
-			"resolved": "https://registry.npmjs.org/shiki/-/shiki-3.22.0.tgz",
-			"integrity": "sha512-LBnhsoYEe0Eou4e1VgJACes+O6S6QC0w71fCSp5Oya79inkwkm15gQ1UF6VtQ8j/taMDh79hAB49WUk8ALQW3g==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@shikijs/core": "3.22.0",
-				"@shikijs/engine-javascript": "3.22.0",
-				"@shikijs/engine-oniguruma": "3.22.0",
-				"@shikijs/langs": "3.22.0",
-				"@shikijs/themes": "3.22.0",
-				"@shikijs/types": "3.22.0",
-				"@shikijs/vscode-textmate": "^10.0.2",
-				"@types/hast": "^3.0.4"
-			}
-		},
-		"node_modules/shiki-stream": {
-			"version": "0.1.4",
-			"resolved": "https://registry.npmjs.org/shiki-stream/-/shiki-stream-0.1.4.tgz",
-			"integrity": "sha512-4pz6JGSDmVTTkPJ/ueixHkFAXY4ySCc+unvCaDZV7hqq/sdJZirRxgIXSuNSKgiFlGTgRR97sdu2R8K55sPsrw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@shikijs/core": "^3.0.0"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/antfu"
-			},
-			"peerDependencies": {
-				"react": "^19.0.0",
-				"solid-js": "^1.9.0",
-				"vue": "^3.2.0"
-			},
-			"peerDependenciesMeta": {
-				"react": {
-					"optional": true
-				},
-				"solid-js": {
-					"optional": true
-				},
-				"vue": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/sigma": {
-			"version": "3.0.2",
-			"resolved": "https://registry.npmjs.org/sigma/-/sigma-3.0.2.tgz",
-			"integrity": "sha512-/BUbeOwPGruiBOm0YQQ6ZMcLIZ6tf/W+Jcm7dxZyAX0tK3WP9/sq7/NAWBxPIxVahdGjCJoGwej0Gdrv0DxlQQ==",
-			"license": "MIT",
-			"dependencies": {
-				"events": "^3.3.0",
-				"graphology-utils": "^2.5.2"
-			}
-		},
-		"node_modules/smol-toml": {
-			"version": "1.6.0",
-			"resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.6.0.tgz",
-			"integrity": "sha512-4zemZi0HvTnYwLfrpk/CF9LOd9Lt87kAt50GnqhMpyF9U3poDAP2+iukq2bZsO/ufegbYehBkqINbsWxj4l4cw==",
-			"license": "BSD-3-Clause",
-			"engines": {
-				"node": ">= 18"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/cyyynthia"
-			}
-		},
-		"node_modules/sonner": {
-			"version": "2.0.7",
-			"resolved": "https://registry.npmjs.org/sonner/-/sonner-2.0.7.tgz",
-			"integrity": "sha512-W6ZN4p58k8aDKA4XPcx2hpIQXBRAgyiWVkYhT7CvK6D3iAu7xjvVyhQHg2/iaKJZ1XVJ4r7XuwGL+WGEK37i9w==",
-			"license": "MIT",
-			"peerDependencies": {
-				"react": "^18.0.0 || ^19.0.0 || ^19.0.0-rc",
-				"react-dom": "^18.0.0 || ^19.0.0 || ^19.0.0-rc"
-			}
-		},
-		"node_modules/source-map": {
-			"version": "0.7.6",
-			"resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.6.tgz",
-			"integrity": "sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==",
-			"license": "BSD-3-Clause",
-			"peer": true,
-			"engines": {
-				"node": ">= 12"
-			}
-		},
-		"node_modules/source-map-js": {
-			"version": "1.2.1",
-			"dev": true,
-			"license": "BSD-3-Clause",
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/space-separated-tokens": {
-			"version": "2.0.2",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/split-on-first": {
-			"version": "3.0.0",
-			"resolved": "https://registry.npmjs.org/split-on-first/-/split-on-first-3.0.0.tgz",
-			"integrity": "sha512-qxQJTx2ryR0Dw0ITYyekNQWpz6f8dGd7vffGNflQQ3Iqj9NJ6qiZ7ELpZsJ/QBhIVAiDfXdag3+Gp8RvWa62AA==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=12"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/sindresorhus"
-			}
-		},
-		"node_modules/split-string": {
-			"version": "3.1.0",
-			"resolved": "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz",
-			"integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"extend-shallow": "^3.0.0"
-			},
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/split-string/node_modules/extend-shallow": {
-			"version": "3.0.2",
-			"resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
-			"integrity": "sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"assign-symbols": "^1.0.0",
-				"is-extendable": "^1.0.1"
-			},
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/string-convert": {
-			"version": "0.2.1",
-			"resolved": "https://registry.npmjs.org/string-convert/-/string-convert-0.2.1.tgz",
-			"integrity": "sha512-u/1tdPl4yQnPBjnVrmdLo9gtuLvELKsAoRapekWggdiQNvvvum+jYF329d84NAa660KQw7pB2n36KrIKVoXa3A==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/stringify-entities": {
-			"version": "4.0.4",
-			"license": "MIT",
-			"dependencies": {
-				"character-entities-html4": "^2.0.0",
-				"character-entities-legacy": "^3.0.0"
-			},
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/style-mod": {
-			"version": "4.1.3",
-			"resolved": "https://registry.npmjs.org/style-mod/-/style-mod-4.1.3.tgz",
-			"integrity": "sha512-i/n8VsZydrugj3Iuzll8+x/00GH2vnYsk1eomD8QiRrSAeW6ItbCQDtfXCeJHd0iwiNagqjQkvpvREEPtW3IoQ==",
-			"license": "MIT"
-		},
-		"node_modules/style-to-js": {
-			"version": "1.1.21",
-			"license": "MIT",
-			"dependencies": {
-				"style-to-object": "1.0.14"
-			}
-		},
-		"node_modules/style-to-object": {
-			"version": "1.0.14",
-			"license": "MIT",
-			"dependencies": {
-				"inline-style-parser": "0.2.7"
-			}
-		},
-		"node_modules/stylis": {
-			"version": "4.3.6",
-			"resolved": "https://registry.npmjs.org/stylis/-/stylis-4.3.6.tgz",
-			"integrity": "sha512-yQ3rwFWRfwNUY7H5vpU0wfdkNSnvnJinhF9830Swlaxl03zsOjCfmX0ugac+3LtK0lYSgwL/KXc8oYL3mG4YFQ==",
-			"license": "MIT"
-		},
-		"node_modules/sucrase": {
-			"version": "3.35.1",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@jridgewell/gen-mapping": "^0.3.2",
-				"commander": "^4.0.0",
-				"lines-and-columns": "^1.1.6",
-				"mz": "^2.7.0",
-				"pirates": "^4.0.1",
-				"tinyglobby": "^0.2.11",
-				"ts-interface-checker": "^0.1.9"
-			},
-			"bin": {
-				"sucrase": "bin/sucrase",
-				"sucrase-node": "bin/sucrase-node"
-			},
-			"engines": {
-				"node": ">=16 || 14 >=14.17"
-			}
-		},
-		"node_modules/supports-preserve-symlinks-flag": {
-			"version": "1.0.0",
-			"license": "MIT",
-			"engines": {
-				"node": ">= 0.4"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/ljharb"
-			}
-		},
-		"node_modules/swr": {
-			"version": "2.4.0",
-			"resolved": "https://registry.npmjs.org/swr/-/swr-2.4.0.tgz",
-			"integrity": "sha512-sUlC20T8EOt1pHmDiqueUWMmRRX03W7w5YxovWX7VR2KHEPCTMly85x05vpkP5i6Bu4h44ePSMD9Tc+G2MItFw==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"dequal": "^2.0.3",
-				"use-sync-external-store": "^1.6.0"
-			},
-			"peerDependencies": {
-				"react": "^16.11.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-			}
-		},
-		"node_modules/tabbable": {
-			"version": "6.4.0",
-			"resolved": "https://registry.npmjs.org/tabbable/-/tabbable-6.4.0.tgz",
-			"integrity": "sha512-05PUHKSNE8ou2dwIxTngl4EzcnsCDZGJ/iCLtDflR/SHB/ny14rXc+qU5P4mG9JkusiV7EivzY9Mhm55AzAvCg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/tailwindcss": {
-			"version": "3.4.19",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@alloc/quick-lru": "^5.2.0",
-				"arg": "^5.0.2",
-				"chokidar": "^3.6.0",
-				"didyoumean": "^1.2.2",
-				"dlv": "^1.1.3",
-				"fast-glob": "^3.3.2",
-				"glob-parent": "^6.0.2",
-				"is-glob": "^4.0.3",
-				"jiti": "^1.21.7",
-				"lilconfig": "^3.1.3",
-				"micromatch": "^4.0.8",
-				"normalize-path": "^3.0.0",
-				"object-hash": "^3.0.0",
-				"picocolors": "^1.1.1",
-				"postcss": "^8.4.47",
-				"postcss-import": "^15.1.0",
-				"postcss-js": "^4.0.1",
-				"postcss-load-config": "^4.0.2 || ^5.0 || ^6.0",
-				"postcss-nested": "^6.2.0",
-				"postcss-selector-parser": "^6.1.2",
-				"resolve": "^1.22.8",
-				"sucrase": "^3.35.0"
-			},
-			"bin": {
-				"tailwind": "lib/cli.js",
-				"tailwindcss": "lib/cli.js"
-			},
-			"engines": {
-				"node": ">=14.0.0"
-			}
-		},
-		"node_modules/tailwindcss-animate": {
-			"version": "1.0.7",
-			"dev": true,
-			"license": "MIT",
-			"peerDependencies": {
-				"tailwindcss": ">=3.0.0 || insiders"
-			}
-		},
-		"node_modules/tailwindcss/node_modules/chokidar": {
-			"version": "3.6.0",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"anymatch": "~3.1.2",
-				"braces": "~3.0.2",
-				"glob-parent": "~5.1.2",
-				"is-binary-path": "~2.1.0",
-				"is-glob": "~4.0.1",
-				"normalize-path": "~3.0.0",
-				"readdirp": "~3.6.0"
-			},
-			"engines": {
-				"node": ">= 8.10.0"
-			},
-			"funding": {
-				"url": "https://paulmillr.com/funding/"
-			},
-			"optionalDependencies": {
-				"fsevents": "~2.3.2"
-			}
-		},
-		"node_modules/tailwindcss/node_modules/chokidar/node_modules/glob-parent": {
-			"version": "5.1.2",
-			"dev": true,
-			"license": "ISC",
-			"dependencies": {
-				"is-glob": "^4.0.1"
-			},
-			"engines": {
-				"node": ">= 6"
-			}
-		},
-		"node_modules/tailwindcss/node_modules/chokidar/node_modules/readdirp": {
-			"version": "3.6.0",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"picomatch": "^2.2.1"
-			},
-			"engines": {
-				"node": ">=8.10.0"
-			}
-		},
-		"node_modules/tailwindcss/node_modules/chokidar/node_modules/readdirp/node_modules/picomatch": {
-			"version": "2.3.1",
-			"dev": true,
-			"license": "MIT",
-			"engines": {
-				"node": ">=8.6"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/jonschlinkert"
-			}
-		},
-		"node_modules/tailwindcss/node_modules/postcss-selector-parser": {
-			"version": "6.1.2",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"cssesc": "^3.0.0",
-				"util-deprecate": "^1.0.2"
-			},
-			"engines": {
-				"node": ">=4"
-			}
-		},
-		"node_modules/thenify": {
-			"version": "3.3.1",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"any-promise": "^1.0.0"
-			}
-		},
-		"node_modules/thenify-all": {
-			"version": "1.6.0",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"thenify": ">= 3.1.0 < 4"
-			},
-			"engines": {
-				"node": ">=0.8"
-			}
-		},
-		"node_modules/throttle-debounce": {
-			"version": "5.0.2",
-			"resolved": "https://registry.npmjs.org/throttle-debounce/-/throttle-debounce-5.0.2.tgz",
-			"integrity": "sha512-B71/4oyj61iNH0KeCamLuE2rmKuTO5byTOSVwECM5FA7TiAiAW+UqTKZ9ERueC4qvgSttUhdmq1mXC3kJqGX7A==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=12.22"
-			}
-		},
-		"node_modules/tiny-invariant": {
-			"version": "1.3.3",
-			"license": "MIT"
-		},
-		"node_modules/tiny-warning": {
-			"version": "1.0.3",
-			"license": "MIT"
-		},
-		"node_modules/tinyexec": {
-			"version": "1.0.2",
-			"resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.2.tgz",
-			"integrity": "sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=18"
-			}
-		},
-		"node_modules/tinyglobby": {
-			"version": "0.2.15",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"fdir": "^6.5.0",
-				"picomatch": "^4.0.3"
-			},
-			"engines": {
-				"node": ">=12.0.0"
-			},
-			"funding": {
-				"url": "https://github.com/sponsors/SuperchupuDev"
-			}
-		},
-		"node_modules/to-regex-range": {
-			"version": "5.0.1",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"is-number": "^7.0.0"
-			},
-			"engines": {
-				"node": ">=8.0"
-			}
-		},
-		"node_modules/to-vfile": {
-			"version": "8.0.0",
-			"resolved": "https://registry.npmjs.org/to-vfile/-/to-vfile-8.0.0.tgz",
-			"integrity": "sha512-IcmH1xB5576MJc9qcfEC/m/nQCFt3fzMHz45sSlgJyTWjRbKW1HAkJpuf3DgE57YzIlZcwcBZA5ENQbBo4aLkg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"vfile": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/trim-lines": {
-			"version": "3.0.1",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/trough": {
-			"version": "2.2.0",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/ts-dedent": {
-			"version": "2.2.0",
-			"resolved": "https://registry.npmjs.org/ts-dedent/-/ts-dedent-2.2.0.tgz",
-			"integrity": "sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=6.10"
-			}
-		},
-		"node_modules/ts-interface-checker": {
-			"version": "0.1.13",
-			"dev": true,
-			"license": "Apache-2.0"
-		},
-		"node_modules/ts-md5": {
-			"version": "2.0.1",
-			"resolved": "https://registry.npmjs.org/ts-md5/-/ts-md5-2.0.1.tgz",
-			"integrity": "sha512-yF35FCoEOFBzOclSkMNEUbFQZuv89KEQ+5Xz03HrMSGUGB1+r+El+JiGOFwsP4p9RFNzwlrydYoTLvPOuICl9w==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=18"
-			}
-		},
-		"node_modules/tslib": {
-			"version": "2.8.1",
-			"license": "0BSD"
-		},
-		"node_modules/typescript": {
-			"version": "5.9.3",
-			"dev": true,
-			"license": "Apache-2.0",
-			"bin": {
-				"tsc": "bin/tsc",
-				"tsserver": "bin/tsserver"
-			},
-			"engines": {
-				"node": ">=14.17"
-			}
-		},
-		"node_modules/ufo": {
-			"version": "1.6.3",
-			"resolved": "https://registry.npmjs.org/ufo/-/ufo-1.6.3.tgz",
-			"integrity": "sha512-yDJTmhydvl5lJzBmy/hyOAA0d+aqCBuwl818haVdYCRrWV84o7YyeVm4QlVHStqNrrJSTb6jKuFAVqAFsr+K3Q==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/unified": {
-			"version": "11.0.5",
-			"license": "MIT",
-			"dependencies": {
-				"@types/unist": "^3.0.0",
-				"bail": "^2.0.0",
-				"devlop": "^1.0.0",
-				"extend": "^3.0.0",
-				"is-plain-obj": "^4.0.0",
-				"trough": "^2.0.0",
-				"vfile": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/unist-util-find-after": {
-			"version": "5.0.0",
-			"resolved": "https://registry.npmjs.org/unist-util-find-after/-/unist-util-find-after-5.0.0.tgz",
-			"integrity": "sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/unist": "^3.0.0",
-				"unist-util-is": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/unist-util-is": {
-			"version": "6.0.1",
-			"license": "MIT",
-			"dependencies": {
-				"@types/unist": "^3.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/unist-util-position": {
-			"version": "5.0.0",
-			"license": "MIT",
-			"dependencies": {
-				"@types/unist": "^3.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/unist-util-position-from-estree": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/unist-util-position-from-estree/-/unist-util-position-from-estree-2.0.0.tgz",
-			"integrity": "sha512-KaFVRjoqLyF6YXCbVLNad/eS4+OfPQQn2yOd7zF/h5T/CSL2v8NpN6a5TPvtbXthAGw5nG+PuTtq+DdIZr+cRQ==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/unist": "^3.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/unist-util-remove-position": {
-			"version": "5.0.0",
-			"resolved": "https://registry.npmjs.org/unist-util-remove-position/-/unist-util-remove-position-5.0.0.tgz",
-			"integrity": "sha512-Hp5Kh3wLxv0PHj9m2yZhhLt58KzPtEYKQQ4yxfYFEO7EvHwzyDYnduhHnY1mDxoqr7VUwVuHXk9RXKIiYS1N8Q==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/unist": "^3.0.0",
-				"unist-util-visit": "^5.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/unist-util-stringify-position": {
-			"version": "4.0.0",
-			"license": "MIT",
-			"dependencies": {
-				"@types/unist": "^3.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/unist-util-visit": {
-			"version": "5.1.0",
-			"license": "MIT",
-			"dependencies": {
-				"@types/unist": "^3.0.0",
-				"unist-util-is": "^6.0.0",
-				"unist-util-visit-parents": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/unist-util-visit-parents": {
-			"version": "6.0.2",
-			"license": "MIT",
-			"dependencies": {
-				"@types/unist": "^3.0.0",
-				"unist-util-is": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/update-browserslist-db": {
-			"version": "1.2.3",
-			"dev": true,
-			"funding": [
-				{
-					"type": "opencollective",
-					"url": "https://opencollective.com/browserslist"
-				},
-				{
-					"type": "tidelift",
-					"url": "https://tidelift.com/funding/github/npm/browserslist"
-				},
-				{
-					"type": "github",
-					"url": "https://github.com/sponsors/ai"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"escalade": "^3.2.0",
-				"picocolors": "^1.1.1"
-			},
-			"bin": {
-				"update-browserslist-db": "cli.js"
-			},
-			"peerDependencies": {
-				"browserslist": ">= 4.21.0"
-			}
-		},
-		"node_modules/url-join": {
-			"version": "5.0.0",
-			"resolved": "https://registry.npmjs.org/url-join/-/url-join-5.0.0.tgz",
-			"integrity": "sha512-n2huDr9h9yzd6exQVnH/jU5mr+Pfx08LRXXZhkLLetAMESRj+anQsTAh940iMrIetKAmry9coFuZQ2jY8/p3WA==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-			}
-		},
-		"node_modules/use-callback-ref": {
-			"version": "1.3.3",
-			"resolved": "https://registry.npmjs.org/use-callback-ref/-/use-callback-ref-1.3.3.tgz",
-			"integrity": "sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg==",
-			"license": "MIT",
-			"dependencies": {
-				"tslib": "^2.0.0"
-			},
-			"engines": {
-				"node": ">=10"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/use-merge-value": {
-			"version": "1.2.0",
-			"resolved": "https://registry.npmjs.org/use-merge-value/-/use-merge-value-1.2.0.tgz",
-			"integrity": "sha512-DXgG0kkgJN45TcyoXL49vJnn55LehnrmoHc7MbKi+QDBvr8dsesqws8UlyIWGHMR+JXgxc1nvY+jDGMlycsUcw==",
-			"license": "MIT",
-			"peerDependencies": {
-				"react": ">= 16.x"
-			}
-		},
-		"node_modules/use-sidecar": {
-			"version": "1.1.3",
-			"resolved": "https://registry.npmjs.org/use-sidecar/-/use-sidecar-1.1.3.tgz",
-			"integrity": "sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ==",
-			"license": "MIT",
-			"dependencies": {
-				"detect-node-es": "^1.1.0",
-				"tslib": "^2.0.0"
-			},
-			"engines": {
-				"node": ">=10"
-			},
-			"peerDependencies": {
-				"@types/react": "*",
-				"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/use-sync-external-store": {
-			"version": "1.6.0",
-			"license": "MIT",
-			"peerDependencies": {
-				"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-			}
-		},
-		"node_modules/util-deprecate": {
-			"version": "1.0.2",
-			"dev": true,
-			"license": "MIT"
-		},
-		"node_modules/uuid": {
-			"version": "13.0.0",
-			"resolved": "https://registry.npmjs.org/uuid/-/uuid-13.0.0.tgz",
-			"integrity": "sha512-XQegIaBTVUjSHliKqcnFqYypAd4S+WCYt5NIeRs6w/UAry7z8Y9j5ZwRRL4kzq9U3sD6v+85er9FvkEaBpji2w==",
-			"funding": [
-				"https://github.com/sponsors/broofa",
-				"https://github.com/sponsors/ctavan"
-			],
-			"license": "MIT",
-			"peer": true,
-			"bin": {
-				"uuid": "dist-node/bin/uuid"
-			}
-		},
-		"node_modules/v8n": {
-			"version": "1.5.1",
-			"resolved": "https://registry.npmjs.org/v8n/-/v8n-1.5.1.tgz",
-			"integrity": "sha512-LdabyT4OffkyXFCe9UT+uMkxNBs5rcTVuZClvxQr08D5TUgo1OFKkoT65qYRCsiKBl/usHjpXvP4hHMzzDRj3A==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/vfile": {
-			"version": "6.0.3",
-			"license": "MIT",
-			"dependencies": {
-				"@types/unist": "^3.0.0",
-				"vfile-message": "^4.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/vfile-location": {
-			"version": "5.0.3",
-			"resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-5.0.3.tgz",
-			"integrity": "sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"@types/unist": "^3.0.0",
-				"vfile": "^6.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/vfile-message": {
-			"version": "4.0.3",
-			"license": "MIT",
-			"dependencies": {
-				"@types/unist": "^3.0.0",
-				"unist-util-stringify-position": "^4.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/unified"
-			}
-		},
-		"node_modules/victory-vendor": {
-			"version": "37.3.6",
-			"license": "MIT AND ISC",
-			"dependencies": {
-				"@types/d3-array": "^3.0.3",
-				"@types/d3-ease": "^3.0.0",
-				"@types/d3-interpolate": "^3.0.1",
-				"@types/d3-scale": "^4.0.2",
-				"@types/d3-shape": "^3.1.0",
-				"@types/d3-time": "^3.0.0",
-				"@types/d3-timer": "^3.0.0",
-				"d3-array": "^3.1.6",
-				"d3-ease": "^3.0.1",
-				"d3-interpolate": "^3.0.1",
-				"d3-scale": "^4.0.2",
-				"d3-shape": "^3.1.0",
-				"d3-time": "^3.0.0",
-				"d3-timer": "^3.0.1"
-			}
-		},
-		"node_modules/virtua": {
-			"version": "0.48.6",
-			"resolved": "https://registry.npmjs.org/virtua/-/virtua-0.48.6.tgz",
-			"integrity": "sha512-Cl4uMvMV5c9RuOy9zhkFMYwx/V4YLBMYLRSWkO8J46opQZ3P7KMq0CqCVOOAKUckjl/r//D2jWTBGYWzmgtzrQ==",
-			"license": "MIT",
-			"peer": true,
-			"peerDependencies": {
-				"react": ">=16.14.0",
-				"react-dom": ">=16.14.0",
-				"solid-js": ">=1.0",
-				"svelte": ">=5.0",
-				"vue": ">=3.2"
-			},
-			"peerDependenciesMeta": {
-				"react": {
-					"optional": true
-				},
-				"react-dom": {
-					"optional": true
-				},
-				"solid-js": {
-					"optional": true
-				},
-				"svelte": {
-					"optional": true
-				},
-				"vue": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/vite": {
-			"version": "6.4.1",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"esbuild": "^0.25.0",
-				"fdir": "^6.4.4",
-				"picomatch": "^4.0.2",
-				"postcss": "^8.5.3",
-				"rollup": "^4.34.9",
-				"tinyglobby": "^0.2.13"
-			},
-			"bin": {
-				"vite": "bin/vite.js"
-			},
-			"engines": {
-				"node": "^18.0.0 || ^20.0.0 || >=22.0.0"
-			},
-			"funding": {
-				"url": "https://github.com/vitejs/vite?sponsor=1"
-			},
-			"optionalDependencies": {
-				"fsevents": "~2.3.3"
-			},
-			"peerDependencies": {
-				"@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
-				"jiti": ">=1.21.0",
-				"less": "*",
-				"lightningcss": "^1.21.0",
-				"sass": "*",
-				"sass-embedded": "*",
-				"stylus": "*",
-				"sugarss": "*",
-				"terser": "^5.16.0",
-				"tsx": "^4.8.1",
-				"yaml": "^2.4.2"
-			},
-			"peerDependenciesMeta": {
-				"@types/node": {
-					"optional": true
-				},
-				"jiti": {
-					"optional": true
-				},
-				"less": {
-					"optional": true
-				},
-				"lightningcss": {
-					"optional": true
-				},
-				"sass": {
-					"optional": true
-				},
-				"sass-embedded": {
-					"optional": true
-				},
-				"stylus": {
-					"optional": true
-				},
-				"sugarss": {
-					"optional": true
-				},
-				"terser": {
-					"optional": true
-				},
-				"tsx": {
-					"optional": true
-				},
-				"yaml": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/vscode-jsonrpc": {
-			"version": "8.2.0",
-			"resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.2.0.tgz",
-			"integrity": "sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA==",
-			"license": "MIT",
-			"peer": true,
-			"engines": {
-				"node": ">=14.0.0"
-			}
-		},
-		"node_modules/vscode-languageserver": {
-			"version": "9.0.1",
-			"resolved": "https://registry.npmjs.org/vscode-languageserver/-/vscode-languageserver-9.0.1.tgz",
-			"integrity": "sha512-woByF3PDpkHFUreUa7Hos7+pUWdeWMXRd26+ZX2A8cFx6v/JPTtd4/uN0/jB6XQHYaOlHbio03NTHCqrgG5n7g==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"vscode-languageserver-protocol": "3.17.5"
-			},
-			"bin": {
-				"installServerIntoExtension": "bin/installServerIntoExtension"
-			}
-		},
-		"node_modules/vscode-languageserver-protocol": {
-			"version": "3.17.5",
-			"resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.17.5.tgz",
-			"integrity": "sha512-mb1bvRJN8SVznADSGWM9u/b07H7Ecg0I3OgXDuLdn307rl/J3A9YD6/eYOssqhecL27hK1IPZAsaqh00i/Jljg==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"vscode-jsonrpc": "8.2.0",
-				"vscode-languageserver-types": "3.17.5"
-			}
-		},
-		"node_modules/vscode-languageserver-textdocument": {
-			"version": "1.0.12",
-			"resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.12.tgz",
-			"integrity": "sha512-cxWNPesCnQCcMPeenjKKsOCKQZ/L6Tv19DTRIGuLWe32lyzWhihGVJ/rcckZXJxfdKCFvRLS3fpBIsV/ZGX4zA==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/vscode-languageserver-types": {
-			"version": "3.17.5",
-			"resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.17.5.tgz",
-			"integrity": "sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/vscode-uri": {
-			"version": "3.1.0",
-			"resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-3.1.0.tgz",
-			"integrity": "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==",
-			"license": "MIT",
-			"peer": true
-		},
-		"node_modules/w3c-keyname": {
-			"version": "2.2.8",
-			"resolved": "https://registry.npmjs.org/w3c-keyname/-/w3c-keyname-2.2.8.tgz",
-			"integrity": "sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==",
-			"license": "MIT"
-		},
-		"node_modules/web-namespaces": {
-			"version": "2.0.1",
-			"resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz",
-			"integrity": "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==",
-			"license": "MIT",
-			"peer": true,
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		},
-		"node_modules/yallist": {
-			"version": "3.1.1",
-			"dev": true,
-			"license": "ISC"
-		},
-		"node_modules/zod": {
-			"version": "4.3.6",
-			"resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz",
-			"integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==",
-			"license": "MIT",
-			"funding": {
-				"url": "https://github.com/sponsors/colinhacks"
-			}
-		},
-		"node_modules/zustand": {
-			"version": "4.5.7",
-			"resolved": "https://registry.npmjs.org/zustand/-/zustand-4.5.7.tgz",
-			"integrity": "sha512-CHOUy7mu3lbD6o6LJLfllpjkzhHXSBlX8B9+qPddUsIfeF5S/UZ5q0kmCsnRqT1UHFQZchNFDDzMbQsuesHWlw==",
-			"license": "MIT",
-			"dependencies": {
-				"use-sync-external-store": "^1.2.2"
-			},
-			"engines": {
-				"node": ">=12.7.0"
-			},
-			"peerDependencies": {
-				"@types/react": ">=16.8",
-				"immer": ">=9.0.6",
-				"react": ">=16.8"
-			},
-			"peerDependenciesMeta": {
-				"@types/react": {
-					"optional": true
-				},
-				"immer": {
-					"optional": true
-				},
-				"react": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/zwitch": {
-			"version": "2.0.4",
-			"license": "MIT",
-			"funding": {
-				"type": "github",
-				"url": "https://github.com/sponsors/wooorm"
-			}
-		}
-	}
-}
diff --git a/interface/package.json b/interface/package.json
index 249dbad30..ea5405bea 100644
--- a/interface/package.json
+++ b/interface/package.json
@@ -38,6 +38,7 @@
 		"@radix-ui/react-tooltip": "^1.2.8",
 		"@react-sigma/core": "^5.0.6",
 		"@tanstack/react-query": "^5.62.0",
+		"@tanstack/react-query-devtools": "^5.91.3",
 		"@tanstack/react-router": "^1.159.5",
 		"@tanstack/react-virtual": "^3.13.18",
 		"@tanstack/router-devtools": "^1.159.5",
diff --git a/interface/src/App.tsx b/interface/src/App.tsx
index 886e844c8..78e154a2f 100644
--- a/interface/src/App.tsx
+++ b/interface/src/App.tsx
@@ -1,5 +1,7 @@
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { ReactQueryDevtools } from "@tanstack/react-query-devtools";
 import { RouterProvider } from "@tanstack/react-router";
+import { ErrorBoundary } from "@/components/ErrorBoundary";
 import { LiveContextProvider } from "@/hooks/useLiveContext";
 import { router } from "@/router";
 
@@ -15,10 +17,15 @@ const queryClient = new QueryClient({
 
 export function App() {
 	return (
-		<QueryClientProvider client={queryClient}>
-			<LiveContextProvider>
-				<RouterProvider router={router} />
-			</LiveContextProvider>
-		</QueryClientProvider>
+		<ErrorBoundary>
+			<QueryClientProvider client={queryClient}>
+				<LiveContextProvider>
+					<RouterProvider router={router} />
+				</LiveContextProvider>
+				{import.meta.env.DEV && (
+				<ReactQueryDevtools initialIsOpen={false} buttonPosition="bottom-right" />
+			)}
+			</QueryClientProvider>
+		</ErrorBoundary>
 	);
 }
diff --git a/interface/src/api/client.ts b/interface/src/api/client.ts
index e78808eea..d2c15719e 100644
--- a/interface/src/api/client.ts
+++ b/interface/src/api/client.ts
@@ -40,6 +40,14 @@ export interface OutboundMessageEvent {
 	text: string;
 }
 
+export interface OutboundMessageDeltaEvent {
+	type: "outbound_message_delta";
+	agent_id: string;
+	channel_id: string;
+	text_delta: string;
+	aggregated_text: string;
+}
+
 export interface TypingStateEvent {
 	type: "typing_state";
 	agent_id: string;
@@ -53,6 +61,8 @@ export interface WorkerStartedEvent {
 	channel_id: string | null;
 	worker_id: string;
 	task: string;
+	worker_type?: string;
+	interactive?: boolean;
 }
 
 export interface WorkerStatusEvent {
@@ -63,12 +73,20 @@ export interface WorkerStatusEvent {
 	status: string;
 }
 
+export interface WorkerIdleEvent {
+	type: "worker_idle";
+	agent_id: string;
+	channel_id: string | null;
+	worker_id: string;
+}
+
 export interface WorkerCompletedEvent {
 	type: "worker_completed";
 	agent_id: string;
 	channel_id: string | null;
 	worker_id: string;
 	result: string;
+	success?: boolean;
 }
 
 export interface BranchStartedEvent {
@@ -94,6 +112,7 @@ export interface ToolStartedEvent {
 	process_type: ProcessType;
 	process_id: string;
 	tool_name: string;
+	args: string;
 }
 
 export interface ToolCompletedEvent {
@@ -103,19 +122,44 @@ export interface ToolCompletedEvent {
 	process_type: ProcessType;
 	process_id: string;
 	tool_name: string;
+	result: string;
+}
+
+// -- OpenCode live transcript part types --
+
+export type OpenCodeToolState =
+	| { status: "pending" }
+	| { status: "running"; title?: string; input?: string }
+	| { status: "completed"; title?: string; input?: string; output?: string }
+	| { status: "error"; error?: string };
+
+export type OpenCodePart =
+	| { type: "text"; id: string; text: string }
+	| { type: "tool"; id: string; tool: string } & OpenCodeToolState
+	| { type: "step_start"; id: string }
+	| { type: "step_finish"; id: string; reason?: string };
+
+export interface OpenCodePartUpdatedEvent {
+	type: "opencode_part_updated";
+	agent_id: string;
+	worker_id: string;
+	part: OpenCodePart;
 }
 
 export type ApiEvent =
 	| InboundMessageEvent
 	| OutboundMessageEvent
+	| OutboundMessageDeltaEvent
 	| TypingStateEvent
 	| WorkerStartedEvent
 	| WorkerStatusEvent
+	| WorkerIdleEvent
 	| WorkerCompletedEvent
 	| BranchStartedEvent
 	| BranchCompletedEvent
 	| ToolStartedEvent
-	| ToolCompletedEvent;
+	| ToolCompletedEvent
+	| OpenCodePartUpdatedEvent;
 
 async function fetchJson<T>(path: string): Promise<T> {
 	const response = await fetch(`${API_BASE}${path}`);
@@ -168,6 +212,7 @@ export interface WorkerStatusInfo {
 	started_at: string;
 	notify_on_complete: boolean;
 	tool_calls: number;
+	interactive: boolean;
 }
 
 export interface BranchStatusInfo {
@@ -193,6 +238,54 @@ export interface StatusBlockSnapshot {
 /** channel_id -> StatusBlockSnapshot */
 export type ChannelStatusResponse = Record<string, StatusBlockSnapshot>;
 
+// --- Workers API types ---
+
+export type ActionContent =
+	| { type: "text"; text: string }
+	| { type: "tool_call"; id: string; name: string; args: string };
+
+export type TranscriptStep =
+	| { type: "action"; content: ActionContent[] }
+	| { type: "tool_result"; call_id: string; name: string; text: string };
+
+export interface WorkerRunInfo {
+	id: string;
+	task: string;
+	status: string;
+	worker_type: string;
+	channel_id: string | null;
+	channel_name: string | null;
+	started_at: string;
+	completed_at: string | null;
+	has_transcript: boolean;
+	live_status: string | null;
+	tool_calls: number;
+	opencode_port: number | null;
+	interactive: boolean;
+}
+
+export interface WorkerDetailResponse {
+	id: string;
+	task: string;
+	result: string | null;
+	status: string;
+	worker_type: string;
+	channel_id: string | null;
+	channel_name: string | null;
+	started_at: string;
+	completed_at: string | null;
+	transcript: TranscriptStep[] | null;
+	tool_calls: number;
+	opencode_session_id: string | null;
+	opencode_port: number | null;
+	interactive: boolean;
+}
+
+export interface WorkerListResponse {
+	workers: WorkerRunInfo[];
+	total: number;
+}
+
 export interface AgentInfo {
 	id: string;
 	display_name?: string;
@@ -273,6 +366,8 @@ export interface UpdateStatus {
 	release_notes: string | null;
 	deployment: Deployment;
 	can_apply: boolean;
+	cannot_apply_reason: string | null;
+	docker_image: string | null;
 	checked_at: string | null;
 	error: string | null;
 }
@@ -515,6 +610,17 @@ export interface BrowserSection {
 	enabled: boolean;
 	headless: boolean;
 	evaluate_enabled: boolean;
+	persist_session: boolean;
+	close_policy: "close_browser" | "close_tabs" | "detach";
+}
+
+export interface ChannelSection {
+	listen_only_mode: boolean;
+}
+
+export interface SandboxSection {
+	mode: "enabled" | "disabled";
+	writable_paths: string[];
 }
 
 export interface DiscordSection {
@@ -530,7 +636,9 @@ export interface AgentConfigResponse {
 	coalesce: CoalesceSection;
 	memory_persistence: MemoryPersistenceSection;
 	browser: BrowserSection;
+	channel: ChannelSection;
 	discord: DiscordSection;
+	sandbox: SandboxSection;
 }
 
 // Partial update types - all fields are optional
@@ -591,6 +699,17 @@ export interface BrowserUpdate {
 	enabled?: boolean;
 	headless?: boolean;
 	evaluate_enabled?: boolean;
+	persist_session?: boolean;
+	close_policy?: "close_browser" | "close_tabs" | "detach";
+}
+
+export interface ChannelUpdate {
+	listen_only_mode?: boolean;
+}
+
+export interface SandboxUpdate {
+	mode?: "enabled" | "disabled";
+	writable_paths?: string[];
 }
 
 export interface DiscordUpdate {
@@ -606,7 +725,9 @@ export interface AgentConfigUpdateRequest {
 	coalesce?: CoalesceUpdate;
 	memory_persistence?: MemoryPersistenceUpdate;
 	browser?: BrowserUpdate;
+	channel?: ChannelUpdate;
 	discord?: DiscordUpdate;
+	sandbox?: SandboxUpdate;
 }
 
 // -- Cron Types --
@@ -665,6 +786,7 @@ export interface ProviderStatus {
 	openai: boolean;
 	openai_chatgpt: boolean;
 	openrouter: boolean;
+	kilo: boolean;
 	zhipu: boolean;
 	groq: boolean;
 	together: boolean;
@@ -675,6 +797,7 @@ export interface ProviderStatus {
 	gemini: boolean;
 	ollama: boolean;
 	opencode_zen: boolean;
+	opencode_go: boolean;
 	nvidia: boolean;
 	minimax: boolean;
 	minimax_cn: boolean;
@@ -764,6 +887,7 @@ export interface SkillInfo {
 	file_path: string;
 	base_dir: string;
 	source: "instance" | "workspace";
+	source_repo?: string;
 }
 
 export interface SkillsListResponse {
@@ -799,12 +923,14 @@ export interface RegistrySkill {
 	skillId: string;
 	name: string;
 	installs: number;
+	description?: string;
 	id?: string;
 }
 
 export interface RegistryBrowseResponse {
 	skills: RegistrySkill[];
 	has_more: boolean;
+	total?: number;
 }
 
 export interface RegistrySearchResponse {
@@ -813,6 +939,72 @@ export interface RegistrySearchResponse {
 	count: number;
 }
 
+// -- Task Types --
+
+export type TaskStatus = "pending_approval" | "backlog" | "ready" | "in_progress" | "done";
+export type TaskPriority = "critical" | "high" | "medium" | "low";
+
+export interface TaskSubtask {
+	title: string;
+	completed: boolean;
+}
+
+export interface TaskItem {
+	id: string;
+	agent_id: string;
+	task_number: number;
+	title: string;
+	description?: string;
+	status: TaskStatus;
+	priority: TaskPriority;
+	subtasks: TaskSubtask[];
+	metadata: Record<string, unknown>;
+	source_memory_id?: string;
+	worker_id?: string;
+	created_by: string;
+	approved_at?: string;
+	approved_by?: string;
+	created_at: string;
+	updated_at: string;
+	completed_at?: string;
+}
+
+export interface TaskListResponse {
+	tasks: TaskItem[];
+}
+
+export interface TaskResponse {
+	task: TaskItem;
+}
+
+export interface TaskActionResponse {
+	success: boolean;
+	message: string;
+}
+
+export interface CreateTaskRequest {
+	title: string;
+	description?: string;
+	status?: TaskStatus;
+	priority?: TaskPriority;
+	subtasks?: TaskSubtask[];
+	metadata?: Record<string, unknown>;
+	source_memory_id?: string;
+	created_by?: string;
+}
+
+export interface UpdateTaskRequest {
+	title?: string;
+	description?: string;
+	status?: TaskStatus;
+	priority?: TaskPriority;
+	subtasks?: TaskSubtask[];
+	metadata?: Record<string, unknown>;
+	complete_subtask?: number;
+	worker_id?: string;
+	approved_by?: string;
+}
+
 // -- Messaging / Bindings Types --
 
 export interface PlatformStatus {
@@ -820,17 +1012,68 @@ export interface PlatformStatus {
 	enabled: boolean;
 }
 
+export interface AdapterInstanceStatus {
+	platform: string;
+	name: string | null;
+	runtime_key: string;
+	configured: boolean;
+	enabled: boolean;
+	binding_count: number;
+}
+
 export interface MessagingStatusResponse {
 	discord: PlatformStatus;
 	slack: PlatformStatus;
 	telegram: PlatformStatus;
 	webhook: PlatformStatus;
 	twitch: PlatformStatus;
+	email: PlatformStatus;
+	instances: AdapterInstanceStatus[];
+}
+
+export interface CreateMessagingInstanceRequest {
+	platform: string;
+	name?: string;
+	enabled?: boolean;
+	credentials: {
+		discord_token?: string;
+		slack_bot_token?: string;
+		slack_app_token?: string;
+		telegram_token?: string;
+		twitch_username?: string;
+		twitch_oauth_token?: string;
+		twitch_client_id?: string;
+		twitch_client_secret?: string;
+		twitch_refresh_token?: string;
+		email_imap_host?: string;
+		email_imap_port?: number;
+		email_imap_username?: string;
+		email_imap_password?: string;
+		email_smtp_host?: string;
+		email_smtp_port?: number;
+		email_smtp_username?: string;
+		email_smtp_password?: string;
+		email_from_address?: string;
+		webhook_port?: number;
+		webhook_bind?: string;
+		webhook_auth_token?: string;
+	};
+}
+
+export interface DeleteMessagingInstanceRequest {
+	platform: string;
+	name?: string;
+}
+
+export interface MessagingInstanceActionResponse {
+	success: boolean;
+	message: string;
 }
 
 export interface BindingInfo {
 	agent_id: string;
 	channel: string;
+	adapter: string | null;
 	guild_id: string | null;
 	workspace_id: string | null;
 	chat_id: string | null;
@@ -846,6 +1089,7 @@ export interface BindingsListResponse {
 export interface CreateBindingRequest {
 	agent_id: string;
 	channel: string;
+	adapter?: string;
 	guild_id?: string;
 	workspace_id?: string;
 	chat_id?: string;
@@ -856,6 +1100,17 @@ export interface CreateBindingRequest {
 		discord_token?: string;
 		slack_bot_token?: string;
 		slack_app_token?: string;
+		telegram_token?: string;
+		email_imap_host?: string;
+		email_imap_port?: number;
+		email_imap_username?: string;
+		email_imap_password?: string;
+		email_smtp_host?: string;
+		email_smtp_port?: number;
+		email_smtp_username?: string;
+		email_smtp_password?: string;
+		email_from_address?: string;
+		email_from_name?: string;
 		twitch_username?: string;
 		twitch_oauth_token?: string;
 		twitch_client_id?: string;
@@ -873,11 +1128,13 @@ export interface CreateBindingResponse {
 export interface UpdateBindingRequest {
 	original_agent_id: string;
 	original_channel: string;
+	original_adapter?: string;
 	original_guild_id?: string;
 	original_workspace_id?: string;
 	original_chat_id?: string;
 	agent_id: string;
 	channel: string;
+	adapter?: string;
 	guild_id?: string;
 	workspace_id?: string;
 	chat_id?: string;
@@ -894,6 +1151,7 @@ export interface UpdateBindingResponse {
 export interface DeleteBindingRequest {
 	agent_id: string;
 	channel: string;
+	adapter?: string;
 	guild_id?: string;
 	workspace_id?: string;
 	chat_id?: string;
@@ -1057,6 +1315,66 @@ export interface AgentMessageEvent {
 	channel_id: string;
 }
 
+// ── Secrets ──────────────────────────────────────────────────────────────
+
+export type SecretCategory = "system" | "tool";
+export type StoreState = "unencrypted" | "locked" | "unlocked";
+
+export interface SecretStoreStatus {
+	state: StoreState;
+	encrypted: boolean;
+	secret_count: number;
+	system_count: number;
+	tool_count: number;
+	platform_managed: boolean;
+}
+
+export interface SecretListItem {
+	name: string;
+	category: SecretCategory;
+	created_at: string;
+	updated_at: string;
+}
+
+export interface SecretListResponse {
+	secrets: SecretListItem[];
+}
+
+export interface PutSecretResponse {
+	name: string;
+	category: SecretCategory;
+	reload_required: boolean;
+	message: string;
+}
+
+export interface DeleteSecretResponse {
+	deleted: string;
+	warning?: string;
+}
+
+export interface EncryptResponse {
+	master_key: string;
+	message: string;
+}
+
+export interface UnlockResponse {
+	state: string;
+	secret_count: number;
+	message: string;
+}
+
+export interface MigrationItem {
+	config_key: string;
+	secret_name: string;
+	category: SecretCategory;
+}
+
+export interface MigrateResponse {
+	migrated: MigrationItem[];
+	skipped: string[];
+	message: string;
+}
+
 export const api = {
 	status: () => fetchJson<StatusResponse>("/status"),
 	overview: () => fetchJson<InstanceOverviewResponse>("/overview"),
@@ -1076,6 +1394,15 @@ export const api = {
 		return fetchJson<MessagesResponse>(`/channels/messages?${params}`);
 	},
 	channelStatus: () => fetchJson<ChannelStatusResponse>("/channels/status"),
+	workersList: (agentId: string, params: { limit?: number; offset?: number; status?: string } = {}) => {
+		const search = new URLSearchParams({ agent_id: agentId });
+		if (params.limit) search.set("limit", String(params.limit));
+		if (params.offset) search.set("offset", String(params.offset));
+		if (params.status) search.set("status", params.status);
+		return fetchJson<WorkerListResponse>(`/agents/workers?${search}`);
+	},
+	workerDetail: (agentId: string, workerId: string) =>
+		fetchJson<WorkerDetailResponse>(`/agents/workers/detail?agent_id=${encodeURIComponent(agentId)}&worker_id=${encodeURIComponent(workerId)}`),
 	agentMemories: (agentId: string, params: MemoriesListParams = {}) => {
 		const search = new URLSearchParams({ agent_id: agentId });
 		if (params.limit) search.set("limit", String(params.limit));
@@ -1411,11 +1738,13 @@ export const api = {
 		return response.json() as Promise<DeleteBindingResponse>;
 	},
 
-	togglePlatform: async (platform: string, enabled: boolean) => {
+	togglePlatform: async (platform: string, enabled: boolean, adapter?: string) => {
+		const body: Record<string, unknown> = { platform, enabled };
+		if (adapter) body.adapter = adapter;
 		const response = await fetch(`${API_BASE}/messaging/toggle`, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ platform, enabled }),
+			body: JSON.stringify(body),
 		});
 		if (!response.ok) {
 			throw new Error(`API error: ${response.status}`);
@@ -1423,11 +1752,13 @@ export const api = {
 		return response.json() as Promise<{ success: boolean; message: string }>;
 	},
 
-	disconnectPlatform: async (platform: string) => {
+	disconnectPlatform: async (platform: string, adapter?: string) => {
+		const body: Record<string, unknown> = { platform };
+		if (adapter) body.adapter = adapter;
 		const response = await fetch(`${API_BASE}/messaging/disconnect`, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ platform }),
+			body: JSON.stringify(body),
 		});
 		if (!response.ok) {
 			throw new Error(`API error: ${response.status}`);
@@ -1435,6 +1766,30 @@ export const api = {
 		return response.json() as Promise<{ success: boolean; message: string }>;
 	},
 
+	createMessagingInstance: async (request: CreateMessagingInstanceRequest) => {
+		const response = await fetch(`${API_BASE}/messaging/instances`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(request),
+		});
+		if (!response.ok) {
+			throw new Error(`API error: ${response.status}`);
+		}
+		return response.json() as Promise<MessagingInstanceActionResponse>;
+	},
+
+	deleteMessagingInstance: async (request: DeleteMessagingInstanceRequest) => {
+		const response = await fetch(`${API_BASE}/messaging/instances`, {
+			method: "DELETE",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(request),
+		});
+		if (!response.ok) {
+			throw new Error(`API error: ${response.status}`);
+		}
+		return response.json() as Promise<MessagingInstanceActionResponse>;
+	},
+
 	// Global Settings API
 	globalSettings: () => fetchJson<GlobalSettingsResponse>("/settings"),
 	
@@ -1650,5 +2005,129 @@ export const api = {
 	webChatHistory: (agentId: string, sessionId: string, limit = 100) =>
 		fetch(`${API_BASE}/webchat/history?agent_id=${encodeURIComponent(agentId)}&session_id=${encodeURIComponent(sessionId)}&limit=${limit}`),
 
+	// Tasks API
+	listTasks: (agentId: string, params?: { status?: TaskStatus; priority?: TaskPriority; limit?: number }) => {
+		const search = new URLSearchParams({ agent_id: agentId });
+		if (params?.status) search.set("status", params.status);
+		if (params?.priority) search.set("priority", params.priority);
+		if (params?.limit) search.set("limit", String(params.limit));
+		return fetchJson<TaskListResponse>(`/agents/tasks?${search}`);
+	},
+	getTask: (agentId: string, taskNumber: number) =>
+		fetchJson<TaskResponse>(`/agents/tasks/${taskNumber}?agent_id=${encodeURIComponent(agentId)}`),
+	createTask: async (agentId: string, request: CreateTaskRequest): Promise<TaskResponse> => {
+		const response = await fetch(`${API_BASE}/agents/tasks`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ ...request, agent_id: agentId }),
+		});
+		if (!response.ok) throw new Error(`API error: ${response.status}`);
+		return response.json() as Promise<TaskResponse>;
+	},
+	updateTask: async (agentId: string, taskNumber: number, request: UpdateTaskRequest): Promise<TaskResponse> => {
+		const response = await fetch(`${API_BASE}/agents/tasks/${taskNumber}`, {
+			method: "PUT",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ ...request, agent_id: agentId }),
+		});
+		if (!response.ok) throw new Error(`API error: ${response.status}`);
+		return response.json() as Promise<TaskResponse>;
+	},
+	deleteTask: async (agentId: string, taskNumber: number): Promise<TaskActionResponse> => {
+		const response = await fetch(`${API_BASE}/agents/tasks/${taskNumber}?agent_id=${encodeURIComponent(agentId)}`, {
+			method: "DELETE",
+		});
+		if (!response.ok) throw new Error(`API error: ${response.status}`);
+		return response.json() as Promise<TaskActionResponse>;
+	},
+	approveTask: async (agentId: string, taskNumber: number, approvedBy?: string): Promise<TaskResponse> => {
+		const response = await fetch(`${API_BASE}/agents/tasks/${taskNumber}/approve`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ agent_id: agentId, approved_by: approvedBy }),
+		});
+		if (!response.ok) throw new Error(`API error: ${response.status}`);
+		return response.json() as Promise<TaskResponse>;
+	},
+	executeTask: async (agentId: string, taskNumber: number): Promise<TaskResponse> => {
+		const response = await fetch(`${API_BASE}/agents/tasks/${taskNumber}/execute`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ agent_id: agentId }),
+		});
+		if (!response.ok) throw new Error(`API error: ${response.status}`);
+		return response.json() as Promise<TaskResponse>;
+	},
+
+	// Secrets API
+	secretsStatus: () => fetchJson<SecretStoreStatus>("/secrets/status"),
+	listSecrets: () => fetchJson<SecretListResponse>("/secrets"),
+	putSecret: async (name: string, value: string, category?: SecretCategory): Promise<PutSecretResponse> => {
+		const response = await fetch(`${API_BASE}/secrets/${encodeURIComponent(name)}`, {
+			method: "PUT",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ value, category }),
+		});
+		if (!response.ok) {
+			const body = await response.json().catch(() => ({}));
+			throw new Error(body.error || `API error: ${response.status}`);
+		}
+		return response.json() as Promise<PutSecretResponse>;
+	},
+	deleteSecret: async (name: string): Promise<DeleteSecretResponse> => {
+		const response = await fetch(`${API_BASE}/secrets/${encodeURIComponent(name)}`, {
+			method: "DELETE",
+		});
+		if (!response.ok) {
+			const body = await response.json().catch(() => ({}));
+			throw new Error(body.error || `API error: ${response.status}`);
+		}
+		return response.json() as Promise<DeleteSecretResponse>;
+	},
+	enableEncryption: async (): Promise<EncryptResponse> => {
+		const response = await fetch(`${API_BASE}/secrets/encrypt`, { method: "POST" });
+		if (!response.ok) {
+			const body = await response.json().catch(() => ({}));
+			throw new Error(body.error || `API error: ${response.status}`);
+		}
+		return response.json() as Promise<EncryptResponse>;
+	},
+	unlockSecrets: async (masterKey: string): Promise<UnlockResponse> => {
+		const response = await fetch(`${API_BASE}/secrets/unlock`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ master_key: masterKey }),
+		});
+		if (!response.ok) {
+			const body = await response.json().catch(() => ({}));
+			throw new Error(body.error || `API error: ${response.status}`);
+		}
+		return response.json() as Promise<UnlockResponse>;
+	},
+	lockSecrets: async (): Promise<{ state: string; message: string }> => {
+		const response = await fetch(`${API_BASE}/secrets/lock`, { method: "POST" });
+		if (!response.ok) {
+			const body = await response.json().catch(() => ({}));
+			throw new Error(body.error || `API error: ${response.status}`);
+		}
+		return response.json();
+	},
+	rotateKey: async (): Promise<{ master_key: string; message: string }> => {
+		const response = await fetch(`${API_BASE}/secrets/rotate`, { method: "POST" });
+		if (!response.ok) {
+			const body = await response.json().catch(() => ({}));
+			throw new Error(body.error || `API error: ${response.status}`);
+		}
+		return response.json();
+	},
+	migrateSecrets: async (): Promise<MigrateResponse> => {
+		const response = await fetch(`${API_BASE}/secrets/migrate`, { method: "POST" });
+		if (!response.ok) {
+			const body = await response.json().catch(() => ({}));
+			throw new Error(body.error || `API error: ${response.status}`);
+		}
+		return response.json() as Promise<MigrateResponse>;
+	},
+
 	eventsUrl: `${API_BASE}/events`,
 };
diff --git a/interface/src/components/AgentTabs.tsx b/interface/src/components/AgentTabs.tsx
index c89ddd61a..1f0aaa8b4 100644
--- a/interface/src/components/AgentTabs.tsx
+++ b/interface/src/components/AgentTabs.tsx
@@ -8,6 +8,7 @@ const tabs = [
 	{ label: "Memories", to: "/agents/$agentId/memories" as const, exact: false },
 	{ label: "Ingest", to: "/agents/$agentId/ingest" as const, exact: false },
 	{ label: "Workers", to: "/agents/$agentId/workers" as const, exact: false },
+	{ label: "Tasks", to: "/agents/$agentId/tasks" as const, exact: false },
 	{ label: "Cortex", to: "/agents/$agentId/cortex" as const, exact: false },
 	{ label: "Skills", to: "/agents/$agentId/skills" as const, exact: false },
 	{ label: "Cron", to: "/agents/$agentId/cron" as const, exact: false },
diff --git a/interface/src/components/ChannelCard.tsx b/interface/src/components/ChannelCard.tsx
index 27e7e6084..b49be17de 100644
--- a/interface/src/components/ChannelCard.tsx
+++ b/interface/src/components/ChannelCard.tsx
@@ -3,19 +3,22 @@ import { AnimatePresence, motion } from "framer-motion";
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { api } from "@/api/client";
 import type { ChannelInfo } from "@/api/client";
-import type { ActiveBranch, ActiveWorker, ChannelLiveState } from "@/hooks/useChannelLiveState";
+import { isOpenCodeWorker, type ActiveBranch, type ActiveWorker, type ChannelLiveState } from "@/hooks/useChannelLiveState";
 import { LiveDuration } from "@/components/LiveDuration";
 import { formatTimeAgo, formatTimestamp, platformIcon, platformColor } from "@/lib/format";
 
 const VISIBLE_MESSAGES = 6;
 
 function WorkerBadge({ worker }: { worker: ActiveWorker }) {
+	const oc = isOpenCodeWorker(worker);
 	return (
-		<div className="flex items-center gap-2 rounded-md bg-amber-500/10 px-2.5 py-1.5 text-tiny">
-			<div className="h-1.5 w-1.5 animate-pulse rounded-full bg-amber-400" />
+		<div className={`flex items-center gap-2 rounded-md px-2.5 py-1.5 text-tiny ${
+			oc ? "bg-zinc-500/10" : "bg-amber-500/10"
+		}`}>
+			<div className={`h-1.5 w-1.5 animate-pulse rounded-full ${oc ? "bg-zinc-400" : "bg-amber-400"}`} />
 			<div className="min-w-0 flex-1">
 				<div className="flex items-center gap-1.5">
-					<span className="font-medium text-amber-300">Worker</span>
+					<span className={`font-medium ${oc ? "text-zinc-300" : "text-amber-300"}`}>Worker</span>
 					<span className="truncate text-ink-dull">{worker.task}</span>
 				</div>
 				<div className="mt-0.5 flex items-center gap-2 text-ink-faint">
@@ -23,7 +26,7 @@ function WorkerBadge({ worker }: { worker: ActiveWorker }) {
 					{worker.currentTool && (
 						<>
 							<span className="text-ink-faint/50">·</span>
-							<span className="text-amber-400/70">{worker.currentTool}</span>
+							<span className={oc ? "text-zinc-400/70" : "text-amber-400/70"}>{worker.currentTool}</span>
 						</>
 					)}
 					{worker.toolCalls > 0 && (
diff --git a/interface/src/components/ChannelEditModal.tsx b/interface/src/components/ChannelEditModal.tsx
index e290a321b..e29a72251 100644
--- a/interface/src/components/ChannelEditModal.tsx
+++ b/interface/src/components/ChannelEditModal.tsx
@@ -18,7 +18,7 @@ import {
 import {PlatformIcon} from "@/lib/platformIcons";
 import {TagInput} from "@/components/TagInput";
 
-type Platform = "discord" | "slack" | "telegram" | "twitch" | "webhook";
+type Platform = "discord" | "slack" | "telegram" | "twitch" | "email" | "webhook";
 
 interface ChannelEditModalProps {
 	platform: Platform;
diff --git a/interface/src/components/ChannelSettingCard.tsx b/interface/src/components/ChannelSettingCard.tsx
index d44b9801f..198babecb 100644
--- a/interface/src/components/ChannelSettingCard.tsx
+++ b/interface/src/components/ChannelSettingCard.tsx
@@ -1,7 +1,12 @@
 import {useState} from "react";
 import {AnimatePresence, motion} from "framer-motion";
 import {useMutation, useQuery, useQueryClient} from "@tanstack/react-query";
-import {api, type PlatformStatus, type BindingInfo} from "@/api/client";
+import {
+	api,
+	type AdapterInstanceStatus,
+	type BindingInfo,
+	type CreateMessagingInstanceRequest,
+} from "@/api/client";
 import {
 	Button,
 	Input,
@@ -20,42 +25,101 @@ import {
 import {PlatformIcon} from "@/lib/platformIcons";
 import {TagInput} from "@/components/TagInput";
 import {FontAwesomeIcon} from "@fortawesome/react-fontawesome";
-import {faChevronDown} from "@fortawesome/free-solid-svg-icons";
+import {faChevronDown, faPlus} from "@fortawesome/free-solid-svg-icons";
 
-type Platform = "discord" | "slack" | "telegram" | "twitch" | "webhook";
+type Platform = "discord" | "slack" | "telegram" | "twitch" | "email" | "webhook";
 
-interface ChannelSettingCardProps {
-	platform: Platform;
-	name: string;
-	description: string;
-	status?: PlatformStatus;
+const PLATFORM_LABELS: Record<Platform, string> = {
+	discord: "Discord",
+	slack: "Slack",
+	telegram: "Telegram",
+	twitch: "Twitch",
+	email: "Email",
+	webhook: "Webhook",
+};
+
+const DOC_LINKS: Partial<Record<Platform, string>> = {
+	discord: "https://docs.spacebot.sh/discord-setup",
+	slack: "https://docs.spacebot.sh/slack-setup",
+	telegram: "https://docs.spacebot.sh/telegram-setup",
+	twitch: "https://docs.spacebot.sh/twitch-setup",
+};
+
+// --- Platform Catalog (Left Column) ---
+
+interface PlatformCatalogProps {
+	onAddInstance: (platform: Platform) => void;
+}
+
+export function PlatformCatalog({onAddInstance}: PlatformCatalogProps) {
+	const PLATFORMS: Platform[] = [
+		"discord",
+		"slack",
+		"telegram",
+		"twitch",
+		"email",
+		"webhook",
+	];
+
+	const COMING_SOON = [
+		{platform: "whatsapp", name: "WhatsApp"},
+		{platform: "matrix", name: "Matrix"},
+		{platform: "imessage", name: "iMessage"},
+		{platform: "irc", name: "IRC"},
+		{platform: "lark", name: "Lark"},
+		{platform: "dingtalk", name: "DingTalk"},
+	];
+
+	return (
+		<div className="flex flex-col gap-1">
+			<h3 className="text-xs font-semibold text-ink-faint uppercase tracking-wider mb-2">
+				Available
+			</h3>
+			{PLATFORMS.map((platform) => (
+				<button
+					key={platform}
+					type="button"
+					onClick={() => onAddInstance(platform)}
+					className="flex items-center gap-2.5 rounded-md px-3 py-2 text-left hover:bg-app-hover transition-colors group"
+				>
+					<PlatformIcon platform={platform} size="sm" className="text-ink-faint" />
+					<span className="flex-1 text-sm text-ink">{PLATFORM_LABELS[platform]}</span>
+					<FontAwesomeIcon
+						icon={faPlus}
+						className="text-ink-faint opacity-0 group-hover:opacity-100 transition-opacity text-xs"
+					/>
+				</button>
+			))}
+
+			<h3 className="text-xs font-semibold text-ink-faint uppercase tracking-wider mt-4 mb-2">
+				Coming Soon
+			</h3>
+			{COMING_SOON.map(({platform, name}) => (
+				<div
+					key={platform}
+					className="flex items-center gap-2.5 rounded-md px-3 py-2 opacity-40"
+				>
+					<PlatformIcon platform={platform} size="sm" className="text-ink-faint/50" />
+					<span className="flex-1 text-sm text-ink-dull">{name}</span>
+				</div>
+			))}
+		</div>
+	);
+}
+
+// --- Instance Card (Right Column) ---
+
+interface InstanceCardProps {
+	instance: AdapterInstanceStatus;
 	expanded: boolean;
-	onToggle: () => void;
+	onToggleExpand: () => void;
 }
 
-export function ChannelSettingCard({
-	platform,
-	name,
-	description,
-	status,
-	expanded,
-	onToggle,
-}: ChannelSettingCardProps) {
+export function InstanceCard({instance, expanded, onToggleExpand}: InstanceCardProps) {
 	const queryClient = useQueryClient();
-	const configured = status?.configured ?? false;
-	const enabled = status?.enabled ?? false;
-
-	const [credentialInputs, setCredentialInputs] = useState<
-		Record<string, string>
-	>({});
-	const [message, setMessage] = useState<{
-		text: string;
-		type: "success" | "error";
-	} | null>(null);
-	const [confirmDisconnect, setConfirmDisconnect] = useState(false);
-	const [editingBinding, setEditingBinding] = useState<BindingInfo | null>(
-		null,
-	);
+	const [message, setMessage] = useState<{text: string; type: "success" | "error"} | null>(null);
+	const [confirmRemove, setConfirmRemove] = useState(false);
+	const [editingBinding, setEditingBinding] = useState<BindingInfo | null>(null);
 	const [addingBinding, setAddingBinding] = useState(false);
 	const [bindingForm, setBindingForm] = useState({
 		agent_id: "main",
@@ -67,11 +131,16 @@ export function ChannelSettingCard({
 		dm_allowed_users: [] as string[],
 	});
 
+	const platform = instance.platform as Platform;
+	const instanceLabel = instance.name
+		? `${PLATFORM_LABELS[platform]} "${instance.name}"`
+		: PLATFORM_LABELS[platform];
+
 	const {data: bindingsData} = useQuery({
 		queryKey: ["bindings"],
 		queryFn: () => api.bindings(),
 		staleTime: 5_000,
-		enabled: expanded && configured,
+		enabled: expanded,
 	});
 
 	const {data: agentsData} = useQuery({
@@ -81,35 +150,35 @@ export function ChannelSettingCard({
 		enabled: expanded,
 	});
 
-	const platformBindings =
-		bindingsData?.bindings?.filter((b) => b.channel === platform) ?? [];
+	// Filter bindings for this specific instance
+	const instanceBindings = (bindingsData?.bindings ?? []).filter((binding) => {
+		if (binding.channel !== platform) return false;
+		if (instance.name === null) return !binding.adapter;
+		return binding.adapter === instance.name;
+	});
 
 	const toggleEnabled = useMutation({
 		mutationFn: (newEnabled: boolean) =>
-			api.togglePlatform(platform, newEnabled),
+			api.togglePlatform(platform, newEnabled, instance.name ?? undefined),
 		onSuccess: () => {
 			queryClient.invalidateQueries({queryKey: ["messaging-status"]});
 		},
-		onError: (error) =>
-			setMessage({text: `Failed: ${error.message}`, type: "error"}),
+		onError: (error) => setMessage({text: `Failed: ${error.message}`, type: "error"}),
 	});
 
-	// --- Mutations ---
-
-	const saveCreds = useMutation({
-		mutationFn: api.createBinding,
+	const deleteInstance = useMutation({
+		mutationFn: () =>
+			api.deleteMessagingInstance({platform, name: instance.name ?? undefined}),
 		onSuccess: (result) => {
 			if (result.success) {
-				setCredentialInputs({});
-				setMessage({text: result.message, type: "success"});
+				setConfirmRemove(false);
 				queryClient.invalidateQueries({queryKey: ["messaging-status"]});
 				queryClient.invalidateQueries({queryKey: ["bindings"]});
 			} else {
 				setMessage({text: result.message, type: "error"});
 			}
 		},
-		onError: (error) =>
-			setMessage({text: `Failed: ${error.message}`, type: "error"}),
+		onError: (error) => setMessage({text: `Failed: ${error.message}`, type: "error"}),
 	});
 
 	const addBindingMutation = useMutation({
@@ -120,12 +189,12 @@ export function ChannelSettingCard({
 				resetBindingForm();
 				setMessage({text: result.message, type: "success"});
 				queryClient.invalidateQueries({queryKey: ["bindings"]});
+				queryClient.invalidateQueries({queryKey: ["messaging-status"]});
 			} else {
 				setMessage({text: result.message, type: "error"});
 			}
 		},
-		onError: (error) =>
-			setMessage({text: `Failed: ${error.message}`, type: "error"}),
+		onError: (error) => setMessage({text: `Failed: ${error.message}`, type: "error"}),
 	});
 
 	const updateBindingMutation = useMutation({
@@ -136,12 +205,12 @@ export function ChannelSettingCard({
 				resetBindingForm();
 				setMessage({text: result.message, type: "success"});
 				queryClient.invalidateQueries({queryKey: ["bindings"]});
+				queryClient.invalidateQueries({queryKey: ["messaging-status"]});
 			} else {
 				setMessage({text: result.message, type: "error"});
 			}
 		},
-		onError: (error) =>
-			setMessage({text: `Failed: ${error.message}`, type: "error"}),
+		onError: (error) => setMessage({text: `Failed: ${error.message}`, type: "error"}),
 	});
 
 	const deleteBindingMutation = useMutation({
@@ -150,24 +219,12 @@ export function ChannelSettingCard({
 			if (result.success) {
 				setMessage({text: result.message, type: "success"});
 				queryClient.invalidateQueries({queryKey: ["bindings"]});
+				queryClient.invalidateQueries({queryKey: ["messaging-status"]});
 			} else {
 				setMessage({text: result.message, type: "error"});
 			}
 		},
-		onError: (error) =>
-			setMessage({text: `Failed: ${error.message}`, type: "error"}),
-	});
-
-	const disconnectMutation = useMutation({
-		mutationFn: () => api.disconnectPlatform(platform),
-		onSuccess: () => {
-			setConfirmDisconnect(false);
-			setMessage(null);
-			queryClient.invalidateQueries({queryKey: ["messaging-status"]});
-			queryClient.invalidateQueries({queryKey: ["bindings"]});
-		},
-		onError: (error) =>
-			setMessage({text: `Failed: ${error.message}`, type: "error"}),
+		onError: (error) => setMessage({text: `Failed: ${error.message}`, type: "error"}),
 	});
 
 	function resetBindingForm() {
@@ -182,43 +239,15 @@ export function ChannelSettingCard({
 		});
 	}
 
-	function handleSaveCredentials() {
-		const request: any = {agent_id: "main", channel: platform};
-		if (platform === "discord") {
-			if (!credentialInputs.discord_token?.trim()) return;
-			request.platform_credentials = {
-				discord_token: credentialInputs.discord_token.trim(),
-			};
-		} else if (platform === "slack") {
-			if (
-				!credentialInputs.slack_bot_token?.trim() ||
-				!credentialInputs.slack_app_token?.trim()
-			)
-				return;
-			request.platform_credentials = {
-				slack_bot_token: credentialInputs.slack_bot_token.trim(),
-				slack_app_token: credentialInputs.slack_app_token.trim(),
-			};
-		} else if (platform === "telegram") {
-			if (!credentialInputs.telegram_token?.trim()) return;
-			request.platform_credentials = {
-				telegram_token: credentialInputs.telegram_token.trim(),
-			};
-		} else if (platform === "twitch") {
-			if (!credentialInputs.twitch_username?.trim() || !credentialInputs.twitch_oauth_token?.trim()) return;
-			request.platform_credentials = {
-				twitch_username: credentialInputs.twitch_username.trim(),
-				twitch_oauth_token: credentialInputs.twitch_oauth_token.trim(),
-				twitch_client_id: credentialInputs.twitch_client_id?.trim(),
-				twitch_client_secret: credentialInputs.twitch_client_secret?.trim(),
-				twitch_refresh_token: credentialInputs.twitch_refresh_token?.trim(),
-			};
-		}
-		saveCreds.mutate(request);
-	}
-
 	function handleAddBinding() {
-		const request: any = {agent_id: bindingForm.agent_id, channel: platform};
+		const request: Record<string, unknown> = {
+			agent_id: bindingForm.agent_id,
+			channel: platform,
+		};
+		// Auto-populate adapter for named instances
+		if (instance.name) {
+			request.adapter = instance.name;
+		}
 		if (platform === "discord" && bindingForm.guild_id.trim())
 			request.guild_id = bindingForm.guild_id.trim();
 		if (platform === "slack" && bindingForm.workspace_id.trim())
@@ -231,20 +260,24 @@ export function ChannelSettingCard({
 			request.require_mention = true;
 		if (bindingForm.dm_allowed_users.length > 0)
 			request.dm_allowed_users = bindingForm.dm_allowed_users;
-		addBindingMutation.mutate(request);
+		addBindingMutation.mutate(request as any);
 	}
 
 	function handleUpdateBinding() {
 		if (!editingBinding) return;
-		const request: any = {
+		const request: Record<string, unknown> = {
 			original_agent_id: editingBinding.agent_id,
 			original_channel: editingBinding.channel,
+			original_adapter: editingBinding.adapter || undefined,
 			original_guild_id: editingBinding.guild_id || undefined,
 			original_workspace_id: editingBinding.workspace_id || undefined,
 			original_chat_id: editingBinding.chat_id || undefined,
 			agent_id: bindingForm.agent_id,
 			channel: platform,
 		};
+		if (instance.name) {
+			request.adapter = instance.name;
+		}
 		if (platform === "discord" && bindingForm.guild_id.trim())
 			request.guild_id = bindingForm.guild_id.trim();
 		if (platform === "slack" && bindingForm.workspace_id.trim())
@@ -252,18 +285,21 @@ export function ChannelSettingCard({
 		if (platform === "telegram" && bindingForm.chat_id.trim())
 			request.chat_id = bindingForm.chat_id.trim();
 		request.channel_ids = bindingForm.channel_ids;
-		request.require_mention =
-			platform === "discord" ? bindingForm.require_mention : false;
+		request.require_mention = platform === "discord" ? bindingForm.require_mention : false;
 		request.dm_allowed_users = bindingForm.dm_allowed_users;
-		updateBindingMutation.mutate(request);
+		updateBindingMutation.mutate(request as any);
 	}
 
 	function handleDeleteBinding(binding: BindingInfo) {
-		const request: any = {agent_id: binding.agent_id, channel: binding.channel};
+		const request: Record<string, unknown> = {
+			agent_id: binding.agent_id,
+			channel: binding.channel,
+		};
+		if (binding.adapter) request.adapter = binding.adapter;
 		if (binding.guild_id) request.guild_id = binding.guild_id;
 		if (binding.workspace_id) request.workspace_id = binding.workspace_id;
 		if (binding.chat_id) request.chat_id = binding.chat_id;
-		deleteBindingMutation.mutate(request);
+		deleteBindingMutation.mutate(request as any);
 	}
 
 	function startEditBinding(binding: BindingInfo) {
@@ -284,29 +320,29 @@ export function ChannelSettingCard({
 
 	return (
 		<div className="rounded-lg border border-app-line bg-app-box">
-			{/* Header — always visible, acts as toggle */}
-			<div
-				role="button"
-				onClick={onToggle}
-				className="flex w-full items-center gap-3 p-4 text-left cursor-pointer"
+			{/* Collapsed summary header */}
+			<button
+				type="button"
+				onClick={onToggleExpand}
+				aria-expanded={expanded}
+				className="flex w-full items-center gap-3 p-3 text-left cursor-pointer"
 			>
-				<PlatformIcon
-					platform={platform}
-					size="lg"
-					className="text-ink-faint"
-				/>
+				<PlatformIcon platform={platform} size="sm" className="text-ink-faint" />
 				<div className="flex-1 min-w-0">
 					<div className="flex items-center gap-2">
-						<span className="text-sm font-medium text-ink">{name}</span>
-						{configured && (
-							<span
-								className={`text-tiny ${enabled ? "text-green-400" : "text-ink-faint"}`}
-							>
-								{enabled ? "● Active" : "○ Disabled"}
-							</span>
-						)}
+						<span className="text-sm font-medium text-ink">
+							{PLATFORM_LABELS[platform]}
+						</span>
+						<span className="rounded bg-app-selected/60 px-1.5 py-0.5 text-[10px] font-medium uppercase leading-none text-ink-faint">
+							{instance.name || "default"}
+						</span>
+						<span className={`text-tiny ${instance.enabled ? "text-green-400" : "text-ink-faint"}`}>
+							{instance.enabled ? "● Active" : "○ Disabled"}
+						</span>
 					</div>
-					<p className="mt-0.5 text-sm text-ink-dull">{description}</p>
+					<p className="text-tiny text-ink-faint mt-0.5">
+						{instance.binding_count} binding{instance.binding_count !== 1 ? "s" : ""}
+					</p>
 				</div>
 				<motion.div
 					animate={{rotate: expanded ? 180 : 0}}
@@ -315,7 +351,7 @@ export function ChannelSettingCard({
 				>
 					<FontAwesomeIcon icon={faChevronDown} size="sm" />
 				</motion.div>
-			</div>
+			</button>
 
 			{/* Expanded content */}
 			<AnimatePresence initial={false}>
@@ -327,67 +363,126 @@ export function ChannelSettingCard({
 						transition={{duration: 0.25, ease: [0.4, 0, 0.2, 1]}}
 						className="overflow-hidden"
 					>
-						<div className="border-t border-app-line/50 bg-app-darkBox px-4 pb-4 pt-4 flex flex-col gap-4">
+						<div className="border-t border-app-line/50 bg-app-darkBox px-4 pb-4 pt-3 flex flex-col gap-4">
 							{/* Enable/Disable toggle */}
-							{configured && (
+							<div className="flex items-center justify-between">
+								<div>
+									<span className="text-sm font-medium text-ink">Enabled</span>
+									<p className="mt-0.5 text-sm text-ink-dull">
+										{instance.enabled ? "Receiving messages" : "Adapter paused"}
+									</p>
+								</div>
+								<Toggle
+									checked={instance.enabled}
+									onCheckedChange={(checked) => toggleEnabled.mutate(checked)}
+									disabled={toggleEnabled.isPending}
+								/>
+							</div>
+
+							{/* Bindings section (scoped to this instance) */}
+							<div className="flex flex-col gap-3 border-t border-app-line/50 pt-3">
 								<div className="flex items-center justify-between">
-									<div>
-										<span className="text-sm font-medium text-ink">
-											Enabled
-										</span>
-										<p className="mt-0.5 text-sm text-ink-dull">
-											{enabled
-												? `${name} is receiving messages`
-												: `${name} is disconnected`}
-										</p>
-									</div>
-									<Toggle
-										checked={enabled}
-										onCheckedChange={(checked) => toggleEnabled.mutate(checked)}
-										disabled={toggleEnabled.isPending}
-									/>
+									<h3 className="text-sm font-medium text-ink">Bindings</h3>
+									<Button
+										size="sm"
+										variant="outline"
+										onClick={() => {
+											setAddingBinding(true);
+											setEditingBinding(null);
+											resetBindingForm();
+											setMessage(null);
+										}}
+									>
+										Add
+									</Button>
 								</div>
-							)}
-							{/* Credentials */}
-							<CredentialsSection
-								platform={platform}
-								configured={configured}
-								credentialInputs={credentialInputs}
-								setCredentialInputs={setCredentialInputs}
-								onSave={handleSaveCredentials}
-								saving={saveCreds.isPending}
-							/>
 
-							{/* Bindings (only when connected) */}
-							{configured && (
-								<BindingsSection
-									platform={platform}
-									bindings={platformBindings}
-									agents={agentsData?.agents ?? []}
-									isEditingOrAdding={isEditingOrAdding}
-									editingBinding={editingBinding}
-									bindingForm={bindingForm}
-									setBindingForm={setBindingForm}
-									onStartAdd={() => {
-										setAddingBinding(true);
-										setEditingBinding(null);
-										resetBindingForm();
-										setMessage(null);
-									}}
-									onStartEdit={startEditBinding}
-									onCancelEdit={() => {
-										setEditingBinding(null);
-										setAddingBinding(false);
-										setMessage(null);
+								{instanceBindings.length > 0 ? (
+									<div className="rounded-md border border-app-line bg-app-box">
+										{instanceBindings.map((binding, idx) => (
+											<div
+												key={idx}
+												className="flex items-center gap-2 border-b border-app-line/50 px-3 py-2 last:border-b-0"
+											>
+												<div className="flex-1 min-w-0">
+													<span className="text-sm text-ink">{binding.agent_id}</span>
+													<div className="flex flex-wrap gap-1.5 mt-0.5 text-tiny text-ink-faint">
+														{binding.guild_id && <span>Guild: {binding.guild_id}</span>}
+														{binding.workspace_id && <span>Workspace: {binding.workspace_id}</span>}
+														{binding.chat_id && <span>Chat: {binding.chat_id}</span>}
+														{binding.channel_ids.length > 0 && (
+															<span>
+																{binding.channel_ids.length} channel{binding.channel_ids.length > 1 ? "s" : ""}
+															</span>
+														)}
+														{binding.dm_allowed_users.length > 0 && (
+															<span>
+																{binding.dm_allowed_users.length} DM user{binding.dm_allowed_users.length > 1 ? "s" : ""}
+															</span>
+														)}
+														{binding.require_mention && <span>Mention only</span>}
+														{!binding.guild_id &&
+															!binding.workspace_id &&
+															!binding.chat_id &&
+															binding.channel_ids.length === 0 && (
+																<span>All conversations</span>
+															)}
+													</div>
+												</div>
+												<Button size="sm" variant="outline" onClick={() => startEditBinding(binding)}>
+													Edit
+												</Button>
+												<Button
+													size="sm"
+													variant="outline"
+													onClick={() => handleDeleteBinding(binding)}
+													loading={deleteBindingMutation.isPending}
+												>
+													Remove
+												</Button>
+											</div>
+										))}
+									</div>
+								) : (
+									<p className="text-sm text-ink-faint py-1">
+										No bindings. Messages will route to the default agent.
+									</p>
+								)}
+
+								{/* Add/Edit binding modal */}
+								<Dialog
+									open={isEditingOrAdding}
+									onOpenChange={(open) => {
+										if (!open) {
+											setEditingBinding(null);
+											setAddingBinding(false);
+											setMessage(null);
+										}
 									}}
-									onAdd={handleAddBinding}
-									onUpdate={handleUpdateBinding}
-									onDelete={handleDeleteBinding}
-									addPending={addBindingMutation.isPending}
-									updatePending={updateBindingMutation.isPending}
-									deletePending={deleteBindingMutation.isPending}
-								/>
-							)}
+								>
+									<DialogContent className="max-w-md">
+										<DialogHeader>
+											<DialogTitle>
+												{editingBinding ? "Edit Binding" : "Add Binding"}
+											</DialogTitle>
+										</DialogHeader>
+										<BindingForm
+											platform={platform}
+											agents={agentsData?.agents ?? []}
+											bindingForm={bindingForm}
+											setBindingForm={setBindingForm}
+											editing={!!editingBinding}
+											onSave={editingBinding ? handleUpdateBinding : handleAddBinding}
+											onCancel={() => {
+												setEditingBinding(null);
+												setAddingBinding(false);
+												setMessage(null);
+											}}
+											saving={editingBinding ? updateBindingMutation.isPending : addBindingMutation.isPending}
+										/>
+									</DialogContent>
+								</Dialog>
+							</div>
 
 							{/* Status message */}
 							{message && (
@@ -402,16 +497,38 @@ export function ChannelSettingCard({
 								</div>
 							)}
 
-							{/* Disconnect */}
-							{configured && platform !== "webhook" && (
-								<DisconnectSection
-									name={name}
-									confirmDisconnect={confirmDisconnect}
-									setConfirmDisconnect={setConfirmDisconnect}
-									onDisconnect={() => disconnectMutation.mutate()}
-									disconnecting={disconnectMutation.isPending}
-								/>
-							)}
+							{/* Remove instance */}
+							<div className="border-t border-app-line/50 pt-3">
+									{!confirmRemove ? (
+										<Button
+											variant="outline"
+											size="sm"
+											onClick={() => setConfirmRemove(true)}
+										>
+											Remove {instanceLabel}
+										</Button>
+									) : (
+										<div className="flex flex-col gap-2">
+											<p className="text-sm text-red-400">
+												This will remove credentials and bindings for {instanceLabel}.
+												The adapter will stop immediately.
+											</p>
+											<div className="flex gap-2">
+												<Button variant="ghost" size="sm" onClick={() => setConfirmRemove(false)}>
+													Cancel
+												</Button>
+												<Button
+													size="sm"
+													onClick={() => deleteInstance.mutate()}
+													loading={deleteInstance.isPending}
+													className="bg-red-500/20 text-red-400 hover:bg-red-500/30"
+												>
+													Confirm Remove
+												</Button>
+											</div>
+										</div>
+									)}
+								</div>
 						</div>
 					</motion.div>
 				)}
@@ -420,454 +537,430 @@ export function ChannelSettingCard({
 	);
 }
 
-// --- Disabled card for coming soon platforms ---
+// --- Add Instance Inline Card ---
 
-interface DisabledChannelCardProps {
-	platform: string;
-	name: string;
-	description: string;
+interface AddInstanceCardProps {
+	platform: Platform;
+	isDefault: boolean;
+	onCancel: () => void;
+	onCreated: () => void;
 }
 
-export function DisabledChannelCard({
-	platform,
-	name,
-	description,
-}: DisabledChannelCardProps) {
-	return (
-		<div className="rounded-lg border border-app-line bg-app-box p-4 opacity-40">
-			<div className="flex items-center gap-3">
-				<PlatformIcon
-					platform={platform}
-					size="lg"
-					className="text-ink-faint/50"
-				/>
-				<div className="flex-1">
-					<span className="text-sm font-medium text-ink">{name}</span>
-					<p className="mt-0.5 text-sm text-ink-dull">{description}</p>
-				</div>
-				<Button variant="outline" size="sm" disabled>
-					Coming Soon
-				</Button>
-			</div>
-		</div>
-	);
-}
+export function AddInstanceCard({platform, isDefault, onCancel, onCreated}: AddInstanceCardProps) {
+	const queryClient = useQueryClient();
+	const [instanceName, setInstanceName] = useState("");
+	const [credentialInputs, setCredentialInputs] = useState<Record<string, string>>({});
+	const [message, setMessage] = useState<{text: string; type: "success" | "error"} | null>(null);
 
-// --- Sub-sections ---
+	const createInstance = useMutation({
+		mutationFn: api.createMessagingInstance,
+		onSuccess: (result) => {
+			if (result.success) {
+				queryClient.invalidateQueries({queryKey: ["messaging-status"]});
+				queryClient.invalidateQueries({queryKey: ["bindings"]});
+				onCreated();
+			} else {
+				setMessage({text: result.message, type: "error"});
+			}
+		},
+		onError: (error) => setMessage({text: `Failed: ${error.message}`, type: "error"}),
+	});
 
-function CredentialsSection({
-	platform,
-	configured,
-	credentialInputs,
-	setCredentialInputs,
-	onSave,
-	saving,
-}: {
-	platform: Platform;
-	configured: boolean;
-	credentialInputs: Record<string, string>;
-	setCredentialInputs: (inputs: Record<string, string>) => void;
-	onSave: () => void;
-	saving: boolean;
-}) {
-	return (
-		<div className="flex flex-col gap-3">
-			<h3 className="text-sm font-medium text-ink">
-				{configured ? "Update Credentials" : "Credentials"}
-			</h3>
+	function handleSave() {
+		const credentials: CreateMessagingInstanceRequest["credentials"] = {};
 
-			{platform === "discord" && (
-				<div>
-					<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-						Bot Token
-					</label>
-					<Input
-						type="password"
-						size="lg"
-						value={credentialInputs.discord_token ?? ""}
-						onChange={(e) =>
-							setCredentialInputs({
-								...credentialInputs,
-								discord_token: e.target.value,
-							})
-						}
-						placeholder={
-							configured
-								? "Enter new token to update"
-								: "MTk4NjIyNDgzNDcxOTI1MjQ4.D..."
-						}
-						onKeyDown={(e) => {
-							if (e.key === "Enter") onSave();
-						}}
-					/>
-					<p className="mt-1.5 text-xs text-ink-faint">
-						Need help?{" "}
-						<a href="https://docs.spacebot.sh/discord-setup" target="_blank" rel="noopener noreferrer" className="text-accent hover:underline">
-							Read the Discord setup docs &rarr;
-						</a>
-					</p>
+		if (platform === "discord") {
+			if (!credentialInputs.discord_token?.trim()) {
+				setMessage({text: "Bot token is required", type: "error"});
+				return;
+			}
+			credentials.discord_token = credentialInputs.discord_token.trim();
+		} else if (platform === "slack") {
+			if (!credentialInputs.slack_bot_token?.trim() || !credentialInputs.slack_app_token?.trim()) {
+				setMessage({text: "Both bot token and app token are required", type: "error"});
+				return;
+			}
+			credentials.slack_bot_token = credentialInputs.slack_bot_token.trim();
+			credentials.slack_app_token = credentialInputs.slack_app_token.trim();
+		} else if (platform === "telegram") {
+			if (!credentialInputs.telegram_token?.trim()) {
+				setMessage({text: "Bot token is required", type: "error"});
+				return;
+			}
+			credentials.telegram_token = credentialInputs.telegram_token.trim();
+		} else if (platform === "twitch") {
+			if (!credentialInputs.twitch_username?.trim() || !credentialInputs.twitch_oauth_token?.trim()) {
+				setMessage({text: "Username and OAuth token are required", type: "error"});
+				return;
+			}
+			credentials.twitch_username = credentialInputs.twitch_username.trim();
+			credentials.twitch_oauth_token = credentialInputs.twitch_oauth_token.trim();
+			if (credentialInputs.twitch_client_id?.trim())
+				credentials.twitch_client_id = credentialInputs.twitch_client_id.trim();
+			if (credentialInputs.twitch_client_secret?.trim())
+				credentials.twitch_client_secret = credentialInputs.twitch_client_secret.trim();
+			if (credentialInputs.twitch_refresh_token?.trim())
+				credentials.twitch_refresh_token = credentialInputs.twitch_refresh_token.trim();
+		} else if (platform === "email") {
+			if (!credentialInputs.email_imap_host?.trim() || !credentialInputs.email_smtp_host?.trim()) {
+				setMessage({text: "IMAP host and SMTP host are required", type: "error"});
+				return;
+			}
+			if (!credentialInputs.email_imap_username?.trim() || !credentialInputs.email_imap_password?.trim()) {
+				setMessage({text: "IMAP username and password are required", type: "error"});
+				return;
+			}
+			if (!credentialInputs.email_smtp_username?.trim() || !credentialInputs.email_smtp_password?.trim()) {
+				setMessage({text: "SMTP username and password are required", type: "error"});
+				return;
+			}
+			if (!credentialInputs.email_from_address?.trim()) {
+				setMessage({text: "From address is required", type: "error"});
+				return;
+			}
+			credentials.email_imap_host = credentialInputs.email_imap_host.trim();
+			credentials.email_imap_username = credentialInputs.email_imap_username.trim();
+			credentials.email_imap_password = credentialInputs.email_imap_password.trim();
+			credentials.email_smtp_host = credentialInputs.email_smtp_host.trim();
+			credentials.email_smtp_username = credentialInputs.email_smtp_username.trim();
+			credentials.email_smtp_password = credentialInputs.email_smtp_password.trim();
+			credentials.email_from_address = credentialInputs.email_from_address.trim();
+			if (credentialInputs.email_imap_port?.trim())
+				credentials.email_imap_port = parseInt(credentialInputs.email_imap_port.trim(), 10) || undefined;
+			if (credentialInputs.email_smtp_port?.trim())
+				credentials.email_smtp_port = parseInt(credentialInputs.email_smtp_port.trim(), 10) || undefined;
+		} else if (platform === "webhook") {
+			if (credentialInputs.webhook_port?.trim())
+				credentials.webhook_port = parseInt(credentialInputs.webhook_port.trim(), 10) || undefined;
+			if (credentialInputs.webhook_bind?.trim())
+				credentials.webhook_bind = credentialInputs.webhook_bind.trim();
+			if (credentialInputs.webhook_auth_token?.trim())
+				credentials.webhook_auth_token = credentialInputs.webhook_auth_token.trim();
+		}
+
+		if (!isDefault && !instanceName.trim()) {
+			setMessage({text: "Instance name is required", type: "error"});
+			return;
+		}
+
+		createInstance.mutate({
+			platform,
+			name: isDefault ? undefined : instanceName.trim(),
+			credentials,
+		});
+	}
+
+	const docLink = DOC_LINKS[platform];
+
+	return (
+		<div className="rounded-lg border border-accent/30 bg-app-box">
+			<div className="p-4 flex flex-col gap-3">
+				<div className="flex items-center gap-2">
+					<PlatformIcon platform={platform} size="sm" className="text-ink-faint" />
+					<span className="text-sm font-medium text-ink">
+						{isDefault
+							? `Add ${PLATFORM_LABELS[platform]}`
+							: `Add ${PLATFORM_LABELS[platform]} Instance`}
+					</span>
 				</div>
-			)}
 
-			{platform === "slack" && (
-				<>
+				{/* Instance name (only for non-default) */}
+				{!isDefault && (
 					<div>
-						<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-							Bot Token
+						<label className="mb-1 block text-sm font-medium text-ink-dull">
+							Instance Name
 						</label>
 						<Input
-							type="password"
 							size="lg"
-							value={credentialInputs.slack_bot_token ?? ""}
-							onChange={(e) =>
-								setCredentialInputs({
-									...credentialInputs,
-									slack_bot_token: e.target.value,
-								})
-							}
-							placeholder={
-								configured ? "Enter new token to update" : "xoxb-..."
-							}
+							value={instanceName}
+							onChange={(e) => setInstanceName(e.target.value)}
+							placeholder='e.g. "support", "sales"'
 						/>
 					</div>
+				)}
+
+				{/* Platform-specific credential fields */}
+				{platform === "discord" && (
 					<div>
-						<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-							App Token
-						</label>
+						<label className="mb-1.5 block text-sm font-medium text-ink-dull">Bot Token</label>
 						<Input
 							type="password"
 							size="lg"
-							value={credentialInputs.slack_app_token ?? ""}
-							onChange={(e) =>
-								setCredentialInputs({
-									...credentialInputs,
-									slack_app_token: e.target.value,
-								})
-							}
-							placeholder={
-								configured ? "Enter new token to update" : "xapp-..."
-							}
-							onKeyDown={(e) => {
-								if (e.key === "Enter") onSave();
-							}}
+							value={credentialInputs.discord_token ?? ""}
+							onChange={(e) => setCredentialInputs({...credentialInputs, discord_token: e.target.value})}
+							placeholder="MTk4NjIyNDgzNDcxOTI1MjQ4.D..."
+							onKeyDown={(e) => { if (e.key === "Enter") handleSave(); }}
 						/>
 					</div>
-					<p className="text-xs text-ink-faint">
-						Need help?{" "}
-						<a href="https://docs.spacebot.sh/slack-setup" target="_blank" rel="noopener noreferrer" className="text-accent hover:underline">
-							Read the Slack setup docs &rarr;
-						</a>
-					</p>
-				</>
-			)}
-
-			{platform === "telegram" && (
-				<div>
-					<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-						Bot Token
-					</label>
-					<Input
-						type="password"
-						size="lg"
-						value={credentialInputs.telegram_token ?? ""}
-						onChange={(e) =>
-							setCredentialInputs({
-								...credentialInputs,
-								telegram_token: e.target.value,
-							})
-						}
-						placeholder={
-							configured
-								? "Enter new token to update"
-								: "123456789:ABCdefGHI..."
-						}
-						onKeyDown={(e) => {
-							if (e.key === "Enter") onSave();
-						}}
-					/>
-					<p className="mt-1.5 text-xs text-ink-faint">
-						Need help?{" "}
-						<a href="https://docs.spacebot.sh/telegram-setup" target="_blank" rel="noopener noreferrer" className="text-accent hover:underline">
-							Read the Telegram setup docs &rarr;
-						</a>
-					</p>
-				</div>
-			)}
+				)}
 
-			{platform === "twitch" && (
-				<>
-					<div>
-						<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-							Bot Username
-						</label>
-						<Input
-							size="lg"
-							value={credentialInputs.twitch_username ?? ""}
-							onChange={(e) =>
-								setCredentialInputs({
-									...credentialInputs,
-									twitch_username: e.target.value,
-								})
-							}
-							placeholder={
-								configured ? "Enter new username to update" : "my_bot"
-							}
-						/>
-					</div>
-					<div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+				{platform === "slack" && (
+					<>
 						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								Client ID
-							</label>
+							<label className="mb-1.5 block text-sm font-medium text-ink-dull">Bot Token</label>
 							<Input
+								type="password"
 								size="lg"
-								value={credentialInputs.twitch_client_id ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										twitch_client_id: e.target.value,
-									})
-								}
-								placeholder={
-									configured ? "Enter new client id to update" : "your-app-client-id"
-								}
+								value={credentialInputs.slack_bot_token ?? ""}
+								onChange={(e) => setCredentialInputs({...credentialInputs, slack_bot_token: e.target.value})}
+								placeholder="xoxb-..."
 							/>
 						</div>
 						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								Client Secret
-							</label>
+							<label className="mb-1.5 block text-sm font-medium text-ink-dull">App Token</label>
 							<Input
 								type="password"
 								size="lg"
-								value={credentialInputs.twitch_client_secret ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										twitch_client_secret: e.target.value,
-									})
-								}
-								placeholder={
-									configured ? "Enter new client secret to update" : "your-app-client-secret"
-								}
+								value={credentialInputs.slack_app_token ?? ""}
+								onChange={(e) => setCredentialInputs({...credentialInputs, slack_app_token: e.target.value})}
+								placeholder="xapp-..."
+								onKeyDown={(e) => { if (e.key === "Enter") handleSave(); }}
 							/>
 						</div>
+					</>
+				)}
+
+				{platform === "telegram" && (
+					<div>
+						<label className="mb-1.5 block text-sm font-medium text-ink-dull">Bot Token</label>
+						<Input
+							type="password"
+							size="lg"
+							value={credentialInputs.telegram_token ?? ""}
+							onChange={(e) => setCredentialInputs({...credentialInputs, telegram_token: e.target.value})}
+							placeholder="123456789:ABCdefGHI..."
+							onKeyDown={(e) => { if (e.key === "Enter") handleSave(); }}
+						/>
 					</div>
-					<div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+				)}
+
+				{platform === "twitch" && (
+					<>
 						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								OAuth Access Token
-							</label>
+							<label className="mb-1.5 block text-sm font-medium text-ink-dull">Bot Username</label>
 							<Input
-								type="password"
 								size="lg"
-								value={credentialInputs.twitch_oauth_token ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										twitch_oauth_token: e.target.value,
-									})
-								}
-								placeholder={
-									configured ? "Enter new token to update" : "abcd1234..."
-								}
-								onKeyDown={(e) => {
-									if (e.key === "Enter") onSave();
-								}}
+								value={credentialInputs.twitch_username ?? ""}
+								onChange={(e) => setCredentialInputs({...credentialInputs, twitch_username: e.target.value})}
+								placeholder="my_bot"
 							/>
 						</div>
+						<div className="grid grid-cols-2 gap-3">
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">Client ID</label>
+								<Input
+									size="lg"
+									value={credentialInputs.twitch_client_id ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, twitch_client_id: e.target.value})}
+									placeholder="your-client-id"
+								/>
+							</div>
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">Client Secret</label>
+								<Input
+									type="password"
+									size="lg"
+									value={credentialInputs.twitch_client_secret ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, twitch_client_secret: e.target.value})}
+									placeholder="your-client-secret"
+								/>
+							</div>
+						</div>
+						<div className="grid grid-cols-2 gap-3">
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">OAuth Token</label>
+								<Input
+									type="password"
+									size="lg"
+									value={credentialInputs.twitch_oauth_token ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, twitch_oauth_token: e.target.value})}
+									placeholder="abcd1234..."
+									onKeyDown={(e) => { if (e.key === "Enter") handleSave(); }}
+								/>
+							</div>
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">Refresh Token</label>
+								<Input
+									type="password"
+									size="lg"
+									value={credentialInputs.twitch_refresh_token ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, twitch_refresh_token: e.target.value})}
+									placeholder="refresh-token"
+								/>
+							</div>
+						</div>
+					</>
+				)}
+
+				{platform === "email" && (
+					<>
+						<div className="grid grid-cols-2 gap-3">
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">IMAP Host</label>
+								<Input
+									size="lg"
+									value={credentialInputs.email_imap_host ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_imap_host: e.target.value})}
+									placeholder="imap.gmail.com"
+								/>
+							</div>
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">IMAP Port</label>
+								<Input
+									size="lg"
+									value={credentialInputs.email_imap_port ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_imap_port: e.target.value})}
+									placeholder="993"
+								/>
+							</div>
+						</div>
+						<div className="grid grid-cols-2 gap-3">
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">IMAP Username</label>
+								<Input
+									size="lg"
+									value={credentialInputs.email_imap_username ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_imap_username: e.target.value})}
+									placeholder="user@example.com"
+								/>
+							</div>
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">IMAP Password</label>
+								<Input
+									type="password"
+									size="lg"
+									value={credentialInputs.email_imap_password ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_imap_password: e.target.value})}
+									placeholder="App password"
+								/>
+							</div>
+						</div>
+						<div className="grid grid-cols-2 gap-3">
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">SMTP Host</label>
+								<Input
+									size="lg"
+									value={credentialInputs.email_smtp_host ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_smtp_host: e.target.value})}
+									placeholder="smtp.gmail.com"
+								/>
+							</div>
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">SMTP Port</label>
+								<Input
+									size="lg"
+									value={credentialInputs.email_smtp_port ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_smtp_port: e.target.value})}
+									placeholder="587"
+								/>
+							</div>
+						</div>
+						<div className="grid grid-cols-2 gap-3">
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">SMTP Username</label>
+								<Input
+									size="lg"
+									value={credentialInputs.email_smtp_username ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_smtp_username: e.target.value})}
+									placeholder="user@example.com"
+								/>
+							</div>
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">SMTP Password</label>
+								<Input
+									type="password"
+									size="lg"
+									value={credentialInputs.email_smtp_password ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_smtp_password: e.target.value})}
+									placeholder="App password"
+								/>
+							</div>
+						</div>
 						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								OAuth Refresh Token
-							</label>
+							<label className="mb-1.5 block text-sm font-medium text-ink-dull">From Address</label>
+							<Input
+								size="lg"
+								value={credentialInputs.email_from_address ?? ""}
+								onChange={(e) => setCredentialInputs({...credentialInputs, email_from_address: e.target.value})}
+								placeholder="bot@example.com"
+								onKeyDown={(e) => { if (e.key === "Enter") handleSave(); }}
+							/>
+						</div>
+					</>
+				)}
+
+				{platform === "webhook" && (
+					<>
+						<div className="grid grid-cols-2 gap-3">
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">Port</label>
+								<Input
+									size="lg"
+									value={credentialInputs.webhook_port ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, webhook_port: e.target.value})}
+									placeholder="18789"
+								/>
+							</div>
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">Bind Address</label>
+								<Input
+									size="lg"
+									value={credentialInputs.webhook_bind ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, webhook_bind: e.target.value})}
+									placeholder="127.0.0.1"
+								/>
+							</div>
+						</div>
+						<div>
+							<label className="mb-1.5 block text-sm font-medium text-ink-dull">Auth Token</label>
 							<Input
 								type="password"
 								size="lg"
-								value={credentialInputs.twitch_refresh_token ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										twitch_refresh_token: e.target.value,
-									})
-								}
-								placeholder={
-									configured ? "Enter new refresh token to update" : "refresh-token-from-twitch"
-								}
+								value={credentialInputs.webhook_auth_token ?? ""}
+								onChange={(e) => setCredentialInputs({...credentialInputs, webhook_auth_token: e.target.value})}
+								placeholder="Optional — leave empty for no auth"
+								onKeyDown={(e) => { if (e.key === "Enter") handleSave(); }}
 							/>
 						</div>
-					</div>
-					<p className="mt-1 text-xs text-ink-faint">
-						Use tokens from your Twitch application with chat:read and chat:write scopes enabled. Tokens are stored in your Spacebot instance and refreshed automatically while running.
-					</p>
-					<p className="mt-1.5 text-xs text-ink-faint">
+					</>
+				)}
+
+				{docLink && (
+					<p className="text-xs text-ink-faint">
 						Need help?{" "}
-						<a href="https://docs.spacebot.sh/twitch-setup" target="_blank" rel="noopener noreferrer" className="text-accent hover:underline">
-							Read the Twitch setup docs &rarr;
+						<a href={docLink} target="_blank" rel="noopener noreferrer" className="text-accent hover:underline">
+							Read the {PLATFORM_LABELS[platform]} setup docs &rarr;
 						</a>
 					</p>
-				</>
-			)}
-
-			{platform === "webhook" && (
-				<p className="text-sm text-ink-dull">
-					Webhook receiver requires no additional credentials.
-				</p>
-			)}
-
-			{platform !== "webhook" &&
-				Object.values(credentialInputs).some((v) => v?.trim()) && (
-					<Button onClick={onSave} loading={saving} size="sm">
-						{configured ? "Update Credentials" : "Connect"}
-					</Button>
 				)}
-		</div>
-	);
-}
 
-function BindingsSection({
-	platform,
-	bindings,
-	agents,
-	isEditingOrAdding,
-	editingBinding,
-	bindingForm,
-	setBindingForm,
-	onStartAdd,
-	onStartEdit,
-	onCancelEdit,
-	onAdd,
-	onUpdate,
-	onDelete,
-	addPending,
-	updatePending,
-	deletePending,
-}: {
-	platform: Platform;
-	bindings: BindingInfo[];
-	agents: {id: string}[];
-	isEditingOrAdding: boolean;
-	editingBinding: BindingInfo | null;
-	bindingForm: {
-		agent_id: string;
-		guild_id: string;
-		workspace_id: string;
-		chat_id: string;
-		channel_ids: string[];
-		require_mention: boolean;
-		dm_allowed_users: string[];
-	};
-	setBindingForm: (form: any) => void;
-	onStartAdd: () => void;
-	onStartEdit: (binding: BindingInfo) => void;
-	onCancelEdit: () => void;
-	onAdd: () => void;
-	onUpdate: () => void;
-	onDelete: (binding: BindingInfo) => void;
-	addPending: boolean;
-	updatePending: boolean;
-	deletePending: boolean;
-}) {
-	return (
-		<div className="flex flex-col gap-3 border-t border-app-line/50 pt-4">
-			<div className="flex items-center justify-between">
-				<h3 className="text-sm font-medium text-ink">Bindings</h3>
-				<Button size="sm" variant="outline" onClick={onStartAdd}>
-					Add
-				</Button>
-			</div>
+				{message && (
+					<div
+						className={`rounded-md border px-3 py-2 text-sm ${
+							message.type === "success"
+								? "border-green-500/20 bg-green-500/10 text-green-400"
+								: "border-red-500/20 bg-red-500/10 text-red-400"
+						}`}
+					>
+						{message.text}
+					</div>
+				)}
 
-			{/* Binding list */}
-			{bindings.length > 0 ? (
-				<div className="rounded-md border border-app-line bg-app-box">
-					{bindings.map((binding, idx) => (
-						<div
-							key={idx}
-							className="flex items-center gap-2 border-b border-app-line/50 px-3 py-2 last:border-b-0"
-						>
-							<div className="flex-1 min-w-0">
-								<span className="text-sm text-ink">{binding.agent_id}</span>
-								<div className="flex flex-wrap gap-1.5 mt-0.5 text-tiny text-ink-faint">
-									{binding.guild_id && <span>Guild: {binding.guild_id}</span>}
-									{binding.workspace_id && (
-										<span>Workspace: {binding.workspace_id}</span>
-									)}
-									{binding.chat_id && <span>Chat: {binding.chat_id}</span>}
-									{binding.channel_ids.length > 0 && (
-										<span>
-											{binding.channel_ids.length} channel
-											{binding.channel_ids.length > 1 ? "s" : ""}
-										</span>
-									)}
-									{binding.dm_allowed_users.length > 0 && (
-										<span>
-											{binding.dm_allowed_users.length} DM user
-											{binding.dm_allowed_users.length > 1 ? "s" : ""}
-										</span>
-									)}
-									{binding.require_mention && (
-										<span>Mention only</span>
-									)}
-									{!binding.guild_id &&
-										!binding.workspace_id &&
-										!binding.chat_id &&
-										binding.channel_ids.length === 0 && (
-											<span>All conversations</span>
-										)}
-								</div>
-							</div>
-							<Button
-								size="sm"
-								variant="outline"
-								onClick={() => onStartEdit(binding)}
-							>
-								Edit
-							</Button>
-							<Button
-								size="sm"
-								variant="outline"
-								onClick={() => onDelete(binding)}
-								loading={deletePending}
-							>
-								Remove
-							</Button>
-						</div>
-					))}
+				<div className="flex gap-2 justify-end">
+					<Button size="sm" variant="ghost" onClick={onCancel}>
+						Cancel
+					</Button>
+					<Button size="sm" onClick={handleSave} loading={createInstance.isPending}>
+						{isDefault ? "Connect" : "Create Instance"}
+					</Button>
 				</div>
-			) : (
-				<p className="text-sm text-ink-faint py-2">
-					No bindings. Messages will route to the default agent.
-				</p>
-			)}
-
-			{/* Add/Edit binding modal */}
-			<Dialog
-				open={isEditingOrAdding}
-				onOpenChange={(open) => {
-					if (!open) onCancelEdit();
-				}}
-			>
-				<DialogContent className="max-w-md">
-					<DialogHeader>
-						<DialogTitle>
-							{editingBinding ? "Edit Binding" : "Add Binding"}
-						</DialogTitle>
-					</DialogHeader>
-					<BindingForm
-						platform={platform}
-						agents={agents}
-						bindingForm={bindingForm}
-						setBindingForm={setBindingForm}
-						editing={!!editingBinding}
-						onSave={editingBinding ? onUpdate : onAdd}
-						onCancel={onCancelEdit}
-						saving={editingBinding ? updatePending : addPending}
-					/>
-				</DialogContent>
-			</Dialog>
+			</div>
 		</div>
 	);
 }
 
+// --- Binding Form (shared between add/edit) ---
+
 function BindingForm({
 	platform,
 	agents,
@@ -886,6 +979,7 @@ function BindingForm({
 		workspace_id: string;
 		chat_id: string;
 		channel_ids: string[];
+		require_mention: boolean;
 		dm_allowed_users: string[];
 	};
 	setBindingForm: (form: any) => void;
@@ -897,21 +991,15 @@ function BindingForm({
 	return (
 		<div className="flex flex-col gap-3">
 			<div>
-				<label className="mb-1 block text-sm font-medium text-ink-dull">
-					Agent
-				</label>
+				<label className="mb-1 block text-sm font-medium text-ink-dull">Agent</label>
 				<Select
 					value={bindingForm.agent_id}
 					onValueChange={(v) => setBindingForm({...bindingForm, agent_id: v})}
 				>
-					<SelectTrigger>
-						<SelectValue />
-					</SelectTrigger>
+					<SelectTrigger><SelectValue /></SelectTrigger>
 					<SelectContent>
 						{agents.map((a) => (
-							<SelectItem key={a.id} value={a.id}>
-								{a.id}
-							</SelectItem>
+							<SelectItem key={a.id} value={a.id}>{a.id}</SelectItem>
 						)) ?? <SelectItem value="main">main</SelectItem>}
 					</SelectContent>
 				</Select>
@@ -919,62 +1007,46 @@ function BindingForm({
 
 			{platform === "discord" && (
 				<div>
-					<label className="mb-1 block text-sm font-medium text-ink-dull">
-						Guild ID
-					</label>
+					<label className="mb-1 block text-sm font-medium text-ink-dull">Guild ID</label>
 					<Input
 						size="lg"
 						value={bindingForm.guild_id}
-						onChange={(e) =>
-							setBindingForm({...bindingForm, guild_id: e.target.value})
-						}
-						placeholder="Optional — leave empty for all servers"
+						onChange={(e) => setBindingForm({...bindingForm, guild_id: e.target.value})}
+						placeholder="Optional -- leave empty for all servers"
 					/>
 				</div>
 			)}
 
 			{platform === "slack" && (
 				<div>
-					<label className="mb-1 block text-sm font-medium text-ink-dull">
-						Workspace ID
-					</label>
+					<label className="mb-1 block text-sm font-medium text-ink-dull">Workspace ID</label>
 					<Input
 						size="lg"
 						value={bindingForm.workspace_id}
-						onChange={(e) =>
-							setBindingForm({...bindingForm, workspace_id: e.target.value})
-						}
-						placeholder="Optional — leave empty for all workspaces"
+						onChange={(e) => setBindingForm({...bindingForm, workspace_id: e.target.value})}
+						placeholder="Optional -- leave empty for all workspaces"
 					/>
 				</div>
 			)}
 
 			{platform === "telegram" && (
 				<div>
-					<label className="mb-1 block text-sm font-medium text-ink-dull">
-						Chat ID
-					</label>
+					<label className="mb-1 block text-sm font-medium text-ink-dull">Chat ID</label>
 					<Input
 						size="lg"
 						value={bindingForm.chat_id}
-						onChange={(e) =>
-							setBindingForm({...bindingForm, chat_id: e.target.value})
-						}
-						placeholder="Optional — leave empty for all chats"
+						onChange={(e) => setBindingForm({...bindingForm, chat_id: e.target.value})}
+						placeholder="Optional -- leave empty for all chats"
 					/>
 				</div>
 			)}
 
 			{(platform === "discord" || platform === "slack") && (
 				<div>
-					<label className="mb-1 block text-sm font-medium text-ink-dull">
-						Channel IDs
-					</label>
+					<label className="mb-1 block text-sm font-medium text-ink-dull">Channel IDs</label>
 					<TagInput
 						value={bindingForm.channel_ids}
-						onChange={(ids) =>
-							setBindingForm({...bindingForm, channel_ids: ids})
-						}
+						onChange={(ids) => setBindingForm({...bindingForm, channel_ids: ids})}
 						placeholder="Add channel ID..."
 					/>
 				</div>
@@ -985,49 +1057,35 @@ function BindingForm({
 					<input
 						type="checkbox"
 						checked={bindingForm.require_mention}
-						onChange={(e) =>
-							setBindingForm({...bindingForm, require_mention: e.target.checked})
-						}
+						onChange={(e) => setBindingForm({...bindingForm, require_mention: e.target.checked})}
 						className="h-4 w-4 rounded border-app-line bg-app-box"
 					/>
-					<label className="text-sm text-ink-dull">
-						Require @mention or reply to bot
-					</label>
+					<label className="text-sm text-ink-dull">Require @mention or reply to bot</label>
 				</div>
 			)}
 
 			{platform === "twitch" && (
 				<div>
-					<label className="mb-1 block text-sm font-medium text-ink-dull">
-						Channels
-					</label>
+					<label className="mb-1 block text-sm font-medium text-ink-dull">Channels</label>
 					<TagInput
 						value={bindingForm.channel_ids}
-						onChange={(ids) =>
-							setBindingForm({...bindingForm, channel_ids: ids})
-						}
+						onChange={(ids) => setBindingForm({...bindingForm, channel_ids: ids})}
 						placeholder="Add channel name..."
 					/>
 				</div>
 			)}
 
 			<div>
-				<label className="mb-1 block text-sm font-medium text-ink-dull">
-					DM Allowed Users
-				</label>
+				<label className="mb-1 block text-sm font-medium text-ink-dull">DM Allowed Users</label>
 				<TagInput
 					value={bindingForm.dm_allowed_users}
-					onChange={(users) =>
-						setBindingForm({...bindingForm, dm_allowed_users: users})
-					}
+					onChange={(users) => setBindingForm({...bindingForm, dm_allowed_users: users})}
 					placeholder="Add user ID..."
 				/>
 			</div>
 
 			<DialogFooter>
-				<Button size="sm" variant="ghost" onClick={onCancel}>
-					Cancel
-				</Button>
+				<Button size="sm" variant="ghost" onClick={onCancel}>Cancel</Button>
 				<Button size="sm" onClick={onSave} loading={saving}>
 					{editing ? "Update" : "Add Binding"}
 				</Button>
@@ -1036,54 +1094,29 @@ function BindingForm({
 	);
 }
 
-function DisconnectSection({
+// --- Backward compat: keep DisabledChannelCard export for any other consumers ---
+
+export function DisabledChannelCard({
+	platform,
 	name,
-	confirmDisconnect,
-	setConfirmDisconnect,
-	onDisconnect,
-	disconnecting,
+	description,
 }: {
+	platform: string;
 	name: string;
-	confirmDisconnect: boolean;
-	setConfirmDisconnect: (v: boolean) => void;
-	onDisconnect: () => void;
-	disconnecting: boolean;
+	description: string;
 }) {
 	return (
-		<div className="border-t border-app-line/50 pt-4">
-			{!confirmDisconnect ? (
-				<Button
-					variant="outline"
-					size="sm"
-					onClick={() => setConfirmDisconnect(true)}
-				>
-					Disconnect {name}
-				</Button>
-			) : (
-				<div className="flex flex-col gap-2">
-					<p className="text-sm text-red-400">
-						This will remove all credentials and bindings for {name}. The bot
-						will stop responding immediately.
-					</p>
-					<div className="flex gap-2">
-						<Button
-							variant="ghost"
-							size="sm"
-							onClick={() => setConfirmDisconnect(false)}
-						>
-							Cancel
-						</Button>
-						<Button
-							size="sm"
-							onClick={onDisconnect}
-							loading={disconnecting}
-							className="bg-red-500/20 text-red-400 hover:bg-red-500/30"
-						>
-							Confirm Disconnect
-						</Button>
-					</div>
+		<div className="rounded-lg border border-app-line bg-app-box p-4 opacity-40">
+			<div className="flex items-center gap-3">
+				<PlatformIcon platform={platform} size="lg" className="text-ink-faint/50" />
+				<div className="flex-1">
+					<span className="text-sm font-medium text-ink">{name}</span>
+					<p className="mt-0.5 text-sm text-ink-dull">{description}</p>
 				</div>
-			)}
+				<Button variant="outline" size="sm" disabled>
+					Coming Soon
+				</Button>
+			</div>
 		</div>
 	);
 }
diff --git a/interface/src/components/CortexChatPanel.tsx b/interface/src/components/CortexChatPanel.tsx
index dd763848d..c9bd1c4b7 100644
--- a/interface/src/components/CortexChatPanel.tsx
+++ b/interface/src/components/CortexChatPanel.tsx
@@ -11,6 +11,70 @@ interface CortexChatPanelProps {
 	onClose?: () => void;
 }
 
+interface StarterPrompt {
+	label: string;
+	prompt: string;
+}
+
+const STARTER_PROMPTS: StarterPrompt[] = [
+	{
+		label: "Run health check",
+		prompt: "Give me an agent health report with active risks, stale work, and the top 3 fixes to do now.",
+	},
+	{
+		label: "Audit memories",
+		prompt: "Audit memory quality, find stale or contradictory memories, and propose exact cleanup actions.",
+	},
+	{
+		label: "Review workers",
+		prompt: "List recent worker runs, inspect failures, and summarize root cause plus next actions.",
+	},
+	{
+		label: "Draft task spec",
+		prompt: "Turn this goal into a task spec with subtasks, then move it to ready when it is execution-ready: ",
+	},
+];
+
+function EmptyCortexState({
+	channelId,
+	onStarterPrompt,
+	disabled,
+}: {
+	channelId?: string;
+	onStarterPrompt: (prompt: string) => void;
+	disabled: boolean;
+}) {
+	const contextHint = channelId
+		? "Current channel transcript is injected for this send only."
+		: "No channel transcript is injected. Operating at full agent scope.";
+
+	return (
+		<div className="mx-auto w-full max-w-md">
+			<div className="rounded-2xl border border-app-line/40 bg-app-darkBox/15 p-5">
+				<h3 className="font-plex text-base font-medium text-ink">Cortex chat</h3>
+				<p className="mt-2 text-sm leading-relaxed text-ink-dull">
+					System-level control for this agent: memory, tasks, worker inspection, and direct tool execution.
+				</p>
+				<p className="mt-2 text-tiny text-ink-faint">{contextHint}</p>
+
+				<div className="mt-4 grid grid-cols-2 gap-2">
+					{STARTER_PROMPTS.map((item) => (
+						<button
+							key={item.label}
+							type="button"
+							onClick={() => onStarterPrompt(item.prompt)}
+							disabled={disabled}
+							className="rounded-lg border border-app-line/35 bg-app-box/20 px-2.5 py-2 text-left text-tiny text-ink-dull transition-colors hover:border-app-line/60 hover:text-ink disabled:opacity-40"
+						>
+							{item.label}
+						</button>
+					))}
+				</div>
+			</div>
+		</div>
+	);
+}
+
 function ToolActivityIndicator({ activity }: { activity: ToolActivity[] }) {
 	if (activity.length === 0) return null;
 
@@ -128,7 +192,7 @@ function CortexChatInput({
 }
 
 export function CortexChatPanel({ agentId, channelId, onClose }: CortexChatPanelProps) {
-	const { messages, isStreaming, error, toolActivity, sendMessage, newThread } = useCortexChat(agentId, channelId);
+	const { messages, threadId, isStreaming, error, toolActivity, sendMessage, newThread } = useCortexChat(agentId, channelId);
 	const [input, setInput] = useState("");
 	const messagesEndRef = useRef<HTMLDivElement>(null);
 
@@ -143,6 +207,11 @@ export function CortexChatPanel({ agentId, channelId, onClose }: CortexChatPanel
 		sendMessage(trimmed);
 	};
 
+	const handleStarterPrompt = (prompt: string) => {
+		if (isStreaming || !threadId) return;
+		sendMessage(prompt);
+	};
+
 	return (
 		<div className="flex h-full w-full flex-col">
 			{/* Header */}
@@ -183,12 +252,6 @@ export function CortexChatPanel({ agentId, channelId, onClose }: CortexChatPanel
 			{/* Messages */}
 			<div className="flex-1 overflow-y-auto">
 				<div className="flex flex-col gap-5 p-3 pb-4">
-					{messages.length === 0 && !isStreaming && (
-						<div className="flex items-center justify-center py-12">
-							<p className="text-sm text-ink-faint">Ask the cortex anything</p>
-						</div>
-					)}
-
 					{messages.map((message) => (
 						<div key={message.id}>
 							{message.role === "user" ? (
@@ -222,6 +285,16 @@ export function CortexChatPanel({ agentId, channelId, onClose }: CortexChatPanel
 				</div>
 			</div>
 
+			{messages.length === 0 && !isStreaming && (
+				<div className="px-3 pb-2">
+					<EmptyCortexState
+						channelId={channelId}
+						onStarterPrompt={handleStarterPrompt}
+						disabled={isStreaming || !threadId}
+					/>
+				</div>
+			)}
+
 			{/* Input */}
 			<div className="border-t border-app-line/50 p-3">
 				<CortexChatInput
diff --git a/interface/src/components/ErrorBoundary.tsx b/interface/src/components/ErrorBoundary.tsx
new file mode 100644
index 000000000..368c15b0e
--- /dev/null
+++ b/interface/src/components/ErrorBoundary.tsx
@@ -0,0 +1,57 @@
+import { Component, type ErrorInfo, type ReactNode } from "react";
+
+interface Props {
+	children: ReactNode;
+}
+
+interface State {
+	hasError: boolean;
+	error: Error | null;
+}
+
+export class ErrorBoundary extends Component<Props, State> {
+	constructor(props: Props) {
+		super(props);
+		this.state = { hasError: false, error: null };
+	}
+
+	static getDerivedStateFromError(error: Error): State {
+		return { hasError: true, error };
+	}
+
+	componentDidCatch(error: Error, info: ErrorInfo) {
+		console.error("[ErrorBoundary]", error, info.componentStack);
+	}
+
+	render() {
+		if (!this.state.hasError) {
+			return this.props.children;
+		}
+
+		return (
+			<div className="flex h-screen w-screen items-center justify-center bg-app">
+				<div className="max-w-md space-y-4 rounded-lg border border-red-500/20 bg-red-500/10 p-6">
+					<h2 className="text-lg font-semibold text-red-400">
+						Something went wrong
+					</h2>
+					<p className="text-sm text-ink-faint">
+						The interface crashed unexpectedly. This is usually caused by a
+						rendering error.
+					</p>
+					{this.state.error && (
+						<pre className="overflow-auto rounded bg-app-darkBox p-3 text-xs text-ink-dull">
+							{this.state.error.message}
+						</pre>
+					)}
+					<button
+						type="button"
+						onClick={() => window.location.reload()}
+						className="rounded bg-red-500/20 px-4 py-2 text-sm font-medium text-red-400 transition-colors hover:bg-red-500/30"
+					>
+						Reload
+					</button>
+				</div>
+			</div>
+		);
+	}
+}
diff --git a/interface/src/components/Markdown.tsx b/interface/src/components/Markdown.tsx
index 81bbf057e..b903aa96b 100644
--- a/interface/src/components/Markdown.tsx
+++ b/interface/src/components/Markdown.tsx
@@ -1,9 +1,15 @@
 import ReactMarkdown from "react-markdown";
 import remarkGfm from "remark-gfm";
 
-export function Markdown({ children }: { children: string }) {
+export function Markdown({
+	children,
+	className,
+}: {
+	children: string;
+	className?: string;
+}) {
 	return (
-		<div className="markdown">
+		<div className={className ? `markdown ${className}` : "markdown"}>
 			<ReactMarkdown
 				remarkPlugins={[remarkGfm]}
 				components={{
diff --git a/interface/src/components/ModelSelect.tsx b/interface/src/components/ModelSelect.tsx
index 8abab4391..8a2b3c7df 100644
--- a/interface/src/components/ModelSelect.tsx
+++ b/interface/src/components/ModelSelect.tsx
@@ -15,6 +15,7 @@ interface ModelSelectProps {
 const PROVIDER_LABELS: Record<string, string> = {
   anthropic: "Anthropic",
   openrouter: "OpenRouter",
+  kilo: "Kilo Gateway",
   openai: "OpenAI",
   "openai-chatgpt": "ChatGPT Plus (OAuth)",
   deepseek: "DeepSeek",
@@ -27,6 +28,7 @@ const PROVIDER_LABELS: Record<string, string> = {
   zhipu: "Z.ai (GLM)",
   ollama: "Ollama",
   "opencode-zen": "OpenCode Zen",
+  "opencode-go": "OpenCode Go",
   minimax: "MiniMax",
   "minimax-cn": "MiniMax CN",
 };
@@ -128,6 +130,7 @@ export function ModelSelect({
 
   const providerOrder = [
     "openrouter",
+    "kilo",
     "anthropic",
     "openai",
     "openai-chatgpt",
@@ -141,12 +144,16 @@ export function ModelSelect({
     "fireworks",
     "zhipu",
     "opencode-zen",
+    "opencode-go",
     "minimax",
     "minimax-cn",
   ];
+  const providerRank = (provider: string) => {
+    const index = providerOrder.indexOf(provider);
+    return index === -1 ? Number.MAX_SAFE_INTEGER : index;
+  };
   const sortedProviders = Object.keys(grouped).sort(
-    (a, b) =>
-      (providerOrder.indexOf(a) ?? 99) - (providerOrder.indexOf(b) ?? 99),
+    (a, b) => providerRank(a) - providerRank(b),
   );
 
   return (
diff --git a/interface/src/components/Sidebar.tsx b/interface/src/components/Sidebar.tsx
index ef51575b8..863b9bc48 100644
--- a/interface/src/components/Sidebar.tsx
+++ b/interface/src/components/Sidebar.tsx
@@ -35,12 +35,13 @@ interface SidebarProps {
 
 interface SortableAgentItemProps {
 	agentId: string;
+	displayName?: string;
 	activity?: { workers: number; branches: number };
 	isActive: boolean;
 	collapsed: boolean;
 }
 
-function SortableAgentItem({ agentId, activity, isActive, collapsed }: SortableAgentItemProps) {
+function SortableAgentItem({ agentId, displayName, activity, isActive, collapsed }: SortableAgentItemProps) {
 	const {
 		attributes,
 		listeners,
@@ -67,9 +68,9 @@ function SortableAgentItem({ agentId, activity, isActive, collapsed }: SortableA
 						isActive ? "bg-sidebar-selected text-sidebar-ink" : "text-sidebar-inkDull hover:bg-sidebar-selected/50"
 					}`}
 					style={{ pointerEvents: isDragging ? 'none' : 'auto' }}
-					title={agentId}
+					title={displayName ?? agentId}
 				>
-					{agentId.charAt(0).toUpperCase()}
+					{(displayName ?? agentId).charAt(0).toUpperCase()}
 				</Link>
 			</div>
 		);
@@ -87,7 +88,7 @@ function SortableAgentItem({ agentId, activity, isActive, collapsed }: SortableA
 				}`}
 				style={{ pointerEvents: isDragging ? 'none' : 'auto' }}
 			>
-				<span className="flex-1 truncate">{agentId}</span>
+				<span className="flex-1 truncate">{displayName ?? agentId}</span>
 				{activity && (activity.workers > 0 || activity.branches > 0) && (
 					<div className="flex items-center gap-1">
 						{activity.workers > 0 && (
@@ -126,6 +127,11 @@ export function Sidebar({ liveStates, collapsed, onToggle }: SidebarProps) {
 	const channels = channelsData?.channels ?? [];
 	
 	const agentIds = useMemo(() => agents.map((a) => a.id), [agents]);
+	const agentDisplayNames = useMemo(() => {
+		const map: Record<string, string | undefined> = {};
+		for (const a of agents) map[a.id] = a.display_name;
+		return map;
+	}, [agents]);
 	const [agentOrder, setAgentOrder] = useAgentOrder(agentIds);
 
 	const matchRoute = useMatchRoute();
@@ -225,17 +231,18 @@ export function Sidebar({ liveStates, collapsed, onToggle }: SidebarProps) {
 					onDragEnd={handleDragEnd}
 				>
 					<SortableContext items={agentOrder} strategy={verticalListSortingStrategy}>
-						{agentOrder.map((agentId) => {
-							const isActive = !!matchRoute({ to: "/agents/$agentId", params: { agentId }, fuzzy: true });
-							return (
-								<SortableAgentItem
-									key={agentId}
-									agentId={agentId}
-									isActive={isActive}
-									collapsed={true}
-								/>
-							);
-						})}
+					{agentOrder.map((agentId) => {
+						const isActive = !!matchRoute({ to: "/agents/$agentId", params: { agentId }, fuzzy: true });
+						return (
+							<SortableAgentItem
+								key={agentId}
+								agentId={agentId}
+								displayName={agentDisplayNames[agentId]}
+								isActive={isActive}
+								collapsed={true}
+							/>
+						);
+					})}
 					</SortableContext>
 				</DndContext>
 				<button
@@ -289,20 +296,21 @@ export function Sidebar({ liveStates, collapsed, onToggle }: SidebarProps) {
 							>
 								<SortableContext items={agentOrder} strategy={verticalListSortingStrategy}>
 									<div className="flex flex-col gap-0.5">
-										{agentOrder.map((agentId) => {
-											const activity = agentActivity[agentId];
-											const isActive = !!matchRoute({ to: "/agents/$agentId", params: { agentId }, fuzzy: true });
+									{agentOrder.map((agentId) => {
+										const activity = agentActivity[agentId];
+										const isActive = !!matchRoute({ to: "/agents/$agentId", params: { agentId }, fuzzy: true });
 
-											return (
-												<SortableAgentItem
-													key={agentId}
-													agentId={agentId}
-													activity={activity}
-													isActive={isActive}
-													collapsed={false}
-												/>
-											);
-										})}
+										return (
+											<SortableAgentItem
+												key={agentId}
+												agentId={agentId}
+												displayName={agentDisplayNames[agentId]}
+												activity={activity}
+												isActive={isActive}
+												collapsed={false}
+											/>
+										);
+									})}
 									</div>
 								</SortableContext>
 							</DndContext>
diff --git a/interface/src/components/TagInput.tsx b/interface/src/components/TagInput.tsx
index 88c5306ee..1a9aad507 100644
--- a/interface/src/components/TagInput.tsx
+++ b/interface/src/components/TagInput.tsx
@@ -1,6 +1,5 @@
 import {useState, useRef, KeyboardEvent} from "react";
 import {X} from "lucide-react";
-import {Input} from "@/ui";
 
 interface TagInputProps {
 	value: string[];
diff --git a/interface/src/components/TopologyGraph.tsx b/interface/src/components/TopologyGraph.tsx
index 44402c938..aac095aa9 100644
--- a/interface/src/components/TopologyGraph.tsx
+++ b/interface/src/components/TopologyGraph.tsx
@@ -11,6 +11,7 @@ import {
 	type NodeProps,
 	type EdgeProps,
 	type NodeChange,
+	type EdgeChange,
 	useNodesState,
 	useEdgesState,
 	useReactFlow,
@@ -79,6 +80,22 @@ function savePositions(nodes: Node[]) {
 	}
 }
 
+// -- Handle persistence --
+
+const HANDLES_KEY = "spacebot:topology:handles";
+
+type SavedHandles = Record<string, { sourceHandle: string; targetHandle: string }>;
+
+function loadHandles(): SavedHandles {
+	try {
+		const raw = localStorage.getItem(HANDLES_KEY);
+		if (raw) return JSON.parse(raw);
+	} catch {
+		// ignore
+	}
+	return {};
+}
+
 /** Deterministic gradient from a seed string. */
 function seedGradient(seed: string): [string, string] {
 	let hash = 0;
@@ -368,23 +385,23 @@ function getHandlesForKind(
 	kind: string,
 	sourcePos?: { x: number; y: number },
 	targetPos?: { x: number; y: number },
+	savedHandles?: { sourceHandle: string; targetHandle: string },
 ): {
 	sourceHandle: string;
 	targetHandle: string;
 } {
+	// Use saved handles if available (user's explicit choice)
+	if (savedHandles) {
+		return savedHandles;
+	}
+	
 	if (kind === "hierarchical") {
 		// from is above to: connect bottom of superior to top of subordinate
 		return { sourceHandle: "bottom", targetHandle: "top" };
 	}
-	// Peer: pick the side facing the other node
+	// Peer: always use left/right handles (horizontal connections)
 	if (sourcePos && targetPos) {
 		const dx = targetPos.x - sourcePos.x;
-		const dy = targetPos.y - sourcePos.y;
-		if (Math.abs(dy) > Math.abs(dx)) {
-			return dy > 0
-				? { sourceHandle: "bottom", targetHandle: "top" }
-				: { sourceHandle: "top", targetHandle: "bottom" };
-		}
 		return dx > 0
 			? { sourceHandle: "right", targetHandle: "left" }
 			: { sourceHandle: "left", targetHandle: "right" };
@@ -912,7 +929,16 @@ function TopologyGraphInner({ activeEdges, agents }: TopologyGraphInnerProps) {
 	const deleteLink = useMutation({
 		mutationFn: (params: { from: string; to: string }) =>
 			api.deleteLink(params.from, params.to),
-		onSuccess: () => {
+		onSuccess: (_, params) => {
+			// Clean up saved handles
+			const edgeId = `${params.from}->${params.to}`;
+			const currentHandles = loadHandles();
+			delete currentHandles[edgeId];
+			try {
+				localStorage.setItem(HANDLES_KEY, JSON.stringify(currentHandles));
+			} catch {
+				// ignore
+			}
 			queryClient.invalidateQueries({ queryKey: ["topology"] });
 			setSelectedEdge(null);
 		},
@@ -1008,6 +1034,26 @@ function TopologyGraphInner({ activeEdges, agents }: TopologyGraphInnerProps) {
 			const from = (kind === "hierarchical" && isFromTop) ? connection.target : connection.source;
 			const to = (kind === "hierarchical" && isFromTop) ? connection.source : connection.target;
 
+			// Save handle information to localStorage
+			// Handles need to be stored relative to the final from/to, not the connection source/target
+			const edgeId = `${from}->${to}`;
+			if (connection.sourceHandle && connection.targetHandle) {
+				const currentHandles = loadHandles();
+				currentHandles[edgeId] = {
+					sourceHandle: (kind === "hierarchical" && isFromTop) 
+						? connection.targetHandle 
+						: connection.sourceHandle,
+					targetHandle: (kind === "hierarchical" && isFromTop) 
+						? connection.sourceHandle 
+						: connection.targetHandle,
+				};
+				try {
+					localStorage.setItem(HANDLES_KEY, JSON.stringify(currentHandles));
+				} catch {
+					// ignore
+				}
+			}
+
 			createLink.mutate({
 				from,
 				to,
@@ -1018,6 +1064,27 @@ function TopologyGraphInner({ activeEdges, agents }: TopologyGraphInnerProps) {
 		[edges, createLink],
 	);
 
+	const handleEdgesChange = useCallback(
+		(changes: EdgeChange[]) => {
+			// Intercept edge removal (Delete/Backspace key)
+			for (const change of changes) {
+				if (change.type === "remove") {
+					const edge = edges.find((e) => e.id === change.id);
+					if (edge) {
+						// Parse edge ID format: "from->to"
+						const [from, to] = edge.id.split("->");
+						if (from && to) {
+							deleteLink.mutate({ from, to });
+						}
+					}
+				}
+			}
+			// Apply the changes to local state
+			onEdgesChange(changes);
+		},
+		[edges, deleteLink, onEdgesChange],
+	);
+
 	const onEdgeClick = useCallback(
 		(_: React.MouseEvent, edge: Edge) => {
 			setSelectedEdge(edge);
@@ -1223,7 +1290,7 @@ function TopologyGraphInner({ activeEdges, agents }: TopologyGraphInnerProps) {
 				nodes={nodes}
 				edges={edges}
 				onNodesChange={handleNodesChange}
-				onEdgesChange={onEdgesChange}
+				onEdgesChange={handleEdgesChange}
 				onConnect={onConnect}
 				onEdgeClick={onEdgeClick}
 				onNodeClick={onNodeClick}
@@ -1392,6 +1459,7 @@ function buildGraph(
 	agentProfiles: Map<string, AgentSummary>,
 ): { initialNodes: Node[]; initialEdges: Edge[] } {
 	const saved = loadPositions();
+	const savedHandles = loadHandles();
 	const allNodes: Node[] = [];
 
 	// Topology agent lookup for display_name / role
@@ -1574,10 +1642,12 @@ function buildGraph(
 	// Compute connected handles using actual positions
 	const connectedHandles = new Set<string>();
 	for (const link of links) {
+		const edgeId = `${link.from}->${link.to}`;
 		const { sourceHandle, targetHandle } = getHandlesForKind(
 			link.kind,
 			nodePositionMap.get(link.from),
 			nodePositionMap.get(link.to),
+			savedHandles[edgeId],
 		);
 		connectedHandles.add(`${link.from}:${sourceHandle}`);
 		connectedHandles.add(`${link.to}:${targetHandle}`);
@@ -1605,6 +1675,7 @@ function buildGraph(
 			link.kind,
 			nodePositionMap.get(link.from),
 			nodePositionMap.get(link.to),
+			savedHandles[edgeId],
 		);
 		return {
 			id: edgeId,
diff --git a/interface/src/components/UpdateBanner.tsx b/interface/src/components/UpdateBanner.tsx
deleted file mode 100644
index c278ca149..000000000
--- a/interface/src/components/UpdateBanner.tsx
+++ /dev/null
@@ -1,87 +0,0 @@
-import { useState } from "react";
-import { useQuery, useMutation } from "@tanstack/react-query";
-import { api } from "@/api/client";
-import { Banner, BannerActions, Button } from "@/ui";
-import { Cancel01Icon } from "@hugeicons/core-free-icons";
-import { HugeiconsIcon } from "@hugeicons/react";
-
-export function UpdateBanner() {
-	const [dismissed, setDismissed] = useState(false);
-
-	const { data } = useQuery({
-		queryKey: ["updateCheck"],
-		queryFn: api.updateCheck,
-		staleTime: 60_000,
-		refetchInterval: 300_000,
-	});
-
-	const applyMutation = useMutation({
-		mutationFn: api.updateApply,
-		onSuccess: (result) => {
-			if (result.status === "error") {
-				setApplyError(result.error ?? "Update failed");
-			}
-		},
-	});
-
-	const [applyError, setApplyError] = useState<string | null>(null);
-
-	// Platform-managed instances get updates via rollout, not self-service
-	if (!data || !data.update_available || dismissed || data.deployment === "hosted") return null;
-
-	const isApplying = applyMutation.isPending;
-
-	return (
-		<div>
-			<Banner variant="cyan" dot="static" className="border-cyan-500/20">
-				<span>
-					Version <strong>{data.latest_version}</strong> is available
-					<span className="text-ink-faint ml-1">(current: {data.current_version})</span>
-				</span>
-				{data.release_url && (
-					<a
-						href={data.release_url}
-						target="_blank"
-						rel="noopener noreferrer"
-						className="underline hover:text-cyan-300"
-					>
-						Release notes
-					</a>
-				)}
-				<BannerActions>
-					{data.can_apply && (
-						<Button
-							onClick={() => {
-								setApplyError(null);
-								applyMutation.mutate();
-							}}
-							size="sm"
-							loading={isApplying}
-							className="bg-cyan-500/20 text-xs text-cyan-300 hover:bg-cyan-500/30"
-						>
-							Update now
-						</Button>
-					)}
-					{!data.can_apply && data.deployment === "docker" && (
-						<span className="text-xs text-ink-faint">
-							Mount docker.sock for one-click updates
-						</span>
-					)}
-					<Button
-						onClick={() => setDismissed(true)}
-						variant="ghost"
-						size="icon"
-						className="h-7 w-7"
-					>
-						<HugeiconsIcon icon={Cancel01Icon} size={14} />
-					</Button>
-				</BannerActions>
-			</Banner>
-			{applyError && (
-				<div className="border-b border-red-500/20 bg-red-500/10 px-4 py-1 text-xs text-red-400">
-					{applyError}
-				</div>
-			)}
-		</div>
-	);
-}
diff --git a/interface/src/components/UpdatePill.tsx b/interface/src/components/UpdatePill.tsx
new file mode 100644
index 000000000..7096114b4
--- /dev/null
+++ b/interface/src/components/UpdatePill.tsx
@@ -0,0 +1,27 @@
+import {useQuery} from "@tanstack/react-query";
+import {Link} from "@tanstack/react-router";
+import {api} from "@/api/client";
+
+export function UpdatePill() {
+	const {data} = useQuery({
+		queryKey: ["update-check"],
+		queryFn: api.updateCheck,
+		staleTime: 60_000,
+		refetchInterval: 300_000,
+	});
+
+	if (!data || !data.update_available || data.deployment === "hosted") {
+		return null;
+	}
+
+	return (
+		<Link
+			to="/settings"
+			search={{tab: "updates"}}
+			className="inline-flex items-center gap-2 rounded-full border border-cyan-500/30 bg-cyan-500/10 px-3 py-1 text-xs font-medium text-cyan-300 transition-colors hover:border-cyan-400/60 hover:bg-cyan-500/20"
+		>
+			<span className="h-1.5 w-1.5 rounded-full bg-cyan-300" />
+			Update {data.latest_version ?? "available"}
+		</Link>
+	);
+}
diff --git a/interface/src/components/WebChatPanel.tsx b/interface/src/components/WebChatPanel.tsx
index 747e0de5a..ef38c20c3 100644
--- a/interface/src/components/WebChatPanel.tsx
+++ b/interface/src/components/WebChatPanel.tsx
@@ -1,37 +1,54 @@
-import {useEffect, useRef, useState} from "react";
-import {
-	useWebChat,
-	getPortalChatSessionId,
-	type ToolActivity,
-} from "@/hooks/useWebChat";
-import type {ActiveWorker} from "@/hooks/useChannelLiveState";
-import {useLiveContext} from "@/hooks/useLiveContext";
-import {Markdown} from "@/components/Markdown";
+import { useEffect, useRef, useState } from "react";
+import { useWebChat } from "@/hooks/useWebChat";
+import { isOpenCodeWorker, type ActiveWorker } from "@/hooks/useChannelLiveState";
+import { useLiveContext } from "@/hooks/useLiveContext";
+import { Markdown } from "@/components/Markdown";
 
 interface WebChatPanelProps {
 	agentId: string;
 }
 
-function ToolActivityIndicator({activity}: {activity: ToolActivity[]}) {
-	if (activity.length === 0) return null;
+function ActiveWorkersPanel({ workers }: { workers: ActiveWorker[] }) {
+	if (workers.length === 0) return null;
+
+	// Use neutral chrome when all workers are opencode, amber when all builtin, mixed stays amber
+	const allOpenCode = workers.every(isOpenCodeWorker);
+	const borderColor = allOpenCode ? "border-zinc-500/25 bg-zinc-500/5" : "border-amber-500/25 bg-amber-500/5";
+	const headerColor = allOpenCode ? "text-zinc-200" : "text-amber-200";
+	const dotColor = allOpenCode ? "bg-zinc-400" : "bg-amber-400";
 
 	return (
-		<div className="flex flex-wrap items-center gap-1.5 mt-2">
-			{activity.map((tool, index) => (
-				<span
-					key={`${tool.tool}-${index}`}
-					className="inline-flex items-center gap-1.5 rounded-full bg-app-box/60 px-2.5 py-0.5"
-				>
-					{tool.status === "running" ? (
-						<span className="h-1.5 w-1.5 animate-pulse rounded-full bg-amber-400" />
-					) : (
-						<span className="h-1.5 w-1.5 rounded-full bg-green-400" />
-					)}
-					<span className="font-mono text-tiny text-ink-faint">
-						{tool.tool}
-					</span>
+		<div className={`rounded-lg border px-3 py-2 ${borderColor}`}>
+			<div className={`mb-2 flex items-center gap-1.5 text-tiny ${headerColor}`}>
+				<div className={`h-1.5 w-1.5 animate-pulse rounded-full ${dotColor}`} />
+				<span>
+					{workers.length} active worker{workers.length !== 1 ? "s" : ""}
 				</span>
-			))}
+			</div>
+			<div className="flex flex-col gap-1.5">
+				{workers.map((worker) => {
+					const oc = isOpenCodeWorker(worker);
+					return (
+						<div
+							key={worker.id}
+							className={`flex min-w-0 items-center gap-2 rounded-md px-2.5 py-1.5 text-tiny ${
+								oc ? "bg-zinc-500/10" : "bg-amber-500/10"
+							}`}
+						>
+							<span className={`font-medium ${oc ? "text-zinc-300" : "text-amber-300"}`}>Worker</span>
+							<span className="min-w-0 flex-1 truncate text-ink-dull">
+								{worker.task}
+							</span>
+							<span className="shrink-0 text-ink-faint">{worker.status}</span>
+							{worker.currentTool && (
+								<span className={`max-w-40 shrink-0 truncate ${oc ? "text-zinc-400/80" : "text-amber-400/80"}`}>
+									{worker.currentTool}
+								</span>
+							)}
+						</div>
+					);
+				})}
+			</div>
 		</div>
 	);
 }
@@ -46,51 +63,17 @@ function ThinkingIndicator() {
 	);
 }
 
-function ActiveWorkersPanel({workers}: {workers: ActiveWorker[]}) {
-	if (workers.length === 0) return null;
-
-	return (
-		<div className="rounded-lg border border-amber-500/25 bg-amber-500/5 px-3 py-2">
-			<div className="mb-2 flex items-center gap-1.5 text-tiny text-amber-200">
-				<div className="h-1.5 w-1.5 animate-pulse rounded-full bg-amber-400" />
-				<span>
-					{workers.length} active worker{workers.length !== 1 ? "s" : ""}
-				</span>
-			</div>
-			<div className="flex flex-col gap-1.5">
-				{workers.map((worker) => (
-					<div
-						key={worker.id}
-						className="flex min-w-0 items-center gap-2 rounded-md bg-amber-500/10 px-2.5 py-1.5 text-tiny"
-					>
-						<span className="font-medium text-amber-300">Worker</span>
-						<span className="min-w-0 flex-1 truncate text-ink-dull">
-							{worker.task}
-						</span>
-						<span className="shrink-0 text-ink-faint">{worker.status}</span>
-						{worker.currentTool && (
-							<span className="max-w-40 shrink-0 truncate text-amber-400/80">
-								{worker.currentTool}
-							</span>
-						)}
-					</div>
-				))}
-			</div>
-		</div>
-	);
-}
-
 function FloatingChatInput({
 	value,
 	onChange,
 	onSubmit,
-	isStreaming,
+	disabled,
 	agentId,
 }: {
 	value: string;
 	onChange: (value: string) => void;
 	onSubmit: () => void;
-	isStreaming: boolean;
+	disabled: boolean;
 	agentId: string;
 }) {
 	const textareaRef = useRef<HTMLTextAreaElement>(null);
@@ -134,19 +117,19 @@ function FloatingChatInput({
 							onChange={(event) => onChange(event.target.value)}
 							onKeyDown={handleKeyDown}
 							placeholder={
-								isStreaming
+								disabled
 									? "Waiting for response..."
 									: `Message ${agentId}...`
 							}
-							disabled={isStreaming}
+							disabled={disabled}
 							rows={1}
 							className="flex-1 resize-none bg-transparent px-1 py-1.5 text-sm text-ink placeholder:text-ink-faint/60 focus:outline-none disabled:opacity-40"
-							style={{maxHeight: "200px"}}
+							style={{ maxHeight: "200px" }}
 						/>
 						<button
 							type="button"
 							onClick={onSubmit}
-							disabled={isStreaming || !value.trim()}
+							disabled={disabled || !value.trim()}
 							className="flex h-8 w-8 shrink-0 items-center justify-center rounded-full bg-accent text-white transition-all duration-150 hover:bg-accent-deep disabled:opacity-30 disabled:hover:bg-accent"
 						>
 							<svg
@@ -169,23 +152,26 @@ function FloatingChatInput({
 	);
 }
 
-export function WebChatPanel({agentId}: WebChatPanelProps) {
-	const {messages, isStreaming, error, toolActivity, sendMessage} =
-		useWebChat(agentId);
-	const {liveStates} = useLiveContext();
+export function WebChatPanel({ agentId }: WebChatPanelProps) {
+	const { sessionId, isSending, error, sendMessage } = useWebChat(agentId);
+	const { liveStates } = useLiveContext();
 	const [input, setInput] = useState("");
 	const messagesEndRef = useRef<HTMLDivElement>(null);
-	const sessionId = getPortalChatSessionId(agentId);
-	const activeWorkers = Object.values(liveStates[sessionId]?.workers ?? {});
+
+	const liveState = liveStates[sessionId];
+	const timeline = liveState?.timeline ?? [];
+	const isTyping = liveState?.isTyping ?? false;
+	const activeWorkers = Object.values(liveState?.workers ?? {});
 	const hasActiveWorkers = activeWorkers.length > 0;
 
+	// Auto-scroll on new messages or typing state changes
 	useEffect(() => {
-		messagesEndRef.current?.scrollIntoView({behavior: "smooth"});
-	}, [messages.length, isStreaming, toolActivity.length, activeWorkers.length]);
+		messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+	}, [timeline.length, isTyping, activeWorkers.length]);
 
 	const handleSubmit = () => {
 		const trimmed = input.trim();
-		if (!trimmed || isStreaming) return;
+		if (!trimmed || isSending) return;
 		setInput("");
 		sendMessage(trimmed);
 	};
@@ -201,7 +187,7 @@ export function WebChatPanel({agentId}: WebChatPanelProps) {
 						</div>
 					)}
 
-					{messages.length === 0 && !isStreaming && (
+					{timeline.length === 0 && !isTyping && (
 						<div className="flex flex-col items-center justify-center py-24">
 							<p className="text-sm text-ink-faint">
 								Start a conversation with {agentId}
@@ -209,37 +195,27 @@ export function WebChatPanel({agentId}: WebChatPanelProps) {
 						</div>
 					)}
 
-					{messages.map((message) => (
-						<div key={message.id}>
-							{message.role === "user" ? (
-								<div className="flex justify-end">
-									<div className="max-w-[85%] rounded-2xl rounded-br-md bg-accent/10 px-4 py-2.5">
-										<p className="text-sm text-ink">{message.content}</p>
+					{timeline.map((item) => {
+						if (item.type !== "message") return null;
+						return (
+							<div key={item.id}>
+								{item.role === "user" ? (
+									<div className="flex justify-end">
+										<div className="max-w-[85%] rounded-2xl rounded-br-md bg-accent/10 px-4 py-2.5">
+											<p className="text-sm text-ink">{item.content}</p>
+										</div>
 									</div>
-								</div>
-							) : (
-								<div className="text-sm text-ink-dull">
-									<Markdown>{message.content}</Markdown>
-								</div>
-							)}
-						</div>
-					))}
-
-					{/* Streaming state */}
-					{isStreaming &&
-						messages[messages.length - 1]?.role !== "assistant" && (
-							<div>
-								<ToolActivityIndicator activity={toolActivity} />
-								{toolActivity.length === 0 && <ThinkingIndicator />}
+								) : (
+									<div className="text-sm text-ink-dull">
+										<Markdown>{item.content}</Markdown>
+									</div>
+								)}
 							</div>
-						)}
+						);
+					})}
 
-					{/* Inline tool activity during streaming assistant message */}
-					{isStreaming &&
-						messages[messages.length - 1]?.role === "assistant" &&
-						toolActivity.length > 0 && (
-							<ToolActivityIndicator activity={toolActivity} />
-						)}
+					{/* Typing indicator */}
+					{isTyping && <ThinkingIndicator />}
 
 					{error && (
 						<div className="rounded-lg border border-red-500/20 bg-red-500/5 px-4 py-3 text-sm text-red-400">
@@ -255,7 +231,7 @@ export function WebChatPanel({agentId}: WebChatPanelProps) {
 				value={input}
 				onChange={setInput}
 				onSubmit={handleSubmit}
-				isStreaming={isStreaming}
+				disabled={isSending || isTyping}
 				agentId={agentId}
 			/>
 		</div>
diff --git a/interface/src/hooks/useChannelLiveState.ts b/interface/src/hooks/useChannelLiveState.ts
index 516e61e59..40f73bc7b 100644
--- a/interface/src/hooks/useChannelLiveState.ts
+++ b/interface/src/hooks/useChannelLiveState.ts
@@ -1,9 +1,11 @@
 import { useCallback, useEffect, useRef, useState } from "react";
+import { generateId } from "@/lib/id";
 import {
 	api,
 	type BranchCompletedEvent,
 	type BranchStartedEvent,
 	type InboundMessageEvent,
+	type OutboundMessageDeltaEvent,
 	type OutboundMessageEvent,
 	type TimelineItem,
 	type ToolCompletedEvent,
@@ -12,6 +14,7 @@ import {
 	type WorkerCompletedEvent,
 	type WorkerStartedEvent,
 	type WorkerStatusEvent,
+	type WorkerIdleEvent,
 	type ChannelInfo,
 } from "../api/client";
 
@@ -22,6 +25,17 @@ export interface ActiveWorker {
 	startedAt: number;
 	toolCalls: number;
 	currentTool: string | null;
+	/** Whether the worker is idle (waiting for follow-up input). */
+	isIdle: boolean;
+	/** Whether this worker accepts follow-up input via route. */
+	interactive: boolean;
+	/** Worker type: "builtin", "opencode", "task", etc. */
+	workerType: string;
+}
+
+/** Check whether a worker is an opencode worker (by type or task prefix). */
+export function isOpenCodeWorker(worker: { workerType?: string; task?: string }): boolean {
+	return worker.workerType === "opencode" || (worker.task?.startsWith("[opencode]") ?? false);
 }
 
 export interface ActiveBranch {
@@ -38,6 +52,7 @@ export interface ChannelLiveState {
 	timeline: TimelineItem[];
 	workers: Record<string, ActiveWorker>;
 	branches: Record<string, ActiveBranch>;
+	streamingMessageId: string | null;
 	historyLoaded: boolean;
 	hasMore: boolean;
 	loadingMore: boolean;
@@ -46,7 +61,16 @@ export interface ChannelLiveState {
 const PAGE_SIZE = 50;
 
 function emptyLiveState(): ChannelLiveState {
-	return { isTyping: false, timeline: [], workers: {}, branches: {}, historyLoaded: false, hasMore: true, loadingMore: false };
+	return {
+		isTyping: false,
+		timeline: [],
+		workers: {},
+		branches: {},
+		streamingMessageId: null,
+		historyLoaded: false,
+		hasMore: true,
+		loadingMore: false,
+	};
 }
 
 /** Get a sortable timestamp from any timeline item. */
@@ -58,6 +82,26 @@ function itemTimestamp(item: TimelineItem): string {
 	}
 }
 
+function itemKey(item: TimelineItem): string {
+	return `${item.type}:${item.id}`;
+}
+
+function assistantMessageItem(
+	id: string,
+	agentId: string,
+	content: string,
+): TimelineItem {
+	return {
+		type: "message",
+		id,
+		role: "assistant",
+		sender_name: agentId,
+		sender_id: null,
+		content,
+		created_at: new Date().toISOString(),
+	};
+}
+
 /**
  * Manages all live channel state from SSE events, message history loading,
  * and status snapshot fetching. Returns the state map and SSE event handlers.
@@ -124,6 +168,9 @@ export function useChannelLiveState(channels: ChannelInfo[]) {
 							startedAt: new Date(w.started_at).getTime(),
 							toolCalls: w.tool_calls,
 							currentTool: existingWorker?.currentTool ?? null,
+							isIdle: w.status === "idle",
+							interactive: w.interactive,
+							workerType: existingWorker?.workerType ?? (w.task.startsWith("[opencode]") ? "opencode" : "builtin"),
 						};
 					}
 					const branches: Record<string, ActiveBranch> = {};
@@ -187,7 +234,7 @@ export function useChannelLiveState(channels: ChannelInfo[]) {
 		const event = data as InboundMessageEvent;
 		pushItem(event.channel_id, {
 			type: "message",
-			id: `in-${Date.now()}-${crypto.randomUUID()}`,
+			id: `in-${generateId()}`,
 			role: "user",
 			sender_name: event.sender_name ?? event.sender_id,
 			sender_id: event.sender_id,
@@ -198,20 +245,121 @@ export function useChannelLiveState(channels: ChannelInfo[]) {
 
 	const handleOutboundMessage = useCallback((data: unknown) => {
 		const event = data as OutboundMessageEvent;
-		pushItem(event.channel_id, {
-			type: "message",
-			id: `out-${Date.now()}-${crypto.randomUUID()}`,
-			role: "assistant",
-			sender_name: event.agent_id,
-			sender_id: null,
-			content: event.text,
-			created_at: new Date().toISOString(),
+		setLiveStates((prev) => {
+			const existing = getOrCreate(prev, event.channel_id);
+			const streamingMessageId = existing.streamingMessageId;
+			if (streamingMessageId) {
+				const streamIndex = existing.timeline.findIndex(
+					(item) => item.type === "message" && item.id === streamingMessageId,
+				);
+
+				const timeline = [...existing.timeline];
+				if (streamIndex >= 0) {
+					const streamItem = timeline[streamIndex];
+					if (streamItem.type === "message") {
+						timeline[streamIndex] = { ...streamItem, content: event.text };
+					}
+				} else {
+					timeline.push(
+						assistantMessageItem(
+							`out-${generateId()}`,
+							event.agent_id,
+							event.text,
+						),
+					);
+				}
+
+				return {
+					...prev,
+					[event.channel_id]: {
+						...existing,
+						timeline,
+						streamingMessageId: null,
+						isTyping: false,
+					},
+				};
+			}
+
+			return {
+				...prev,
+				[event.channel_id]: {
+					...existing,
+					timeline: [
+						...existing.timeline,
+						assistantMessageItem(
+							`out-${generateId()}`,
+							event.agent_id,
+							event.text,
+						),
+					],
+					isTyping: false,
+				},
+			};
 		});
+	}, []);
+
+	const handleOutboundMessageDelta = useCallback((data: unknown) => {
+		const event = data as OutboundMessageDeltaEvent;
 		setLiveStates((prev) => {
 			const existing = getOrCreate(prev, event.channel_id);
-			return { ...prev, [event.channel_id]: { ...existing, isTyping: false } };
+			const streamMessageId = existing.streamingMessageId;
+
+			if (streamMessageId) {
+				const streamIndex = existing.timeline.findIndex(
+					(item) => item.type === "message" && item.id === streamMessageId,
+				);
+
+				if (streamIndex >= 0) {
+					const timeline = [...existing.timeline];
+					const streamItem = timeline[streamIndex];
+					if (streamItem.type === "message") {
+						timeline[streamIndex] = {
+							...streamItem,
+							content: event.aggregated_text,
+						};
+					}
+					return {
+						...prev,
+						[event.channel_id]: { ...existing, timeline },
+					};
+				}
+
+				const messageId = `stream-${generateId()}`;
+				return {
+					...prev,
+					[event.channel_id]: {
+						...existing,
+						timeline: [
+							...existing.timeline,
+							assistantMessageItem(
+								messageId,
+								event.agent_id,
+								event.aggregated_text,
+							),
+						],
+						streamingMessageId: messageId,
+					},
+				};
+			}
+
+			const messageId = `stream-${generateId()}`;
+			return {
+				...prev,
+				[event.channel_id]: {
+					...existing,
+					timeline: [
+						...existing.timeline,
+						assistantMessageItem(
+							messageId,
+							event.agent_id,
+							event.aggregated_text,
+						),
+					],
+					streamingMessageId: messageId,
+				},
+			};
 		});
-	}, [pushItem]);
+	}, []);
 
 	const handleTypingState = useCallback((data: unknown) => {
 		const event = data as TypingStateEvent;
@@ -235,14 +383,17 @@ export function useChannelLiveState(channels: ChannelInfo[]) {
 					...existing,
 					workers: {
 						...existing.workers,
-						[event.worker_id]: {
-							id: event.worker_id,
-							task: event.task,
-							status: "starting",
-							startedAt: Date.now(),
-							toolCalls: 0,
-							currentTool: null,
-						},
+					[event.worker_id]: {
+						id: event.worker_id,
+						task: event.task,
+						status: "starting",
+						startedAt: Date.now(),
+						toolCalls: 0,
+						currentTool: null,
+						isIdle: false,
+						interactive: event.interactive ?? false,
+						workerType: event.worker_type ?? "builtin",
+					},
 					},
 				},
 			};
@@ -274,7 +425,7 @@ export function useChannelLiveState(channels: ChannelInfo[]) {
 						...state,
 						workers: {
 							...state.workers,
-							[event.worker_id]: { ...worker, status: event.status },
+							[event.worker_id]: { ...worker, status: event.status, isIdle: false },
 						},
 					},
 				};
@@ -296,7 +447,52 @@ export function useChannelLiveState(channels: ChannelInfo[]) {
 								...state,
 								workers: {
 									...state.workers,
-									[event.worker_id]: { ...worker, status: event.status },
+									[event.worker_id]: { ...worker, status: event.status, isIdle: false },
+								},
+							},
+						};
+					}
+				}
+				return prev;
+			});
+		}
+	}, [updateItem]);
+
+	const handleWorkerIdle = useCallback((data: unknown) => {
+		const event = data as WorkerIdleEvent;
+		if (event.channel_id) {
+			setLiveStates((prev) => {
+				const state = prev[event.channel_id!];
+				const worker = state?.workers[event.worker_id];
+				if (!worker) return prev;
+				return {
+					...prev,
+					[event.channel_id!]: {
+						...state,
+						workers: {
+							...state.workers,
+							[event.worker_id]: { ...worker, isIdle: true },
+						},
+					},
+				};
+			});
+			// Update timeline item status to idle
+			updateItem(event.channel_id, event.worker_id, (item) => {
+				if (item.type !== "worker_run") return item;
+				return { ...item, status: "idle" };
+			});
+		} else {
+			setLiveStates((prev) => {
+				for (const [channelId, state] of Object.entries(prev)) {
+					const worker = state.workers[event.worker_id];
+					if (worker) {
+						return {
+							...prev,
+							[channelId]: {
+								...state,
+								workers: {
+									...state.workers,
+									[event.worker_id]: { ...worker, isIdle: true },
 								},
 							},
 						};
@@ -579,12 +775,15 @@ export function useChannelLiveState(channels: ChannelInfo[]) {
 					setLiveStates((current) => {
 						const existing = current[channelId];
 						if (!existing) return current;
+						const existingKeys = new Set(existing.timeline.map(itemKey));
+						const olderItems = data.items.filter((item) => !existingKeys.has(itemKey(item)));
+						const hasMore = olderItems.length === 0 ? false : data.has_more;
 						return {
 							...current,
 							[channelId]: {
 								...existing,
-								timeline: [...data.items, ...existing.timeline],
-								hasMore: data.has_more,
+								timeline: [...olderItems, ...existing.timeline],
+								hasMore,
 								loadingMore: false,
 							},
 						};
@@ -606,9 +805,11 @@ export function useChannelLiveState(channels: ChannelInfo[]) {
 	const handlers = {
 		inbound_message: handleInboundMessage,
 		outbound_message: handleOutboundMessage,
+		outbound_message_delta: handleOutboundMessageDelta,
 		typing_state: handleTypingState,
 		worker_started: handleWorkerStarted,
 		worker_status: handleWorkerStatus,
+		worker_idle: handleWorkerIdle,
 		worker_completed: handleWorkerCompleted,
 		branch_started: handleBranchStarted,
 		branch_completed: handleBranchCompleted,
diff --git a/interface/src/hooks/useCortexChat.ts b/interface/src/hooks/useCortexChat.ts
index dd5720ed6..578f16dec 100644
--- a/interface/src/hooks/useCortexChat.ts
+++ b/interface/src/hooks/useCortexChat.ts
@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 import { api, type CortexChatMessage } from "@/api/client";
+import { generateId } from "@/lib/id";
 
 export interface ToolActivity {
 	tool: string;
@@ -44,7 +45,7 @@ async function consumeSSE(
 }
 
 function generateThreadId(): string {
-	return crypto.randomUUID();
+	return generateId();
 }
 
 export function useCortexChat(agentId: string, channelId?: string) {
diff --git a/interface/src/hooks/useEventSource.ts b/interface/src/hooks/useEventSource.ts
index b638f7f58..1647f8d64 100644
--- a/interface/src/hooks/useEventSource.ts
+++ b/interface/src/hooks/useEventSource.ts
@@ -31,8 +31,8 @@ export function useEventSource(url: string, options: UseEventSourceOptions) {
 
 	const [connectionState, setConnectionState] = useState<ConnectionState>("connecting");
 
-	const reconnectTimeout = useRef<ReturnType<typeof setTimeout>>();
-	const eventSourceRef = useRef<EventSource>();
+	const reconnectTimeout = useRef<ReturnType<typeof setTimeout> | null>(null);
+	const eventSourceRef = useRef<EventSource | null>(null);
 	const retryDelayRef = useRef(INITIAL_RETRY_MS);
 	const hadConnectionRef = useRef(false);
 
diff --git a/interface/src/hooks/useLiveContext.tsx b/interface/src/hooks/useLiveContext.tsx
index dd987dc90..0fc58d4c8 100644
--- a/interface/src/hooks/useLiveContext.tsx
+++ b/interface/src/hooks/useLiveContext.tsx
@@ -1,8 +1,9 @@
 import { createContext, useContext, useCallback, useRef, useState, useMemo, type ReactNode } from "react";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { api, type AgentMessageEvent, type ChannelInfo } from "@/api/client";
+import { api, type AgentMessageEvent, type ChannelInfo, type ToolStartedEvent, type ToolCompletedEvent, type WorkerStatusEvent, type TranscriptStep, type OpenCodePart, type OpenCodePartUpdatedEvent } from "@/api/client";
+import { generateId } from "@/lib/id";
 import { useEventSource, type ConnectionState } from "@/hooks/useEventSource";
-import { useChannelLiveState, type ChannelLiveState } from "@/hooks/useChannelLiveState";
+import { useChannelLiveState, type ChannelLiveState, type ActiveWorker } from "@/hooks/useChannelLiveState";
 
 interface LiveContextValue {
 	liveStates: Record<string, ChannelLiveState>;
@@ -12,6 +13,16 @@ interface LiveContextValue {
 	loadOlderMessages: (channelId: string) => void;
 	/** Set of edge IDs ("from->to") with recent message activity */
 	activeLinks: Set<string>;
+	/** Flat map of all active workers across all channels, keyed by worker_id. */
+	activeWorkers: Record<string, ActiveWorker & { channelId?: string; agentId: string }>;
+	/** Monotonically increasing counter, bumped on every worker lifecycle SSE event. */
+	workerEventVersion: number;
+	/** Monotonically increasing counter, bumped on every task lifecycle SSE event. */
+	taskEventVersion: number;
+	/** Live transcript steps for running workers, keyed by worker_id. Built from SSE tool events. */
+	liveTranscripts: Record<string, TranscriptStep[]>;
+	/** Live OpenCode parts for running workers, keyed by worker_id. Parts are insertion-ordered Maps keyed by part ID. */
+	liveOpenCodeParts: Record<string, Map<string, OpenCodePart>>;
 }
 
 const LiveContext = createContext<LiveContextValue>({
@@ -21,6 +32,11 @@ const LiveContext = createContext<LiveContextValue>({
 	hasData: false,
 	loadOlderMessages: () => {},
 	activeLinks: new Set(),
+	activeWorkers: {},
+	workerEventVersion: 0,
+	taskEventVersion: 0,
+	liveTranscripts: {},
+	liveOpenCodeParts: {},
 });
 
 export function useLiveContext() {
@@ -42,6 +58,39 @@ export function LiveContextProvider({ children }: { children: ReactNode }) {
 	const channels = channelsData?.channels ?? [];
 	const { liveStates, handlers: channelHandlers, syncStatusSnapshot, loadOlderMessages } = useChannelLiveState(channels);
 
+	// Flat active workers map + event version counter for the workers tab.
+	// This is a separate piece of state from channel liveStates so the workers
+	// tab can react to SSE events without scanning all channels.
+	const [workerEventVersion, setWorkerEventVersion] = useState(0);
+	const bumpWorkerVersion = useCallback(() => setWorkerEventVersion((v) => v + 1), []);
+
+	const [taskEventVersion, setTaskEventVersion] = useState(0);
+	const bumpTaskVersion = useCallback(() => setTaskEventVersion((v) => v + 1), []);
+
+	// Live transcript accumulator: builds TranscriptStep[] from SSE tool events
+	// for running workers. Cleared when worker completes.
+	const [liveTranscripts, setLiveTranscripts] = useState<Record<string, TranscriptStep[]>>({});
+
+	// Live OpenCode parts: per-worker insertion-ordered Map keyed by part ID.
+	// Updated via opencode_part_updated SSE events. Cleared when worker completes.
+	const [liveOpenCodeParts, setLiveOpenCodeParts] = useState<Record<string, Map<string, OpenCodePart>>>({});
+
+	// Derive flat active workers from channel live states
+	const pendingToolCallIdsRef = useRef<Record<string, Record<string, string[]>>>({});
+
+	const activeWorkers = useMemo(() => {
+		const channelAgentIds = new Map(channels.map((channel) => [channel.id, channel.agent_id]));
+		const map: Record<string, ActiveWorker & { channelId?: string; agentId: string }> = {};
+		for (const [channelId, state] of Object.entries(liveStates)) {
+			const channelAgentId = channelAgentIds.get(channelId);
+			if (!channelAgentId) continue;
+			for (const [workerId, worker] of Object.entries(state.workers)) {
+				map[workerId] = { ...worker, channelId, agentId: channelAgentId };
+			}
+		}
+		return map;
+	}, [liveStates, channels]);
+
 	// Track recently active link edges
 	const [activeLinks, setActiveLinks] = useState<Set<string>>(new Set());
 	const timersRef = useRef<Map<string, ReturnType<typeof setTimeout>>>(new Map());
@@ -85,14 +134,137 @@ export function LiveContextProvider({ children }: { children: ReactNode }) {
 		[markEdgeActive],
 	);
 
-	// Merge channel handlers with agent message handlers
+	// Wrap channel worker handlers to also bump the worker event version
+	// and accumulate live transcript steps from SSE events.
+	const wrappedWorkerStarted = useCallback((data: unknown) => {
+		channelHandlers.worker_started(data);
+		const event = data as { worker_id: string };
+		setLiveTranscripts((prev) => ({ ...prev, [event.worker_id]: [] }));
+		setLiveOpenCodeParts((prev) => ({ ...prev, [event.worker_id]: new Map() }));
+		delete pendingToolCallIdsRef.current[event.worker_id];
+		bumpWorkerVersion();
+	}, [channelHandlers, bumpWorkerVersion]);
+
+	const wrappedWorkerStatus = useCallback((data: unknown) => {
+		channelHandlers.worker_status(data);
+		const event = data as WorkerStatusEvent;
+		// Push status text as an action step in the live transcript
+		if (event.status && event.status !== "starting" && event.status !== "running") {
+			setLiveTranscripts((prev) => {
+				const steps = prev[event.worker_id] ?? [];
+				const step: TranscriptStep = {
+					type: "action",
+					content: [{ type: "text", text: event.status }],
+				};
+				return { ...prev, [event.worker_id]: [...steps, step] };
+			});
+		}
+		bumpWorkerVersion();
+	}, [channelHandlers, bumpWorkerVersion]);
+
+	const wrappedWorkerIdle = useCallback((data: unknown) => {
+		channelHandlers.worker_idle(data);
+		bumpWorkerVersion();
+	}, [channelHandlers, bumpWorkerVersion]);
+
+	const wrappedWorkerCompleted = useCallback((data: unknown) => {
+		channelHandlers.worker_completed(data);
+		const event = data as { worker_id: string };
+		delete pendingToolCallIdsRef.current[event.worker_id];
+		// Clean up live OpenCode parts — persisted transcript takes over
+		setLiveOpenCodeParts((prev) => {
+			const next = { ...prev };
+			delete next[event.worker_id];
+			return next;
+		});
+		bumpWorkerVersion();
+	}, [channelHandlers, bumpWorkerVersion]);
+
+	const wrappedToolStarted = useCallback((data: unknown) => {
+		channelHandlers.tool_started(data);
+		const event = data as ToolStartedEvent;
+		if (event.process_type === "worker") {
+			const callId = generateId();
+			const pendingByTool = pendingToolCallIdsRef.current[event.process_id] ?? {};
+			const queue = pendingByTool[event.tool_name] ?? [];
+			pendingByTool[event.tool_name] = [...queue, callId];
+			pendingToolCallIdsRef.current[event.process_id] = pendingByTool;
+			setLiveTranscripts((prev) => {
+				const steps = prev[event.process_id] ?? [];
+				const step: TranscriptStep = {
+					type: "action",
+					content: [{
+						type: "tool_call",
+						id: callId,
+						name: event.tool_name,
+						args: event.args || "",
+					}],
+				};
+				return { ...prev, [event.process_id]: [...steps, step] };
+			});
+			bumpWorkerVersion();
+		}
+	}, [channelHandlers, bumpWorkerVersion]);
+
+	const wrappedToolCompleted = useCallback((data: unknown) => {
+		channelHandlers.tool_completed(data);
+		const event = data as ToolCompletedEvent;
+		if (event.process_type === "worker") {
+			const pendingByTool = pendingToolCallIdsRef.current[event.process_id];
+			const queue = pendingByTool?.[event.tool_name] ?? [];
+			const [callId, ...rest] = queue;
+			if (pendingByTool) {
+				if (rest.length > 0) {
+					pendingByTool[event.tool_name] = rest;
+				} else {
+					delete pendingByTool[event.tool_name];
+				}
+				if (Object.keys(pendingByTool).length === 0) {
+					delete pendingToolCallIdsRef.current[event.process_id];
+				}
+			}
+			setLiveTranscripts((prev) => {
+				const steps = prev[event.process_id] ?? [];
+				const step: TranscriptStep = {
+					type: "tool_result",
+					call_id: callId ?? `${event.process_id}:${event.tool_name}:${steps.length}`,
+					name: event.tool_name,
+					text: event.result || "",
+				};
+				return { ...prev, [event.process_id]: [...steps, step] };
+			});
+			bumpWorkerVersion();
+		}
+	}, [channelHandlers, bumpWorkerVersion]);
+
+	// Handle OpenCode part updates — upsert parts into the per-worker ordered map
+	const handleOpenCodePartUpdated = useCallback((data: unknown) => {
+		const event = data as OpenCodePartUpdatedEvent;
+		setLiveOpenCodeParts((prev) => {
+			const existing = prev[event.worker_id] ?? new Map<string, OpenCodePart>();
+			const next = new Map(existing);
+			next.set(event.part.id, event.part);
+			return { ...prev, [event.worker_id]: next };
+		});
+		bumpWorkerVersion();
+	}, [bumpWorkerVersion]);
+
+	// Merge channel handlers with agent message + task handlers
 	const handlers = useMemo(
 		() => ({
 			...channelHandlers,
+			worker_started: wrappedWorkerStarted,
+			worker_status: wrappedWorkerStatus,
+			worker_idle: wrappedWorkerIdle,
+			worker_completed: wrappedWorkerCompleted,
+			tool_started: wrappedToolStarted,
+			tool_completed: wrappedToolCompleted,
+			opencode_part_updated: handleOpenCodePartUpdated,
 			agent_message_sent: handleAgentMessage,
 			agent_message_received: handleAgentMessage,
+			task_updated: bumpTaskVersion,
 		}),
-		[channelHandlers, handleAgentMessage],
+		[channelHandlers, wrappedWorkerStarted, wrappedWorkerStatus, wrappedWorkerIdle, wrappedWorkerCompleted, wrappedToolStarted, wrappedToolCompleted, handleOpenCodePartUpdated, handleAgentMessage, bumpTaskVersion],
 	);
 
 	const onReconnect = useCallback(() => {
@@ -100,7 +272,10 @@ export function LiveContextProvider({ children }: { children: ReactNode }) {
 		queryClient.invalidateQueries({ queryKey: ["channels"] });
 		queryClient.invalidateQueries({ queryKey: ["status"] });
 		queryClient.invalidateQueries({ queryKey: ["agents"] });
-	}, [syncStatusSnapshot, queryClient]);
+		queryClient.invalidateQueries({ queryKey: ["tasks"] });
+		// Bump task version so any mounted task views refetch immediately.
+		bumpTaskVersion();
+	}, [syncStatusSnapshot, queryClient, bumpTaskVersion]);
 
 	const { connectionState } = useEventSource(api.eventsUrl, {
 		handlers,
@@ -111,7 +286,7 @@ export function LiveContextProvider({ children }: { children: ReactNode }) {
 	const hasData = channels.length > 0 || channelsData !== undefined;
 
 	return (
-		<LiveContext.Provider value={{ liveStates, channels, connectionState, hasData, loadOlderMessages, activeLinks }}>
+		<LiveContext.Provider value={{ liveStates, channels, connectionState, hasData, loadOlderMessages, activeLinks, activeWorkers, workerEventVersion, taskEventVersion, liveTranscripts, liveOpenCodeParts }}>
 			{children}
 		</LiveContext.Provider>
 	);
diff --git a/interface/src/hooks/useTheme.ts b/interface/src/hooks/useTheme.ts
new file mode 100644
index 000000000..797b76456
--- /dev/null
+++ b/interface/src/hooks/useTheme.ts
@@ -0,0 +1,87 @@
+import { useState, useEffect, useCallback } from "react";
+
+export type ThemeId = "default" | "vanilla" | "midnight" | "noir";
+
+export interface ThemeOption {
+	id: ThemeId;
+	name: string;
+	description: string;
+	className: string;
+}
+
+export const THEMES: ThemeOption[] = [
+	{
+		id: "default",
+		name: "Default",
+		description: "Dark theme with purple accent",
+		className: "",
+	},
+	{
+		id: "vanilla",
+		name: "Vanilla",
+		description: "Light theme with blue accent",
+		className: "vanilla-theme",
+	},
+	{
+		id: "midnight",
+		name: "Midnight",
+		description: "Deep blue dark theme",
+		className: "midnight-theme",
+	},
+	{
+		id: "noir",
+		name: "Noir",
+		description: "Pure black and white theme",
+		className: "noir-theme",
+	},
+];
+
+const STORAGE_KEY = "spacebot-theme";
+
+function getInitialTheme(): ThemeId {
+	if (typeof window === "undefined") return "default";
+	const stored = localStorage.getItem(STORAGE_KEY);
+	if (stored && THEMES.some((t) => t.id === stored)) {
+		return stored as ThemeId;
+	}
+	return "default";
+}
+
+function applyThemeClass(themeId: ThemeId) {
+	const theme = THEMES.find((t) => t.id === themeId);
+	const root = document.documentElement;
+
+	// Remove all theme classes
+	THEMES.forEach((t) => {
+		if (t.className) {
+			root.classList.remove(t.className);
+		}
+	});
+
+	// Add the selected theme class
+	if (theme?.className) {
+		root.classList.add(theme.className);
+	}
+}
+
+export function useTheme() {
+	const [theme, setThemeState] = useState<ThemeId>(getInitialTheme);
+
+	// Apply theme on mount and when theme changes
+	useEffect(() => {
+		applyThemeClass(theme);
+	}, [theme]);
+
+	const setTheme = useCallback((newTheme: ThemeId) => {
+		setThemeState(newTheme);
+		localStorage.setItem(STORAGE_KEY, newTheme);
+	}, []);
+
+	return { theme, setTheme, themes: THEMES };
+}
+
+// Initialize theme on page load (before React hydrates)
+if (typeof window !== "undefined") {
+	const initialTheme = getInitialTheme();
+	applyThemeClass(initialTheme);
+}
diff --git a/interface/src/hooks/useWebChat.ts b/interface/src/hooks/useWebChat.ts
index a74bef7ad..95168480e 100644
--- a/interface/src/hooks/useWebChat.ts
+++ b/interface/src/hooks/useWebChat.ts
@@ -1,167 +1,41 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useState } from "react";
 import { api } from "@/api/client";
 
-export interface ToolActivity {
-	tool: string;
-	status: "running" | "done";
-}
-
-export interface WebChatMessage {
-	id: string;
-	role: "user" | "assistant";
-	content: string;
-}
-
 export function getPortalChatSessionId(agentId: string) {
 	return `portal:chat:${agentId}`;
 }
 
-async function consumeSSE(
-	response: Response,
-	onEvent: (eventType: string, data: string) => void,
-) {
-	const reader = response.body?.getReader();
-	if (!reader) return;
-
-	const decoder = new TextDecoder();
-	let buffer = "";
-
-	while (true) {
-		const { done, value } = await reader.read();
-		if (done) break;
-
-		buffer += decoder.decode(value, { stream: true });
-		const lines = buffer.split("\n");
-		buffer = lines.pop() ?? "";
-
-		let currentEvent = "";
-		let currentData = "";
-
-		for (const line of lines) {
-			if (line.startsWith("event: ")) {
-				currentEvent = line.slice(7);
-			} else if (line.startsWith("data: ")) {
-				currentData = line.slice(6);
-			} else if (line === "" && currentEvent) {
-				onEvent(currentEvent, currentData);
-				currentEvent = "";
-				currentData = "";
-			}
-		}
-	}
-}
-
+/**
+ * Sends messages to the webchat endpoint. The response arrives via the global
+ * SSE event bus (same timeline used by regular channels) — no per-request SSE.
+ */
 export function useWebChat(agentId: string) {
 	const sessionId = getPortalChatSessionId(agentId);
-	const [messages, setMessages] = useState<WebChatMessage[]>([]);
-	const [isStreaming, setIsStreaming] = useState(false);
+	const [isSending, setIsSending] = useState(false);
 	const [error, setError] = useState<string | null>(null);
-	const [toolActivity, setToolActivity] = useState<ToolActivity[]>([]);
-	const streamingTextRef = useRef("");
-
-	useEffect(() => {
-		let cancelled = false;
-		(async () => {
-			try {
-				const response = await api.webChatHistory(agentId, sessionId);
-				if (!response.ok || cancelled) return;
-				const history: { id: string; role: string; content: string }[] = await response.json();
-				if (cancelled) return;
-				setMessages(
-					history.map((m) => ({
-						id: m.id,
-						role: m.role as "user" | "assistant",
-						content: m.content,
-					})),
-				);
-			} catch { /* ignore — fresh session */ }
-		})();
-		return () => { cancelled = true; };
-	}, [agentId, sessionId]);
-
-	const sendMessage = useCallback(async (text: string) => {
-		if (isStreaming) return;
-
-		setError(null);
-		setIsStreaming(true);
-		setToolActivity([]);
-		streamingTextRef.current = "";
 
-		const userMessage: WebChatMessage = {
-			id: `user-${Date.now()}`,
-			role: "user",
-			content: text,
-		};
-		setMessages((prev) => [...prev, userMessage]);
+	const sendMessage = useCallback(
+		async (text: string) => {
+			if (isSending) return;
 
-		const assistantId = `assistant-${Date.now()}`;
+			setError(null);
+			setIsSending(true);
 
-		try {
-			const response = await api.webChatSend(agentId, sessionId, text);
-			if (!response.ok) {
-				throw new Error(`HTTP ${response.status}`);
-			}
-
-			await consumeSSE(response, (eventType, data) => {
-				if (eventType === "tool_started") {
-					try {
-						const parsed = JSON.parse(data);
-						setToolActivity((prev) => [
-							...prev,
-							{ tool: parsed.ToolStarted?.tool_name ?? "tool", status: "running" },
-						]);
-					} catch { /* ignore */ }
-				} else if (eventType === "tool_completed") {
-					try {
-						const parsed = JSON.parse(data);
-						const toolName = parsed.ToolCompleted?.tool_name ?? "tool";
-						setToolActivity((prev) =>
-							prev.map((t) =>
-								t.tool === toolName && t.status === "running"
-									? { ...t, status: "done" }
-									: t,
-							),
-						);
-					} catch { /* ignore */ }
-				} else if (eventType === "text") {
-					try {
-						const parsed = JSON.parse(data);
-						const content = parsed.Text ?? "";
-						setMessages((prev) => {
-							const existing = prev.find((m) => m.id === assistantId);
-							if (existing) {
-								return prev.map((m) =>
-									m.id === assistantId ? { ...m, content } : m,
-								);
-							}
-							return [...prev, { id: assistantId, role: "assistant", content }];
-						});
-					} catch { /* ignore */ }
-				} else if (eventType === "stream_chunk") {
-					try {
-						const parsed = JSON.parse(data);
-						const chunk = parsed.StreamChunk ?? "";
-						streamingTextRef.current += chunk;
-						const accumulated = streamingTextRef.current;
-						setMessages((prev) => {
-							const existing = prev.find((m) => m.id === assistantId);
-							if (existing) {
-								return prev.map((m) =>
-									m.id === assistantId ? { ...m, content: accumulated } : m,
-								);
-							}
-							return [...prev, { id: assistantId, role: "assistant", content: accumulated }];
-						});
-					} catch { /* ignore */ }
+			try {
+				const response = await api.webChatSend(agentId, sessionId, text);
+				if (!response.ok) {
+					throw new Error(`HTTP ${response.status}`);
 				}
-			});
-		} catch (error) {
-			setError(error instanceof Error ? error.message : "Request failed");
-		} finally {
-			setIsStreaming(false);
-			setToolActivity([]);
-		}
-	}, [agentId, sessionId, isStreaming]);
+			} catch (error) {
+				setError(
+					error instanceof Error ? error.message : "Request failed",
+				);
+			} finally {
+				setIsSending(false);
+			}
+		},
+		[agentId, sessionId, isSending],
+	);
 
-	return { messages, isStreaming, error, toolActivity, sendMessage };
+	return { sessionId, isSending, error, sendMessage };
 }
diff --git a/interface/src/lib/id.ts b/interface/src/lib/id.ts
new file mode 100644
index 000000000..44bca3097
--- /dev/null
+++ b/interface/src/lib/id.ts
@@ -0,0 +1,14 @@
+/**
+ * Generate a unique ID, preferring crypto.randomUUID() when available.
+ *
+ * crypto.randomUUID() requires a secure context (HTTPS or localhost).
+ * Over plain HTTP (e.g. Tailscale) it's unavailable, so we fall back
+ * to Date.now + Math.random which is sufficient for ephemeral client-side IDs.
+ */
+export function generateId(): string {
+	try {
+		return crypto.randomUUID();
+	} catch {
+		return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+	}
+}
diff --git a/interface/src/lib/providerIcons.tsx b/interface/src/lib/providerIcons.tsx
index 29487961a..eaf286c79 100644
--- a/interface/src/lib/providerIcons.tsx
+++ b/interface/src/lib/providerIcons.tsx
@@ -90,6 +90,26 @@ function OllamaIcon({ size = 24, className }: IconProps) {
 	);
 }
 
+function KiloIcon({ size = 24, className }: IconProps) {
+	return (
+		<svg
+			width={size}
+			height={size}
+			viewBox="0 0 100 100"
+			fill="none"
+			xmlns="http://www.w3.org/2000/svg"
+			className={className}
+			aria-hidden="true"
+			focusable="false"
+		>
+			<path
+				fill="currentColor"
+				d="M0,0v100h100V0H0ZM92.5925926,92.5925926H7.4074074V7.4074074h85.1851852v85.1851852ZM61.1111044,71.9096084h9.2592593v7.4074074h-11.6402116l-5.026455-5.026455v-11.6402116h7.4074074v9.2592593ZM77.7777711,71.9096084h-7.4074074v-9.2592593h-9.2592593v-7.4074074h11.6402116l5.026455,5.026455v11.6402116ZM46.2962963,61.1114207h-7.4074074v-7.4074074h7.4074074v7.4074074ZM22.2222222,53.7040133h7.4074074v16.6666667h16.6666667v7.4074074h-19.047619l-5.026455-5.026455v-19.047619ZM77.7777711,38.8888889v7.4074074h-24.0740741v-7.4074074h8.2781918v-9.2592593h-8.2781918v-7.4074074h10.6591442l5.026455,5.026455v11.6402116h8.3884749ZM29.6296296,30.5555556h9.2592593l7.4074074,7.4074074v8.3333333h-7.4074074v-8.3333333h-9.2592593v8.3333333h-7.4074074v-24.0740741h7.4074074v8.3333333ZM46.2962963,30.5555556h-7.4074074v-8.3333333h7.4074074v8.3333333Z"
+			/>
+		</svg>
+	);
+}
+
 export function ProviderIcon({ provider, className = "text-ink-faint", size = 24 }: ProviderIconProps) {
 	const iconProps: Partial<IconProps> = {
 		size,
@@ -101,6 +121,7 @@ export function ProviderIcon({ provider, className = "text-ink-faint", size = 24
 		openai: OpenAI,
 		"openai-chatgpt": OpenAI,
 		openrouter: OpenRouter,
+		kilo: KiloIcon,
 		groq: Groq,
 		mistral: Mistral,
 		gemini: Google,
@@ -112,6 +133,7 @@ export function ProviderIcon({ provider, className = "text-ink-faint", size = 24
 		"zai-coding-plan": ZAI,
 		ollama: OllamaIcon,
 		"opencode-zen": OpenCodeZenIcon,
+		"opencode-go": OpenCodeZenIcon,
 		nvidia: NvidiaIcon,
 		minimax: Minimax,
 		"minimax-cn": Minimax,
diff --git a/interface/src/router.tsx b/interface/src/router.tsx
index 1c6950f05..d65ce23fe 100644
--- a/interface/src/router.tsx
+++ b/interface/src/router.tsx
@@ -8,7 +8,6 @@ import {
 import {BASE_PATH} from "@/api/client";
 import {ConnectionBanner} from "@/components/ConnectionBanner";
 import {SetupBanner} from "@/components/SetupBanner";
-import {UpdateBanner} from "@/components/UpdateBanner";
 import {Sidebar} from "@/components/Sidebar";
 import {Overview} from "@/routes/Overview";
 import {AgentDetail} from "@/routes/AgentDetail";
@@ -20,6 +19,8 @@ import {AgentConfig} from "@/routes/AgentConfig";
 import {AgentCron} from "@/routes/AgentCron";
 import {AgentIngest} from "@/routes/AgentIngest";
 import {AgentSkills} from "@/routes/AgentSkills";
+import {AgentWorkers} from "@/routes/AgentWorkers";
+import {AgentTasks} from "@/routes/AgentTasks";
 import {AgentChat} from "@/routes/AgentChat";
 import {Settings} from "@/routes/Settings";
 import {useLiveContext} from "@/hooks/useLiveContext";
@@ -38,7 +39,6 @@ function RootLayout() {
 			/>
 			<div className="flex flex-1 flex-col overflow-hidden">
 				<ConnectionBanner state={connectionState} hasData={hasData} />
-				<UpdateBanner />
 				<SetupBanner />
 				<div className="flex-1 overflow-hidden">
 					<Outlet />
@@ -187,15 +187,32 @@ const agentIngestRoute = createRoute({
 const agentWorkersRoute = createRoute({
 	getParentRoute: () => rootRoute,
 	path: "/agents/$agentId/workers",
+	validateSearch: (search: Record<string, unknown>): {worker?: string} => ({
+		worker: typeof search.worker === "string" ? search.worker : undefined,
+	}),
 	component: function AgentWorkersPage() {
 		const {agentId} = agentWorkersRoute.useParams();
 		return (
 			<div className="flex h-full flex-col">
 				<AgentHeader agentId={agentId} />
-				<div className="flex flex-1 items-center justify-center">
-					<p className="text-sm text-ink-faint">
-						Workers control interface coming soon
-					</p>
+				<div className="flex-1 overflow-hidden">
+					<AgentWorkers agentId={agentId} />
+				</div>
+			</div>
+		);
+	},
+});
+
+const agentTasksRoute = createRoute({
+	getParentRoute: () => rootRoute,
+	path: "/agents/$agentId/tasks",
+	component: function AgentTasksPage() {
+		const {agentId} = agentTasksRoute.useParams();
+		return (
+			<div className="flex h-full flex-col">
+				<AgentHeader agentId={agentId} />
+				<div className="flex-1 overflow-hidden">
+					<AgentTasks agentId={agentId} />
 				</div>
 			</div>
 		);
@@ -305,6 +322,7 @@ const routeTree = rootRoute.addChildren([
 	agentMemoriesRoute,
 	agentIngestRoute,
 	agentWorkersRoute,
+	agentTasksRoute,
 	agentCortexRoute,
 	agentSkillsRoute,
 	agentCronRoute,
diff --git a/interface/src/routes/AgentConfig.tsx b/interface/src/routes/AgentConfig.tsx
index 8655eb339..363f915c5 100644
--- a/interface/src/routes/AgentConfig.tsx
+++ b/interface/src/routes/AgentConfig.tsx
@@ -1,8 +1,9 @@
 import { useCallback, useEffect, useState, useRef } from "react";
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import { api, type AgentConfigResponse, type AgentConfigUpdateRequest } from "@/api/client";
-import { Button, SettingSidebarButton, Input, TextArea, Toggle, NumberStepper, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, cx } from "@/ui";
+import { Button, SettingSidebarButton, TextArea, Toggle, NumberStepper, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, cx } from "@/ui";
 import { ModelSelect } from "@/components/ModelSelect";
+import { TagInput } from "@/components/TagInput";
 import { Markdown } from "@/components/Markdown";
 import { motion, AnimatePresence } from "framer-motion";
 import { useSearch, useNavigate } from "@tanstack/react-router";
@@ -14,7 +15,7 @@ function supportsAdaptiveThinking(modelId: string): boolean {
 		|| id.includes("sonnet-4-6") || id.includes("sonnet-4.6");
 }
 
-type SectionId = "soul" | "identity" | "user" | "routing" | "tuning" | "compaction" | "cortex" | "coalesce" | "memory" | "browser";
+type SectionId = "soul" | "identity" | "user" | "routing" | "tuning" | "compaction" | "cortex" | "coalesce" | "memory" | "browser" | "channel" | "sandbox";
 
 const SECTIONS: {
 	id: SectionId;
@@ -33,6 +34,8 @@ const SECTIONS: {
 	{ id: "coalesce", label: "Coalesce", group: "config", description: "Message batching", detail: "When multiple messages arrive in quick succession, coalescing batches them into a single LLM turn. This prevents the agent from responding to each message individually in fast-moving conversations." },
 	{ id: "memory", label: "Memory Persistence", group: "config", description: "Auto-save interval", detail: "Spawns a silent background branch at regular intervals to recall existing memories and save new ones from the recent conversation. Runs without blocking the channel." },
 	{ id: "browser", label: "Browser", group: "config", description: "Chrome automation", detail: "Controls browser automation tools available to workers. When enabled, workers can navigate web pages, take screenshots, and interact with sites. JavaScript evaluation is a separate permission." },
+	{ id: "channel", label: "Channel Behavior", group: "config", description: "Reply behavior", detail: "Listen-only mode suppresses unsolicited replies in busy channels. The agent still responds to slash commands, @mentions, and replies to its own messages." },
+	{ id: "sandbox", label: "Sandbox", group: "config", description: "Process containment", detail: "OS-level filesystem containment for shell and exec tool subprocesses. When enabled, worker processes run inside a kernel-enforced sandbox (bubblewrap on Linux, sandbox-exec on macOS) with an allowlist-only filesystem — only system paths, the workspace, and explicitly configured extra paths are accessible." },
 ];
 
 interface AgentConfigProps {
@@ -62,7 +65,7 @@ export function AgentConfig({ agentId }: AgentConfigProps) {
 	// Sync activeSection with URL search param
 	useEffect(() => {
 		if (search.tab) {
-			const validSections: SectionId[] = ["soul", "identity", "user", "routing", "tuning", "compaction", "cortex", "coalesce", "memory", "browser"];
+			const validSections = SECTIONS.map((section) => section.id);
 			if (validSections.includes(search.tab as SectionId)) {
 				setActiveSection(search.tab as SectionId);
 			}
@@ -103,9 +106,32 @@ export function AgentConfig({ agentId }: AgentConfigProps) {
 
 	const configMutation = useMutation({
 		mutationFn: (update: AgentConfigUpdateRequest) => api.updateAgentConfig(update),
-		onMutate: () => setSaving(true),
+		onMutate: (update) => {
+			setSaving(true);
+			// Optimistically merge the sent values into the cache so the UI
+			// reflects the change immediately (covers fields the backend
+			// doesn't yet return in its response, like sandbox).
+			const previous = queryClient.getQueryData<AgentConfigResponse>(["agent-config", agentId]);
+			if (previous) {
+				const { agent_id: _, ...sections } = update;
+				const merged = { ...previous } as unknown as Record<string, unknown>;
+				const prev = previous as unknown as Record<string, unknown>;
+				for (const [key, value] of Object.entries(sections)) {
+					if (value !== undefined) {
+						merged[key] = {
+							...(prev[key] as Record<string, unknown> | undefined),
+							...value,
+						};
+					}
+				}
+				queryClient.setQueryData(["agent-config", agentId], merged as unknown as AgentConfigResponse);
+			}
+		},
 		onSuccess: (result) => {
-			queryClient.setQueryData(["agent-config", agentId], result);
+			// Merge server response with cache to preserve fields the backend
+			// doesn't yet return (e.g. sandbox).
+			const previous = queryClient.getQueryData<AgentConfigResponse>(["agent-config", agentId]);
+			queryClient.setQueryData(["agent-config", agentId], { ...previous, ...result });
 			setDirty(false);
 			setSaving(false);
 		},
@@ -384,24 +410,33 @@ interface ConfigSectionEditorProps {
 	onSave: (update: Partial<AgentConfigUpdateRequest>) => void;
 }
 
+const SANDBOX_DEFAULTS = { mode: "enabled" as const, writable_paths: [] as string[] };
+
 function ConfigSectionEditor({ sectionId, label, description, detail, config, onDirtyChange, saveHandlerRef, onSave }: ConfigSectionEditorProps) {
-	const [localValues, setLocalValues] = useState<Record<string, string | number | boolean>>(() => {
+	type ConfigValues = Record<string, string | number | boolean | string[]>;
+	const sandbox = config.sandbox ?? SANDBOX_DEFAULTS;
+	const channel = config.channel ?? { listen_only_mode: false };
+	const [localValues, setLocalValues] = useState<ConfigValues>(() => {
 		// Initialize from config based on section
 		switch (sectionId) {
 			case "routing":
-				return { ...config.routing };
+				return { ...config.routing } as ConfigValues;
 			case "tuning":
-				return { ...config.tuning };
+				return { ...config.tuning } as ConfigValues;
 			case "compaction":
-				return { ...config.compaction };
+				return { ...config.compaction } as ConfigValues;
 			case "cortex":
-				return { ...config.cortex };
+				return { ...config.cortex } as ConfigValues;
 			case "coalesce":
-				return { ...config.coalesce };
+				return { ...config.coalesce } as ConfigValues;
 			case "memory":
-				return { ...config.memory_persistence };
+				return { ...config.memory_persistence } as ConfigValues;
 			case "browser":
-				return { ...config.browser };
+				return { ...config.browser } as ConfigValues;
+			case "channel":
+				return { ...channel } as ConfigValues;
+			case "sandbox":
+				return { mode: sandbox.mode, writable_paths: sandbox.writable_paths } as ConfigValues;
 			default:
 				return {};
 		}
@@ -438,11 +473,17 @@ function ConfigSectionEditor({ sectionId, label, description, detail, config, on
 				case "browser":
 					setLocalValues({ ...config.browser });
 					break;
+				case "channel":
+					setLocalValues({ ...channel });
+					break;
+				case "sandbox":
+					setLocalValues({ mode: sandbox.mode, writable_paths: sandbox.writable_paths });
+					break;
 			}
 		}
 	}, [config, sectionId, localDirty]);
 
-	const handleChange = useCallback((field: string, value: string | number | boolean) => {
+	const handleChange = useCallback((field: string, value: string | number | boolean | string[]) => {
 		setLocalValues((prev) => ({ ...prev, [field]: value }));
 		setLocalDirty(true);
 	}, []);
@@ -475,6 +516,12 @@ function ConfigSectionEditor({ sectionId, label, description, detail, config, on
 			case "browser":
 				setLocalValues({ ...config.browser });
 				break;
+			case "channel":
+				setLocalValues({ ...channel });
+				break;
+			case "sandbox":
+				setLocalValues({ mode: sandbox.mode, writable_paths: sandbox.writable_paths });
+				break;
 		}
 		setLocalDirty(false);
 	}, [config, sectionId]);
@@ -783,6 +830,70 @@ function ConfigSectionEditor({ sectionId, label, description, detail, config, on
 							value={localValues.evaluate_enabled as boolean}
 							onChange={(v) => handleChange("evaluate_enabled", v)}
 						/>
+						<ConfigToggleField
+							label="Persist Session"
+							description="Keep the browser alive across worker lifetimes. Cookies, tabs, and login sessions survive between tasks. Requires agent restart to take effect."
+							value={localValues.persist_session as boolean}
+							onChange={(v) => handleChange("persist_session", v)}
+						/>
+						<div className="flex flex-col gap-1.5">
+							<label className="text-sm font-medium text-ink">Close Policy</label>
+							<p className="text-tiny text-ink-faint">What happens when a worker calls &quot;close&quot; or finishes.</p>
+							<Select
+								value={localValues.close_policy as string}
+								onValueChange={(v) => handleChange("close_policy", v)}
+							>
+								<SelectTrigger className="border-app-line/50 bg-app-darkBox/30">
+									<SelectValue />
+								</SelectTrigger>
+								<SelectContent>
+									<SelectItem value="close_browser">Close Browser</SelectItem>
+									<SelectItem value="close_tabs">Close Tabs</SelectItem>
+									<SelectItem value="detach">Detach</SelectItem>
+								</SelectContent>
+							</Select>
+						</div>
+					</div>
+				);
+			case "sandbox":
+				return (
+					<div className="grid gap-4">
+						<div className="flex flex-col gap-1.5">
+							<label className="text-sm font-medium text-ink">Mode</label>
+							<p className="text-tiny text-ink-faint">Kernel-enforced filesystem containment for shell and exec subprocesses.</p>
+							<Select
+								value={localValues.mode as string}
+								onValueChange={(v) => handleChange("mode", v)}
+							>
+								<SelectTrigger className="border-app-line/50 bg-app-darkBox/30">
+									<SelectValue />
+								</SelectTrigger>
+								<SelectContent>
+									<SelectItem value="enabled">Enabled</SelectItem>
+									<SelectItem value="disabled">Disabled</SelectItem>
+								</SelectContent>
+							</Select>
+						</div>
+						<div className="flex flex-col gap-1.5">
+						<label className="text-sm font-medium text-ink">Extra Allowed Paths</label>
+						<p className="text-tiny text-ink-faint">Additional directories workers can read and write beyond the workspace. The workspace is always accessible. Press Enter to add a path.</p>
+							<TagInput
+								value={(localValues.writable_paths as string[]) ?? []}
+								onChange={(paths) => handleChange("writable_paths", paths)}
+								placeholder="/home/user/projects/myapp"
+							/>
+						</div>
+					</div>
+				);
+			case "channel":
+				return (
+					<div className="grid gap-4">
+						<ConfigToggleField
+							label="Listen-Only Mode"
+							description="Only respond when explicitly invoked (slash command, @mention, or reply-to-bot)."
+							value={localValues.listen_only_mode as boolean}
+							onChange={(v) => handleChange("listen_only_mode", v)}
+						/>
 					</div>
 				);
 			default:
@@ -815,28 +926,6 @@ function ConfigSectionEditor({ sectionId, label, description, detail, config, on
 
 // -- Form Field Components --
 
-interface ConfigFieldProps {
-	label: string;
-	description: string;
-	value: string;
-	onChange: (value: string) => void;
-}
-
-function ConfigField({ label, description, value, onChange }: ConfigFieldProps) {
-	return (
-		<div className="flex flex-col gap-1.5">
-			<label className="text-sm font-medium text-ink">{label}</label>
-			<p className="text-tiny text-ink-faint">{description}</p>
-			<Input
-				type="text"
-				value={value}
-				onChange={(e) => onChange(e.target.value)}
-				className="mt-1 border-app-line/50 bg-app-darkBox/30"
-			/>
-		</div>
-	);
-}
-
 interface ConfigToggleFieldProps {
 	label: string;
 	description: string;
diff --git a/interface/src/routes/AgentCortex.tsx b/interface/src/routes/AgentCortex.tsx
index 6765b7373..5f4a9dd3a 100644
--- a/interface/src/routes/AgentCortex.tsx
+++ b/interface/src/routes/AgentCortex.tsx
@@ -3,7 +3,6 @@ import { useQuery } from "@tanstack/react-query";
 import { AnimatePresence, motion } from "framer-motion";
 import {
 	api,
-	CORTEX_EVENT_TYPES,
 	type CortexEvent,
 	type CortexEventType,
 } from "@/api/client";
diff --git a/interface/src/routes/AgentCron.tsx b/interface/src/routes/AgentCron.tsx
index 469ecf297..ed6a41fef 100644
--- a/interface/src/routes/AgentCron.tsx
+++ b/interface/src/routes/AgentCron.tsx
@@ -2,7 +2,6 @@ import { useState } from "react";
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import { api, type CronJobWithStats, type CreateCronRequest } from "@/api/client";
 import { formatDuration, formatTimeAgo } from "@/lib/format";
-import { AnimatePresence, motion } from "framer-motion";
 import { Clock05Icon } from "@hugeicons/core-free-icons";
 import { HugeiconsIcon } from "@hugeicons/react";
 import {
diff --git a/interface/src/routes/AgentDetail.tsx b/interface/src/routes/AgentDetail.tsx
index 4ed6f6cda..bb614da78 100644
--- a/interface/src/routes/AgentDetail.tsx
+++ b/interface/src/routes/AgentDetail.tsx
@@ -90,14 +90,15 @@ export function AgentDetail({ agentId, liveStates }: AgentDetailProps) {
 	return (
 		<div className="h-full overflow-y-auto">
 			<div className="mx-auto max-w-6xl p-6 pb-24">
-				{/* Hero Section */}
-				<HeroSection
-					agentId={agentId}
-					channelCount={agentChannels.length}
-					workers={activity.workers}
-					branches={activity.branches}
-					hasLiveActivity={hasLiveActivity}
-					onDelete={() => setDeleteOpen(true)}
+			{/* Hero Section */}
+			<HeroSection
+				agentId={agentId}
+				displayName={agent.display_name}
+				channelCount={agentChannels.length}
+				workers={activity.workers}
+				branches={activity.branches}
+				hasLiveActivity={hasLiveActivity}
+				onDelete={() => setDeleteOpen(true)}
 				/>
 				<DeleteAgentDialog open={deleteOpen} onOpenChange={setDeleteOpen} agentId={agentId} />
 
@@ -144,35 +145,51 @@ export function AgentDetail({ agentId, liveStates }: AgentDetailProps) {
 						{/* Memory Donut */}
 						<div className="rounded-xl bg-app-darkBox p-5">
 							<div className="mb-4 flex items-center justify-between">
-								<h3 className="font-plex text-sm font-medium text-ink-dull">Memory Types</h3>
-								<span className="text-2xl font-medium tabular-nums text-ink">{overviewData.memory_total}</span>
+								<h3 className="font-plex text-sm font-medium text-ink-dull">Memory</h3>
+								<Link
+									to="/agents/$agentId/memories"
+									params={{ agentId }}
+									className="text-tiny text-accent hover:text-accent/80"
+								>
+									Edit
+								</Link>
 							</div>
 							<MemoryDonut counts={overviewData.memory_counts} />
 						</div>
 
 						{/* Model Routing */}
 						{configData && (
-							<div className="rounded-xl bg-app-darkBox p-5">
+							<div className="flex h-full flex-col rounded-xl bg-app-darkBox p-5">
 								<div className="mb-4 flex items-center justify-between">
 									<h3 className="font-plex text-sm font-medium text-ink-dull">Model Routing</h3>
 									<Link
 										to="/agents/$agentId/config"
 										params={{ agentId }}
+										search={{ tab: "routing" }}
 										className="text-tiny text-accent hover:text-accent/80"
 									>
 										Edit
 									</Link>
 								</div>
-								<ModelRoutingList config={configData} />
+								<div className="flex-1">
+									<ModelRoutingList config={configData} />
+								</div>
 							</div>
 						)}
 
 						{/* Quick Stats */}
-						<div className="rounded-xl bg-app-darkBox p-5">
-							<div className="mb-4">
+						<div className="flex h-full flex-col rounded-xl bg-app-darkBox p-5">
+							<div className="mb-4 flex items-center justify-between">
 								<h3 className="font-plex text-sm font-medium text-ink-dull">Configuration</h3>
+								<Link
+									to="/agents/$agentId/config"
+									params={{ agentId }}
+									className="text-tiny text-accent hover:text-accent/80"
+								>
+									Edit
+								</Link>
 							</div>
-							<div className="flex flex-col gap-3">
+							<div className="flex flex-1 flex-col justify-evenly gap-2">
 								<StatRow label="Context Window" value={agent.context_window.toLocaleString()} />
 								<StatRow label="Max Turns" value={String(agent.max_turns)} />
 								<StatRow label="Max Branches" value={String(agent.max_concurrent_branches)} />
@@ -208,6 +225,7 @@ export function AgentDetail({ agentId, liveStates }: AgentDetailProps) {
 
 function HeroSection({
 	agentId,
+	displayName,
 	channelCount,
 	workers,
 	branches,
@@ -215,6 +233,7 @@ function HeroSection({
 	onDelete,
 }: {
 	agentId: string;
+	displayName?: string;
 	channelCount: number;
 	workers: number;
 	branches: number;
@@ -225,7 +244,12 @@ function HeroSection({
 		<div className="flex flex-col gap-4 border-b border-app-line pb-6">
 			<div className="flex items-start justify-between">
 				<div>
-					<h1 className="font-plex text-3xl font-semibold text-ink">{agentId}</h1>
+					<h1 className="font-plex text-3xl font-semibold text-ink">
+						{displayName?.trim() ? displayName : agentId}
+					</h1>
+					{displayName?.trim() && (
+						<span className="mt-0.5 text-sm text-ink-faint">{agentId}</span>
+					)}
 					<div className="mt-2 flex items-center gap-4 text-sm">
 						<div className="flex items-center gap-2">
 							<div className={`h-2 w-2 rounded-full ${hasLiveActivity ? "animate-pulse bg-amber-400" : "bg-green-500"}`} />
@@ -470,8 +494,8 @@ function ActivityHeatmap({ data }: { data: { day: number; hour: number; count: n
 
 	const maxCount = Math.max(...data.map((d) => d.count), 1);
 	const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+	const hours = Array.from({ length: 24 }, (_value, index) => index);
 
-	// Create a 7x24 grid
 	const getCell = (day: number, hour: number) => {
 		const cell = data.find((d) => d.day === day && d.hour === hour);
 		return cell?.count ?? 0;
@@ -483,34 +507,30 @@ function ActivityHeatmap({ data }: { data: { day: number; hour: number; count: n
 	};
 
 	return (
-		<div className="h-48 overflow-auto">
-			<div className="flex flex-col gap-1">
-				{/* Hour labels */}
-				<div className="flex gap-1">
-					<div className="w-8 flex-shrink-0" /> {/* Day label spacer */}
-					{Array.from({ length: 24 }, (_, h) => (
-						<div key={h} className="w-4 flex-shrink-0 text-center text-[10px] text-ink-faint">
-							{h % 6 === 0 ? h : ""}
+		<div className="h-48">
+			<div className="grid h-full grid-rows-[auto_repeat(7,minmax(0,1fr))] gap-y-1">
+				<div className="grid grid-cols-[2rem_repeat(24,minmax(0,1fr))] gap-1">
+					<div />
+					{hours.map((hour) => (
+						<div key={hour} className="text-center text-[10px] text-ink-faint">
+							{hour % 6 === 0 ? hour : ""}
 						</div>
 					))}
 				</div>
-				{/* Heatmap grid */}
 				{days.map((dayLabel, day) => (
-					<div key={day} className="flex items-center gap-1">
-						<div className="w-8 flex-shrink-0 text-[10px] text-ink-faint">{dayLabel}</div>
-						<div className="flex gap-1">
-							{Array.from({ length: 24 }, (_, hour) => {
-								const count = getCell(day, hour);
-								return (
-									<div
-										key={hour}
-										title={`${dayLabel} ${hour}:00 - ${count} messages`}
-										className="h-4 w-4 flex-shrink-0 rounded-sm bg-accent transition-opacity hover:ring-1 hover:ring-accent"
-										style={{ opacity: getOpacity(count) }}
-									/>
-								);
-							})}
-						</div>
+					<div key={day} className="grid grid-cols-[2rem_repeat(24,minmax(0,1fr))] items-center gap-1">
+						<div className="text-[10px] text-ink-faint">{dayLabel}</div>
+						{hours.map((hour) => {
+							const count = getCell(day, hour);
+							return (
+								<div
+									key={hour}
+									title={`${dayLabel} ${hour}:00 - ${count} messages`}
+									className="h-3.5 w-full rounded-sm bg-accent transition-opacity hover:ring-1 hover:ring-accent"
+									style={{ opacity: getOpacity(count) }}
+								/>
+							);
+						})}
 					</div>
 				))}
 			</div>
@@ -524,14 +544,15 @@ function MemoryDonut({ counts }: { counts: Record<string, number> }) {
 		value: counts[type] ?? 0,
 		color: MEMORY_TYPE_COLORS[idx % MEMORY_TYPE_COLORS.length],
 	})).filter((d) => d.value > 0);
+	const total = data.reduce((sum, item) => sum + item.value, 0);
 
 	if (data.length === 0) {
 		return <div className="h-48 flex items-center justify-center text-ink-faint text-sm">No memories</div>;
 	}
 
 	return (
-		<div>
-			<div className="h-40">
+			<div>
+			<div className="relative h-40">
 				<ResponsiveContainer width="100%" height="100%">
 					<PieChart>
 						<Pie
@@ -555,11 +576,18 @@ function MemoryDonut({ counts }: { counts: Record<string, number> }) {
 								border: `1px solid ${CHART_COLORS.tooltip.border}`,
 								borderRadius: "6px",
 								fontSize: "12px",
+								padding: "4px 6px",
 							}}
-							itemStyle={{ color: CHART_COLORS.tooltip.text }}
+							wrapperStyle={{ zIndex: 20 }}
+							labelStyle={{ display: "none" }}
+							itemStyle={{ color: CHART_COLORS.tooltip.text, margin: 0, lineHeight: 1.2 }}
 						/>
 					</PieChart>
 				</ResponsiveContainer>
+				<div className="pointer-events-none absolute inset-0 z-0 flex flex-col items-center justify-center">
+					<span className="text-2xl font-medium tabular-nums text-ink">{total}</span>
+					<span className="text-tiny text-ink-faint">total</span>
+				</div>
 			</div>
 			<div className="mt-2 flex flex-wrap justify-center gap-2">
 				{data.map((item) => (
@@ -586,7 +614,7 @@ function ModelRoutingList({ config }: { config: { routing: { channel: string; br
 	];
 
 	return (
-		<div className="flex flex-col gap-2">
+		<div className="flex h-full flex-col justify-evenly gap-2">
 			{models.map(({ label, model, color }) => (
 				<div key={label} className="flex items-center justify-between">
 					<span className="text-tiny text-ink-faint">{label}</span>
@@ -628,29 +656,32 @@ function IdentitySection({
 	if (!hasContent) return null;
 
 	const files = [
-		{ label: "SOUL.md", content: identity.soul },
-		{ label: "IDENTITY.md", content: identity.identity },
-		{ label: "USER.md", content: identity.user },
+		{ label: "SOUL.md", tab: "soul", content: identity.soul },
+		{ label: "IDENTITY.md", tab: "identity", content: identity.identity },
+		{ label: "USER.md", tab: "user", content: identity.user },
 	].filter((f) => f.content && f.content.trim().length > 0 && !f.content.startsWith("<!--"));
 
 	if (files.length === 0) return null;
 
 	return (
 		<section className="mt-6">
-			<div className="mb-3 flex items-center justify-between">
+			<div className="mb-3">
 				<h3 className="font-plex text-sm font-medium text-ink-dull">Identity</h3>
-				<Link
-					to="/agents/$agentId/config"
-					params={{ agentId }}
-					className="text-tiny text-accent hover:text-accent/80"
-				>
-					Edit
-				</Link>
 			</div>
 			<div className="grid grid-cols-1 gap-4 lg:grid-cols-3">
-				{files.map(({ label, content }) => (
+				{files.map(({ label, tab, content }) => (
 					<div key={label} className="rounded-xl bg-app-darkBox p-4">
-						<span className="text-tiny font-medium text-ink-faint">{label}</span>
+						<div className="flex items-center justify-between gap-3">
+							<span className="text-tiny font-medium text-ink-faint">{label}</span>
+							<Link
+								to="/agents/$agentId/config"
+								params={{ agentId }}
+								search={{ tab }}
+								className="text-tiny text-accent hover:text-accent/80"
+							>
+								Edit
+							</Link>
+						</div>
 						<p className="mt-2 line-clamp-4 whitespace-pre-wrap text-sm leading-relaxed text-ink-dull">
 							{content!.trim()}
 						</p>
diff --git a/interface/src/routes/AgentIngest.tsx b/interface/src/routes/AgentIngest.tsx
index 0ae0273b9..582569093 100644
--- a/interface/src/routes/AgentIngest.tsx
+++ b/interface/src/routes/AgentIngest.tsx
@@ -2,7 +2,7 @@ import {useState, useRef, useCallback} from "react";
 import {useQuery, useMutation, useQueryClient} from "@tanstack/react-query";
 import {api, type IngestFileInfo} from "@/api/client";
 import {formatTimeAgo} from "@/lib/format";
-import {Button, Badge} from "@/ui";
+import {Badge} from "@/ui";
 import {clsx} from "clsx";
 import {FontAwesomeIcon} from "@fortawesome/react-fontawesome";
 import {faTrash} from "@fortawesome/free-solid-svg-icons";
diff --git a/interface/src/routes/AgentMemories.tsx b/interface/src/routes/AgentMemories.tsx
index 3aba1ec27..579aebb1f 100644
--- a/interface/src/routes/AgentMemories.tsx
+++ b/interface/src/routes/AgentMemories.tsx
@@ -22,7 +22,7 @@ import {
 	FilterButton,
 } from "@/ui";
 import { formatTimeAgo } from "@/lib/format";
-import { Search01Icon, ArrowDown01Icon, LeftToRightListBulletIcon, WorkflowSquare01Icon, IdeaIcon } from "@hugeicons/core-free-icons";
+import { ArrowDown01Icon, LeftToRightListBulletIcon, WorkflowSquare01Icon, IdeaIcon } from "@hugeicons/core-free-icons";
 import { HugeiconsIcon } from "@hugeicons/react";
 
 type ViewMode = "list" | "graph";
diff --git a/interface/src/routes/AgentSkills.tsx b/interface/src/routes/AgentSkills.tsx
index f41c1b3ae..53ad106e8 100644
--- a/interface/src/routes/AgentSkills.tsx
+++ b/interface/src/routes/AgentSkills.tsx
@@ -53,34 +53,34 @@ function InstalledSkill({
 }) {
 	return (
 		<div className="flex flex-col rounded-lg border border-app-line bg-app-box p-4 transition-colors hover:border-app-line-hover">
-			<div className="flex items-start justify-between gap-3">
-				<div className="flex-1">
-					<div className="flex items-center gap-2">
-						<h3 className="font-plex text-sm font-medium text-ink">
+			<div className="flex items-center justify-between gap-3">
+				<div className="min-w-0 flex-1">
+					<div className="flex min-w-0 items-center gap-2">
+						<h3 className="truncate font-plex text-sm font-medium text-ink">
 							{skill.name}
 						</h3>
 						<Badge variant={skill.source === "instance" ? "accent" : "green"} size="sm">
 							{skill.source}
 						</Badge>
 					</div>
-					<p className="mt-2 text-xs text-ink-faint">
-						{skill.description || "No description provided"}
-					</p>
 				</div>
 				<Button
-					variant="ghost"
-					size="sm"
+					variant="outline"
+					size="icon"
 					onClick={onRemove}
 					disabled={isRemoving}
-					className="text-red-400 hover:text-red-300"
+					className="h-6 w-6 flex-shrink-0"
 				>
 					<FontAwesomeIcon
 						icon={isRemoving ? faSpinner : faTrash}
-						className={isRemoving ? "animate-spin" : ""}
+						className={clsx("text-[11px]", isRemoving && "animate-spin")}
 					/>
 				</Button>
 			</div>
-			<p className="mt-3 font-mono text-xs text-ink-dull">
+			<p className="mt-2 text-xs text-ink-faint">
+				{skill.description || "No description provided"}
+			</p>
+			<p className="mt-3 font-mono text-xs text-ink-dull break-all">
 				{skill.base_dir}
 			</p>
 		</div>
@@ -91,12 +91,16 @@ function RegistrySkillCard({
 	skill,
 	isInstalled,
 	onInstall,
+	onRemove,
 	isInstalling,
+	isRemoving,
 }: {
 	skill: RegistrySkill;
 	isInstalled: boolean;
 	onInstall: () => void;
+	onRemove: () => void;
 	isInstalling: boolean;
+	isRemoving: boolean;
 }) {
 	return (
 		<div className="flex flex-col rounded-lg border border-app-line bg-app-box p-4 transition-colors hover:border-app-line-hover">
@@ -104,28 +108,47 @@ function RegistrySkillCard({
 				<h3 className="truncate font-plex text-sm font-medium text-ink">
 					{skill.name}
 				</h3>
-				{isInstalled && (
-					<FontAwesomeIcon
-						icon={faCheckCircle}
-						className="shrink-0 text-xs text-green-400"
-					/>
-				)}
 			</div>
 			<p className="mt-1 font-mono text-[11px] text-ink-dull/60">{skill.source}</p>
+			<p className="mt-2 flex-1 text-xs text-ink-faint">
+				{skill.description || "No description provided"}
+			</p>
 			<div className="mt-auto flex items-center justify-between gap-2 pt-3">
 				<span className="text-xs text-ink-faint">
 					{formatInstalls(skill.installs)} installs
 				</span>
 				<Button
-					variant={isInstalled ? "ghost" : "outline"}
+					variant="outline"
 					size="icon"
-					onClick={onInstall}
-					disabled={isInstalling || isInstalled}
+					onClick={() => {
+						if (isInstalled) {
+							onRemove();
+						} else {
+							onInstall();
+						}
+					}}
+					disabled={isInstalling || isRemoving}
+					className={clsx(
+						"group h-6 w-6 p-0",
+					)}
+					title={isInstalled ? "Remove installed skill" : "Install skill"}
 				>
-					<FontAwesomeIcon
-						icon={isInstalling ? faSpinner : faDownload}
-						className={clsx("text-xs", isInstalling && "animate-spin")}
-					/>
+					{isInstalling || isRemoving ? (
+						<FontAwesomeIcon icon={faSpinner} className="animate-spin text-xs" />
+					) : isInstalled ? (
+						<span className="relative flex h-3.5 w-3.5 items-center justify-center text-xs">
+							<FontAwesomeIcon
+								icon={faCheckCircle}
+								className="absolute left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2 transition-all duration-150 ease-out group-hover:scale-75 group-hover:opacity-0"
+							/>
+							<FontAwesomeIcon
+								icon={faTrash}
+								className="absolute left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2 scale-75 opacity-0 transition-all duration-150 ease-out group-hover:scale-100 group-hover:opacity-100"
+							/>
+						</span>
+					) : (
+						<FontAwesomeIcon icon={faDownload} className="text-xs" />
+					)}
 				</Button>
 			</div>
 		</div>
@@ -219,6 +242,18 @@ export function AgentSkills({ agentId }: AgentSkillsProps) {
 		},
 	});
 
+	const githubInstallMutation = useMutation({
+		mutationFn: (spec: string) =>
+			api.installSkill({
+				agent_id: agentId,
+				spec,
+				instance: false,
+			}),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["skills", agentId] });
+		},
+	});
+
 	const removeMutation = useMutation({
 		mutationFn: (name: string) =>
 			api.removeSkill({
@@ -231,7 +266,14 @@ export function AgentSkills({ agentId }: AgentSkillsProps) {
 	});
 
 	const installedSkills = skillsData?.skills ?? [];
-	const installedNames = new Set(installedSkills.map((s) => s.name.toLowerCase()));
+	const installedKeys = new Map(
+		installedSkills.map((s) => [
+			s.source_repo
+				? `${s.source_repo}/${s.name}`.toLowerCase()
+				: s.name.toLowerCase(),
+			s.name,
+		]),
+	);
 
 	// Flatten browse pages or use search results
 	const registrySkills: RegistrySkill[] = debouncedSearch
@@ -239,6 +281,7 @@ export function AgentSkills({ agentId }: AgentSkillsProps) {
 		: (browseData?.pages.flatMap((p) => p.skills) ?? []);
 
 	const isRegistryLoading = debouncedSearch ? isSearching : isBrowseLoading;
+	const totalRegistrySkills = browseData?.pages[0]?.total;
 
 	return (
 		<div className="flex h-full flex-col">
@@ -324,19 +367,81 @@ export function AgentSkills({ agentId }: AgentSkillsProps) {
 				<div className="p-6">
 					{activeTab === "browse" && (
 						<div className="space-y-4">
+							<div className="rounded-lg border border-app-line bg-app-box p-6">
+								<h3 className="text-sm font-medium text-ink">
+									Install from GitHub
+								</h3>
+								<p className="mt-1 text-xs text-ink-faint">
+									Install any skill from a GitHub repository
+								</p>
+								<form
+									onSubmit={(e) => {
+										e.preventDefault();
+										const formData = new FormData(e.currentTarget);
+										const spec = formData.get("spec") as string;
+										if (spec) {
+											githubInstallMutation.mutate(spec);
+											e.currentTarget.reset();
+										}
+									}}
+									className="mt-3 flex gap-2"
+								>
+									<input
+										type="text"
+										name="spec"
+										placeholder="owner/repo or owner/repo/skill-name"
+										className="flex-1 rounded-md border border-app-line bg-app-darkBox px-3 py-2 text-sm text-ink placeholder-ink-faint focus:border-accent focus:outline-none"
+									/>
+									<Button
+										type="submit"
+										variant="default"
+										size="default"
+										disabled={githubInstallMutation.isPending}
+									>
+										{githubInstallMutation.isPending ? (
+											<>
+												<FontAwesomeIcon
+													icon={faSpinner}
+													className="animate-spin"
+												/>
+												Installing...
+											</>
+										) : (
+											<>
+												<FontAwesomeIcon icon={faDownload} />
+												Install
+											</>
+										)}
+									</Button>
+								</form>
+								{githubInstallMutation.isError && (
+									<p className="mt-2 text-xs text-red-400">
+										Failed to install skill. Check the repository format.
+									</p>
+								)}
+								{githubInstallMutation.isSuccess && (
+									<p className="mt-2 text-xs text-green-400">
+										Installed {githubInstallMutation.data.installed.length} skill(s):{" "}
+										{githubInstallMutation.data.installed.join(", ")}
+									</p>
+								)}
+							</div>
+
 							<div className="flex items-center justify-between">
 								<h2 className="text-sm font-medium text-ink-dull">
 									{debouncedSearch
 										? `Results for "${debouncedSearch}"`
 										: `${VIEWS.find((v) => v.key === registryView)?.label ?? ""} Skills`}
 								</h2>
-								<span className="text-xs text-ink-faint">
-									{debouncedSearch && searchData
-										? `${searchData.count} results`
+							<span className="text-xs text-ink-faint">
+								{debouncedSearch && searchData
+									? `${searchData.count} results`
+									: totalRegistrySkills != null
+										? `${totalRegistrySkills} skills`
 										: registrySkills.length > 0
 											? `${registrySkills.length} skills`
 											: ""}
-								</span>
+							</span>
 							</div>
 
 							{isRegistryLoading && registrySkills.length === 0 && (
@@ -362,9 +467,11 @@ export function AgentSkills({ agentId }: AgentSkillsProps) {
 							<div className="grid grid-cols-1 gap-3 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4">
 								{registrySkills.map((skill) => {
 									const spec = installSpec(skill);
-									const isInstalled = installedNames.has(
-										skill.name.toLowerCase(),
-									);
+									const compositeKey = `${skill.source}/${skill.name}`.toLowerCase();
+									const installedName =
+										installedKeys.get(compositeKey) ??
+										installedKeys.get(skill.name.toLowerCase());
+									const isInstalled = Boolean(installedName);
 									return (
 										<RegistrySkillCard
 											key={`${skill.source}/${skill.skillId}`}
@@ -373,10 +480,19 @@ export function AgentSkills({ agentId }: AgentSkillsProps) {
 											onInstall={() =>
 												installMutation.mutate(spec)
 											}
+											onRemove={() => {
+												if (installedName) {
+													removeMutation.mutate(installedName);
+												}
+											}}
 											isInstalling={
 												installMutation.isPending &&
 												installMutation.variables === spec
 											}
+											isRemoving={
+												removeMutation.isPending &&
+												removeMutation.variables === installedName
+											}
 										/>
 									);
 								})}
@@ -394,65 +510,6 @@ export function AgentSkills({ agentId }: AgentSkillsProps) {
 								</div>
 							)}
 
-							<div className="mt-8 rounded-lg border border-app-line bg-app-box p-6">
-								<h3 className="text-sm font-medium text-ink">
-									Install from GitHub
-								</h3>
-								<p className="mt-1 text-xs text-ink-faint">
-									Install any skill from a GitHub repository
-								</p>
-								<form
-									onSubmit={(e) => {
-										e.preventDefault();
-										const formData = new FormData(e.currentTarget);
-										const spec = formData.get("spec") as string;
-										if (spec) {
-											installMutation.mutate(spec);
-											e.currentTarget.reset();
-										}
-									}}
-									className="mt-3 flex gap-2"
-								>
-									<input
-										type="text"
-										name="spec"
-										placeholder="owner/repo or owner/repo/skill-name"
-										className="flex-1 rounded-md border border-app-line bg-app-darkBox px-3 py-2 text-sm text-ink placeholder-ink-faint focus:border-accent focus:outline-none"
-									/>
-									<Button
-										type="submit"
-										variant="default"
-										size="default"
-										disabled={installMutation.isPending}
-									>
-										{installMutation.isPending ? (
-											<>
-												<FontAwesomeIcon
-													icon={faSpinner}
-													className="animate-spin"
-												/>
-												Installing...
-											</>
-										) : (
-											<>
-												<FontAwesomeIcon icon={faDownload} />
-												Install
-											</>
-										)}
-									</Button>
-								</form>
-								{installMutation.isError && (
-									<p className="mt-2 text-xs text-red-400">
-										Failed to install skill. Check the repository format.
-									</p>
-								)}
-								{installMutation.isSuccess && (
-									<p className="mt-2 text-xs text-green-400">
-										Installed {installMutation.data.installed.length} skill(s):{" "}
-										{installMutation.data.installed.join(", ")}
-									</p>
-								)}
-							</div>
 						</div>
 					)}
 
diff --git a/interface/src/routes/AgentTasks.tsx b/interface/src/routes/AgentTasks.tsx
new file mode 100644
index 000000000..28b688432
--- /dev/null
+++ b/interface/src/routes/AgentTasks.tsx
@@ -0,0 +1,660 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import {
+  api,
+  type TaskItem,
+  type TaskStatus,
+  type TaskPriority,
+  type CreateTaskRequest,
+} from "@/api/client";
+import { useLiveContext } from "@/hooks/useLiveContext";
+import { Badge } from "@/ui/Badge";
+import { Button } from "@/ui/Button";
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogFooter,
+} from "@/ui/Dialog";
+import { Markdown } from "@/components/Markdown";
+import { formatTimeAgo } from "@/lib/format";
+import { AnimatePresence, motion } from "framer-motion";
+
+const COLUMNS: { status: TaskStatus; label: string }[] = [
+  { status: "pending_approval", label: "Pending Approval" },
+  { status: "backlog", label: "Backlog" },
+  { status: "ready", label: "Ready" },
+  { status: "in_progress", label: "In Progress" },
+  { status: "done", label: "Done" },
+];
+
+const STATUS_COLORS: Record<
+  TaskStatus,
+  "default" | "amber" | "accent" | "violet" | "green"
+> = {
+  pending_approval: "amber",
+  backlog: "default",
+  ready: "accent",
+  in_progress: "violet",
+  done: "green",
+};
+
+const PRIORITY_LABELS: Record<TaskPriority, string> = {
+  critical: "Critical",
+  high: "High",
+  medium: "Medium",
+  low: "Low",
+};
+
+const PRIORITY_COLORS: Record<
+  TaskPriority,
+  "red" | "amber" | "default" | "outline"
+> = {
+  critical: "red",
+  high: "amber",
+  medium: "default",
+  low: "outline",
+};
+
+export function AgentTasks({ agentId }: { agentId: string }) {
+  const queryClient = useQueryClient();
+  const { taskEventVersion } = useLiveContext();
+
+  // Invalidate on SSE task events
+  const prevVersion = useRef(taskEventVersion);
+  useEffect(() => {
+    if (taskEventVersion !== prevVersion.current) {
+      prevVersion.current = taskEventVersion;
+      queryClient.invalidateQueries({ queryKey: ["tasks", agentId] });
+    }
+  }, [taskEventVersion, agentId, queryClient]);
+
+  const { data, isLoading } = useQuery({
+    queryKey: ["tasks", agentId],
+    queryFn: () => api.listTasks(agentId, { limit: 200 }),
+    refetchInterval: 15_000,
+  });
+
+  const tasks = data?.tasks ?? [];
+
+  // Group tasks by status
+  const tasksByStatus: Record<TaskStatus, TaskItem[]> = {
+    pending_approval: [],
+    backlog: [],
+    ready: [],
+    in_progress: [],
+    done: [],
+  };
+  for (const task of tasks) {
+    tasksByStatus[task.status]?.push(task);
+  }
+
+  // Create task dialog
+  const [createOpen, setCreateOpen] = useState(false);
+  // Detail dialog — store task number and derive from live list to stay current.
+  const [selectedTaskNumber, setSelectedTaskNumber] = useState<number | null>(
+    null,
+  );
+  const selectedTask =
+    selectedTaskNumber !== null
+      ? (tasks.find((t) => t.task_number === selectedTaskNumber) ?? null)
+      : null;
+
+  const createMutation = useMutation({
+    mutationFn: (request: CreateTaskRequest) =>
+      api.createTask(agentId, request),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["tasks", agentId] });
+      setCreateOpen(false);
+    },
+  });
+
+  const updateMutation = useMutation({
+    mutationFn: ({
+      taskNumber,
+      ...request
+    }: {
+      taskNumber: number;
+      status?: TaskStatus;
+      priority?: TaskPriority;
+    }) => api.updateTask(agentId, taskNumber, request),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["tasks", agentId] });
+    },
+  });
+
+  const approveMutation = useMutation({
+    mutationFn: (taskNumber: number) =>
+      api.approveTask(agentId, taskNumber, "human"),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["tasks", agentId] });
+    },
+  });
+
+  const executeMutation = useMutation({
+    mutationFn: (taskNumber: number) => api.executeTask(agentId, taskNumber),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["tasks", agentId] });
+    },
+  });
+
+  const deleteMutation = useMutation({
+    mutationFn: (taskNumber: number) => api.deleteTask(agentId, taskNumber),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["tasks", agentId] });
+      setSelectedTaskNumber(null);
+    },
+  });
+
+  if (isLoading) {
+    return (
+      <div className="flex h-full items-center justify-center text-ink-faint">
+        Loading tasks...
+      </div>
+    );
+  }
+
+  if (tasks.length === 0 && !createOpen) {
+    return (
+      <div className="flex h-full flex-col items-center justify-center gap-4 text-ink-faint">
+        <p className="text-sm">No tasks yet</p>
+        <Button size="sm" onClick={() => setCreateOpen(true)}>
+          Create Task
+        </Button>
+        <CreateTaskDialog
+          open={createOpen}
+          onClose={() => setCreateOpen(false)}
+          onCreate={(request) => createMutation.mutate(request)}
+          isPending={createMutation.isPending}
+        />
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex h-full flex-col">
+      {/* Toolbar */}
+      <div className="flex items-center justify-between border-b border-app-line px-4 py-2">
+        <div className="flex items-center gap-3">
+          <span className="text-sm text-ink-dull">
+            {tasks.length} task{tasks.length !== 1 ? "s" : ""}
+          </span>
+          {tasksByStatus.pending_approval.length > 0 && (
+            <Badge variant="amber" size="sm">
+              {tasksByStatus.pending_approval.length} pending approval
+            </Badge>
+          )}
+          {tasksByStatus.in_progress.length > 0 && (
+            <Badge variant="violet" size="sm">
+              {tasksByStatus.in_progress.length} in progress
+            </Badge>
+          )}
+        </div>
+        <Button size="sm" onClick={() => setCreateOpen(true)}>
+          Create Task
+        </Button>
+      </div>
+
+      {/* Kanban Board */}
+      <div className="flex flex-1 flex-wrap content-start gap-3 overflow-y-auto p-4">
+        {COLUMNS.map(({ status, label }) => (
+          <KanbanColumn
+            key={status}
+            status={status}
+            label={label}
+            tasks={tasksByStatus[status]}
+            onSelect={(task) => setSelectedTaskNumber(task.task_number)}
+            onApprove={(task) => approveMutation.mutate(task.task_number)}
+            onExecute={(task) => executeMutation.mutate(task.task_number)}
+            onStatusChange={(task, newStatus) =>
+              updateMutation.mutate({
+                taskNumber: task.task_number,
+                status: newStatus,
+              })
+            }
+          />
+        ))}
+      </div>
+
+      {/* Create Dialog */}
+      <CreateTaskDialog
+        open={createOpen}
+        onClose={() => setCreateOpen(false)}
+        onCreate={(request) => createMutation.mutate(request)}
+        isPending={createMutation.isPending}
+      />
+
+      {/* Detail Dialog */}
+      {selectedTask && (
+        <TaskDetailDialog
+          task={selectedTask}
+          onClose={() => setSelectedTaskNumber(null)}
+          onApprove={() => approveMutation.mutate(selectedTask.task_number)}
+          onExecute={() => executeMutation.mutate(selectedTask.task_number)}
+          onDelete={() => deleteMutation.mutate(selectedTask.task_number)}
+          onStatusChange={(status) =>
+            updateMutation.mutate({
+              taskNumber: selectedTask.task_number,
+              status,
+            })
+          }
+        />
+      )}
+    </div>
+  );
+}
+
+// -- Kanban Column --
+
+function KanbanColumn({
+  status,
+  label,
+  tasks,
+  onSelect,
+  onApprove,
+  onExecute,
+  onStatusChange,
+}: {
+  status: TaskStatus;
+  label: string;
+  tasks: TaskItem[];
+  onSelect: (task: TaskItem) => void;
+  onApprove: (task: TaskItem) => void;
+  onExecute: (task: TaskItem) => void;
+  onStatusChange: (task: TaskItem, status: TaskStatus) => void;
+}) {
+  return (
+    <div className="flex min-h-0 min-w-[14rem] flex-1 basis-[14rem] flex-col rounded-lg border border-app-line/50 bg-app-darkBox/20">
+      {/* Column Header */}
+      <div className="flex items-center gap-2 border-b border-app-line/30 px-3 py-2">
+        <Badge variant={STATUS_COLORS[status]} size="sm">
+          {label}
+        </Badge>
+        <span className="text-tiny text-ink-faint">{tasks.length}</span>
+      </div>
+
+      {/* Cards */}
+      <div className="flex-1 space-y-2 overflow-y-auto p-2">
+        <AnimatePresence mode="popLayout">
+          {tasks.map((task) => (
+            <TaskCard
+              key={task.id}
+              task={task}
+              onSelect={() => onSelect(task)}
+              onApprove={() => onApprove(task)}
+              onExecute={() => onExecute(task)}
+              onStatusChange={(newStatus) => onStatusChange(task, newStatus)}
+            />
+          ))}
+        </AnimatePresence>
+        {tasks.length === 0 && (
+          <div className="py-4 text-center text-tiny text-ink-faint">
+            No tasks
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+// -- Task Card --
+
+function TaskCard({
+  task,
+  onSelect,
+  onApprove,
+  onExecute,
+  onStatusChange,
+}: {
+  task: TaskItem;
+  onSelect: () => void;
+  onApprove: () => void;
+  onExecute: () => void;
+  onStatusChange: (status: TaskStatus) => void;
+}) {
+  const subtasksDone = task.subtasks.filter((s) => s.completed).length;
+  const subtasksTotal = task.subtasks.length;
+
+  return (
+    <motion.div
+      layout
+      initial={{ opacity: 0, scale: 0.95 }}
+      animate={{ opacity: 1, scale: 1 }}
+      exit={{ opacity: 0, scale: 0.95 }}
+      transition={{ duration: 0.15 }}
+      className="cursor-pointer rounded-md border border-app-line/30 bg-app p-3 transition-colors hover:border-app-line"
+      onClick={onSelect}
+    >
+      {/* Title row */}
+      <div className="flex items-start justify-between gap-2">
+        <span className="text-sm font-medium text-ink leading-tight">
+          #{task.task_number} {task.title}
+        </span>
+      </div>
+
+      {/* Meta row */}
+      <div className="mt-2 flex flex-wrap items-center gap-1.5">
+        <Badge variant={PRIORITY_COLORS[task.priority]} size="sm">
+          {PRIORITY_LABELS[task.priority]}
+        </Badge>
+        {subtasksTotal > 0 && (
+          <span className="text-tiny text-ink-faint">
+            {subtasksDone}/{subtasksTotal}
+          </span>
+        )}
+        {task.worker_id && (
+          <Badge variant="violet" size="sm">
+            Worker
+          </Badge>
+        )}
+      </div>
+
+      {/* Subtask progress bar */}
+      {subtasksTotal > 0 && (
+        <div className="mt-2 h-1 overflow-hidden rounded-full bg-app-line/30">
+          <div
+            className="h-full rounded-full bg-accent transition-all"
+            style={{ width: `${(subtasksDone / subtasksTotal) * 100}%` }}
+          />
+        </div>
+      )}
+
+      {/* Quick actions */}
+      <div className="mt-2 flex gap-1" onClick={(e) => e.stopPropagation()}>
+        {task.status === "pending_approval" && (
+          <button
+            className="rounded px-1.5 py-0.5 text-tiny text-accent hover:bg-accent/10"
+            onClick={onApprove}
+          >
+            Approve
+          </button>
+        )}
+        {(task.status === "backlog" || task.status === "pending_approval") && (
+          <button
+            className="rounded px-1.5 py-0.5 text-tiny text-violet-400 hover:bg-violet-400/10"
+            onClick={onExecute}
+          >
+            Execute
+          </button>
+        )}
+        {task.status === "in_progress" && (
+          <button
+            className="rounded px-1.5 py-0.5 text-tiny text-emerald-400 hover:bg-emerald-400/10"
+            onClick={() => onStatusChange("done")}
+          >
+            Mark Done
+          </button>
+        )}
+      </div>
+
+      {/* Footer */}
+      <div className="mt-1.5 text-tiny text-ink-faint">
+        {formatTimeAgo(task.created_at)} by {task.created_by}
+      </div>
+    </motion.div>
+  );
+}
+
+// -- Create Task Dialog --
+
+function CreateTaskDialog({
+  open,
+  onClose,
+  onCreate,
+  isPending,
+}: {
+  open: boolean;
+  onClose: () => void;
+  onCreate: (request: CreateTaskRequest) => void;
+  isPending: boolean;
+}) {
+  const [title, setTitle] = useState("");
+  const [description, setDescription] = useState("");
+  const [priority, setPriority] = useState<TaskPriority>("medium");
+  const [status, setStatus] = useState<TaskStatus>("backlog");
+
+  const handleSubmit = useCallback(() => {
+    if (!title.trim()) return;
+    onCreate({
+      title: title.trim(),
+      description: description.trim() || undefined,
+      priority,
+      status,
+    });
+    setTitle("");
+    setDescription("");
+    setPriority("medium");
+    setStatus("backlog");
+  }, [title, description, priority, status, onCreate]);
+
+  return (
+    <Dialog open={open} onOpenChange={(v) => !v && onClose()}>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>Create Task</DialogTitle>
+        </DialogHeader>
+        <div className="flex flex-col gap-3 py-2">
+          <div>
+            <label className="mb-1 block text-xs text-ink-dull">Title</label>
+            <input
+              className="w-full rounded-md border border-app-line bg-app-darkBox px-3 py-2 text-sm text-ink placeholder:text-ink-faint focus:border-accent focus:outline-none"
+              placeholder="Task title..."
+              value={title}
+              onChange={(e) => setTitle(e.target.value)}
+              onKeyDown={(e) => e.key === "Enter" && handleSubmit()}
+              autoFocus
+            />
+          </div>
+          <div>
+            <label className="mb-1 block text-xs text-ink-dull">
+              Description
+            </label>
+            <textarea
+              className="w-full rounded-md border border-app-line bg-app-darkBox px-3 py-2 text-sm text-ink placeholder:text-ink-faint focus:border-accent focus:outline-none"
+              placeholder="Optional description..."
+              value={description}
+              onChange={(e) => setDescription(e.target.value)}
+              rows={3}
+            />
+          </div>
+          <div className="flex gap-4">
+            <div className="flex-1">
+              <label className="mb-1 block text-xs text-ink-dull">
+                Priority
+              </label>
+              <select
+                className="w-full rounded-md border border-app-line bg-app-darkBox px-3 py-2 text-sm text-ink focus:border-accent focus:outline-none"
+                value={priority}
+                onChange={(e) => setPriority(e.target.value as TaskPriority)}
+              >
+                <option value="critical">Critical</option>
+                <option value="high">High</option>
+                <option value="medium">Medium</option>
+                <option value="low">Low</option>
+              </select>
+            </div>
+            <div className="flex-1">
+              <label className="mb-1 block text-xs text-ink-dull">
+                Initial Status
+              </label>
+              <select
+                className="w-full rounded-md border border-app-line bg-app-darkBox px-3 py-2 text-sm text-ink focus:border-accent focus:outline-none"
+                value={status}
+                onChange={(e) => setStatus(e.target.value as TaskStatus)}
+              >
+                <option value="pending_approval">Pending Approval</option>
+                <option value="backlog">Backlog</option>
+                <option value="ready">Ready</option>
+              </select>
+            </div>
+          </div>
+        </div>
+        <DialogFooter>
+          <Button variant="outline" size="sm" onClick={onClose}>
+            Cancel
+          </Button>
+          <Button
+            size="sm"
+            onClick={handleSubmit}
+            disabled={!title.trim() || isPending}
+          >
+            {isPending ? "Creating..." : "Create"}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+// -- Task Detail Dialog --
+
+function TaskDetailDialog({
+  task,
+  onClose,
+  onApprove,
+  onExecute,
+  onDelete,
+  onStatusChange,
+}: {
+  task: TaskItem;
+  onClose: () => void;
+  onApprove: () => void;
+  onExecute: () => void;
+  onDelete: () => void;
+  onStatusChange: (status: TaskStatus) => void;
+}) {
+  return (
+    <Dialog open={true} onOpenChange={(v) => !v && onClose()}>
+      <DialogContent className="!flex max-h-[85vh] max-w-lg !flex-col overflow-hidden">
+        <DialogHeader className="shrink-0">
+          <DialogTitle>
+            #{task.task_number} {task.title}
+          </DialogTitle>
+        </DialogHeader>
+        <div className="flex min-h-0 flex-1 flex-col gap-3 overflow-y-auto py-2 pr-1">
+          {/* Status + Priority */}
+          <div className="flex items-center gap-2">
+            <Badge variant={STATUS_COLORS[task.status]} size="md">
+              {task.status.replace("_", " ")}
+            </Badge>
+            <Badge variant={PRIORITY_COLORS[task.priority]} size="md">
+              {PRIORITY_LABELS[task.priority]}
+            </Badge>
+            {task.worker_id && (
+              <Badge variant="violet" size="md">
+                Worker: {task.worker_id.slice(0, 8)}
+              </Badge>
+            )}
+          </div>
+
+          {/* Description */}
+          {task.description && (
+            <div>
+              <label className="mb-1 block text-xs text-ink-dull">
+                Description
+              </label>
+              <Markdown className="break-words text-sm text-ink">
+                {task.description}
+              </Markdown>
+            </div>
+          )}
+
+          {/* Subtasks */}
+          {task.subtasks.length > 0 && (
+            <div>
+              <label className="mb-1 block text-xs text-ink-dull">
+                Subtasks ({task.subtasks.filter((s) => s.completed).length}/
+                {task.subtasks.length})
+              </label>
+              <ul className="space-y-1">
+                {task.subtasks.map((subtask, index) => (
+                  <li key={index} className="flex items-center gap-2 text-sm">
+                    <span
+                      className={
+                        subtask.completed
+                          ? "text-emerald-400"
+                          : "text-ink-faint"
+                      }
+                    >
+                      {subtask.completed ? "[x]" : "[ ]"}
+                    </span>
+                    <span
+                      className={
+                        subtask.completed
+                          ? "text-ink-dull line-through"
+                          : "text-ink"
+                      }
+                    >
+                      {subtask.title}
+                    </span>
+                  </li>
+                ))}
+              </ul>
+            </div>
+          )}
+
+          {/* Metadata */}
+          <div className="grid grid-cols-1 gap-2 text-xs text-ink-dull sm:grid-cols-2">
+            <div>Created: {formatTimeAgo(task.created_at)}</div>
+            <div>By: {task.created_by}</div>
+            {task.approved_at && (
+              <div>Approved: {formatTimeAgo(task.approved_at)}</div>
+            )}
+            {task.approved_by && <div>By: {task.approved_by}</div>}
+            {task.completed_at && (
+              <div>Completed: {formatTimeAgo(task.completed_at)}</div>
+            )}
+            <div>Updated: {formatTimeAgo(task.updated_at)}</div>
+          </div>
+        </div>
+
+        <DialogFooter className="shrink-0">
+          <div className="flex w-full flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
+            <button
+              className="text-xs text-red-400 hover:text-red-300"
+              onClick={onDelete}
+            >
+              Delete
+            </button>
+            <div className="flex flex-wrap gap-2 sm:justify-end">
+              {task.status === "pending_approval" && (
+                <Button size="sm" onClick={onApprove}>
+                  Approve
+                </Button>
+              )}
+              {(task.status === "backlog" ||
+                task.status === "pending_approval") && (
+                <Button size="sm" onClick={onExecute}>
+                  Execute
+                </Button>
+              )}
+              {task.status === "ready" && (
+                <Badge variant="accent" size="md">
+                  Waiting for cortex pickup
+                </Badge>
+              )}
+              {task.status === "in_progress" && (
+                <Button size="sm" onClick={() => onStatusChange("done")}>
+                  Mark Done
+                </Button>
+              )}
+              {task.status === "done" && (
+                <Button
+                  size="sm"
+                  variant="outline"
+                  onClick={() => onStatusChange("backlog")}
+                >
+                  Reopen
+                </Button>
+              )}
+              <Button size="sm" variant="outline" onClick={onClose}>
+                Close
+              </Button>
+            </div>
+          </div>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/interface/src/routes/AgentWorkers.tsx b/interface/src/routes/AgentWorkers.tsx
new file mode 100644
index 000000000..1dd9deaea
--- /dev/null
+++ b/interface/src/routes/AgentWorkers.tsx
@@ -0,0 +1,944 @@
+import {useState, useMemo, useEffect, useCallback, useRef} from "react";
+import {useQuery, useQueryClient} from "@tanstack/react-query";
+import {useNavigate, useSearch} from "@tanstack/react-router";
+import {motion} from "framer-motion";
+import {Markdown} from "@/components/Markdown";
+import {
+	api,
+	type WorkerRunInfo,
+	type WorkerDetailResponse,
+	type TranscriptStep,
+	type ActionContent,
+	type OpenCodePart,
+} from "@/api/client";
+import {Badge} from "@/ui/Badge";
+import {formatTimeAgo, formatDuration} from "@/lib/format";
+import {LiveDuration} from "@/components/LiveDuration";
+import {useLiveContext} from "@/hooks/useLiveContext";
+import {cx} from "@/ui/utils";
+
+/** RFC 4648 base64url encoding (no padding), matching OpenCode's directory encoding. */
+export function base64UrlEncode(value: string): string {
+	const bytes = new TextEncoder().encode(value);
+	const binary = Array.from(bytes, (b) => String.fromCharCode(b)).join("");
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+
+const STATUS_FILTERS = ["all", "running", "idle", "done", "failed"] as const;
+type StatusFilter = (typeof STATUS_FILTERS)[number];
+
+const KNOWN_STATUSES = new Set(["running", "idle", "done", "failed"]);
+
+function normalizeStatus(status: string): string {
+	if (KNOWN_STATUSES.has(status)) return status;
+	// Legacy rows where set_status text overwrote the state enum.
+	// If it has a completed_at it finished, otherwise it was interrupted.
+	return "failed";
+}
+
+function statusBadgeVariant(status: string) {
+	switch (status) {
+		case "running":
+			return "amber" as const;
+		case "idle":
+			return "blue" as const;
+		case "failed":
+			return "red" as const;
+		default:
+			return "outline" as const;
+	}
+}
+
+function workerTypeBadgeVariant(workerType: string) {
+	return workerType === "opencode" ? ("accent" as const) : ("outline" as const);
+}
+
+function durationBetween(start: string, end: string | null): string {
+	if (!end) return "";
+	const seconds = Math.floor(
+		(new Date(end).getTime() - new Date(start).getTime()) / 1000,
+	);
+	return formatDuration(seconds);
+}
+
+export function AgentWorkers({agentId}: {agentId: string}) {
+	const [statusFilter, setStatusFilter] = useState<StatusFilter>("all");
+	const [search, setSearch] = useState("");
+	const queryClient = useQueryClient();
+	const navigate = useNavigate();
+	const routeSearch = useSearch({strict: false}) as {worker?: string};
+	const selectedWorkerId = routeSearch.worker ?? null;
+	const {activeWorkers, workerEventVersion, liveTranscripts, liveOpenCodeParts} = useLiveContext();
+
+	// Invalidate worker queries when SSE events fire
+	const prevVersion = useRef(workerEventVersion);
+	useEffect(() => {
+		if (workerEventVersion !== prevVersion.current) {
+			prevVersion.current = workerEventVersion;
+			queryClient.invalidateQueries({queryKey: ["workers", agentId]});
+			if (selectedWorkerId) {
+				queryClient.invalidateQueries({
+					queryKey: ["worker-detail", agentId, selectedWorkerId],
+				});
+			}
+		}
+	}, [workerEventVersion, agentId, selectedWorkerId, queryClient]);
+
+	// List query
+	const {data: listData} = useQuery({
+		queryKey: ["workers", agentId, statusFilter],
+		queryFn: () =>
+			api.workersList(agentId, {
+				limit: 200,
+				status: statusFilter === "all" ? undefined : statusFilter,
+			}),
+		refetchInterval: 10_000,
+	});
+
+	// Detail query (only when a worker is selected).
+	// Returns null instead of throwing on 404 — the worker may not be in the DB
+	// yet while it's still visible via SSE state.
+	const {data: detailData} = useQuery({
+		queryKey: ["worker-detail", agentId, selectedWorkerId],
+		queryFn: () =>
+			selectedWorkerId
+				? api.workerDetail(agentId, selectedWorkerId).catch(() => null)
+				: Promise.resolve(null),
+		enabled: !!selectedWorkerId,
+	});
+
+	const workers = listData?.workers ?? [];
+	const total = listData?.total ?? 0;
+	const scopedActiveWorkers = useMemo(() => {
+		const entries = Object.entries(activeWorkers).filter(
+			([, worker]) => worker.agentId === agentId,
+		);
+		return Object.fromEntries(entries);
+	}, [activeWorkers, agentId]);
+
+	// Merge live SSE state onto the API-returned list.
+	// Workers that exist in SSE state but haven't hit the DB yet
+	// are synthesized and prepended so they appear instantly.
+	const mergedWorkers: WorkerRunInfo[] = useMemo(() => {
+		const dbIds = new Set(workers.map((w) => w.id));
+
+		// Overlay live state onto existing DB rows
+		const merged = workers.map((worker) => {
+			const live = scopedActiveWorkers[worker.id];
+			if (!live) return worker;
+			return {
+				...worker,
+				status: live.isIdle ? "idle" : "running",
+				live_status: live.status,
+				tool_calls: live.toolCalls,
+			};
+		});
+
+		// Synthesize entries for workers only known via SSE (not in DB yet)
+		const synthetic: WorkerRunInfo[] = Object.values(scopedActiveWorkers)
+			.filter((w) => !dbIds.has(w.id))
+			.map((live) => ({
+				id: live.id,
+				task: live.task,
+				status: live.isIdle ? "idle" : "running",
+				worker_type: live.workerType ?? "builtin",
+				channel_id: live.channelId ?? null,
+				channel_name: null,
+				started_at: new Date(live.startedAt).toISOString(),
+				completed_at: null,
+				has_transcript: false,
+				live_status: live.status,
+				tool_calls: live.toolCalls,
+				opencode_port: null,
+				interactive: live.interactive,
+			}));
+
+		return [...synthetic, ...merged];
+	}, [workers, scopedActiveWorkers]);
+
+	// Client-side task text search filter
+	const filteredWorkers = useMemo(() => {
+		if (!search.trim()) return mergedWorkers;
+		const term = search.toLowerCase();
+		return mergedWorkers.filter((w) => w.task.toLowerCase().includes(term));
+	}, [mergedWorkers, search]);
+
+	// Build detail view: prefer DB data, fall back to synthesized live state.
+	// Running workers that haven't hit the DB yet still get a full detail view
+	// from SSE state + live transcript.
+	const mergedDetail: WorkerDetailResponse | null = useMemo(() => {
+		const live = selectedWorkerId ? scopedActiveWorkers[selectedWorkerId] : null;
+
+		if (detailData) {
+			// DB data exists — overlay live status if worker is still running
+			if (!live) return detailData;
+			return { ...detailData, status: live.isIdle ? "idle" : "running" };
+		}
+
+		// No DB data yet — synthesize from SSE state
+		if (!live) return null;
+		return {
+			id: live.id,
+			task: live.task,
+			result: null,
+			status: live.isIdle ? "idle" : "running",
+			worker_type: live.workerType ?? "builtin",
+			channel_id: live.channelId ?? null,
+			channel_name: null,
+			started_at: new Date(live.startedAt).toISOString(),
+			completed_at: null,
+			transcript: null,
+			tool_calls: live.toolCalls,
+			opencode_session_id: null,
+			opencode_port: null,
+			interactive: live.interactive,
+		};
+	}, [detailData, scopedActiveWorkers, selectedWorkerId]);
+
+	const selectWorker = useCallback(
+		(workerId: string | null) => {
+			navigate({
+				to: `/agents/${agentId}/workers`,
+				search: workerId ? {worker: workerId} : {},
+				replace: true,
+			} as any);
+		},
+		[navigate, agentId],
+	);
+
+	return (
+		<div className="flex h-full">
+			{/* Left column: worker list */}
+			<div className="flex w-[360px] flex-shrink-0 flex-col border-r border-app-line/50">
+				{/* Toolbar */}
+				<div className="flex items-center gap-3 border-b border-app-line/50 bg-app-darkBox/20 px-4 py-2.5">
+					<input
+						type="text"
+						placeholder="Search tasks..."
+						value={search}
+						onChange={(e) => setSearch(e.target.value)}
+						className="h-7 flex-1 rounded-md border border-app-line/50 bg-app-input px-2.5 text-xs text-ink placeholder:text-ink-faint focus:border-accent/50 focus:outline-none"
+					/>
+					<span className="text-tiny text-ink-faint">{total}</span>
+				</div>
+
+				{/* Status filter pills */}
+				<div className="flex items-center gap-1.5 border-b border-app-line/50 px-4 py-2">
+					{STATUS_FILTERS.map((filter) => (
+						<button
+							key={filter}
+							onClick={() => setStatusFilter(filter)}
+							className={cx(
+								"rounded-full px-2.5 py-0.5 text-tiny font-medium transition-colors",
+								statusFilter === filter
+									? "bg-accent/15 text-accent"
+									: "text-ink-faint hover:bg-app-hover hover:text-ink-dull",
+							)}
+						>
+							{filter.charAt(0).toUpperCase() + filter.slice(1)}
+						</button>
+					))}
+				</div>
+
+				{/* Worker list */}
+				<div className="flex-1 overflow-y-auto">
+					{filteredWorkers.length === 0 ? (
+						<div className="flex h-32 items-center justify-center">
+							<p className="text-xs text-ink-faint">No workers found</p>
+						</div>
+					) : (
+						filteredWorkers.map((worker) => (
+							<WorkerCard
+								key={worker.id}
+								worker={worker}
+								liveWorker={scopedActiveWorkers[worker.id]}
+								selected={worker.id === selectedWorkerId}
+								onClick={() => selectWorker(worker.id)}
+							/>
+						))
+					)}
+				</div>
+			</div>
+
+			{/* Right column: detail view */}
+			<div className="flex flex-1 flex-col overflow-hidden">
+				{selectedWorkerId && mergedDetail ? (
+					<WorkerDetail
+						detail={mergedDetail}
+						liveWorker={scopedActiveWorkers[selectedWorkerId]}
+						liveTranscript={liveTranscripts[selectedWorkerId]}
+						liveOpenCodeParts={liveOpenCodeParts[selectedWorkerId]}
+					/>
+				) : (
+					<div className="flex flex-1 items-center justify-center">
+						<p className="text-sm text-ink-faint">
+							Select a worker to view details
+						</p>
+					</div>
+				)}
+			</div>
+		</div>
+	);
+}
+
+interface LiveWorker {
+	id: string;
+	task: string;
+	status: string;
+	startedAt: number;
+	toolCalls: number;
+	currentTool: string | null;
+	isIdle: boolean;
+	interactive: boolean;
+	workerType: string;
+}
+
+function WorkerCard({
+	worker,
+	liveWorker,
+	selected,
+	onClick,
+}: {
+	worker: WorkerRunInfo;
+	liveWorker?: LiveWorker;
+	selected: boolean;
+	onClick: () => void;
+}) {
+	const isLive = worker.status === "running" || !!liveWorker;
+	const isIdle = liveWorker?.isIdle ?? worker.status === "idle";
+	const isInteractive = liveWorker?.interactive ?? worker.interactive;
+	const displayStatus = isIdle ? "idle" : isLive ? "running" : normalizeStatus(worker.status);
+	const toolCalls = liveWorker?.toolCalls ?? worker.tool_calls;
+
+	return (
+		<button
+			onClick={onClick}
+			className={cx(
+				"flex w-full flex-col gap-1 border-b border-app-line/30 px-4 py-3 text-left transition-colors",
+				selected ? "bg-app-selected/50" : "",
+			)}
+		>
+			<div className="flex items-start justify-between gap-2">
+				<p className={cx("line-clamp-2 flex-1 text-xs font-medium", selected ? "text-ink" : "text-ink-dull")}>
+					{worker.task}
+				</p>
+				<div className="flex items-center gap-1.5">
+					{isInteractive && (
+						<Badge variant="outline" size="sm">
+							interactive
+						</Badge>
+					)}
+					<Badge
+						variant={statusBadgeVariant(displayStatus)}
+						size="sm"
+						className={!isLive && worker.status === "done" ? "hover:border-app-line hover:text-ink-dull" : undefined}
+					>
+						{isLive && !isIdle && (
+							<span className="h-1.5 w-1.5 animate-pulse rounded-full bg-current" />
+						)}
+						{displayStatus}
+					</Badge>
+				</div>
+			</div>
+			<div className="flex items-center gap-2 text-tiny text-ink-faint">
+				{worker.channel_name && (
+					<span className="truncate">{worker.channel_name}</span>
+				)}
+				{worker.channel_name && <span>·</span>}
+				<span>{worker.worker_type}</span>
+				<span>·</span>
+				{isLive && !isIdle ? (
+					<LiveDuration
+						startMs={
+							liveWorker?.startedAt ??
+							new Date(worker.started_at).getTime()
+						}
+					/>
+				) : (
+					<span>{formatTimeAgo(worker.started_at)}</span>
+				)}
+				{toolCalls > 0 && (
+					<>
+						<span>·</span>
+						<span>{toolCalls} tools</span>
+					</>
+				)}
+			</div>
+		</button>
+	);
+}
+
+type DetailTab = "opencode" | "transcript";
+
+function WorkerDetail({
+	detail,
+	liveWorker,
+	liveTranscript,
+	liveOpenCodeParts,
+}: {
+	detail: WorkerDetailResponse;
+	liveWorker?: LiveWorker;
+	liveTranscript?: TranscriptStep[];
+	liveOpenCodeParts?: Map<string, OpenCodePart>;
+}) {
+	const isLive = detail.status === "running" || !!liveWorker;
+	const isIdle = liveWorker?.isIdle ?? detail.status === "idle";
+	const duration = durationBetween(detail.started_at, detail.completed_at);
+	const displayStatus = liveWorker?.status;
+	const currentTool = liveWorker?.currentTool;
+	const toolCalls = liveWorker?.toolCalls ?? detail.tool_calls ?? 0;
+
+	const isOpenCode = detail.worker_type === "opencode";
+	const hasOpenCodeEmbed =
+		isOpenCode &&
+		detail.opencode_port != null &&
+		detail.opencode_session_id != null;
+
+	// Convert the insertion-ordered Map to an array for rendering
+	const openCodeParts: OpenCodePart[] = useMemo(
+		() => (liveOpenCodeParts ? Array.from(liveOpenCodeParts.values()) : []),
+		[liveOpenCodeParts],
+	);
+
+	const [activeTab, setActiveTab] = useState<DetailTab>(
+		hasOpenCodeEmbed ? "opencode" : "transcript",
+	);
+
+	// Reset tab when switching workers
+	useEffect(() => {
+		setActiveTab(hasOpenCodeEmbed ? "opencode" : "transcript");
+	}, [detail.id, hasOpenCodeEmbed]);
+
+	// Use persisted transcript if available, otherwise fall back to live SSE transcript.
+	// Strip the final action step if it duplicates the result text shown above.
+	const rawTranscript = detail.transcript ?? (isLive ? liveTranscript : null);
+	const transcript = useMemo(() => {
+		if (!rawTranscript || !detail.result) return rawTranscript;
+		const last = rawTranscript[rawTranscript.length - 1];
+		if (
+			last?.type === "action" &&
+			last.content.length === 1 &&
+			last.content[0].type === "text" &&
+			last.content[0].text.trim() === detail.result.trim()
+		) {
+			return rawTranscript.slice(0, -1);
+		}
+		return rawTranscript;
+	}, [rawTranscript, detail.result]);
+	const transcriptRef = useRef<HTMLDivElement>(null);
+
+	// Auto-scroll to latest transcript step for running workers (not idle)
+	const isRunning = isLive && !isIdle;
+	useEffect(() => {
+		if (isRunning && activeTab === "transcript" && transcriptRef.current) {
+			transcriptRef.current.scrollTop = transcriptRef.current.scrollHeight;
+		}
+	}, [isRunning, activeTab, transcript?.length]);
+
+	return (
+		<div className="flex h-full flex-col">
+			{/* Header */}
+			<div className="flex flex-col gap-2 border-b border-app-line/50 bg-app-darkBox/20 px-6 py-4">
+				<div className="flex items-start justify-between gap-3">
+					<TaskText text={detail.task} />
+					<div className="flex items-center gap-2">
+						{isLive && detail.channel_id && (
+							<CancelWorkerButton
+								channelId={detail.channel_id}
+								workerId={detail.id}
+							/>
+						)}
+						{detail.interactive && (
+							<Badge variant="outline" size="sm">
+								interactive
+							</Badge>
+						)}
+						<Badge
+							variant={workerTypeBadgeVariant(detail.worker_type)}
+							size="sm"
+						>
+							{detail.worker_type}
+						</Badge>
+						<Badge
+							variant={statusBadgeVariant(
+								isIdle ? "idle" : isLive ? "running" : normalizeStatus(detail.status),
+							)}
+							size="sm"
+						>
+							{isLive && !isIdle && (
+								<span className="h-1.5 w-1.5 animate-pulse rounded-full bg-current" />
+							)}
+							{isIdle ? "idle" : isLive ? "running" : normalizeStatus(detail.status)}
+						</Badge>
+					</div>
+				</div>
+				<div className="flex items-center gap-3 text-tiny text-ink-faint">
+					{detail.channel_name && <span>{detail.channel_name}</span>}
+					{isRunning ? (
+						<span>
+							Running for{" "}
+							<LiveDuration
+								startMs={
+									liveWorker?.startedAt ??
+									new Date(detail.started_at).getTime()
+								}
+							/>
+						</span>
+					) : isIdle ? (
+						<span className="text-blue-500">Idle — waiting for follow-up</span>
+					) : (
+						duration && <span>{duration}</span>
+					)}
+					{!isLive && <span>{formatTimeAgo(detail.started_at)}</span>}
+					{toolCalls > 0 && (
+						<span>{toolCalls} tool calls</span>
+					)}
+				</div>
+				{/* Live status bar for running workers */}
+				{isRunning && (currentTool || displayStatus) && (
+					<div className="flex items-center gap-2 text-tiny">
+						{currentTool ? (
+							<span className="text-accent">
+								Running {currentTool}...
+							</span>
+						) : displayStatus ? (
+							<span className="text-amber-500">{displayStatus}</span>
+						) : null}
+					</div>
+				)}
+			</div>
+
+			{/* Tab bar (only for OpenCode workers with embed data) */}
+			{hasOpenCodeEmbed && (
+				<div className="flex border-b border-app-line/50">
+					<button
+						onClick={() => setActiveTab("opencode")}
+						className={cx(
+							"px-4 py-2 text-xs font-medium transition-colors",
+							activeTab === "opencode"
+								? "border-b-2 border-accent text-accent"
+								: "text-ink-faint hover:text-ink-dull",
+						)}
+					>
+						OpenCode
+					</button>
+					<button
+						onClick={() => setActiveTab("transcript")}
+						className={cx(
+							"px-4 py-2 text-xs font-medium transition-colors",
+							activeTab === "transcript"
+								? "border-b-2 border-accent text-accent"
+								: "text-ink-faint hover:text-ink-dull",
+						)}
+					>
+						Transcript
+					</button>
+				</div>
+			)}
+
+			{/* Content */}
+			{activeTab === "opencode" && hasOpenCodeEmbed ? (
+				<OpenCodeEmbed
+					port={detail.opencode_port!}
+					sessionId={detail.opencode_session_id!}
+				/>
+			) : (
+				<div ref={transcriptRef} className="flex-1 overflow-y-auto">
+					{/* Result section */}
+					{detail.result && (
+						<div className="border-b border-app-line/30 px-6 py-4">
+							<h3 className="mb-2 text-tiny font-medium uppercase tracking-wider text-ink-faint">
+								Result
+							</h3>
+							<div className="text-xs text-ink">
+								<Markdown>{detail.result}</Markdown>
+							</div>
+						</div>
+					)}
+
+					{/* OpenCode live parts (for running/idle OpenCode workers) */}
+					{isOpenCode && isLive && openCodeParts.length > 0 ? (
+						<div className="px-6 py-4">
+							<h3 className="mb-3 text-tiny font-medium uppercase tracking-wider text-ink-faint">
+								{isIdle ? "Transcript" : "Live Transcript"}
+							</h3>
+							<div className="flex flex-col gap-3">
+								{openCodeParts.map((part) => (
+									<motion.div
+										key={part.id}
+										initial={{opacity: 0, y: 6}}
+										animate={{opacity: 1, y: 0}}
+										transition={{duration: 0.2, ease: "easeOut"}}
+									>
+										<OpenCodePartView part={part} />
+									</motion.div>
+								))}
+								{isRunning && currentTool && (
+									<div className="flex items-center gap-2 py-2 text-tiny text-accent">
+										<span className="h-1.5 w-1.5 animate-pulse rounded-full bg-accent" />
+										Running {currentTool}...
+									</div>
+								)}
+								{isIdle && (
+									<div className="flex items-center gap-2 py-2 text-tiny text-blue-500">
+										Waiting for follow-up input...
+									</div>
+								)}
+							</div>
+						</div>
+					) : transcript && transcript.length > 0 ? (
+						<div className="px-6 py-4">
+							<h3 className="mb-3 text-tiny font-medium uppercase tracking-wider text-ink-faint">
+								{isLive && !isIdle ? "Live Transcript" : "Transcript"}
+							</h3>
+							<div className="flex flex-col gap-3">
+								{transcript.map((step, index) => (
+									<motion.div
+										key={`${step.type}-${index}`}
+										initial={{opacity: 0, y: 6}}
+										animate={{opacity: 1, y: 0}}
+										transition={{duration: 0.2, ease: "easeOut"}}
+									>
+										<TranscriptStepView step={step} />
+									</motion.div>
+								))}
+								{isRunning && currentTool && (
+									<div className="flex items-center gap-2 py-2 text-tiny text-accent">
+										<span className="h-1.5 w-1.5 animate-pulse rounded-full bg-accent" />
+										Running {currentTool}...
+									</div>
+								)}
+								{isIdle && (
+									<div className="flex items-center gap-2 py-2 text-tiny text-blue-500">
+										Waiting for follow-up input...
+									</div>
+								)}
+							</div>
+						</div>
+					) : liveWorker && !isIdle ? (
+						<div className="flex flex-col items-center justify-center gap-2 py-12 text-ink-faint">
+							<div className="h-2 w-2 animate-pulse rounded-full bg-amber-500" />
+							<p className="text-xs">Waiting for first tool call...</p>
+						</div>
+					) : (
+						<div className="px-6 py-8 text-center text-xs text-ink-faint">
+							No transcript available for this worker
+						</div>
+					)}
+				</div>
+			)}
+		</div>
+	);
+}
+
+function OpenCodeEmbed({port, sessionId}: {port: number; sessionId: string}) {
+	const [state, setState] = useState<"loading" | "ready" | "error">("loading");
+
+	useEffect(() => {
+		setState("loading");
+		const controller = new AbortController();
+
+		fetch(`/api/opencode/${port}/global/health`, {signal: controller.signal})
+			.then((response) => {
+				setState(response.ok ? "ready" : "error");
+			})
+			.catch(() => {
+				setState("error");
+			});
+
+		return () => controller.abort();
+	}, [port, sessionId]);
+
+	if (state === "loading") {
+		return (
+			<div className="flex flex-1 items-center justify-center">
+				<div className="flex items-center gap-2 text-xs text-ink-faint">
+					<span className="h-2 w-2 animate-pulse rounded-full bg-accent" />
+					Connecting to OpenCode...
+				</div>
+			</div>
+		);
+	}
+
+	if (state === "error") {
+		return (
+			<div className="flex flex-1 flex-col items-center justify-center gap-2 text-ink-faint">
+				<p className="text-xs">OpenCode server is not reachable</p>
+				<p className="text-tiny">
+					The server may have been stopped. Try the Transcript tab for available data.
+				</p>
+			</div>
+		);
+	}
+
+	// Build the iframe URL. OpenCode uses base64url-encoded directory paths
+	// in its SPA routing. We load the root and let the app navigate — the
+	// server knows its directory, and the session list will show this session.
+	// Direct deep-linking: /api/opencode/{port}/{base64dir}/session/{sessionId}
+	const iframeSrc = `/api/opencode/${port}/`;
+
+	return (
+		<iframe
+			src={iframeSrc}
+			className="h-full w-full flex-1 border-0"
+			title="OpenCode"
+			sandbox="allow-scripts allow-same-origin allow-forms allow-popups"
+		/>
+	);
+}
+
+function TaskText({text}: {text: string}) {
+	const [expanded, setExpanded] = useState(false);
+
+	return (
+		<button
+			onClick={() => setExpanded((v) => !v)}
+			className="text-left text-sm font-medium text-ink-dull"
+		>
+			<p className={expanded ? undefined : "line-clamp-3"}>{text}</p>
+		</button>
+	);
+}
+
+function TranscriptStepView({step}: {step: TranscriptStep}) {
+	if (step.type === "action") {
+		return (
+			<div className="flex flex-col gap-1.5">
+				{step.content.map((content, index) => (
+					<ActionContentView key={index} content={content} />
+				))}
+			</div>
+		);
+	}
+
+	return <ToolResultView step={step} />;
+}
+
+function CancelWorkerButton({
+	channelId,
+	workerId,
+}: {
+	channelId: string;
+	workerId: string;
+}) {
+	const [cancelling, setCancelling] = useState(false);
+
+	return (
+		<button
+			disabled={cancelling}
+			onClick={() => {
+				setCancelling(true);
+				api
+					.cancelProcess(channelId, "worker", workerId)
+					.catch(console.warn)
+					.finally(() => setCancelling(false));
+			}}
+			className="rounded-md border border-app-line px-2 py-0.5 text-tiny font-medium text-ink-dull transition-colors hover:border-ink-faint hover:text-ink disabled:opacity-50"
+		>
+			{cancelling ? "Cancelling..." : "Cancel"}
+		</button>
+	);
+}
+
+function ActionContentView({content}: {content: ActionContent}) {
+	if (content.type === "text") {
+		return (
+			<div className="text-xs text-ink">
+				<Markdown>{content.text}</Markdown>
+			</div>
+		);
+	}
+
+	return <ToolCallView content={content} />;
+}
+
+function ToolCallView({
+	content,
+}: {
+	content: Extract<ActionContent, {type: "tool_call"}>;
+}) {
+	const [expanded, setExpanded] = useState(false);
+
+	return (
+		<div className="rounded-md border border-app-line/50 bg-app-darkBox/30">
+			<button
+				onClick={() => setExpanded(!expanded)}
+				className="flex w-full items-center gap-2 px-3 py-2 text-left text-xs"
+			>
+				<span className="text-accent">&#9656;</span>
+				<span className="font-medium text-ink-dull">{content.name}</span>
+				{!expanded && (
+					<span className="flex-1 truncate text-ink-faint">
+						{content.args.slice(0, 80)}
+					</span>
+				)}
+			</button>
+			{expanded && (
+				<pre className="max-h-60 overflow-auto border-t border-app-line/30 px-3 py-2 font-mono text-tiny text-ink-dull">
+					{content.args}
+				</pre>
+			)}
+		</div>
+	);
+}
+
+function ToolResultView({
+	step,
+}: {
+	step: Extract<TranscriptStep, {type: "tool_result"}>;
+}) {
+	const [expanded, setExpanded] = useState(false);
+	const isLong = step.text.length > 300;
+	const displayText =
+		isLong && !expanded ? step.text.slice(0, 300) + "..." : step.text;
+
+	return (
+		<div className="rounded-md border border-app-line/30 bg-app-darkerBox/50">
+			<div className="flex items-center gap-2 px-3 py-1.5">
+				<span className="text-tiny text-emerald-500">&#10003;</span>
+				{step.name && (
+					<span className="text-tiny font-medium text-ink-faint">
+						{step.name}
+					</span>
+				)}
+			</div>
+			<pre className="max-h-80 overflow-auto whitespace-pre-wrap px-3 pb-2 font-mono text-tiny text-ink-dull">
+				{displayText}
+			</pre>
+			{isLong && (
+				<button
+					onClick={() => setExpanded(!expanded)}
+					className="w-full border-t border-app-line/20 px-3 py-1 text-center text-tiny text-ink-faint hover:text-ink-dull"
+				>
+					{expanded ? "Collapse" : "Show full output"}
+				</button>
+			)}
+		</div>
+	);
+}
+
+// -- OpenCode-native part renderers --
+
+function OpenCodePartView({part}: {part: OpenCodePart}) {
+	switch (part.type) {
+		case "text":
+			return (
+				<div className="text-xs text-ink">
+					<Markdown>{part.text}</Markdown>
+				</div>
+			);
+		case "tool":
+			return <OpenCodeToolPartView part={part} />;
+		case "step_start":
+			return (
+				<div className="flex items-center gap-2 border-t border-app-line/20 pt-3">
+					<div className="h-px flex-1 bg-app-line/30" />
+					<span className="text-tiny text-ink-faint">Step</span>
+					<div className="h-px flex-1 bg-app-line/30" />
+				</div>
+			);
+		case "step_finish":
+			return (
+				<div className="flex items-center gap-2 border-b border-app-line/20 pb-3">
+					<div className="h-px flex-1 bg-app-line/30" />
+					<span className="text-tiny text-ink-faint">
+						{part.reason ? `End: ${part.reason}` : "End step"}
+					</span>
+					<div className="h-px flex-1 bg-app-line/30" />
+				</div>
+			);
+		default:
+			return null;
+	}
+}
+
+function OpenCodeToolPartView({
+	part,
+}: {
+	part: Extract<OpenCodePart, {type: "tool"}>;
+}) {
+	const [expanded, setExpanded] = useState(false);
+	const isRunning = part.status === "running";
+	const isCompleted = part.status === "completed";
+	const isError = part.status === "error";
+
+	const statusIcon = isCompleted
+		? "\u2713"
+		: isError
+			? "\u2717"
+			: isRunning
+				? "\u25B6"
+				: "\u25CB";
+
+	const statusColor = isCompleted
+		? "text-emerald-500"
+		: isError
+			? "text-red-400"
+			: isRunning
+				? "text-accent"
+				: "text-ink-faint";
+
+	const title =
+		(part.status === "running" || part.status === "completed")
+			? (part as any).title
+			: undefined;
+
+	const input =
+		(part.status === "running" || part.status === "completed")
+			? (part as any).input
+			: undefined;
+
+	const output = part.status === "completed" ? (part as any).output : undefined;
+	const error = part.status === "error" ? (part as any).error : undefined;
+
+	return (
+		<div className="rounded-md border border-app-line/50 bg-app-darkBox/30">
+			<button
+				onClick={() => setExpanded(!expanded)}
+				className="flex w-full items-center gap-2 px-3 py-2 text-left text-xs"
+			>
+				<span className={cx(statusColor, isRunning ? "animate-pulse" : "")}>
+					{statusIcon}
+				</span>
+				<span className="font-medium text-ink-dull">{part.tool}</span>
+				{title && (
+					<span className="flex-1 truncate text-ink-faint">{title}</span>
+				)}
+				{!title && !expanded && input && (
+					<span className="flex-1 truncate text-ink-faint">
+						{input.slice(0, 80)}
+					</span>
+				)}
+				{isRunning && (
+					<span className="h-1.5 w-1.5 animate-pulse rounded-full bg-accent" />
+				)}
+			</button>
+			{expanded && (
+				<div className="border-t border-app-line/30">
+					{input && (
+						<div className="border-b border-app-line/20 px-3 py-2">
+							<p className="mb-1 text-tiny font-medium text-ink-faint">Input</p>
+							<pre className="max-h-40 overflow-auto font-mono text-tiny text-ink-dull">
+								{input}
+							</pre>
+						</div>
+					)}
+					{output && (
+						<div className="px-3 py-2">
+							<p className="mb-1 text-tiny font-medium text-ink-faint">Output</p>
+							<pre className="max-h-60 overflow-auto whitespace-pre-wrap font-mono text-tiny text-ink-dull">
+								{output.length > 500 ? output.slice(0, 500) + "..." : output}
+							</pre>
+						</div>
+					)}
+					{error && (
+						<div className="px-3 py-2">
+							<p className="mb-1 text-tiny font-medium text-red-400">Error</p>
+							<pre className="font-mono text-tiny text-red-300">{error}</pre>
+						</div>
+					)}
+				</div>
+			)}
+		</div>
+	);
+}
diff --git a/interface/src/routes/ChannelDetail.tsx b/interface/src/routes/ChannelDetail.tsx
index e5ba17ed3..1d9534832 100644
--- a/interface/src/routes/ChannelDetail.tsx
+++ b/interface/src/routes/ChannelDetail.tsx
@@ -2,7 +2,7 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { Link } from "@tanstack/react-router";
 import { AnimatePresence, motion } from "framer-motion";
 import { api, type ChannelInfo, type TimelineItem, type TimelineBranchRun, type TimelineWorkerRun } from "@/api/client";
-import type { ChannelLiveState, ActiveWorker, ActiveBranch } from "@/hooks/useChannelLiveState";
+import { isOpenCodeWorker, type ChannelLiveState, type ActiveWorker, type ActiveBranch } from "@/hooks/useChannelLiveState";
 import { CortexChatPanel } from "@/components/CortexChatPanel";
 import { LiveDuration } from "@/components/LiveDuration";
 import { Markdown } from "@/components/Markdown";
@@ -19,7 +19,7 @@ interface ChannelDetailProps {
 	onLoadMore: () => void;
 }
 
-function CancelButton({ onClick }: { onClick: () => void }) {
+function CancelButton({ onClick, className }: { onClick: () => void; className?: string }) {
 	const [cancelling, setCancelling] = useState(false);
 	return (
 		<Button
@@ -32,7 +32,7 @@ function CancelButton({ onClick }: { onClick: () => void }) {
 				setCancelling(true);
 				onClick();
 			}}
-			className="ml-auto h-7 w-7 flex-shrink-0 text-ink-faint/50 hover:bg-red-500/15 hover:text-red-400"
+			className={`h-7 w-7 flex-shrink-0 text-ink-faint/50 hover:bg-red-500/15 hover:text-red-400 ${className ?? ""}`}
 			title="Cancel"
 		>
 			<HugeiconsIcon icon={Cancel01Icon} className="h-3.5 w-3.5" />
@@ -49,11 +49,11 @@ function LiveBranchRunItem({ item, live, channelId }: { item: TimelineBranchRun;
 			</span>
 			<div className="min-w-0 flex-1">
 				<div className="rounded-md bg-violet-500/10 px-3 py-2">
-					<div className="flex items-center gap-2">
+					<div className="flex min-w-0 items-center gap-2">
 						<div className="h-2 w-2 animate-pulse rounded-full bg-violet-400" />
 						<span className="text-sm font-medium text-violet-300">Branch</span>
-						<span className="truncate text-sm text-ink-dull">{item.description}</span>
-						<CancelButton onClick={() => { api.cancelProcess(channelId, "branch", item.id).catch(console.warn); }} />
+						<span className="min-w-0 flex-1 truncate text-sm text-ink-dull">{item.description}</span>
+						<CancelButton className="ml-auto" onClick={() => { api.cancelProcess(channelId, "branch", item.id).catch(console.warn); }} />
 					</div>
 					<div className="mt-1 flex items-center gap-3 pl-4 text-tiny text-ink-faint">
 						<LiveDuration startMs={live.startedAt} />
@@ -70,30 +70,63 @@ function LiveBranchRunItem({ item, live, channelId }: { item: TimelineBranchRun;
 	);
 }
 
-function LiveWorkerRunItem({ item, live, channelId }: { item: TimelineWorkerRun; live: ActiveWorker; channelId: string }) {
+function LiveWorkerRunItem({ item, live, channelId, agentId }: { item: TimelineWorkerRun; live: ActiveWorker; channelId: string; agentId: string }) {
+	const [expanded, setExpanded] = useState(true);
+	const oc = isOpenCodeWorker(live);
+
 	return (
 		<div className="flex gap-3 px-3 py-2">
 			<span className="flex-shrink-0 pt-0.5 text-tiny text-ink-faint">
 				{formatTimestamp(new Date(item.started_at).getTime())}
 			</span>
 			<div className="min-w-0 flex-1">
-				<div className="rounded-md bg-amber-500/10 px-3 py-2">
+				<div className={`w-full rounded-md px-3 py-2 transition-colors ${
+					oc ? "bg-zinc-500/10 hover:bg-zinc-500/15" : "bg-amber-500/10 hover:bg-amber-500/15"
+				}`}>
 					<div className="flex min-w-0 items-center gap-2 overflow-hidden">
-						<div className="h-2 w-2 animate-pulse rounded-full bg-amber-400" />
-						<span className="text-sm font-medium text-amber-300">Worker</span>
-						<span className="min-w-0 flex-1 truncate text-sm text-ink-dull">{item.task}</span>
+						<button
+							type="button"
+							onClick={() => setExpanded(!expanded)}
+							className="min-w-0 flex-1 text-left"
+						>
+							<div className="flex min-w-0 items-center gap-2 overflow-hidden">
+								<div className={`h-2 w-2 animate-pulse rounded-full ${oc ? "bg-zinc-400" : "bg-amber-400"}`} />
+								<span className={`text-sm font-medium ${oc ? "text-zinc-300" : "text-amber-300"}`}>Worker</span>
+								<span className={`min-w-0 flex-1 text-sm text-ink-dull ${
+									expanded ? "whitespace-normal break-words" : "truncate"
+								}`}>{item.task}</span>
+								<span className="flex-shrink-0 text-tiny leading-5 text-ink-faint">
+									{expanded ? "▾" : "▸"}
+								</span>
+							</div>
+						</button>
+						<Link
+							to="/agents/$agentId/workers"
+							params={{ agentId }}
+							search={{ worker: item.id }}
+							className={`flex-shrink-0 rounded border px-1.5 py-0.5 text-tiny font-medium transition-colors ${
+								oc
+									? "border-zinc-400/30 text-zinc-300 hover:border-zinc-400/60 hover:bg-zinc-500/15"
+									: "border-amber-400/30 text-amber-300 hover:border-amber-400/60 hover:bg-amber-500/15"
+							}`}
+						>
+							Open
+						</Link>
 						<CancelButton onClick={() => { api.cancelProcess(channelId, "worker", item.id).catch(console.warn); }} />
 					</div>
+				</div>
+				{expanded && (
 					<div className="mt-1 flex min-w-0 items-center gap-3 overflow-hidden pl-4 text-tiny text-ink-faint">
+						<LiveDuration startMs={live.startedAt} />
 						<span className="truncate">{live.status}</span>
 						{live.currentTool && (
-							<span className="truncate text-amber-400/70">{live.currentTool}</span>
+							<span className={`truncate ${oc ? "text-zinc-400/70" : "text-amber-400/70"}`}>{live.currentTool}</span>
 						)}
 						{live.toolCalls > 0 && (
 							<span>{live.toolCalls} tool calls</span>
 						)}
 					</div>
-				</div>
+				)}
 			</div>
 		</div>
 	);
@@ -114,12 +147,18 @@ function BranchRunItem({ item }: { item: TimelineBranchRun }) {
 					variant="ghost"
 					className="h-auto w-full justify-start rounded-md bg-violet-500/10 px-3 py-2 text-left hover:bg-violet-500/15"
 				>
-					<div className="flex items-center gap-2">
-						<div className="h-2 w-2 rounded-full bg-violet-400/50" />
-						<span className="text-sm font-medium text-violet-300">Branch</span>
-						<span className="truncate text-sm text-ink-dull">{item.description}</span>
+					<div className="flex min-w-0 items-start gap-2">
+						<span className="inline-flex flex-shrink-0 items-center gap-2 self-start">
+							<span className="h-2 w-2 rounded-full bg-violet-400/50" />
+							<span className="text-sm font-medium text-violet-300">Branch</span>
+						</span>
+						<span className={`min-w-0 flex-1 text-sm text-ink-dull ${
+							expanded ? "whitespace-normal break-words" : "truncate"
+						}`}>
+							{item.description}
+						</span>
 						{item.conclusion && (
-							<span className="ml-auto text-tiny text-ink-faint">
+							<span className="flex-shrink-0 self-start text-tiny leading-5 text-ink-faint">
 								{expanded ? "▾" : "▸"}
 							</span>
 						)}
@@ -128,7 +167,7 @@ function BranchRunItem({ item }: { item: TimelineBranchRun }) {
 				{expanded && item.conclusion && (
 					<div className="mt-1 rounded-md border border-violet-500/10 bg-violet-500/5 px-3 py-2">
 						<div className="text-sm text-ink-dull">
-							<Markdown>{item.conclusion}</Markdown>
+							<Markdown className="whitespace-pre-wrap break-words">{item.conclusion}</Markdown>
 						</div>
 					</div>
 				)}
@@ -137,8 +176,9 @@ function BranchRunItem({ item }: { item: TimelineBranchRun }) {
 	);
 }
 
-function WorkerRunItem({ item }: { item: TimelineWorkerRun }) {
+function WorkerRunItem({ item, agentId }: { item: TimelineWorkerRun; agentId: string }) {
 	const [expanded, setExpanded] = useState(false);
+	const oc = isOpenCodeWorker({ task: item.task });
 
 	return (
 		<div className="flex gap-3 px-3 py-2">
@@ -146,26 +186,50 @@ function WorkerRunItem({ item }: { item: TimelineWorkerRun }) {
 				{formatTimestamp(new Date(item.started_at).getTime())}
 			</span>
 			<div className="min-w-0 flex-1">
-				<button
-					type="button"
-					onClick={() => setExpanded(!expanded)}
-					className="w-full rounded-md bg-amber-500/10 px-3 py-2 text-left transition-colors hover:bg-amber-500/15 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-amber-400/60"
-				>
+				<div className={`w-full rounded-md px-3 py-2 transition-colors ${
+					oc ? "bg-zinc-500/10 hover:bg-zinc-500/15" : "bg-amber-500/10 hover:bg-amber-500/15"
+				}`}>
 					<div className="flex min-w-0 items-center gap-2 overflow-hidden">
-						<div className="h-2 w-2 rounded-full bg-amber-400/50" />
-						<span className="text-sm font-medium text-amber-300">Worker</span>
-						<span className="min-w-0 flex-1 truncate text-sm text-ink-dull">{item.task}</span>
-						{item.result && (
-							<span className="ml-auto text-tiny text-ink-faint">
-								{expanded ? "▾" : "▸"}
-							</span>
-						)}
+						<button
+							type="button"
+							onClick={() => {
+								if (item.result) setExpanded(!expanded);
+							}}
+							className="min-w-0 flex-1 text-left"
+						>
+							<div className="flex min-w-0 items-center gap-2 overflow-hidden">
+								<div className={`h-2 w-2 rounded-full ${oc ? "bg-zinc-400/50" : "bg-amber-400/50"}`} />
+								<span className={`text-sm font-medium ${oc ? "text-zinc-300" : "text-amber-300"}`}>Worker</span>
+								<span className={`min-w-0 flex-1 text-sm text-ink-dull ${
+									expanded ? "whitespace-normal break-words" : "truncate"
+								}`}>{item.task}</span>
+								{item.result && (
+									<span className="flex-shrink-0 text-tiny leading-5 text-ink-faint">
+										{expanded ? "▾" : "▸"}
+									</span>
+								)}
+							</div>
+						</button>
+						<Link
+							to="/agents/$agentId/workers"
+							params={{ agentId }}
+							search={{ worker: item.id }}
+							className={`flex-shrink-0 rounded border px-1.5 py-0.5 text-tiny font-medium transition-colors ${
+								oc
+									? "border-zinc-400/30 text-zinc-300 hover:border-zinc-400/60 hover:bg-zinc-500/15"
+									: "border-amber-400/30 text-amber-300 hover:border-amber-400/60 hover:bg-amber-500/15"
+							}`}
+						>
+							Open
+						</Link>
 					</div>
-				</button>
+				</div>
 				{expanded && item.result && (
-					<div className="mt-1 rounded-md border border-amber-500/10 bg-amber-500/5 px-3 py-2">
+					<div className={`mt-1 rounded-md border px-3 py-2 ${
+						oc ? "border-zinc-500/10 bg-zinc-500/5" : "border-amber-500/10 bg-amber-500/5"
+					}`}>
 						<div className="text-sm text-ink-dull">
-							<Markdown>{item.result}</Markdown>
+							<Markdown className="whitespace-pre-wrap break-words">{item.result}</Markdown>
 						</div>
 					</div>
 				)}
@@ -174,11 +238,12 @@ function WorkerRunItem({ item }: { item: TimelineWorkerRun }) {
 	);
 }
 
-function TimelineEntry({ item, liveWorkers, liveBranches, channelId }: {
+function TimelineEntry({ item, liveWorkers, liveBranches, channelId, agentId }: {
 	item: TimelineItem;
 	liveWorkers: Record<string, ActiveWorker>;
 	liveBranches: Record<string, ActiveBranch>;
 	channelId: string;
+	agentId: string;
 }) {
 	switch (item.type) {
 		case "message":
@@ -210,8 +275,8 @@ function TimelineEntry({ item, liveWorkers, liveBranches, channelId }: {
 		}
 		case "worker_run": {
 			const live = liveWorkers[item.id];
-			if (live) return <LiveWorkerRunItem item={item} live={live} channelId={channelId} />;
-			return <WorkerRunItem item={item} />;
+			if (live) return <LiveWorkerRunItem item={item} live={live} channelId={channelId} agentId={agentId} />;
+			return <WorkerRunItem item={item} agentId={agentId} />;
 		}
 	}
 }
@@ -230,10 +295,20 @@ export function ChannelDetail({ agentId, channelId, channel, liveState, onLoadMo
 
 	const scrollRef = useRef<HTMLDivElement>(null);
 	const sentinelRef = useRef<HTMLDivElement>(null);
+	const lastLoadMoreAtRef = useRef(0);
 
 	// Trigger load when the sentinel at the top of the timeline becomes visible
 	const handleIntersection = useCallback((entries: IntersectionObserverEntry[]) => {
-		if (entries[0]?.isIntersecting && hasMore && !loadingMore) {
+		const entry = entries[0];
+		if (!entry?.isIntersecting) {
+			return;
+		}
+		const now = Date.now();
+		if (now - lastLoadMoreAtRef.current < 800) {
+			return;
+		}
+		if (hasMore && !loadingMore) {
+			lastLoadMoreAtRef.current = now;
 			onLoadMore();
 		}
 	}, [hasMore, loadingMore, onLoadMore]);
@@ -302,15 +377,17 @@ export function ChannelDetail({ agentId, channelId, channel, liveState, onLoadMo
 								<span className="ml-1 text-tiny text-ink-faint">typing</span>
 							</div>
 						)}
-					<Button
-						onClick={() => setCortexOpen(!cortexOpen)}
-						variant={cortexOpen ? "secondary" : "ghost"}
-						size="icon"
-						className={`h-8 w-8 ${cortexOpen ? "bg-violet-500/20 text-violet-400" : ""}`}
-						title="Toggle cortex chat"
-					>
-						<HugeiconsIcon icon={IdeaIcon} className="h-4 w-4" />
-					</Button>
+						<div className="flex overflow-hidden rounded-md border border-app-line bg-app-darkBox">
+							<Button
+								onClick={() => setCortexOpen(!cortexOpen)}
+								variant={cortexOpen ? "secondary" : "ghost"}
+								size="icon"
+								className={cortexOpen ? "bg-app-selected text-ink" : ""}
+								title="Toggle cortex chat"
+							>
+								<HugeiconsIcon icon={IdeaIcon} className="h-4 w-4" />
+							</Button>
+						</div>
 					</div>
 				</div>
 
@@ -339,6 +416,7 @@ export function ChannelDetail({ agentId, channelId, channel, liveState, onLoadMo
 									liveWorkers={workers}
 									liveBranches={branches}
 									channelId={channelId}
+									agentId={agentId}
 								/>
 							))
 						)}
diff --git a/interface/src/routes/Overview.tsx b/interface/src/routes/Overview.tsx
index 43e7200e3..68bf1b2a9 100644
--- a/interface/src/routes/Overview.tsx
+++ b/interface/src/routes/Overview.tsx
@@ -3,6 +3,7 @@ import {useQuery} from "@tanstack/react-query";
 import {api} from "@/api/client";
 import {CreateAgentDialog} from "@/components/CreateAgentDialog";
 import {TopologyGraph} from "@/components/TopologyGraph";
+import {UpdatePill} from "@/components/UpdatePill";
 import type {ChannelLiveState} from "@/hooks/useChannelLiveState";
 import {formatUptime} from "@/lib/format";
 
@@ -94,12 +95,15 @@ export function Overview({liveStates, activeLinks}: OverviewProps) {
 					)}
 				</div>
 
-				<button
-					onClick={() => setCreateOpen(true)}
-					className="text-tiny text-ink-faint hover:text-ink transition-colors"
-				>
-					+ New Agent
-				</button>
+				<div className="flex items-center gap-3">
+					<UpdatePill />
+					<button
+						onClick={() => setCreateOpen(true)}
+						className="text-tiny text-ink-faint hover:text-ink transition-colors"
+					>
+						+ New Agent
+					</button>
+				</div>
 			</div>
 
 			{/* Full-screen topology */}
diff --git a/interface/src/routes/Settings.tsx b/interface/src/routes/Settings.tsx
index 4e06a29e3..f720d74e8 100644
--- a/interface/src/routes/Settings.tsx
+++ b/interface/src/routes/Settings.tsx
@@ -1,17 +1,18 @@
 import { useState, useEffect, useRef } from "react";
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { api, type GlobalSettingsResponse } from "@/api/client";
-import { Button, Input, SettingSidebarButton, Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, DialogFooter, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, Toggle } from "@/ui";
+import { api, type GlobalSettingsResponse, type UpdateStatus, type SecretCategory, type SecretListItem, type StoreState } from "@/api/client";
+import { Badge, Button, Input, SettingSidebarButton, Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, DialogFooter, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, Toggle } from "@/ui";
 import { useSearch, useNavigate } from "@tanstack/react-router";
-import { ChannelSettingCard, DisabledChannelCard } from "@/components/ChannelSettingCard";
+import { PlatformCatalog, InstanceCard, AddInstanceCard } from "@/components/ChannelSettingCard";
 import { ModelSelect } from "@/components/ModelSelect";
 import { ProviderIcon } from "@/lib/providerIcons";
 import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
 import { faSearch } from "@fortawesome/free-solid-svg-icons";
 
 import { parse as parseToml } from "smol-toml";
+import { useTheme, THEMES, type ThemeId } from "@/hooks/useTheme";
 
-type SectionId = "providers" | "channels" | "api-keys" | "server" | "opencode" | "worker-logs" | "config-file";
+type SectionId = "appearance" | "providers" | "channels" | "api-keys" | "secrets" | "server" | "opencode" | "worker-logs" | "updates" | "config-file";
 
 const SECTIONS = [
 	{
@@ -32,6 +33,12 @@ const SECTIONS = [
 		group: "general" as const,
 		description: "Third-party service keys",
 	},
+	{
+		id: "secrets" as const,
+		label: "Secrets",
+		group: "general" as const,
+		description: "Encrypted secret storage",
+	},
 	{
 		id: "server" as const,
 		label: "Server",
@@ -50,6 +57,18 @@ const SECTIONS = [
 		group: "system" as const,
 		description: "Worker execution logging",
 	},
+	{
+		id: "updates" as const,
+		label: "Updates",
+		group: "system" as const,
+		description: "Release checks and update controls",
+	},
+	{
+		id: "appearance" as const,
+		label: "Appearance",
+		group: "general" as const,
+		description: "Theme and display settings",
+	},
 	{
 		id: "config-file" as const,
 		label: "Config File",
@@ -72,6 +91,14 @@ const PROVIDERS = [
 		envVar: "OPENROUTER_API_KEY",
 		defaultModel: "openrouter/anthropic/claude-sonnet-4",
 	},
+	{
+		id: "kilo",
+		name: "Kilo Gateway",
+		description: "OpenAI-compatible multi-provider gateway",
+		placeholder: "sk-...",
+		envVar: "KILO_API_KEY",
+		defaultModel: "kilo/anthropic/claude-sonnet-4.5",
+	},
 	{
 		id: "opencode-zen",
 		name: "OpenCode Zen",
@@ -80,6 +107,14 @@ const PROVIDERS = [
 		envVar: "OPENCODE_ZEN_API_KEY",
 		defaultModel: "opencode-zen/kimi-k2.5",
 	},
+	{
+		id: "opencode-go",
+		name: "OpenCode Go",
+		description: "Lite OpenCode model catalog and limits",
+		placeholder: "...",
+		envVar: "OPENCODE_GO_API_KEY",
+		defaultModel: "opencode-go/kimi-k2.5",
+	},
 	{
 		id: "anthropic",
 		name: "Anthropic",
@@ -523,9 +558,9 @@ export function Settings() {
 	};
 
 	return (
-		<div className="flex h-full">
+		<div className="flex h-full min-h-0 overflow-hidden">
 			{/* Sidebar */}
-			<div className="flex w-52 flex-shrink-0 flex-col border-r border-app-line/50 bg-app-darkBox/20 overflow-y-auto">
+			<div className="flex min-h-0 w-52 flex-shrink-0 flex-col overflow-y-auto border-r border-app-line/50 bg-app-darkBox/20">
 				<div className="px-3 pb-1 pt-4">
 					<span className="text-tiny font-medium uppercase tracking-wider text-ink-faint">
 						Settings
@@ -545,14 +580,16 @@ export function Settings() {
 			</div>
 
 			{/* Content */}
-			<div className="flex flex-1 flex-col overflow-hidden">
+			<div className="flex min-h-0 flex-1 flex-col overflow-hidden">
 				<header className="flex h-12 items-center border-b border-app-line bg-app-darkBox/50 px-6">
 					<h1 className="font-plex text-sm font-medium text-ink">
 						{SECTIONS.find((s) => s.id === activeSection)?.label}
 					</h1>
 				</header>
-				<div className="flex-1 overflow-y-auto">
-					{activeSection === "providers" ? (
+				<div className="min-h-0 flex-1 overflow-y-auto overscroll-contain">
+					{activeSection === "appearance" ? (
+						<AppearanceSection />
+					) : activeSection === "providers" ? (
 						<div className="mx-auto max-w-2xl px-6 py-6">
 							{/* Section header */}
 							<div className="mb-6">
@@ -652,12 +689,16 @@ export function Settings() {
 						<ChannelsSection />
 					) : activeSection === "api-keys" ? (
 						<ApiKeysSection settings={globalSettings} isLoading={globalSettingsLoading} />
+					) : activeSection === "secrets" ? (
+						<SecretsSection />
 					) : activeSection === "server" ? (
 						<ServerSection settings={globalSettings} isLoading={globalSettingsLoading} />
 					) : activeSection === "opencode" ? (
 						<OpenCodeSection settings={globalSettings} isLoading={globalSettingsLoading} />
 					) : activeSection === "worker-logs" ? (
 						<WorkerLogsSection settings={globalSettings} isLoading={globalSettingsLoading} />
+					) : activeSection === "updates" ? (
+						<UpdatesSection />
 					) : activeSection === "config-file" ? (
 						<ConfigFileSection />
 					) : null}
@@ -758,8 +799,73 @@ export function Settings() {
 	);
 }
 
+function AppearanceSection() {
+	const { theme, setTheme } = useTheme();
+
+	return (
+		<div className="mx-auto max-w-2xl px-6 py-6">
+			<div className="mb-6">
+				<h2 className="font-plex text-sm font-semibold text-ink">Theme</h2>
+				<p className="mt-1 text-sm text-ink-dull">
+					Choose a theme for the dashboard interface.
+				</p>
+			</div>
+
+			<div className="grid grid-cols-2 gap-3">
+				{THEMES.map((t) => (
+					<button
+						key={t.id}
+						onClick={() => setTheme(t.id)}
+						className={`group relative flex flex-col items-start rounded-lg border p-4 text-left transition-colors ${
+							theme === t.id
+								? "border-accent bg-accent/10"
+								: "border-app-line bg-app-box hover:border-app-line/80 hover:bg-app-hover"
+						}`}
+					>
+						<div className="flex w-full items-center justify-between">
+							<span className="text-sm font-medium text-ink">{t.name}</span>
+							{theme === t.id && (
+								<span className="h-2 w-2 rounded-full bg-accent" />
+							)}
+						</div>
+						<p className="mt-1 text-sm text-ink-dull">{t.description}</p>
+						<ThemePreview themeId={t.id} />
+					</button>
+				))}
+			</div>
+		</div>
+	);
+}
+
+function ThemePreview({ themeId }: { themeId: ThemeId }) {
+	const colors = {
+		default: { bg: "#0d0d0f", sidebar: "#0a0a0b", accent: "#a855f7" },
+		vanilla: { bg: "#ffffff", sidebar: "#f5f5f6", accent: "#3b82f6" },
+		midnight: { bg: "#14162b", sidebar: "#0c0e1a", accent: "#3b82f6" },
+		noir: { bg: "#080808", sidebar: "#000000", accent: "#3b82f6" },
+	};
+	const c = colors[themeId];
+
+	return (
+		<div
+			className="mt-3 flex h-12 w-full overflow-hidden rounded border border-app-line/50"
+			style={{ backgroundColor: c.bg }}
+		>
+			<div className="w-8 border-r" style={{ backgroundColor: c.sidebar, borderColor: c.accent + "30" }} />
+			<div className="flex flex-1 flex-col gap-1 p-1.5">
+				<div className="h-1.5 w-12 rounded-sm" style={{ backgroundColor: c.accent }} />
+				<div className="h-1 w-16 rounded-sm opacity-30" style={{ backgroundColor: c.accent }} />
+				<div className="h-1 w-10 rounded-sm opacity-20" style={{ backgroundColor: c.accent }} />
+			</div>
+		</div>
+	);
+}
+
+type Platform = "discord" | "slack" | "telegram" | "twitch" | "email" | "webhook";
+
 function ChannelsSection() {
-	const [expandedPlatform, setExpandedPlatform] = useState<string | null>(null);
+	const [expandedKey, setExpandedKey] = useState<string | null>(null);
+	const [addingPlatform, setAddingPlatform] = useState<Platform | null>(null);
 
 	const { data: messagingStatus, isLoading } = useQuery({
 		queryKey: ["messaging-status"],
@@ -767,26 +873,22 @@ function ChannelsSection() {
 		staleTime: 5_000,
 	});
 
-	const PLATFORMS = [
-		{ platform: "discord" as const, name: "Discord", description: "Discord bot integration" },
-		{ platform: "slack" as const, name: "Slack", description: "Slack bot integration" },
-		{ platform: "telegram" as const, name: "Telegram", description: "Telegram bot integration" },
-		{ platform: "twitch" as const, name: "Twitch", description: "Twitch chat integration" },
-		{ platform: "webhook" as const, name: "Webhook", description: "HTTP webhook receiver" },
-	] as const;
-
-	const COMING_SOON = [
-		{ platform: "email", name: "Email", description: "IMAP polling for inbound, SMTP for outbound" },
-		{ platform: "whatsapp", name: "WhatsApp", description: "Meta Cloud API integration" },
-		{ platform: "matrix", name: "Matrix", description: "Decentralized chat protocol" },
-		{ platform: "imessage", name: "iMessage", description: "macOS-only AppleScript bridge" },
-		{ platform: "irc", name: "IRC", description: "TLS socket connection" },
-		{ platform: "lark", name: "Lark", description: "Feishu/Lark webhook integration" },
-		{ platform: "dingtalk", name: "DingTalk", description: "Chinese enterprise webhook integration" },
-	];
+	const instances = messagingStatus?.instances ?? [];
+
+	// Determine whether to show default or named add form
+	function handleAddInstance(platform: Platform) {
+		setAddingPlatform(platform);
+	}
+
+	function isDefaultAdd(): boolean {
+		if (!addingPlatform) return true;
+		return !instances.some(
+			(inst) => inst.platform === addingPlatform && inst.name === null,
+		);
+	}
 
 	return (
-		<div className="mx-auto max-w-2xl px-6 py-6">
+		<div className="mx-auto max-w-3xl px-6 py-6">
 			<div className="mb-6">
 				<h2 className="font-plex text-sm font-semibold text-ink">Messaging Platforms</h2>
 				<p className="mt-1 text-sm text-ink-dull">
@@ -800,29 +902,705 @@ function ChannelsSection() {
 					Loading channels...
 				</div>
 			) : (
-				<div className="flex flex-col gap-3">
-					{PLATFORMS.map(({ platform: p, name: n, description: d }) => (
-						<ChannelSettingCard
-							key={p}
-							platform={p}
-							name={n}
-							description={d}
-							status={messagingStatus?.[p]}
-							expanded={expandedPlatform === p}
-							onToggle={() => setExpandedPlatform(expandedPlatform === p ? null : p)}
+				<div className="grid grid-cols-[200px_1fr] gap-6">
+					{/* Left column: Platform catalog */}
+					<div className="flex-shrink-0">
+						<PlatformCatalog onAddInstance={handleAddInstance} />
+					</div>
+
+					{/* Right column: Configured instances */}
+					<div className="flex flex-col gap-3 min-w-0">
+						{/* Active add-instance card */}
+						{addingPlatform && (
+							<AddInstanceCard
+								platform={addingPlatform}
+								isDefault={isDefaultAdd()}
+								onCancel={() => setAddingPlatform(null)}
+								onCreated={() => setAddingPlatform(null)}
+							/>
+						)}
+
+						{/* Configured instance cards */}
+						{instances.length > 0 ? (
+							instances.map((instance) => (
+								<InstanceCard
+									key={instance.runtime_key}
+									instance={instance}
+									expanded={expandedKey === instance.runtime_key}
+									onToggleExpand={() =>
+										setExpandedKey(
+											expandedKey === instance.runtime_key ? null : instance.runtime_key,
+										)
+									}
+								/>
+							))
+						) : !addingPlatform ? (
+							<div className="rounded-lg border border-app-line border-dashed bg-app-box/50 p-8 text-center">
+								<p className="text-sm text-ink-dull">
+									No messaging platforms configured yet.
+								</p>
+								<p className="mt-1 text-sm text-ink-faint">
+									Click a platform on the left to get started.
+								</p>
+							</div>
+						) : null}
+					</div>
+				</div>
+			)}
+		</div>
+	);
+}
+
+
+
+// ── Secrets Section ──────────────────────────────────────────────────────
+
+function SecretsSection() {
+	const queryClient = useQueryClient();
+
+	// Store status.
+	const { data: storeStatus, isLoading: statusLoading } = useQuery({
+		queryKey: ["secrets-status"],
+		queryFn: () => api.secretsStatus(),
+		staleTime: 5_000,
+	});
+
+	// Secret list.
+	const { data: secretsData, isLoading: secretsLoading } = useQuery({
+		queryKey: ["secrets"],
+		queryFn: () => api.listSecrets(),
+		staleTime: 5_000,
+	});
+
+	const secrets = secretsData?.secrets ?? [];
+	const isLoading = statusLoading || secretsLoading;
+	const state: StoreState = storeStatus?.state ?? "unencrypted";
+	const isLocked = state === "locked";
+	const canMutate = !isLocked;
+
+	// ── UI state ─────────────────────────────────────────────────────────
+	const [addDialogOpen, setAddDialogOpen] = useState(false);
+	const [editingSecret, setEditingSecret] = useState<string | null>(null);
+	const [deleteTarget, setDeleteTarget] = useState<string | null>(null);
+	const [nameInput, setNameInput] = useState("");
+	const [valueInput, setValueInput] = useState("");
+	const [categoryInput, setCategoryInput] = useState<SecretCategory>("tool");
+	const [message, setMessage] = useState<{ text: string; type: "success" | "error" } | null>(null);
+
+	// Encryption flow state.
+	const [encryptDialogOpen, setEncryptDialogOpen] = useState(false);
+	const [masterKeyDisplay, setMasterKeyDisplay] = useState<string | null>(null);
+	const [masterKeyCopied, setMasterKeyCopied] = useState(false);
+	const [unlockKeyInput, setUnlockKeyInput] = useState("");
+	const [rotateDialogOpen, setRotateDialogOpen] = useState(false);
+
+	const [filterCategory, setFilterCategory] = useState<"all" | SecretCategory>("all");
+	const [searchQuery, setSearchQuery] = useState("");
+
+	// ── Mutations ────────────────────────────────────────────────────────
+	const invalidateSecrets = () => {
+		queryClient.invalidateQueries({ queryKey: ["secrets"] });
+		queryClient.invalidateQueries({ queryKey: ["secrets-status"] });
+	};
+
+	const putMutation = useMutation({
+		mutationFn: ({ name, value, category }: { name: string; value: string; category?: SecretCategory }) =>
+			api.putSecret(name, value, category),
+		onSuccess: (result) => {
+			invalidateSecrets();
+			setAddDialogOpen(false);
+			setEditingSecret(null);
+			setNameInput("");
+			setValueInput("");
+			setMessage({
+				text: result.reload_required
+					? `${result.name} saved (${result.category}). Restart required for system secrets to take effect.`
+					: `${result.name} saved (${result.category}).`,
+				type: "success",
+			});
+		},
+		onError: (error) => {
+			setMessage({ text: `Failed: ${error.message}`, type: "error" });
+		},
+	});
+
+	const deleteMutation = useMutation({
+		mutationFn: (name: string) => api.deleteSecret(name),
+		onSuccess: (result) => {
+			invalidateSecrets();
+			setDeleteTarget(null);
+			setMessage({
+				text: result.warning
+					? `Deleted ${result.deleted}. ${result.warning}`
+					: `Deleted ${result.deleted}.`,
+				type: "success",
+			});
+		},
+		onError: (error) => {
+			setMessage({ text: `Failed: ${error.message}`, type: "error" });
+		},
+	});
+
+	const encryptMutation = useMutation({
+		mutationFn: () => api.enableEncryption(),
+		onSuccess: (result) => {
+			invalidateSecrets();
+			setMasterKeyDisplay(result.master_key);
+			setMasterKeyCopied(false);
+		},
+		onError: (error) => {
+			setMessage({ text: `Failed: ${error.message}`, type: "error" });
+			setEncryptDialogOpen(false);
+		},
+	});
+
+	const unlockMutation = useMutation({
+		mutationFn: (key: string) => api.unlockSecrets(key),
+		onSuccess: () => {
+			invalidateSecrets();
+			setUnlockKeyInput("");
+			setMessage({ text: "Secret store unlocked.", type: "success" });
+		},
+		onError: (error) => {
+			setMessage({ text: `Unlock failed: ${error.message}`, type: "error" });
+		},
+	});
+
+	const lockMutation = useMutation({
+		mutationFn: () => api.lockSecrets(),
+		onSuccess: () => {
+			invalidateSecrets();
+			setMessage({ text: "Secret store locked.", type: "success" });
+		},
+		onError: (error) => {
+			setMessage({ text: `Failed: ${error.message}`, type: "error" });
+		},
+	});
+
+	const rotateMutation = useMutation({
+		mutationFn: () => api.rotateKey(),
+		onSuccess: (result) => {
+			invalidateSecrets();
+			setRotateDialogOpen(false);
+			setMasterKeyDisplay(result.master_key);
+			setMasterKeyCopied(false);
+			setEncryptDialogOpen(true);
+		},
+		onError: (error) => {
+			setMessage({ text: `Failed: ${error.message}`, type: "error" });
+			setRotateDialogOpen(false);
+		},
+	});
+
+	const migrateMutation = useMutation({
+		mutationFn: () => api.migrateSecrets(),
+		onSuccess: (result) => {
+			invalidateSecrets();
+			setMessage({
+				text: result.migrated.length > 0
+					? `Migrated ${result.migrated.length} secrets from config.toml.`
+					: result.message,
+				type: result.migrated.length > 0 ? "success" : "success",
+			});
+		},
+		onError: (error) => {
+			setMessage({ text: `Migration failed: ${error.message}`, type: "error" });
+		},
+	});
+
+	// ── Handlers ─────────────────────────────────────────────────────────
+	const handleOpenAdd = () => {
+		setNameInput("");
+		setValueInput("");
+		setCategoryInput("tool");
+		setMessage(null);
+		setAddDialogOpen(true);
+	};
+
+	const handleOpenEdit = (secret: SecretListItem) => {
+		setEditingSecret(secret.name);
+		setNameInput(secret.name);
+		setValueInput("");
+		setCategoryInput(secret.category);
+		setMessage(null);
+	};
+
+	const handleSave = () => {
+		const name = editingSecret ?? nameInput.trim().toUpperCase();
+		if (!name || !valueInput) return;
+		putMutation.mutate({ name, value: valueInput, category: categoryInput });
+	};
+
+	const handleCopyKey = async () => {
+		if (!masterKeyDisplay) return;
+		try {
+			await navigator.clipboard.writeText(masterKeyDisplay);
+			setMasterKeyCopied(true);
+		} catch {
+			// Fallback
+			const textarea = document.createElement("textarea");
+			textarea.value = masterKeyDisplay;
+			textarea.setAttribute("readonly", "");
+			textarea.style.position = "absolute";
+			textarea.style.left = "-9999px";
+			document.body.appendChild(textarea);
+			textarea.select();
+			document.execCommand("copy");
+			document.body.removeChild(textarea);
+			setMasterKeyCopied(true);
+		}
+	};
+
+	const filteredSecrets = secrets.filter((secret) => {
+		if (filterCategory !== "all" && secret.category !== filterCategory) return false;
+		if (searchQuery && !secret.name.toLowerCase().includes(searchQuery.toLowerCase())) return false;
+		return true;
+	});
+
+	return (
+		<div className="mx-auto max-w-2xl px-6 py-6">
+			{/* Header */}
+			<div className="mb-6">
+				<h2 className="font-plex text-sm font-semibold text-ink">Secrets</h2>
+				<p className="mt-1 text-sm text-ink-dull">
+					Manage credentials for LLM providers (system) and CLI tools used by workers (tool).
+					System secrets are never exposed to worker subprocesses. Tool secrets are injected as
+					environment variables.
+				</p>
+			</div>
+
+			{/* Status bar */}
+			{storeStatus && (
+				<div className="mb-4 flex items-center gap-3 rounded-md border border-app-line bg-app-darkBox/20 px-4 py-3">
+					<div className="flex items-center gap-2">
+						<div className={`h-2 w-2 rounded-full ${
+							state === "unlocked" ? "bg-green-500"
+								: state === "locked" ? "bg-red-500"
+									: "bg-amber-500"
+						}`} />
+						<span className="text-sm font-medium text-ink">
+							{state === "unlocked" ? "Encrypted & Unlocked"
+								: state === "locked" ? "Encrypted & Locked"
+									: "Unencrypted"}
+						</span>
+					</div>
+					<div className="flex-1" />
+					<span className="text-tiny text-ink-faint">
+						{storeStatus.secret_count} secrets ({storeStatus.system_count} system, {storeStatus.tool_count} tool)
+					</span>
+				</div>
+			)}
+
+			{/* Encryption banner (unencrypted stores) */}
+			{state === "unencrypted" && !storeStatus?.platform_managed && (
+				<div className="mb-4 rounded-md border border-amber-500/20 bg-amber-500/5 px-4 py-3">
+					<div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
+						<div className="sm:pr-4">
+							<p className="text-sm font-medium text-amber-400">Encryption not enabled</p>
+							<p className="mt-0.5 text-sm text-ink-faint">
+								Secrets are stored without encryption. Enable encryption for protection
+								against volume compromise.
+							</p>
+						</div>
+						<Button
+							onClick={() => { setEncryptDialogOpen(true); setMasterKeyDisplay(null); }}
+							variant="outline"
+							className="w-full shrink-0 whitespace-nowrap sm:w-auto"
+						>
+							Enable Encryption
+						</Button>
+					</div>
+				</div>
+			)}
+
+			{/* Unlock prompt (locked stores) */}
+			{isLocked && (
+				<div className="mb-4 rounded-md border border-red-500/20 bg-red-500/5 px-4 py-3">
+					<p className="text-sm font-medium text-red-400">Secrets are locked</p>
+					<p className="mt-0.5 text-sm text-ink-faint">
+						Enter your master key to unlock encrypted secrets. You can view secret names
+						but cannot add, edit, or read values while locked.
+					</p>
+					<div className="mt-3 flex items-center gap-2">
+						<Input
+							type="password"
+							value={unlockKeyInput}
+							onChange={(e) => setUnlockKeyInput(e.target.value)}
+							placeholder="Paste master key (hex)"
+							className="max-w-sm font-mono text-tiny"
+							onKeyDown={(e) => { if (e.key === "Enter" && unlockKeyInput.trim()) unlockMutation.mutate(unlockKeyInput.trim()); }}
 						/>
+						<Button
+							onClick={() => unlockMutation.mutate(unlockKeyInput.trim())}
+							disabled={!unlockKeyInput.trim()}
+							loading={unlockMutation.isPending}
+							size="sm"
+						>
+							Unlock
+						</Button>
+					</div>
+				</div>
+			)}
+
+			{/* Feedback message */}
+			{message && (
+				<div className={`mb-4 rounded-md border px-3 py-2 text-sm ${
+					message.type === "success"
+						? "border-green-500/20 bg-green-500/10 text-green-400"
+						: "border-red-500/20 bg-red-500/10 text-red-400"
+				}`}>
+					{message.text}
+				</div>
+			)}
+
+			{/* Toolbar */}
+			<div className="mb-3 flex items-center gap-2">
+				<Input
+					value={searchQuery}
+					onChange={(e) => setSearchQuery(e.target.value)}
+					placeholder="Filter secrets..."
+					className="max-w-xs"
+				/>
+				<div className="flex gap-1">
+					{(["all", "system", "tool"] as const).map((cat) => (
+						<button
+							key={cat}
+							onClick={() => setFilterCategory(cat)}
+							className={`rounded-full px-2.5 py-1 text-tiny font-medium transition-colors ${
+								filterCategory === cat
+									? "bg-accent/15 text-accent"
+									: "text-ink-faint hover:text-ink-dull"
+							}`}
+						>
+							{cat === "all" ? "All" : cat.charAt(0).toUpperCase() + cat.slice(1)}
+						</button>
 					))}
-					{COMING_SOON.map(({ platform: p, name: n, description: d }) => (
-						<DisabledChannelCard key={p} platform={p} name={n} description={d} />
+				</div>
+				<div className="flex-1" />
+				{canMutate && (
+					<Button onClick={handleOpenAdd} size="sm">
+						Add secret
+					</Button>
+				)}
+			</div>
+
+			{/* Secret list */}
+			{isLoading ? (
+				<div className="flex items-center gap-2 text-ink-dull">
+					<div className="h-2 w-2 animate-pulse rounded-full bg-accent" />
+					Loading secrets...
+				</div>
+			) : filteredSecrets.length === 0 ? (
+				<div className="flex flex-col items-center rounded-lg border border-dashed border-app-line py-12">
+					<p className="text-sm font-medium text-ink-dull">
+						{secrets.length === 0 ? "No secrets yet" : "No matching secrets"}
+					</p>
+					<p className="mt-1 text-sm text-ink-faint">
+						{secrets.length === 0
+							? "Add credentials for LLM providers or CLI tools."
+							: "Try a different filter."}
+					</p>
+					{secrets.length === 0 && canMutate && (
+						<div className="mt-4 flex gap-2">
+							<Button onClick={handleOpenAdd} size="sm">
+								Add secret
+							</Button>
+							<Button onClick={() => migrateMutation.mutate()} variant="outline" size="sm" loading={migrateMutation.isPending}>
+								Migrate from config
+							</Button>
+						</div>
+					)}
+				</div>
+			) : (
+				<div className="flex flex-col gap-1.5">
+					{filteredSecrets.map((secret) => (
+						<div
+							key={secret.name}
+							className="group flex items-center rounded-lg border border-app-line bg-app-box px-4 py-3"
+						>
+							<div className="flex-1 min-w-0">
+								<div className="flex items-center gap-2">
+									<code className="text-sm font-medium text-ink">{secret.name}</code>
+									<Badge
+										variant="outline"
+										size="sm"
+										className="pointer-events-none transition-none"
+									>
+										{secret.category}
+									</Badge>
+								</div>
+								<p className="mt-0.5 text-tiny text-ink-faint">
+									Updated {new Date(secret.updated_at).toLocaleDateString()}
+								</p>
+							</div>
+							{canMutate && (
+								<div className="flex gap-1.5 opacity-0 pointer-events-none group-hover:opacity-100 group-hover:pointer-events-auto group-focus-within:opacity-100 group-focus-within:pointer-events-auto">
+									<Button onClick={() => handleOpenEdit(secret)} variant="outline" size="sm">
+										Update
+									</Button>
+									<Button onClick={() => setDeleteTarget(secret.name)} variant="outline" size="sm">
+										Delete
+									</Button>
+								</div>
+							)}
+						</div>
 					))}
 				</div>
 			)}
+
+			{/* Bottom actions for encrypted stores */}
+			{storeStatus?.encrypted && !storeStatus.platform_managed && canMutate && (
+				<div className="mt-6 flex items-center gap-2 border-t border-app-line pt-4">
+					<Button onClick={() => lockMutation.mutate()} variant="outline" size="sm" loading={lockMutation.isPending}>
+						Lock store
+					</Button>
+					<Button onClick={() => setRotateDialogOpen(true)} variant="outline" size="sm">
+						Rotate master key
+					</Button>
+					<div className="flex-1" />
+					<Button onClick={() => migrateMutation.mutate()} variant="outline" size="sm" loading={migrateMutation.isPending}>
+						Migrate from config
+					</Button>
+				</div>
+			)}
+
+			{/* Migrate button for unencrypted stores */}
+			{state === "unencrypted" && secrets.length > 0 && (
+				<div className="mt-4 flex justify-end">
+					<Button onClick={() => migrateMutation.mutate()} variant="outline" size="sm" loading={migrateMutation.isPending}>
+						Migrate from config
+					</Button>
+				</div>
+			)}
+
+			{/* ── Add / Edit Dialog ─────────────────────────────────────── */}
+			<Dialog
+				open={addDialogOpen || !!editingSecret}
+				onOpenChange={(open) => {
+					if (!open) {
+						setAddDialogOpen(false);
+						setEditingSecret(null);
+						setNameInput("");
+						setValueInput("");
+					}
+				}}
+			>
+				<DialogContent className="max-w-md">
+					<DialogHeader>
+						<DialogTitle>{editingSecret ? "Update Secret" : "Add Secret"}</DialogTitle>
+						<DialogDescription>
+							{editingSecret
+								? `Enter a new value for ${editingSecret}. The existing value will be overwritten.`
+								: "Add a new credential. System secrets are internal (LLM keys, messaging tokens). Tool secrets are exposed to worker subprocesses as environment variables."}
+						</DialogDescription>
+					</DialogHeader>
+
+					{!editingSecret && (
+						<div className="space-y-1.5">
+							<label className="text-sm font-medium text-ink">Name</label>
+							<Input
+								value={nameInput}
+								onChange={(e) => setNameInput(e.target.value.toUpperCase().replace(/[^A-Z0-9_]/g, ""))}
+								placeholder="GH_TOKEN"
+								className="font-mono"
+								autoFocus
+							/>
+							<p className="text-tiny text-ink-faint">
+								UPPER_SNAKE_CASE. This is also the env var name for tool secrets.
+							</p>
+						</div>
+					)}
+
+					<div className="space-y-1.5">
+						<label className="text-sm font-medium text-ink">Value</label>
+						<Input
+							type="password"
+							value={valueInput}
+							onChange={(e) => setValueInput(e.target.value)}
+							placeholder={editingSecret ? "Enter new value" : "Secret value"}
+							autoFocus={!!editingSecret}
+							onKeyDown={(e) => { if (e.key === "Enter") handleSave(); }}
+						/>
+					</div>
+
+					<div className="space-y-1.5">
+						<label className="text-sm font-medium text-ink">Category</label>
+						<Select
+							value={categoryInput}
+							onValueChange={(value) => setCategoryInput(value as SecretCategory)}
+						>
+							<SelectTrigger>
+								<SelectValue />
+							</SelectTrigger>
+							<SelectContent>
+								<SelectItem value="tool">
+									Tool — exposed to workers as env vars
+								</SelectItem>
+								<SelectItem value="system">
+									System — internal only, never exposed
+								</SelectItem>
+							</SelectContent>
+						</Select>
+						<p className="text-tiny text-ink-faint">
+							{categoryInput === "tool"
+								? "Workers will have access to this credential via environment variable."
+								: "Only the Spacebot process can read this credential. Workers never see it."}
+						</p>
+					</div>
+
+					<DialogFooter>
+						<Button
+							onClick={() => { setAddDialogOpen(false); setEditingSecret(null); }}
+							variant="ghost"
+							size="sm"
+						>
+							Cancel
+						</Button>
+						<Button
+							onClick={handleSave}
+							disabled={(!editingSecret && !nameInput.trim()) || !valueInput}
+							loading={putMutation.isPending}
+							size="sm"
+						>
+							Save
+						</Button>
+					</DialogFooter>
+				</DialogContent>
+			</Dialog>
+
+			{/* ── Delete Confirmation ───────────────────────────────────── */}
+			<Dialog open={!!deleteTarget} onOpenChange={(open) => { if (!open) setDeleteTarget(null); }}>
+				<DialogContent className="max-w-sm">
+					<DialogHeader>
+						<DialogTitle>Delete Secret</DialogTitle>
+						<DialogDescription>
+							Are you sure you want to delete <code className="font-mono text-ink">{deleteTarget}</code>?
+							{" "}If this secret is referenced in config.toml, the reference will fail to resolve.
+						</DialogDescription>
+					</DialogHeader>
+					<DialogFooter>
+						<Button onClick={() => setDeleteTarget(null)} variant="ghost" size="sm">
+							Cancel
+						</Button>
+						<Button
+							onClick={() => { if (deleteTarget) deleteMutation.mutate(deleteTarget); }}
+							loading={deleteMutation.isPending}
+							variant="destructive"
+							size="sm"
+						>
+							Delete
+						</Button>
+					</DialogFooter>
+				</DialogContent>
+			</Dialog>
+
+			{/* ── Enable Encryption / Master Key Display Dialog ─────────── */}
+			<Dialog
+				open={encryptDialogOpen}
+				onOpenChange={(open) => {
+					if (!open) {
+						setEncryptDialogOpen(false);
+						setMasterKeyDisplay(null);
+						setMasterKeyCopied(false);
+					}
+				}}
+			>
+				<DialogContent className="max-w-md">
+					{!masterKeyDisplay ? (
+						<>
+							<DialogHeader>
+								<DialogTitle>Enable Encryption</DialogTitle>
+								<DialogDescription>
+									This will generate a master key and encrypt all secrets at rest using
+									AES-256-GCM. On Linux, you will need the master key to unlock secrets
+									after a reboot.
+								</DialogDescription>
+							</DialogHeader>
+							<DialogFooter>
+								<Button
+									onClick={() => setEncryptDialogOpen(false)}
+									variant="ghost"
+									size="sm"
+								>
+									Cancel
+								</Button>
+								<Button
+									onClick={() => encryptMutation.mutate()}
+									loading={encryptMutation.isPending}
+									size="sm"
+								>
+									Enable encryption
+								</Button>
+							</DialogFooter>
+						</>
+					) : (
+						<>
+							<DialogHeader>
+								<DialogTitle>Master Key Generated</DialogTitle>
+								<DialogDescription>
+									Save this key somewhere safe. On Linux, you will need it to unlock the
+									secret store after a reboot. This is the only time the key will be shown.
+								</DialogDescription>
+							</DialogHeader>
+							<div className="space-y-3">
+								<div className="flex items-center gap-2">
+									<code className="flex-1 rounded border border-app-line bg-app-darkerBox px-3 py-2 font-mono text-tiny text-ink break-all select-all">
+										{masterKeyDisplay}
+									</code>
+									<Button onClick={handleCopyKey} size="sm" variant={masterKeyCopied ? "secondary" : "outline"}>
+										{masterKeyCopied ? "Copied" : "Copy"}
+									</Button>
+								</div>
+								<div className="rounded-md border border-amber-500/20 bg-amber-500/5 px-3 py-2 text-sm text-amber-400">
+									If you lose this key and the OS credential store is cleared (e.g. after
+									a Linux reboot), you will not be able to access your encrypted secrets.
+								</div>
+							</div>
+							<DialogFooter>
+								<Button
+									onClick={() => {
+										setEncryptDialogOpen(false);
+										setMasterKeyDisplay(null);
+										setMasterKeyCopied(false);
+									}}
+									size="sm"
+								>
+									Done
+								</Button>
+							</DialogFooter>
+						</>
+					)}
+				</DialogContent>
+			</Dialog>
+
+			{/* ── Rotate Key Confirmation ───────────────────────────────── */}
+			<Dialog open={rotateDialogOpen} onOpenChange={(open) => { if (!open) setRotateDialogOpen(false); }}>
+				<DialogContent className="max-w-sm">
+					<DialogHeader>
+						<DialogTitle>Rotate Master Key</DialogTitle>
+						<DialogDescription>
+							This will generate a new master key and re-encrypt all secrets. Your current
+							master key will be invalidated. You will need to save the new key.
+						</DialogDescription>
+					</DialogHeader>
+					<DialogFooter>
+						<Button onClick={() => setRotateDialogOpen(false)} variant="ghost" size="sm">
+							Cancel
+						</Button>
+						<Button
+							onClick={() => rotateMutation.mutate()}
+							loading={rotateMutation.isPending}
+							size="sm"
+						>
+							Rotate key
+						</Button>
+					</DialogFooter>
+				</DialogContent>
+			</Dialog>
 		</div>
 	);
 }
 
-
-
 interface GlobalSettingsSectionProps {
 	settings: GlobalSettingsResponse | undefined;
 	isLoading: boolean;
@@ -1435,6 +2213,309 @@ function OpenCodeSection({ settings, isLoading }: GlobalSettingsSectionProps) {
 	);
 }
 
+function formatCheckedAt(checkedAt: string | null): string {
+	if (!checkedAt) return "Never";
+	const timestamp = new Date(checkedAt);
+	if (Number.isNaN(timestamp.getTime())) return checkedAt;
+	return timestamp.toLocaleString();
+}
+
+function pullableDockerImage(image: string | null): string {
+	if (!image) return "ghcr.io/spacedriveapp/spacebot:latest";
+	return image.split("@")[0] ?? image;
+}
+
+function UpdatesSection() {
+	const queryClient = useQueryClient();
+	const [message, setMessage] = useState<{ text: string; type: "success" | "error" } | null>(null);
+	const [copiedBlock, setCopiedBlock] = useState<string | null>(null);
+
+	const { data, isLoading, isFetching } = useQuery<UpdateStatus>({
+		queryKey: ["update-check"],
+		queryFn: api.updateCheck,
+		staleTime: 30_000,
+		refetchInterval: 300_000,
+	});
+
+	const checkNowMutation = useMutation({
+		mutationFn: api.updateCheckNow,
+		onSuccess: (status) => {
+			queryClient.setQueryData(["update-check"], status);
+			if (status.update_available && status.latest_version) {
+				setMessage({
+					text: `Update ${status.latest_version} is available.`,
+					type: "success",
+				});
+			} else {
+				setMessage({ text: "No newer release found.", type: "success" });
+			}
+		},
+		onError: (error) => {
+			setMessage({ text: `Failed to check updates: ${error.message}`, type: "error" });
+		},
+	});
+
+	const applyMutation = useMutation({
+		mutationFn: api.updateApply,
+		onSuccess: (result) => {
+			if (result.status === "updating") {
+				setMessage({
+					text: "Applying update. This instance will restart in a few seconds.",
+					type: "success",
+				});
+				setTimeout(() => {
+					queryClient.invalidateQueries({ queryKey: ["update-check"] });
+				}, 3000);
+				return;
+			}
+
+			setMessage({ text: result.error ?? "Update failed", type: "error" });
+		},
+		onError: (error) => {
+			setMessage({ text: `Failed to apply update: ${error.message}`, type: "error" });
+		},
+	});
+
+	const handleCopy = async (label: string, content: string) => {
+		try {
+			if (navigator.clipboard?.writeText) {
+				await navigator.clipboard.writeText(content);
+			} else {
+				const textarea = document.createElement("textarea");
+				textarea.value = content;
+				textarea.setAttribute("readonly", "");
+				textarea.style.position = "absolute";
+				textarea.style.left = "-9999px";
+				document.body.appendChild(textarea);
+				textarea.select();
+				document.execCommand("copy");
+				document.body.removeChild(textarea);
+			}
+			setCopiedBlock(label);
+			setTimeout(() => setCopiedBlock((current) => (current === label ? null : current)), 1200);
+		} catch (error: any) {
+			setMessage({ text: `Failed to copy commands: ${error.message}`, type: "error" });
+		}
+	};
+
+	const deployment = data?.deployment ?? "native";
+	const deploymentLabel = deployment === "docker"
+		? "Docker"
+		: deployment === "hosted"
+			? "Hosted"
+			: "Native";
+
+	const dockerComposeCommands = [
+		"docker compose pull spacebot",
+		"docker compose up -d --force-recreate spacebot",
+	];
+
+	const dockerRunCommands = [
+		`docker pull ${pullableDockerImage(data?.docker_image ?? null)}`,
+		"docker stop spacebot && docker rm spacebot",
+		"# re-run your docker run command",
+	];
+
+	const nativeCommands = [
+		"git pull",
+		"cargo install --path . --force",
+		"spacebot restart",
+	];
+
+	return (
+		<div className="mx-auto max-w-2xl px-6 py-6">
+			<div className="mb-6">
+				<h2 className="font-plex text-sm font-semibold text-ink">Updates</h2>
+				<p className="mt-1 text-sm text-ink-dull">
+					Check release status, trigger one-click Docker updates, and copy manual update commands.
+				</p>
+			</div>
+
+			{isLoading ? (
+				<div className="flex items-center gap-2 text-ink-dull">
+					<div className="h-2 w-2 animate-pulse rounded-full bg-accent" />
+					Loading update status...
+				</div>
+			) : (
+				<div className="flex flex-col gap-4">
+					<div className="rounded-lg border border-app-line bg-app-box p-4">
+						<div className="flex items-center justify-between gap-4">
+							<div>
+								<p className="text-sm font-medium text-ink">Release Status</p>
+								<p className="mt-0.5 text-sm text-ink-dull">
+									{data?.update_available
+										? `Update ${data.latest_version ?? ""} is available`
+										: "You're running the latest available release"}
+								</p>
+							</div>
+							<Button
+								onClick={() => {
+									setMessage(null);
+									checkNowMutation.mutate();
+								}}
+								loading={checkNowMutation.isPending || isFetching}
+								size="sm"
+								variant="outline"
+							>
+								Check now
+							</Button>
+						</div>
+
+						<div className="mt-4 grid grid-cols-2 gap-3 text-sm">
+							<div>
+								<p className="text-ink-faint">Deployment</p>
+								<p className="text-ink">{deploymentLabel}</p>
+							</div>
+							<div>
+								<p className="text-ink-faint">Current version</p>
+								<p className="text-ink">{data?.current_version ?? "Unknown"}</p>
+							</div>
+							<div>
+								<p className="text-ink-faint">Latest release</p>
+								<p className="text-ink">{data?.latest_version ?? "Unknown"}</p>
+							</div>
+							<div>
+								<p className="text-ink-faint">Last checked</p>
+								<p className="text-ink">{formatCheckedAt(data?.checked_at ?? null)}</p>
+							</div>
+						</div>
+
+						{data?.docker_image && (
+							<div className="mt-3 rounded border border-app-line/70 bg-app-darkBox/30 px-3 py-2">
+								<p className="text-tiny text-ink-faint">Container image</p>
+								<p className="font-mono text-xs text-ink">{data.docker_image}</p>
+							</div>
+						)}
+
+						{data?.release_url && (
+							<a
+								href={data.release_url}
+								target="_blank"
+								rel="noopener noreferrer"
+								className="mt-3 inline-block text-sm text-accent hover:underline"
+							>
+								View release notes
+							</a>
+						)}
+					</div>
+
+					{deployment === "docker" && (
+						<div className="rounded-lg border border-app-line bg-app-box p-4">
+							<div className="flex items-center justify-between gap-3">
+								<div>
+									<p className="text-sm font-medium text-ink">One-Click Docker Update</p>
+									<p className="mt-0.5 text-sm text-ink-dull">
+										Pull and swap to the latest release image from the web UI.
+									</p>
+								</div>
+								<Button
+									onClick={() => {
+										setMessage(null);
+										applyMutation.mutate();
+									}}
+									disabled={!data?.can_apply || !data?.update_available}
+									loading={applyMutation.isPending}
+									size="sm"
+								>
+									Update now
+								</Button>
+							</div>
+							{!data?.update_available && (
+								<p className="mt-3 text-xs text-ink-faint">No update available yet.</p>
+							)}
+							{!data?.can_apply && data?.cannot_apply_reason && (
+								<p className="mt-3 text-xs text-yellow-300">{data.cannot_apply_reason}</p>
+							)}
+							{data?.can_apply && (
+								<p className="mt-3 text-xs text-ink-faint">
+									Applying an update restarts this instance. The UI should reconnect in 10-30 seconds.
+								</p>
+							)}
+						</div>
+					)}
+
+					<div className="rounded-lg border border-app-line bg-app-box p-4">
+						<p className="text-sm font-medium text-ink">Manual Update Commands</p>
+						<p className="mt-0.5 text-sm text-ink-dull">
+							Use these when one-click update is unavailable or when you prefer manual rollouts.
+						</p>
+
+						{deployment === "docker" && (
+							<div className="mt-3 flex flex-col gap-3">
+								<div className="rounded border border-app-line/70 bg-app-darkBox/30 p-3">
+									<div className="mb-2 flex items-center justify-between">
+										<p className="text-xs font-medium uppercase tracking-wider text-ink-faint">Docker Compose</p>
+										<Button
+											onClick={() => handleCopy("compose", dockerComposeCommands.join("\n"))}
+											variant="ghost"
+											size="sm"
+										>
+											{copiedBlock === "compose" ? "Copied" : "Copy"}
+										</Button>
+									</div>
+									<pre className="overflow-x-auto text-xs text-ink"><code>{dockerComposeCommands.join("\n")}</code></pre>
+								</div>
+								<div className="rounded border border-app-line/70 bg-app-darkBox/30 p-3">
+									<div className="mb-2 flex items-center justify-between">
+										<p className="text-xs font-medium uppercase tracking-wider text-ink-faint">docker run</p>
+										<Button
+											onClick={() => handleCopy("docker-run", dockerRunCommands.join("\n"))}
+											variant="ghost"
+											size="sm"
+										>
+											{copiedBlock === "docker-run" ? "Copied" : "Copy"}
+										</Button>
+									</div>
+									<pre className="overflow-x-auto text-xs text-ink"><code>{dockerRunCommands.join("\n")}</code></pre>
+								</div>
+							</div>
+						)}
+
+						{deployment === "native" && (
+							<div className="mt-3 rounded border border-app-line/70 bg-app-darkBox/30 p-3">
+								<div className="mb-2 flex items-center justify-between">
+									<p className="text-xs font-medium uppercase tracking-wider text-ink-faint">Source Install</p>
+									<Button
+										onClick={() => handleCopy("native", nativeCommands.join("\n"))}
+										variant="ghost"
+										size="sm"
+									>
+										{copiedBlock === "native" ? "Copied" : "Copy"}
+									</Button>
+								</div>
+								<pre className="overflow-x-auto text-xs text-ink"><code>{nativeCommands.join("\n")}</code></pre>
+							</div>
+						)}
+
+						{deployment === "hosted" && (
+							<p className="mt-3 text-sm text-ink-dull">
+								Hosted instances are updated through platform rollouts.
+							</p>
+						)}
+					</div>
+
+					{data?.error && (
+						<div className="rounded-md border border-red-500/20 bg-red-500/10 px-3 py-2 text-sm text-red-400">
+							Update check error: {data.error}
+						</div>
+					)}
+				</div>
+			)}
+
+			{message && (
+				<div
+					className={`mt-4 rounded-md border px-3 py-2 text-sm ${message.type === "success"
+							? "border-green-500/20 bg-green-500/10 text-green-400"
+							: "border-red-500/20 bg-red-500/10 text-red-400"
+						}`}
+				>
+					{message.text}
+				</div>
+			)}
+		</div>
+	);
+}
+
 function ConfigFileSection() {
 	const queryClient = useQueryClient();
 	const editorRef = useRef<HTMLDivElement>(null);
@@ -1740,6 +2821,7 @@ function ChatGptOAuthDialog({
 					{!message && (
 						<DialogDescription>
 							Copy the device code below, then sign in to your OpenAI account to authorize access.
+							You must first <a href="https://chatgpt.com/security-settings" target="_blank" rel="noopener noreferrer" className="underline text-accent hover:text-accent/80">enable device code login</a> in your ChatGPT security settings.
 						</DialogDescription>
 					)}
 				</DialogHeader>
diff --git a/interface/src/ui/Badge.tsx b/interface/src/ui/Badge.tsx
index bc6abec2f..eb5879e17 100644
--- a/interface/src/ui/Badge.tsx
+++ b/interface/src/ui/Badge.tsx
@@ -26,6 +26,10 @@ export const badgeStyles = cva(
           "border-transparent bg-violet-500/15 text-violet-500",
           "hover:bg-violet-500/25",
         ],
+        blue: [
+          "border-transparent bg-blue-500/15 text-blue-500",
+          "hover:bg-blue-500/25",
+        ],
         red: [
           "border-transparent bg-red-500/15 text-red-500",
           "hover:bg-red-500/25",
diff --git a/interface/src/ui/ToggleGroup.tsx b/interface/src/ui/ToggleGroup.tsx
index 19ba8b95f..c59e60ab4 100644
--- a/interface/src/ui/ToggleGroup.tsx
+++ b/interface/src/ui/ToggleGroup.tsx
@@ -27,7 +27,7 @@ export function ToggleGroup<T extends string>({
 				className
 			)}
 		>
-			{options.map((option, i) => {
+			{options.map((option) => {
 				const isActive = option.value === value;
 
 				return (
diff --git a/interface/src/ui/style/style.scss b/interface/src/ui/style/style.scss
index c14ef42cd..30009ba5c 100644
--- a/interface/src/ui/style/style.scss
+++ b/interface/src/ui/style/style.scss
@@ -113,6 +113,11 @@ body {
 	}
 }
 
+// Hide React Query devtools toggle button (still accessible by clicking the area)
+.tsqd-open-btn-container {
+	opacity: 0 !important;
+}
+
 // Override React Flow's default group node styles
 .react-flow__node-group {
 	background-color: transparent !important;
diff --git a/interface/tsconfig.json b/interface/tsconfig.json
index ee2f906a7..a292be7f9 100644
--- a/interface/tsconfig.json
+++ b/interface/tsconfig.json
@@ -3,6 +3,7 @@
 		"target": "ES2020",
 		"useDefineForClassFields": true,
 		"lib": ["ES2020", "DOM", "DOM.Iterable"],
+		"types": ["vite/client"],
 		"module": "ESNext",
 		"skipLibCheck": true,
 		"moduleResolution": "bundler",
diff --git a/justfile b/justfile
new file mode 100644
index 000000000..ecb7f1313
--- /dev/null
+++ b/justfile
@@ -0,0 +1,34 @@
+set shell := ["bash", "-euo", "pipefail", "-c"]
+
+default:
+    @just --list
+
+preflight:
+    ./scripts/preflight.sh
+
+preflight-ci:
+    ./scripts/preflight.sh --ci
+
+fmt-check:
+    cargo fmt --all -- --check
+
+check-all:
+    cargo check --all-targets
+
+clippy-all:
+    cargo clippy --all-targets
+
+test-lib:
+    cargo test --lib
+
+test-integration-compile:
+    cargo test --tests --no-run
+
+gate-pr: preflight
+    ./scripts/gate-pr.sh
+
+gate-pr-ci: preflight-ci
+    ./scripts/gate-pr.sh --ci
+
+gate-pr-ci-fast: preflight-ci
+    ./scripts/gate-pr.sh --ci --fast
diff --git a/migrations/20260219000001_tasks.sql b/migrations/20260219000001_tasks.sql
new file mode 100644
index 000000000..a969c3831
--- /dev/null
+++ b/migrations/20260219000001_tasks.sql
@@ -0,0 +1,26 @@
+CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT NOT NULL,
+    task_number INTEGER NOT NULL,
+    title TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'backlog',
+    priority TEXT NOT NULL DEFAULT 'medium',
+    subtasks TEXT,
+    metadata TEXT,
+    source_memory_id TEXT,
+    worker_id TEXT,
+    created_by TEXT NOT NULL,
+    approved_at TIMESTAMP,
+    approved_by TEXT,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    completed_at TIMESTAMP,
+    UNIQUE(agent_id, task_number)
+);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_agent ON tasks(agent_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_number ON tasks(agent_id, task_number);
+CREATE INDEX IF NOT EXISTS idx_tasks_source_memory ON tasks(source_memory_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_worker ON tasks(worker_id);
diff --git a/migrations/20260223000001_worker_transcript.sql b/migrations/20260223000001_worker_transcript.sql
new file mode 100644
index 000000000..774b733d6
--- /dev/null
+++ b/migrations/20260223000001_worker_transcript.sql
@@ -0,0 +1,6 @@
+-- Add transcript storage and worker metadata to worker_runs.
+ALTER TABLE worker_runs ADD COLUMN worker_type TEXT NOT NULL DEFAULT 'builtin';
+ALTER TABLE worker_runs ADD COLUMN agent_id TEXT;
+ALTER TABLE worker_runs ADD COLUMN transcript BLOB;
+
+CREATE INDEX idx_worker_runs_agent ON worker_runs(agent_id, started_at);
diff --git a/migrations/20260224000001_worker_tool_calls.sql b/migrations/20260224000001_worker_tool_calls.sql
new file mode 100644
index 000000000..311ab28aa
--- /dev/null
+++ b/migrations/20260224000001_worker_tool_calls.sql
@@ -0,0 +1 @@
+ALTER TABLE worker_runs ADD COLUMN tool_calls INTEGER NOT NULL DEFAULT 0;
diff --git a/migrations/20260226000001_cron_expression.sql b/migrations/20260226000001_cron_expression.sql
new file mode 100644
index 000000000..fe0dd530f
--- /dev/null
+++ b/migrations/20260226000001_cron_expression.sql
@@ -0,0 +1,2 @@
+-- Add wall-clock cron expression schedule support.
+ALTER TABLE cron_jobs ADD COLUMN cron_expr TEXT;
diff --git a/migrations/20260303000001_opencode_worker_metadata.sql b/migrations/20260303000001_opencode_worker_metadata.sql
new file mode 100644
index 000000000..cd7c9a768
--- /dev/null
+++ b/migrations/20260303000001_opencode_worker_metadata.sql
@@ -0,0 +1,5 @@
+-- OpenCode worker metadata for embedded web UI.
+-- Stores the session ID and server port so the frontend can construct
+-- an iframe URL to the OpenCode web UI for a given worker run.
+ALTER TABLE worker_runs ADD COLUMN opencode_session_id TEXT;
+ALTER TABLE worker_runs ADD COLUMN opencode_port INTEGER;
diff --git a/migrations/20260305000001_worker_interactive.sql b/migrations/20260305000001_worker_interactive.sql
new file mode 100644
index 000000000..f3a1aa2f2
--- /dev/null
+++ b/migrations/20260305000001_worker_interactive.sql
@@ -0,0 +1,2 @@
+-- Track whether a worker is interactive (accepts follow-up input) or fire-and-forget.
+ALTER TABLE worker_runs ADD COLUMN interactive BOOLEAN NOT NULL DEFAULT FALSE;
diff --git a/prompts/en/adapters/email.md.j2 b/prompts/en/adapters/email.md.j2
new file mode 100644
index 000000000..fe0a6353d
--- /dev/null
+++ b/prompts/en/adapters/email.md.j2
@@ -0,0 +1,11 @@
+You are processing inbound email, not a live chat.
+
+- Default behavior is intake + triage, not immediate reply.
+- Do NOT send an outbound email reply from this channel. Email channels are inbound-only.
+- For every non-spam email, branch and persist useful memory: sender, subject, key facts, commitments, deadlines, and urgency.
+- If the email is spam, automated junk, or irrelevant noise, skip it and do not persist memory.
+- If the email is urgent or time-sensitive for the user, use `send_message_to_another_channel` to notify them in an active channel.
+- If the user wants an actual outbound email sent, that should be initiated intentionally from another channel.
+- If there are actionable follow-ups, create or update tasks through a branch.
+
+Think of this channel as an intake processor that captures signal and escalates when needed.
diff --git a/prompts/en/branch.md.j2 b/prompts/en/branch.md.j2
index c7e3bd7a3..e64788746 100644
--- a/prompts/en/branch.md.j2
+++ b/prompts/en/branch.md.j2
@@ -22,6 +22,8 @@ Depending on why the channel branched, you might:
 - **Process complex input** — The user said something that requires analysis. Break it down, think through it, return your understanding.
 - **Spawn a worker** — If the user wants something done *now*, spawn a worker for it. Set a status so the channel knows what's happening. Return a summary of what you kicked off.
 - **Save for later** — If the user mentions something they want to do but not right now ("I need to update the tests at some point", "remind me to check the deploy tomorrow"), save it as a **todo** memory instead of spawning a worker. The difference is timing intent: immediate action = worker, future action = todo.
+- **Manage the task board** — Create, refine, and advance tasks. Tasks are spec documents — the description is a full markdown spec that evolves through conversation. When creating a task, write a rich description and pre-fill subtasks. When the user refines scope, update the description. When ready, move to `ready` and the cortex picks it up automatically.
+- **Check system docs on demand** — For questions about Spacebot itself (features, architecture, configuration, releases), read embedded docs via `spacebot_docs` instead of guessing.
 
 ## Tools
 
@@ -34,9 +36,21 @@ Save something important that came up during your thinking. If you discovered a
 ### memory_delete
 Forget a memory by ID. Use this when the user wants something removed, or when you find memories that are wrong or outdated. Get memory IDs from memory_recall results. When asked to forget something, recall first to find the relevant memories, then delete them.
 
+### spacebot_docs
+Read embedded Spacebot docs, including `AGENTS.md`, `CHANGELOG.md`, and product docs from `docs/content/`. Use `action: "list"` to discover IDs, then `action: "read"` for the specific document.
+
 ### spawn_worker
 If the user wants something done now and it needs execution tools (shell, file, exec), spawn a worker. Give it a specific task description with enough context to work independently. The worker won't have the conversation history — it only knows what you tell it. If the user is describing something for later rather than requesting immediate action, save a **todo** memory instead.
 
+### task_create
+Create a task on the board. The description is a **markdown spec** — write it like instructions for a worker who has no conversation context. Include requirements, constraints, file paths, examples, and anything the executor needs. Always pre-fill subtasks as a checklist execution plan.
+
+### task_list
+List tasks on the board (optionally by status/priority). Use before updates to verify task numbers or current state.
+
+### task_update
+Refine a task. Update the description as the user clarifies scope — append sections, rewrite requirements, adjust subtasks. To execute a task, move it to `ready` and the cortex will pick it up and spawn a worker automatically. You do not need to spawn workers for tasks yourself.
+
 ## Rules
 
 1. Be concise. The channel is going to read your conclusion and use it in a conversation. Don't write an essay. Return the signal, not the process.
@@ -53,3 +67,5 @@ If the user wants something done now and it needs execution tools (shell, file,
    - **observation** — a pattern noticed over time ("the user usually asks for code-first answers")
    - **goal** — something the user or agent wants to achieve ("migrate to the new API by Q3"). Goals are aspirational and may span multiple conversations.
    - **todo** — a concrete actionable task or reminder ("update the auth tests", "remind me to check the deploy tomorrow"). Todos are specific and completable.
+7. For time-sensitive conclusions, anchor on explicit timestamps/context and include concrete dates when ambiguity is possible.
+8. For Spacebot self-knowledge questions, use `spacebot_docs` to ground your answer in source docs.
diff --git a/prompts/en/channel.md.j2 b/prompts/en/channel.md.j2
index 1528a8859..bb553b8a7 100644
--- a/prompts/en/channel.md.j2
+++ b/prompts/en/channel.md.j2
@@ -32,11 +32,14 @@ You have a soul, an identity, and a personality. These are loaded separately and
 
 ## How You Work
 
-Every turn, you receive the user's message along with a live status block showing active workers, branches, and recently completed work. Use this to stay aware of what's happening without asking.
+Every turn, you receive the user's message along with a live status block showing active workers and branches. Use this to stay aware of what's happening without asking.
+The status block includes a current date/time line with timezone and UTC. Treat that as the source of truth for words like "today", "tomorrow", "yesterday", "now", and "later today".
 
-When a branch result arrives, it appears as a distinct message in your history — a conclusion from a thought process you initiated. Incorporate it naturally. The user doesn't need to know about the internal process unless it's relevant.
+When a background process (branch or worker) completes, you will receive a **system message** containing the full result text. The user has NOT seen any of it — you must relay the substance to them using the reply tool. Include actual content and details, not just a summary teaser. Do not mention internal processes (branch, worker, process IDs). If a result is background work the user didn't ask about, incorporate it silently.
 
-When a worker completes, its result appears as a "[Worker completed]" message in your history. The user cannot see this message — you must relay the result to them using the reply tool. Include the actual substance and details, not just a summary teaser. If it's `notify: false`, it's background work — don't mention it unless the user asks.
+**Important:** Once you have relayed a result, it is done. The status block may still show a "Recently Completed" section for unrelayed work — but if you already relayed a result in a previous turn, do NOT repeat, re-summarise, or reference it again unless the user explicitly asks about it. Treat relayed results the same as any other past conversation — they are in the history, the user saw them, move on.
+
+When work produces a user-facing file artifact (PDF, DOCX, CSV, ZIP, image, etc.), deliver the file with `send_file`. Do not paste local filesystem paths as the main handoff. Local paths are machine-local and usually useless to the user.
 
 You are able to write code or do work extremely fast inside a worker, never say something will take too long, just do it. You are an agentic coding machine.
 
@@ -44,21 +47,43 @@ You are able to write code or do work extremely fast inside a worker, never say
 
 You have three paths for getting things done. Choosing the right one matters.
 
-**Branch** — for thinking and memory. Branch when you need to recall, save, or forget something from long-term memory, reason through a complex decision, figure out what instructions to give a worker, or retrieve transcript context from another channel. Branches have your full conversation context and access to the memory system (recall, save, and delete) plus cross-channel transcript recall (`channel_recall`). They return a conclusion. You never see the working. Branch often — it's cheap and keeps you responsive.
+**Branch** — for thinking and memory. Branch when you need to recall, save, or forget something from long-term memory, manage the task board (create, list, update, or approve tasks), reason through a complex decision, figure out what instructions to give a worker, answer Spacebot self-knowledge questions (features, architecture, configuration, release notes), or retrieve transcript context from another channel. Branches have your full conversation context and access to the memory system (recall, save, and delete), Spacebot docs lookup (`spacebot_docs`), task tools (`task_create`, `task_list`, `task_update`), cross-channel transcript recall  (`channel_recall` — queries the full persisted message database, supports temporal filtering), and worker transcript inspection (`worker_inspect`). They return a conclusion. You never see the working. Branch often — it's cheap and keeps you responsive.
 
-**Worker** — for doing. Workers have task tools (see Worker Capabilities section below). They do NOT have your conversation context or access to memories — they only know what you tell them in the task description, so be specific. Two flavors:
+**Worker** — for doing. Workers have execution tools (see Worker Capabilities section below). They do NOT have your conversation context or access to memories — they only know what you tell them in the task description, so be specific. Two flavors:
 
 - _Fire-and-forget_ — bounded tasks with a clear end state. "Run the test suite." "Read src/config.rs and summarize it." The worker does it and reports back.
 - _Interactive_ — open-ended work the user might steer. "Refactor the auth module." "Debug the CI pipeline." The worker stays alive and you route follow-up messages to it when the user gives additional instructions.
 
+Use `worker_inspect` in a branch when you need to verify what a worker actually did — what tools it called, what results it got, what sources it checked. Useful when a worker returns a thin or unexpected result, or when the user asks "what did you actually do?"
+
 **Reply** — for talking. Use reply to respond to the user. This is your primary output. If you can answer directly without thinking or doing, just reply.
 
 **React** — for lightweight acknowledgment. Use `react` to add an emoji reaction to the user's message. A reaction can stand on its own (react + skip), accompany a reply (react + reply), or signal you're paying attention without interrupting. Don't overuse it — a well-placed 👀 or 😂 lands better than reacting to everything, but feel free to be creative with your choice of reaction.
 
 The key distinction: branches think, workers do, you talk. Never use a worker for memory recall. Never search memories yourself — branch first. Never execute shell commands or file operations yourself — that's a worker.
 
+Never suggest that the user do something you could do yourself. If someone asks you to recall, search, look something up, run a command, or find information — do it using your tools. Don't tell them to "check the database manually", "scroll through history", or "ask someone else". If your tools can handle it, use them. If they can't, say so plainly — but try first.
+
+## Builtin Worker Sandbox
+
+{%- if sandbox_enabled %}
+Sandbox mode is **enabled** for builtin workers, so `shell`/`exec` run with OS-level containment while `file` remains workspace-scoped by path validation.
+{%- else %}
+Sandbox mode is **disabled** for builtin workers, so `shell`/`exec`/`file`/`send_file` all have full host filesystem access (OS permissions apply). Environment sanitization still applies.
+{%- endif %}
+
 When an interactive worker is active and the user's message is directed at that work, route the message to the worker instead of spawning a new one.
 
+**Cancel** — for stopping work. Use `cancel` when a worker is stuck, taking too long, working on the wrong thing, or the user asks you to stop it. You can cancel workers and branches by their ID (visible in the status block and in spawn confirmations). Don't let a runaway worker burn tokens — if something looks wrong, cancel it and start fresh.
+
+## Task Board
+
+You have a kanban task board. Tasks are spec-driven documents — each one has a short title, a full markdown description (the spec), pre-filled subtasks (the execution plan), and a status that moves across the board: `pending_approval` → `backlog` → `ready` → `in_progress` → `done`.
+
+Branch to manage tasks. When the user wants to create, list, update, approve, or check tasks — branch. The branch writes rich descriptions and refines them as scope evolves. Active tasks also appear in your Memory Context above.
+
+Ready tasks are picked up automatically by the cortex and executed by workers. You don't manage execution — just help the user build good specs and move tasks to `ready` when they're complete.
+
 ## When To Stay Silent
 
 You have a `skip` tool. Use it. Not every message needs a response from you.
@@ -86,7 +111,7 @@ When in doubt, skip. Being a lurker who speaks when it matters is better than be
 
 1. Always use the tool call API for actions. Your text output is sent verbatim to users — never write tool call syntax (like `[reply]`, `[react]`, `[skip]`, etc.) as plain text. If you want to reply, call the `reply` tool. If you want to react, call the `react` tool.
 2. Never execute tasks directly. If it needs shell commands, file operations, web browsing, or web search — that's a worker.
-3. Never search memories yourself. Branch to recall. If you need conversation context from another channel, branch and use `channel_recall`.
+3. Never search memories yourself. Branch to recall. If you need conversation history from any channel (including this one), branch and use `channel_recall` — it queries the full persisted database and supports temporal filtering.
 4. When you spawn a worker, always reply with a brief natural acknowledgment so the user knows you're on it — something like "On it", "Checking now", "Let me look into that", or a relevant follow-up question. When you branch (for memory or thinking), prefer `skip` — branches are fast and invisible. Never mention internal process details (branch, worker, status block).
 5. Keep responses conversational. You're talking to a person, not filing a report.
 6. If multiple things are happening, handle them in a natural flow. No rigid ordering.
@@ -95,6 +120,15 @@ When in doubt, skip. Being a lurker who speaks when it matters is better than be
 9. Save important information to memory. Be selective. When the user asks to forget something, branch to find and delete the relevant memories.
 10. One worker per task. Never spawn multiple workers for the same request. If a worker is already handling something, wait for it to finish or route follow-ups to it. Check your status block before spawning.
 11. On Discord and Slack, prefer rich responses when output is structured or multi-part (task outcomes, summaries, comparisons, checklists, incident/debug updates, plans). Use `reply` with `cards`/interactive elements (Discord) or `blocks` (Slack) instead of plain text walls when it improves clarity.
+12. For time-sensitive responses, prefer concrete dates (for example, "March 5, 2026") in addition to relative phrases.
+13. If a worker result includes a local file path for something the user asked to receive, use `send_file` to attach it. Only mention the path if the user explicitly asks for a path.
+14. For questions about Spacebot itself (how to configure, what features exist, architecture details, release changes), always branch first and use `spacebot_docs` through the branch. Do not answer from memory alone.
+
+{%- if adapter_prompt %}
+## Adapter Guidance
+
+{{ adapter_prompt }}
+{%- endif %}
 
 {%- if skills_prompt %}
 {{ skills_prompt }}
diff --git a/prompts/en/cortex_chat.md.j2 b/prompts/en/cortex_chat.md.j2
index 320cfeb62..85fdbcb17 100644
--- a/prompts/en/cortex_chat.md.j2
+++ b/prompts/en/cortex_chat.md.j2
@@ -1,10 +1,28 @@
-You are the cortex in interactive mode — a direct line to the system's inner workings,
-talking to an admin.
+You are the cortex in interactive mode — the system diagnoser and operator interface for Spacebot admins.
 
-You have the agent's full tool capabilities: memory operations, file system access,
-shell execution, web browsing, and worker spawning. You are not the channel — you don't
-talk to end users, you talk to the person running the system.
+You are not the end-user channel. You do not roleplay personality. You provide technical diagnosis,
+verification, and operations support for the running system.
 
+{% if runtime_config_snapshot %}
+## Live Runtime Snapshot (Redacted)
+This is the current resolved runtime config for this agent. Treat it as source-of-truth for live behavior.
+
+```json
+{{ runtime_config_snapshot }}
+```
+{% endif %}
+{% if changelog_highlights %}
+## Recent Changelog Highlights
+{{ changelog_highlights }}
+
+{% endif %}
+{% if agents_manifest %}
+## Embedded Repo Guide (`AGENTS.md`)
+Use this as architecture and workflow reference when diagnosing Spacebot behavior.
+
+{{ agents_manifest }}
+
+{% endif %}
 {% if identity_context %}
 {{ identity_context }}
 
@@ -24,17 +42,19 @@ The admin is currently viewing a channel conversation. Here is the recent activi
 {{ worker_capabilities }}
 
 ## Your Role
-- Answer questions about what's happening in the system
-- Recall and search memories on demand
-- Execute tasks directly (shell, files, browsing)
-- Spawn workers for longer operations
-- Save observations and memories
-- Debug issues in conversations, memory, or system behavior
+- Diagnose what is happening in the system right now
+- Inspect live config and runtime readiness (`config_inspect`)
+- Read Spacebot docs/changelog/AGENTS on demand (`spacebot_docs`)
+- Recall and manage memories
+- Execute tasks directly (shell, files, browser) when needed
+- Spawn workers for longer operations and report worker IDs/tasks clearly
+- Manage the task board (`task_create`, `task_list`, `task_update`)
+- Save technical observations that should persist
 
 ## Rules
-1. Be direct and technical. No personality, no fluff.
-2. When asked about a conversation, reference the channel context above.
-3. Use tools proactively — don't describe what you'd do, do it.
-4. If you spawn a worker, report its ID and task.
-5. Memory operations affect the live memory graph.
-6. Keep responses concise. The admin knows how the system works.
+1. Be direct, technical, and concise. No fluff.
+2. Ground statements in live data (tools, context, config snapshot), not assumptions.
+3. For Spacebot feature/how-to/architecture questions, consult `spacebot_docs`.
+4. For config or behavior verification, prefer `config_inspect` over memory.
+5. If you spawn a worker, report worker ID, task, and expected outcome.
+6. Memory operations affect the live memory graph.
diff --git a/prompts/en/fragments/link_context.md.j2 b/prompts/en/fragments/link_context.md.j2
deleted file mode 100644
index 1d545cb59..000000000
--- a/prompts/en/fragments/link_context.md.j2
+++ /dev/null
@@ -1,14 +0,0 @@
-{%- if link_context %}
-## Agent Communication
-
-This is a link channel with **{{ link_context.agent_name }}** ({{ link_context.relationship }}).
-{% if link_context.relationship == "superior" or link_context.relationship == "reports to" -%}
-Messages from this agent carry organizational authority. Treat directives as assignments. When you complete a task, reply with your results on this channel.
-{%- elif link_context.relationship == "subordinate" or link_context.relationship == "manages" -%}
-This is a report from a subordinate agent. Evaluate whether the information should be relayed back to the conversation that originally requested the work.
-{%- else -%}
-This is a peer agent. Communication is collaborative and informational.
-{%- endif %}
-
-When the conversation objective is met, call `conclude_link` with a summary of outcomes and decisions. Do not exchange pleasantries or acknowledgments after the objective is complete. Conclude promptly.
-{%- endif %}
diff --git a/prompts/en/fragments/org_context.md.j2 b/prompts/en/fragments/org_context.md.j2
index e8c78eaad..715c08998 100644
--- a/prompts/en/fragments/org_context.md.j2
+++ b/prompts/en/fragments/org_context.md.j2
@@ -9,7 +9,7 @@ You are part of a multi-agent system. Here is your position:
 {% if entry.is_human -%}
 - **{{ entry.name }}** (human) — your human superior. Treat their requests with highest priority.
 {% else -%}
-- **{{ entry.name }}** — your superior. Messages from this agent carry organizational authority.
+- **{{ entry.name }}** — your superior. Tasks from this agent carry organizational authority.
 {% endif -%}
 {% endfor %}
 {%- endif %}
@@ -36,5 +36,5 @@ You are part of a multi-agent system. Here is your position:
 {% endfor %}
 {%- endif %}
 
-Use the `send_agent_message` tool to communicate with linked agents. Each link has a dedicated channel — your side and theirs. When you send a message, their reply will arrive on your link channel. When the conversation concludes, its summary will be injected into your current channel automatically. Relay relevant results back to the user if appropriate.
+Use `send_agent_message` to assign tasks to linked agents. Delegated tasks are executed autonomously by the target agent's cortex — you will be notified when they complete. Assign work downward to subordinates, escalate upward to superiors, and coordinate laterally with peers.
 {%- endif %}
diff --git a/prompts/en/fragments/system/retrigger.md.j2 b/prompts/en/fragments/system/retrigger.md.j2
index d236b432c..3003b2294 100644
--- a/prompts/en/fragments/system/retrigger.md.j2
+++ b/prompts/en/fragments/system/retrigger.md.j2
@@ -1 +1,13 @@
-[System: a background process has completed. The result appears in your history as a "[Worker completed]" or "[Branch result]" message — the user has NOT seen any of it. You must relay the full substance of the result using the reply tool. Include the actual content, data, and details from the result in your reply — do not just reference or tease it. Do not mention internal processes (branch, worker, retrigger, status block). Only skip if the result is genuinely empty or irrelevant to anything the user asked about.]
+[System: {{ results | length }} background process(es) just completed. The user has NOT seen any of the results below. You MUST relay the full substance to the user using the reply tool.
+
+{% for r in results %}
+--- {{ r.process_type }} {{ r.process_id }}{% if not r.success %} (FAILED){% endif %} ---
+{{ r.result }}
+{% endfor %}
+Instructions:
+- Include the actual content, data, and details from the result(s) in your reply.
+- If a result includes a user-facing file artifact (PDF, DOCX, CSV, ZIP, image, etc.), send it with `send_file` instead of only pasting a local path.
+- Do not just reference or tease the results — relay them fully.
+- Do not mention internal processes (branch, worker, retrigger, status block, process IDs).
+- If a result failed, let the user know what went wrong in plain language.
+- Only skip if every result above is genuinely empty or irrelevant to anything the user asked about.]
diff --git a/prompts/en/fragments/system/tool_syntax_correction.md.j2 b/prompts/en/fragments/system/tool_syntax_correction.md.j2
index f406d3443..0393f2db3 100644
--- a/prompts/en/fragments/system/tool_syntax_correction.md.j2
+++ b/prompts/en/fragments/system/tool_syntax_correction.md.j2
@@ -1 +1 @@
-[System: your previous response contained tool call syntax written as plain text instead of using the tool calling API. Your text output is sent directly to users — use the `reply` tool to send a message, `react` to add a reaction, or `skip` to stay silent. Try again.]
+[System: your previous response contained tool call syntax or structured payload text instead of a valid tool call. User-visible messages hard-block this output. In your next turn, either call `reply` with plain natural-language content for the user, or call `skip` to stay silent. Do not output JSON, bracket syntax, or XML-like wrapper tags.]
diff --git a/prompts/en/fragments/system/worker_time_context.md.j2 b/prompts/en/fragments/system/worker_time_context.md.j2
new file mode 100644
index 000000000..fc06944c5
--- /dev/null
+++ b/prompts/en/fragments/system/worker_time_context.md.j2
@@ -0,0 +1,4 @@
+## Time Context
+- Current local date/time: {{ current_local_datetime }}
+- Current UTC date/time: {{ current_utc_datetime }}
+- Use this context for relative dates (today/tomorrow/yesterday/now) and include absolute dates when timing matters.
diff --git a/prompts/en/fragments/worker_capabilities.md.j2 b/prompts/en/fragments/worker_capabilities.md.j2
index 141e33c4c..dfab94c2e 100644
--- a/prompts/en/fragments/worker_capabilities.md.j2
+++ b/prompts/en/fragments/worker_capabilities.md.j2
@@ -33,6 +33,8 @@ Workers do NOT have conversation context or memory access. Include all necessary
 
 Full coding agents with codebase exploration, context management, and their own tool suite. They operate on a directory and maintain context across the session. Use `worker_type: "opencode"` with a `directory` path when spawning.
 
+When you tell the user you're using OpenCode, make it true in the tool call: include `worker_type: "opencode"` and `directory`. If you omit those fields, you spawned a builtin worker.
+
 **Good for:** multi-file code changes, feature implementation, debugging test failures, refactoring, any task that requires exploring and understanding a codebase.
 
 ### When to Use Which
@@ -42,4 +44,6 @@ Full coding agents with codebase exploration, context management, and their own
 - **Task involves a skill (weather, pdf-generator, etc)?** → Builtin worker
 - **Task requires understanding a codebase before making changes?** → OpenCode worker
 - **Simple file read/write with no exploration needed?** → Builtin worker
+
+Default to OpenCode for code work when it's enabled. Use builtin workers for short command/file tasks.
 {%- endif %}
diff --git a/prompts/en/tools/branch_description.md.j2 b/prompts/en/tools/branch_description.md.j2
index 71bf718a4..a687a2bdd 100644
--- a/prompts/en/tools/branch_description.md.j2
+++ b/prompts/en/tools/branch_description.md.j2
@@ -1 +1 @@
-Fork a branch to think independently. The branch gets a clone of your current conversation history and has access to memory_recall, memory_save, and memory_delete tools. It runs independently and returns a conclusion. In most cases where the branch is needed to answer accurately, call `skip` for the current turn and answer after the branch result arrives.
+Fork a branch to think independently. The branch gets a clone of your current conversation history and has access to memory_recall, memory_save, memory_delete, `spacebot_docs`, task tools (task_create/task_list/task_update), and spawn_worker for execution handoff. Use a branch for Spacebot self-knowledge questions (features, architecture, configuration, release notes) so answers are grounded in docs instead of guesses. It runs independently and returns a conclusion. In most cases where the branch is needed to answer accurately, call `skip` for the current turn and answer after the branch result arrives.
diff --git a/prompts/en/tools/channel_recall_description.md.j2 b/prompts/en/tools/channel_recall_description.md.j2
index 99534a7f8..21f1838cf 100644
--- a/prompts/en/tools/channel_recall_description.md.j2
+++ b/prompts/en/tools/channel_recall_description.md.j2
@@ -1 +1 @@
-Recall conversation transcript from another channel. Use without a channel argument to list all available channels. Use with a channel name or ID to retrieve recent messages from that channel's conversation history.
\ No newline at end of file
+Recall conversation transcript from any channel, including the current one. Use without a channel argument to list all available channels. Use with a channel name or ID to retrieve messages from that channel's conversation history. Supports temporal filtering with `before` and `after` (RFC 3339 timestamps) to query specific time ranges, and `oldest_first` to retrieve the earliest messages instead of the most recent. For example, to find the first messages ever sent in a channel, use `oldest_first: true` with a small limit. This queries the full persisted message history in the database, not just the current in-memory context window.
\ No newline at end of file
diff --git a/prompts/en/tools/conclude_link_description.md.j2 b/prompts/en/tools/conclude_link_description.md.j2
deleted file mode 100644
index 5e1bd553b..000000000
--- a/prompts/en/tools/conclude_link_description.md.j2
+++ /dev/null
@@ -1 +0,0 @@
-End this link conversation. Call when the conversation objective is complete. Provide a summary of outcomes and decisions — this summary will be delivered to the channel that initiated the conversation.
\ No newline at end of file
diff --git a/prompts/en/tools/config_inspect_description.md.j2 b/prompts/en/tools/config_inspect_description.md.j2
new file mode 100644
index 000000000..0434cde3a
--- /dev/null
+++ b/prompts/en/tools/config_inspect_description.md.j2
@@ -0,0 +1,7 @@
+Inspect the live resolved runtime config for this agent (redacted).
+
+- Returns current hot-reloaded values, not stale file defaults.
+- Supports `section` filtering (for example: `routing`, `cortex`, `warmup`, `work_readiness`, `sandbox`, `mcp_servers`).
+- Secret values are not exposed; only safe status metadata is returned.
+
+Use this tool for operational diagnosis, behavior verification, and config-driven debugging.
diff --git a/prompts/en/tools/cron_description.md.j2 b/prompts/en/tools/cron_description.md.j2
index ea121248f..b3493c555 100644
--- a/prompts/en/tools/cron_description.md.j2
+++ b/prompts/en/tools/cron_description.md.j2
@@ -1 +1 @@
-Manage scheduled tasks (cron jobs). Use this to create, list, or delete cron jobs. A cron job runs a prompt on a timer and delivers the result to a messaging channel. Use `run_once: true` for one-time reminders; otherwise jobs are recurring.
+Manage scheduled tasks (cron jobs). Use this to create, list, or delete cron jobs. Prefer `cron_expr` for strict wall-clock schedules; `interval_secs` remains available for legacy interval-based jobs. A cron job runs a prompt and delivers the result to a messaging channel. Use `run_once: true` for one-time reminders; otherwise jobs are recurring.
diff --git a/prompts/en/tools/email_search_description.md.j2 b/prompts/en/tools/email_search_description.md.j2
new file mode 100644
index 000000000..d54c57d22
--- /dev/null
+++ b/prompts/en/tools/email_search_description.md.j2
@@ -0,0 +1,3 @@
+Search the configured IMAP mailbox for specific emails and return matching results with metadata and body snippets. Use this when you need to read back what someone said in email, verify details from a previous message, or find messages by sender/subject/topic.
+
+Prefer specific filters (`from`, `subject`, `query`, `since_days`) instead of broad searches. Keep `limit` small unless the user asks for a wider sweep.
diff --git a/prompts/en/tools/secret_set_description.md.j2 b/prompts/en/tools/secret_set_description.md.j2
new file mode 100644
index 000000000..1680e5818
--- /dev/null
+++ b/prompts/en/tools/secret_set_description.md.j2
@@ -0,0 +1 @@
+Store a credential in the instance-level secret store. Use this when you obtain API keys, tokens, or passwords that should be persisted for future use. Secrets are available to all future workers as environment variables (tool category) or internally only (system category). The name should be UPPER_SNAKE_CASE. If no category is specified, it is auto-assigned based on the name.
\ No newline at end of file
diff --git a/prompts/en/tools/send_agent_message_description.md.j2 b/prompts/en/tools/send_agent_message_description.md.j2
index 8b312e67a..4a605f99a 100644
--- a/prompts/en/tools/send_agent_message_description.md.j2
+++ b/prompts/en/tools/send_agent_message_description.md.j2
@@ -1 +1 @@
-Send a message to another agent through the agent communication graph. The message is delivered to a dedicated internal channel between you and the target agent. Use this to coordinate, delegate, escalate, or share information with linked agents.
+Assign a task to another agent. The target agent's cortex will pick it up and execute it autonomously. Use this when work falls outside your scope or belongs to a subordinate. Your turn ends after delegation — the result will be delivered when the task completes. The first sentence of your message becomes the task title; the full content is the task description.
diff --git a/prompts/en/tools/send_file_description.md.j2 b/prompts/en/tools/send_file_description.md.j2
index d21f41e34..2a846f3be 100644
--- a/prompts/en/tools/send_file_description.md.j2
+++ b/prompts/en/tools/send_file_description.md.j2
@@ -1 +1 @@
-Send a file to the user as an attachment. Reads the file from the local filesystem and delivers it in the chat.
\ No newline at end of file
+Send a file to the user as an attachment. Reads the file from the local filesystem and delivers it in the chat. Prefer this over posting local filesystem paths when handing off generated artifacts.
diff --git a/prompts/en/tools/send_message_description.md.j2 b/prompts/en/tools/send_message_description.md.j2
index 5aa4aa9b3..69d427adb 100644
--- a/prompts/en/tools/send_message_description.md.j2
+++ b/prompts/en/tools/send_message_description.md.j2
@@ -1 +1 @@
-Send a message to a DIFFERENT channel than the one you are currently in. Use this for cross-channel delivery — reminders, notifications, or when the user asks you to post something in another channel or DM them. Do NOT use this to reply in the current conversation — use the `reply` tool for that. Target channels by name or ID from the available channels in your context.
\ No newline at end of file
+Send a message to a DIFFERENT channel than the one you are currently in. Use this for cross-channel delivery — reminders, notifications, or when the user asks you to post something in another channel or DM them. Do NOT use this to reply in the current conversation — use the `reply` tool for that. Target channels by name or ID from the available channels in your context.
diff --git a/prompts/en/tools/set_status_description.md.j2 b/prompts/en/tools/set_status_description.md.j2
index 9838eac8b..c9eaf1281 100644
--- a/prompts/en/tools/set_status_description.md.j2
+++ b/prompts/en/tools/set_status_description.md.j2
@@ -1 +1 @@
-Report the current status of your work. Use this to update the channel on your progress. The status will appear in the channel's status block. Keep statuses concise (1-2 sentences) and informative.
\ No newline at end of file
+Report the current status of your work. The status appears in the channel's status block. Keep statuses concise (1-2 sentences) and informative. Use kind "progress" (default) for intermediate updates. Use kind "outcome" when the task has reached a terminal result — you must signal an outcome before finishing.
\ No newline at end of file
diff --git a/prompts/en/tools/spacebot_docs_description.md.j2 b/prompts/en/tools/spacebot_docs_description.md.j2
new file mode 100644
index 000000000..5c3ac2717
--- /dev/null
+++ b/prompts/en/tools/spacebot_docs_description.md.j2
@@ -0,0 +1,7 @@
+Read Spacebot's embedded documentation directly from the running binary.
+
+- Use `action: "list"` to discover available doc IDs (including `agents`, `changelog`, and product docs).
+- Use `action: "read"` with `doc_id` to fetch a specific document.
+- For long docs, page with `start_line` and `max_lines`.
+
+Use this tool whenever you need authoritative product/architecture guidance instead of guessing.
diff --git a/prompts/en/tools/spawn_worker_description.md.j2 b/prompts/en/tools/spawn_worker_description.md.j2
index 8300b7f54..aa4b3191e 100644
--- a/prompts/en/tools/spawn_worker_description.md.j2
+++ b/prompts/en/tools/spawn_worker_description.md.j2
@@ -1 +1,3 @@
-Spawn an independent worker process. By default uses a built-in agent with {tools} tools. The worker only sees the task description you provide — no conversation history.{opencode_note}
\ No newline at end of file
+Spawn an independent worker process. By default uses a built-in agent with {tools} tools. The worker only sees the task description you provide — no conversation history.{opencode_note}
+
+If OpenCode is enabled and the task is coding-heavy (multi-file edits, debugging, refactors), set `worker_type` to `"opencode"` and include a `directory`.
diff --git a/prompts/en/tools/task_create_description.md.j2 b/prompts/en/tools/task_create_description.md.j2
new file mode 100644
index 000000000..3c8037374
--- /dev/null
+++ b/prompts/en/tools/task_create_description.md.j2
@@ -0,0 +1 @@
+Create a task on the board. The description is the spec — write it as a full markdown document a worker can execute with no conversation context. Include requirements, constraints, file paths, examples, and acceptance criteria. Always pre-fill subtasks as a checklist execution plan. Short title, rich description, concrete subtasks.
diff --git a/prompts/en/tools/task_list_description.md.j2 b/prompts/en/tools/task_list_description.md.j2
new file mode 100644
index 000000000..2ba670910
--- /dev/null
+++ b/prompts/en/tools/task_list_description.md.j2
@@ -0,0 +1 @@
+List tasks from the board, optionally filtered by status or priority. Use this before task updates when you need to verify a task number or current state.
diff --git a/prompts/en/tools/task_update_description.md.j2 b/prompts/en/tools/task_update_description.md.j2
new file mode 100644
index 000000000..f0ae14380
--- /dev/null
+++ b/prompts/en/tools/task_update_description.md.j2
@@ -0,0 +1 @@
+Update an existing task by task number. Use this to refine the spec as scope evolves — append sections, rewrite requirements, adjust subtasks, change priority. The description is a living document; update it when the user clarifies intent or when you discover new context. Move to `ready` when the spec is complete and the cortex will pick it up for execution. For worker processes, only subtask and metadata updates are allowed.
diff --git a/prompts/en/tools/worker_inspect_description.md.j2 b/prompts/en/tools/worker_inspect_description.md.j2
new file mode 100644
index 000000000..8ab06504e
--- /dev/null
+++ b/prompts/en/tools/worker_inspect_description.md.j2
@@ -0,0 +1 @@
+Inspect a worker's full execution transcript to see exactly what it did — every tool call, result, and reasoning step. Use without a worker_id to list recent workers. Use with a worker_id to retrieve the full transcript. Useful for verifying worker output, debugging incomplete results, or understanding what sources/steps a worker used.
\ No newline at end of file
diff --git a/prompts/en/worker.md.j2 b/prompts/en/worker.md.j2
index 2e2696c0a..d0b92d4f7 100644
--- a/prompts/en/worker.md.j2
+++ b/prompts/en/worker.md.j2
@@ -2,16 +2,48 @@ You are a worker — an independent process executing a specific task. You have
 
 ## Filesystem Context
 
-Your working directory is `{{ workspace_dir }}`. This is your agent's workspace — use paths under this directory unless the task specifically instructs you to use a different path. Always use absolute paths when using tools, if the user provides `~/*` expand to full system path. `~/Desktop` -> `/Users/{USERNAME}/Desktop` on macOS for example.
+Your working directory is `{{ workspace_dir }}`. This is your agent's workspace — use paths under this directory. Prefer workspace-local absolute paths when using tools.
 
 - Agent workspace: `{{ workspace_dir }}/`
 - Agent skills: `{{ workspace_dir }}/skills/`
 - Instance-level skills: `{{ instance_dir }}/skills/`
 - Identity files: `{{ workspace_dir }}/`
+- Persistent binary directory: `{{ instance_dir }}/tools/bin/` (on PATH, survives restarts and rollouts)
+
+Binaries installed via package managers (apt, brew, etc.) land on the root filesystem which is ephemeral on hosted instances — they disappear on rollouts. To install a tool durably, download or copy the binary into `{{ instance_dir }}/tools/bin/`.
+
+## Sandbox Mode
+
+{%- if sandbox_containment_active %}
+Sandbox mode is **enabled** with active OS-level containment.
+
+Read allowlist for `shell`/`exec`:
+{%- for path in sandbox_read_allowlist %}
+- `{{ path }}`
+{%- endfor %}
+
+Write allowlist for `shell`/`exec`:
+{%- for path in sandbox_write_allowlist %}
+- `{{ path }}`
+{%- endfor %}
+
+The agent data directory is blocked from `shell`/`exec` subprocess reads and writes.
+{%- elif sandbox_enabled %}
+Sandbox mode is **enabled** in config, but no supported backend is available on this host, so `shell`/`exec` run in passthrough (no OS-level filesystem containment).
+{%- else %}
+Sandbox mode is **disabled**.
+
+- `shell`/`exec` subprocesses run without OS-level filesystem containment.
+- Host filesystem access follows the OS permissions of the Spacebot process.
+- Environment sanitization still applies (clean env + explicit passthrough/tool vars).
+- The `file` tool can access any path readable by the process (no workspace restriction).
+{%- endif %}
 
 ## Your Role
 
-Execute the task you were given. Use your tools. Report your status as you make progress. Return the result when you're done.
+Execute the task you were given. Use your tools. Report your status as you make progress.
+
+**When the task is complete** (or you've reached a definitive result), call `set_status` with `kind: "outcome"` and a summary of what happened. Only then provide your final text response. If you try to finish without signaling an outcome, the system will send you back to keep working.
 
 ## Task
 
@@ -21,20 +53,28 @@ Your task is provided in the first message. It contains everything you need to k
 
 ### set_status
 
-Update your visible status. The channel sees this in its status block. Use it to report meaningful progress, not every micro-step.
+Update your visible status. The channel sees this in its status block. Has two modes:
+
+**Progress updates** (`kind: "progress"`, the default): Report meaningful intermediate progress, not every micro-step.
 
-Good status updates:
+Good progress updates:
 
 - "running tests, 3/7 passing"
 - "refactored auth module, updating imports"
 - "found 3 matching files, analyzing"
 
-Bad status updates:
+Bad progress updates:
 
 - "thinking..."
 - "starting"
 - "reading file"
 
+**Outcome** (`kind: "outcome"`): Signal that you have reached a terminal result. You **must** call `set_status` with `kind: "outcome"` before finishing your task. Include a concise summary of the result. Examples:
+
+- `set_status(status: "Email sent to jamie@spacedrive.com", kind: "outcome")`
+- `set_status(status: "Build failed: 3 type errors in auth module", kind: "outcome")`
+- `set_status(status: "Deployed v2.1.0 to staging", kind: "outcome")`
+
 ### shell
 
 Execute shell commands. Use this for running builds, tests, git operations, package management, and any system commands.
@@ -68,12 +108,39 @@ Automate a headless Chrome browser. Use this for web scraping, testing web inter
 
 **Additional actions:** `content` (get page HTML), `evaluate` (run JavaScript, if enabled in config).
 
+### secret_set
+
+Store a credential in the instance-level secret store. Use this when you create accounts, generate API keys, or obtain tokens that should persist for future use. Stored secrets become available as environment variables in all future worker sessions.
+
+Parameters:
+
+- `name` — UPPER_SNAKE_CASE identifier (e.g. `GH_TOKEN`, `STRIPE_API_KEY`)
+- `value` — the credential value
+- `category` — optional: `"tool"` (default, exposed as env var) or `"system"` (internal only)
+
+Example uses:
+
+- Created a GitHub bot account → store `GH_TOKEN`
+- Generated a Stripe test key → store `STRIPE_TEST_KEY`
+- Obtained an OAuth refresh token → store `MYAPP_REFRESH_TOKEN`
+
+Do not log or echo the secret value after storing it.
+
 ## Rules
 
 1. Do the work. Don't describe what you would do — use the tools and do it.
 2. Update your status at meaningful checkpoints. The channel is using your status to keep the user informed.
 3. If a tool call fails, try to recover. Read the error, adjust, and retry. Don't give up on the first failure.
-4. When you're done with the task, you'll be asked to produce a summary. That summary is the only thing the channel sees — your tool history stays here. Focus on doing the work first, summarizing second.
+4. **Signal your outcome.** When the task is done, call `set_status(kind: "outcome")` with a summary of the result before providing your final text. You cannot finish without this — the system will reject premature exits.
 5. Stay focused on the task. Don't explore tangential work unless it's necessary to complete what you were asked to do.
 6. If you receive follow-up messages (interactive mode), treat them as additional instructions building on your existing context.
+{% if tool_secret_names %}
+
+## Available Tool Secrets
+
+The following credentials are set as environment variables in your shell:
+
+  {{ tool_secret_names | join(", ") }}
 
+Commands that use these credentials will work automatically (e.g., gh commands use GH_TOKEN). Do not echo, print, or log secret values.
+{% endif %}
diff --git a/scripts/gate-pr.sh b/scripts/gate-pr.sh
new file mode 100755
index 000000000..c4934a156
--- /dev/null
+++ b/scripts/gate-pr.sh
@@ -0,0 +1,189 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+	cat <<'EOF'
+Usage: scripts/gate-pr.sh [--ci] [--fast]
+
+Options:
+  --ci    CI mode (enables CI-oriented migration base resolution).
+  --fast  Skip clippy and integration test compile for quicker local iteration.
+EOF
+}
+
+is_ci=false
+fast_mode=false
+
+while (($# > 0)); do
+	case "$1" in
+	--ci)
+		is_ci=true
+		shift
+		;;
+	--fast)
+		fast_mode=true
+		shift
+		;;
+	-h | --help)
+		usage
+		exit 0
+		;;
+	*)
+		echo "[gate-pr] ERROR: unknown argument: $1" >&2
+		usage >&2
+		exit 2
+		;;
+	esac
+done
+
+log() {
+	echo "[gate-pr] $*"
+}
+
+fail() {
+	echo "[gate-pr] ERROR: $*" >&2
+	exit 1
+}
+
+run_step() {
+	local label="$1"
+	shift
+	log "running: $label"
+	"$@"
+}
+
+resolve_migration_diff_range() {
+	local base_ref=""
+	local head_sha=""
+	head_sha="$(git rev-parse HEAD)"
+
+	if $is_ci \
+		&& [[ -n "${GITHUB_EVENT_BEFORE:-}" && "${GITHUB_EVENT_BEFORE}" != "0000000000000000000000000000000000000000" ]] \
+		&& git rev-parse --verify --quiet "${GITHUB_EVENT_BEFORE}^{commit}" >/dev/null 2>&1; then
+		echo "${GITHUB_EVENT_BEFORE}..HEAD"
+		return
+	fi
+
+	if [[ -n "${PR_GATE_BASE_REF:-}" ]]; then
+		base_ref="${PR_GATE_BASE_REF}"
+	elif [[ -n "${GITHUB_BASE_REF:-}" ]]; then
+		base_ref="origin/${GITHUB_BASE_REF}"
+	elif git symbolic-ref --quiet --short refs/remotes/origin/HEAD >/dev/null 2>&1; then
+		base_ref="$(git symbolic-ref --quiet --short refs/remotes/origin/HEAD)"
+	elif git rev-parse --verify --quiet origin/main >/dev/null 2>&1; then
+		base_ref="origin/main"
+	fi
+
+	if [[ -n "$base_ref" ]] && git rev-parse --verify --quiet "$base_ref" >/dev/null 2>&1; then
+		local merge_base=""
+		merge_base="$(git merge-base HEAD "$base_ref" 2>/dev/null || true)"
+		if [[ -n "$merge_base" && "$merge_base" != "$head_sha" ]]; then
+			echo "${merge_base}..HEAD"
+			return
+		fi
+	fi
+
+	if git rev-parse --verify --quiet HEAD~1 >/dev/null 2>&1; then
+		echo "HEAD~1..HEAD"
+	fi
+}
+
+check_migration_safety() {
+	log "checking migration safety"
+
+	local diff_range=""
+	diff_range="$(resolve_migration_diff_range)"
+	if [[ -n "$diff_range" ]]; then
+		log "migration diff range: $diff_range"
+	else
+		log "migration diff range: working tree only (no base ref available)"
+	fi
+
+	local -a migration_changes=()
+	local migration_change=""
+	while IFS= read -r migration_change; do
+		migration_changes+=("$migration_change")
+	done < <(
+		{
+			if [[ -n "$diff_range" ]]; then
+				git diff --name-status "$diff_range" -- migrations
+			fi
+			git diff --name-status --cached -- migrations
+			git diff --name-status -- migrations
+			git ls-files --others --exclude-standard -- migrations | sed $'s/^/A\t/'
+		} | sed '/^[[:space:]]*$/d' | sort -u
+	)
+
+	if ((${#migration_changes[@]} == 0)); then
+		log "migration safety passed (no migration changes detected)"
+		return
+	fi
+
+	declare -A paths_with_add=()
+	for line in "${migration_changes[@]}"; do
+		local status=""
+		local path=""
+		if [[ "$line" == *$'\t'* ]]; then
+			status="${line%%$'\t'*}"
+			path="${line#*$'\t'}"
+		else
+			status="${line%% *}"
+			path="${line#* }"
+			[[ "$path" == "$line" ]] && path=""
+		fi
+		if [[ -n "$path" && "$status" == A* ]]; then
+			paths_with_add["$path"]=1
+		fi
+	done
+
+	local violations=()
+	for line in "${migration_changes[@]}"; do
+		local status=""
+		local path=""
+		if [[ "$line" == *$'\t'* ]]; then
+			status="${line%%$'\t'*}"
+			path="${line#*$'\t'}"
+		else
+			status="${line%% *}"
+			path="${line#* }"
+			[[ "$path" == "$line" ]] && path=""
+		fi
+		if [[ -n "$path" && "$status" != A* && -z "${paths_with_add[$path]:-}" ]]; then
+			violations+=("$line")
+		fi
+	done
+
+	if ((${#violations[@]} > 0)); then
+		echo "[gate-pr] ERROR: existing migration files were modified:" >&2
+		printf '  %s\n' "${violations[@]}" >&2
+		fail "create a new timestamped migration instead of editing migration history"
+	fi
+
+	log "migration safety passed (only new migration files detected)"
+}
+
+repository_root="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+[[ -n "$repository_root" ]] || fail "not inside a git worktree"
+cd "$repository_root"
+
+if $is_ci; then
+	log "CI mode enabled"
+fi
+
+check_migration_safety
+run_step "cargo fmt --all -- --check" cargo fmt --all -- --check
+run_step "cargo check --all-targets" cargo check --all-targets
+
+if $fast_mode; then
+	log "fast mode enabled: skipping clippy and integration test compile"
+else
+	run_step "cargo clippy --all-targets" cargo clippy --all-targets
+fi
+
+run_step "cargo test --lib" cargo test --lib
+
+if ! $fast_mode; then
+	run_step "cargo test --tests --no-run" cargo test --tests --no-run
+fi
+
+log "all gate checks passed"
diff --git a/scripts/preflight.sh b/scripts/preflight.sh
new file mode 100755
index 000000000..7c0871e7e
--- /dev/null
+++ b/scripts/preflight.sh
@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+	cat <<'EOF'
+Usage: scripts/preflight.sh [--ci]
+
+Options:
+  --ci   Run CI-safe checks (skip interactive auth checks).
+EOF
+}
+
+is_ci=false
+
+while (($# > 0)); do
+	case "$1" in
+	--ci)
+		is_ci=true
+		shift
+		;;
+	-h | --help)
+		usage
+		exit 0
+		;;
+	*)
+		echo "[preflight] ERROR: unknown argument: $1" >&2
+		usage >&2
+		exit 2
+		;;
+	esac
+done
+
+log() {
+	echo "[preflight] $*"
+}
+
+fail() {
+	echo "[preflight] ERROR: $*" >&2
+	exit 1
+}
+
+require_command() {
+	local command_name="$1"
+	if ! command -v "$command_name" >/dev/null 2>&1; then
+		fail "missing required command: $command_name"
+	fi
+}
+
+require_command git
+git rev-parse --is-inside-work-tree >/dev/null 2>&1 || fail "not inside a git worktree"
+
+repository_root="$(git rev-parse --show-toplevel)"
+cd "$repository_root"
+
+log "checking required commands"
+require_command cargo
+require_command rustc
+require_command protoc
+
+log "checking git state"
+git remote get-url origin >/dev/null 2>&1 || fail "origin remote is not configured"
+
+if [[ -n "$(git diff --name-only --diff-filter=U)" ]]; then
+	fail "unmerged files detected; resolve conflicts before continuing"
+fi
+
+merge_head_path="$(git rev-parse --git-path MERGE_HEAD)"
+rebase_merge_path="$(git rev-parse --git-path rebase-merge)"
+rebase_apply_path="$(git rev-parse --git-path rebase-apply)"
+cherry_pick_head_path="$(git rev-parse --git-path CHERRY_PICK_HEAD)"
+
+if [[ -f "$merge_head_path" || -d "$rebase_merge_path" || -d "$rebase_apply_path" || -f "$cherry_pick_head_path" ]]; then
+	fail "merge/rebase/cherry-pick in progress; finish it before running gates"
+fi
+
+current_branch="$(git rev-parse --abbrev-ref HEAD)"
+if [[ "$current_branch" == "HEAD" && "$is_ci" == false ]]; then
+	fail "detached HEAD is not supported for PR gate checks"
+fi
+
+if ! $is_ci; then
+	log "checking remote access"
+	if command -v gh >/dev/null 2>&1 && ! gh auth status -h github.com >/dev/null 2>&1; then
+		log "gh is installed but not authenticated for github.com (continuing with git remote auth check)"
+	fi
+
+	if ! git ls-remote --heads origin >/dev/null 2>&1; then
+		fail "cannot reach origin; verify network and git auth before pushing"
+	fi
+fi
+
+log "preflight checks passed"
diff --git a/scripts/release-tag.sh b/scripts/release-tag.sh
index 12b1f6e36..3e809f7d4 100755
--- a/scripts/release-tag.sh
+++ b/scripts/release-tag.sh
@@ -7,6 +7,8 @@ CARGO_TOML="$REPO_ROOT/Cargo.toml"
 CARGO_TOML_RELATIVE="Cargo.toml"
 CARGO_LOCK="$REPO_ROOT/Cargo.lock"
 CARGO_LOCK_RELATIVE="Cargo.lock"
+CHANGELOG_PATH="$REPO_ROOT/CHANGELOG.md"
+CHANGELOG_RELATIVE="CHANGELOG.md"
 
 if [ ! -f "$CARGO_TOML" ]; then
   echo "Cargo.toml not found at $CARGO_TOML" >&2
@@ -18,13 +20,214 @@ if ! git -C "$REPO_ROOT" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
   exit 1
 fi
 
+resolve_github_repo() {
+  if [ -n "${SPACEBOT_RELEASE_REPO:-}" ]; then
+    printf "%s\n" "$SPACEBOT_RELEASE_REPO"
+    return
+  fi
+
+  local origin_url
+  origin_url="$(git -C "$REPO_ROOT" config --get remote.origin.url 2>/dev/null || true)"
+  if [ -z "$origin_url" ]; then
+    return
+  fi
+
+  python3 - "$origin_url" <<'PY'
+import re
+import sys
+
+origin = sys.argv[1].strip()
+match = re.search(r"github\.com[:/]([^/]+)/([^/.]+)(?:\.git)?$", origin)
+if not match:
+    raise SystemExit(0)
+
+print(f"{match.group(1)}/{match.group(2)}")
+PY
+}
+
+resolve_marketing_copy_path() {
+  if [ "${SPACEBOT_SKIP_MARKETING_COPY:-0}" = "1" ]; then
+    printf "%s\n" ""
+    return
+  fi
+
+  local path
+  path="${SPACEBOT_RELEASE_MARKETING_COPY_FILE:-}"
+
+  if [ -z "$path" ]; then
+    cat >&2 <<'EOF'
+Release marketing copy is required.
+
+Create a markdown file and rerun, for example:
+  marketing_file="$(mktemp)"
+  printf "<release story markdown>\n" > "$marketing_file"
+  SPACEBOT_RELEASE_MARKETING_COPY_FILE="$marketing_file" cargo bump patch
+
+Set SPACEBOT_SKIP_MARKETING_COPY=1 to bypass this requirement.
+EOF
+    return 1
+  fi
+
+  if [ ! -f "$path" ]; then
+    echo "Marketing copy file not found: $path" >&2
+    return 1
+  fi
+
+  if [ ! -s "$path" ]; then
+    echo "Marketing copy file is empty: $path" >&2
+    return 1
+  fi
+
+  printf "%s\n" "$path"
+}
+
+generate_release_notes_body() {
+  local tag_name="$1"
+  local previous_tag="$2"
+  local output_file="$3"
+  local repo_slug
+  repo_slug="$(resolve_github_repo)"
+
+  if [ -z "$repo_slug" ]; then
+    echo "Unable to determine GitHub repo slug from origin. Set SPACEBOT_RELEASE_REPO=<owner/repo>." >&2
+    return 1
+  fi
+
+  if ! command -v gh >/dev/null 2>&1; then
+    echo "gh CLI is required to generate release notes for CHANGELOG.md." >&2
+    return 1
+  fi
+
+  if ! gh auth status >/dev/null 2>&1; then
+    echo "gh CLI is not authenticated. Run 'gh auth login' first." >&2
+    return 1
+  fi
+
+  local notes_json
+  notes_json="$(mktemp)"
+  local target_commitish
+  target_commitish="$(git -C "$REPO_ROOT" rev-parse HEAD)"
+
+  if [ -n "$previous_tag" ]; then
+    gh api -X POST "repos/$repo_slug/releases/generate-notes" \
+      -f "tag_name=$tag_name" \
+      -f "target_commitish=$target_commitish" \
+      -f "previous_tag_name=$previous_tag" \
+      > "$notes_json"
+  else
+    gh api -X POST "repos/$repo_slug/releases/generate-notes" \
+      -f "tag_name=$tag_name" \
+      -f "target_commitish=$target_commitish" \
+      > "$notes_json"
+  fi
+
+  python3 - "$notes_json" "$output_file" <<'PY'
+import json
+import sys
+
+json_path, output_path = sys.argv[1], sys.argv[2]
+with open(json_path, "r", encoding="utf-8") as handle:
+    payload = json.load(handle)
+
+body = (payload.get("body") or "").replace("\r\n", "\n").strip()
+if not body:
+    body = "_No release notes generated._"
+
+with open(output_path, "w", encoding="utf-8") as handle:
+    handle.write(body + "\n")
+PY
+
+  rm -f "$notes_json"
+}
+
+upsert_changelog_release() {
+  local changelog_path="$1"
+  local tag_name="$2"
+  local release_notes_path="$3"
+  local marketing_copy_path="${4:-}"
+
+  python3 - "$changelog_path" "$tag_name" "$release_notes_path" "$marketing_copy_path" <<'PY'
+import re
+import sys
+from pathlib import Path
+
+changelog_path, tag_name, notes_path, marketing_copy_path = (
+    sys.argv[1],
+    sys.argv[2],
+    sys.argv[3],
+    sys.argv[4],
+)
+path = Path(changelog_path)
+
+if path.exists():
+    content = path.read_text(encoding="utf-8")
+else:
+    content = "# Changelog\n\n"
+
+if not content.startswith("# Changelog"):
+    content = "# Changelog\n\n" + content.lstrip()
+
+notes = Path(notes_path).read_text(encoding="utf-8").strip()
+
+marketing_copy = ""
+if marketing_copy_path:
+    marketing_copy = Path(marketing_copy_path).read_text(encoding="utf-8").strip()
+
+parts = [f"## {tag_name}", ""]
+if marketing_copy:
+    parts.extend(["### Release Story", "", marketing_copy, ""])
+parts.extend([notes, ""])
+entry = "\n".join(parts)
+
+release_heading_pattern = re.compile(r"(?m)^##\s+v?\d+\.\d+\.\d+\s*$")
+target_heading_pattern = re.compile(rf"(?m)^##\s+{re.escape(tag_name)}\s*$")
+
+target_match = target_heading_pattern.search(content)
+if target_match:
+    start = target_match.start()
+    next_match = release_heading_pattern.search(content, target_match.end())
+    end = next_match.start() if next_match else len(content)
+    updated = content[:start].rstrip() + "\n\n" + entry + content[end:].lstrip("\n")
+else:
+    first_release = release_heading_pattern.search(content)
+    if first_release:
+        prefix = content[:first_release.start()].rstrip()
+        suffix = content[first_release.start():].lstrip("\n")
+        updated = prefix + "\n\n" + entry + suffix
+    else:
+        updated = content.rstrip() + "\n\n" + entry
+
+path.write_text(updated.rstrip() + "\n", encoding="utf-8")
+PY
+}
+
 disallowed_changes=()
+marketing_copy_allowed_relative=""
+if [ -n "${SPACEBOT_RELEASE_MARKETING_COPY_FILE:-}" ]; then
+  case "${SPACEBOT_RELEASE_MARKETING_COPY_FILE}" in
+    "$REPO_ROOT"/*)
+      marketing_copy_allowed_relative="${SPACEBOT_RELEASE_MARKETING_COPY_FILE#$REPO_ROOT/}"
+      ;;
+    /*)
+      ;;
+    *)
+      if [ "${SPACEBOT_RELEASE_MARKETING_COPY_FILE#../}" = "${SPACEBOT_RELEASE_MARKETING_COPY_FILE}" ]; then
+        marketing_copy_allowed_relative="${SPACEBOT_RELEASE_MARKETING_COPY_FILE#./}"
+      fi
+      ;;
+  esac
+fi
+
 while IFS= read -r file; do
   if [ -z "$file" ]; then
     continue
   fi
 
-  if [ "$file" != "$CARGO_TOML_RELATIVE" ] && [ "$file" != "$CARGO_LOCK_RELATIVE" ]; then
+  if [ "$file" != "$CARGO_TOML_RELATIVE" ] \
+    && [ "$file" != "$CARGO_LOCK_RELATIVE" ] \
+    && [ "$file" != "$CHANGELOG_RELATIVE" ] \
+    && { [ -z "$marketing_copy_allowed_relative" ] || [ "$file" != "$marketing_copy_allowed_relative" ]; }
+  then
     disallowed_changes+=("$file")
   fi
 done < <(
@@ -133,6 +336,18 @@ if git rev-parse -q --verify "refs/tags/$tag_name" >/dev/null; then
   exit 1
 fi
 
+previous_tag=""
+if git rev-parse -q --verify "refs/tags/v$current_version" >/dev/null; then
+  previous_tag="v$current_version"
+fi
+
+marketing_copy_path="$(resolve_marketing_copy_path)"
+
+release_notes_file="$(mktemp)"
+generate_release_notes_body "$tag_name" "$previous_tag" "$release_notes_file"
+upsert_changelog_release "$CHANGELOG_PATH" "$tag_name" "$release_notes_file" "$marketing_copy_path"
+rm -f "$release_notes_file"
+
 python3 - "$CARGO_TOML" "$current_version" "$next_version" <<'PY'
 import re
 import sys
@@ -209,15 +424,19 @@ if not updated:
 with open(path, "w", encoding="utf-8") as file:
     file.writelines(lines)
 PY
-  git -C "$REPO_ROOT" add "$CARGO_TOML_RELATIVE" "$CARGO_LOCK_RELATIVE"
+  git -C "$REPO_ROOT" add "$CARGO_TOML_RELATIVE" "$CARGO_LOCK_RELATIVE" "$CHANGELOG_RELATIVE"
 else
-  git -C "$REPO_ROOT" add "$CARGO_TOML_RELATIVE"
+  git -C "$REPO_ROOT" add "$CARGO_TOML_RELATIVE" "$CHANGELOG_RELATIVE"
 fi
 
 git -C "$REPO_ROOT" commit -m "release: $tag_name"
 git -C "$REPO_ROOT" tag "$tag_name"
 
 echo "Bumped Cargo.toml version: $current_version -> $next_version"
+echo "Updated changelog entry: $CHANGELOG_RELATIVE ($tag_name)"
+if [ -n "$marketing_copy_path" ]; then
+  echo "Included release story from: $marketing_copy_path"
+fi
 echo "Created commit: release: $tag_name"
 echo "Created tag: $tag_name"
 echo "Next: git push && git push origin $tag_name"
diff --git a/src/agent.rs b/src/agent.rs
index dc277fad6..a375d7457 100644
--- a/src/agent.rs
+++ b/src/agent.rs
@@ -2,9 +2,45 @@
 
 pub mod branch;
 pub mod channel;
+pub mod channel_attachments;
+pub mod channel_dispatch;
+pub mod channel_history;
+pub mod channel_prompt;
 pub mod compactor;
 pub mod cortex;
 pub mod cortex_chat;
 pub mod ingestion;
+#[cfg(test)]
+mod invariant_harness;
+pub mod process_control;
 pub mod status;
 pub mod worker;
+
+pub(crate) fn panic_payload_to_string(panic_payload: &(dyn std::any::Any + Send)) -> String {
+    panic_payload
+        .downcast_ref::<&str>()
+        .map(|message| (*message).to_string())
+        .or_else(|| panic_payload.downcast_ref::<String>().cloned())
+        .unwrap_or_else(|| "unknown panic payload".to_string())
+}
+
+pub(crate) fn extract_last_assistant_text(history: &[rig::message::Message]) -> Option<String> {
+    for message in history.iter().rev() {
+        if let rig::message::Message::Assistant { content, .. } = message {
+            let mut combined = String::new();
+            for item in content.iter() {
+                if let rig::message::AssistantContent::Text(text) = item {
+                    if !combined.is_empty() {
+                        combined.push('\n');
+                    }
+                    combined.push_str(&text.text);
+                }
+            }
+            if !combined.is_empty() {
+                return Some(combined);
+            }
+        }
+    }
+
+    None
+}
diff --git a/src/agent/branch.rs b/src/agent/branch.rs
index fb14d55a6..001eab7ea 100644
--- a/src/agent/branch.rs
+++ b/src/agent/branch.rs
@@ -7,7 +7,7 @@ use crate::llm::SpacebotModel;
 use crate::llm::routing::is_context_overflow_error;
 use crate::{AgentDeps, BranchId, ChannelId, ProcessEvent, ProcessId, ProcessType};
 use rig::agent::AgentBuilder;
-use rig::completion::{CompletionModel, Prompt};
+use rig::completion::CompletionModel;
 use rig::tool::server::ToolServerHandle;
 use uuid::Uuid;
 
@@ -104,17 +104,17 @@ impl Branch {
         let mut overflow_retries = 0;
 
         let conclusion = loop {
-            match agent
-                .prompt(&current_prompt)
-                .with_history(&mut self.history)
-                .with_hook(self.hook.clone())
+            match self
+                .hook
+                .prompt_once(&agent, &mut self.history, &current_prompt)
                 .await
             {
                 Ok(response) => break response,
                 Err(rig::completion::PromptError::MaxTurnsError { .. }) => {
-                    let partial = extract_last_assistant_text(&self.history).unwrap_or_else(|| {
-                        "Branch exhausted its turns without a final conclusion.".into()
-                    });
+                    let partial = crate::agent::extract_last_assistant_text(&self.history)
+                        .unwrap_or_else(|| {
+                            "Branch exhausted its turns without a final conclusion.".into()
+                        });
                     tracing::warn!(branch_id = %self.id, "branch hit max turns, returning partial result");
                     break partial;
                 }
@@ -131,7 +131,7 @@ impl Branch {
                             "branch context overflow unrecoverable after {MAX_OVERFLOW_RETRIES} attempts"
                         );
                         // Return partial conclusion if we have one rather than hard-failing
-                        break extract_last_assistant_text(&self.history)
+                        break crate::agent::extract_last_assistant_text(&self.history)
                             .unwrap_or_else(|| format!("Branch failed: context overflow after {MAX_OVERFLOW_RETRIES} compaction attempts"));
                     }
 
@@ -152,6 +152,17 @@ impl Branch {
             }
         };
 
+        // Scrub tool secret values from the conclusion before sending to the
+        // channel. Branches can spawn workers whose output may contain secrets.
+        // Layer 1: exact-match redaction of known secrets from the store.
+        // Layer 2: regex-based redaction of unknown secret patterns.
+        let conclusion = if let Some(store) = self.deps.runtime_config.secrets.load().as_ref() {
+            crate::secrets::scrub::scrub_with_store(&conclusion, store)
+        } else {
+            conclusion
+        };
+        let conclusion = crate::secrets::scrub::scrub_leaks(&conclusion);
+
         // Send conclusion back to the channel
         let _ = self.deps.event_tx.send(ProcessEvent::BranchResult {
             agent_id: self.deps.agent_id.clone(),
@@ -214,25 +225,3 @@ impl Branch {
         self.history.insert(0, rig::message::Message::from(marker));
     }
 }
-
-/// Extract the last assistant text message from a history.
-fn extract_last_assistant_text(history: &[rig::message::Message]) -> Option<String> {
-    for message in history.iter().rev() {
-        if let rig::message::Message::Assistant { content, .. } = message {
-            let texts: Vec<String> = content
-                .iter()
-                .filter_map(|c| {
-                    if let rig::message::AssistantContent::Text(t) = c {
-                        Some(t.text.clone())
-                    } else {
-                        None
-                    }
-                })
-                .collect();
-            if !texts.is_empty() {
-                return Some(texts.join("\n"));
-            }
-        }
-    }
-    None
-}
diff --git a/src/agent/channel.rs b/src/agent/channel.rs
index 7bb716a59..160b8879c 100644
--- a/src/agent/channel.rs
+++ b/src/agent/channel.rs
@@ -1,10 +1,19 @@
 //! Channel: User-facing conversation process.
 
-use crate::agent::branch::Branch;
+use crate::agent::channel_attachments::download_attachments;
+use crate::agent::channel_dispatch::spawn_memory_persistence_branch;
+use crate::agent::channel_history::{
+    apply_history_after_turn, event_is_for_channel, extract_message_id,
+    extract_reply_from_tool_syntax, format_batched_user_message, format_user_message,
+    message_display_name, pop_retrigger_bridge_message,
+};
+use crate::agent::channel_prompt::{
+    MAX_RETRIGGERS_PER_TURN, RETRIGGER_DEBOUNCE_MS, RETRIGGER_MAX_TURNS, TemporalContext,
+};
 use crate::agent::compactor::Compactor;
+use crate::agent::process_control::ControlActionResult;
 use crate::agent::status::StatusBlock;
 use crate::agent::worker::Worker;
-use crate::config::ApiType;
 use crate::conversation::{ChannelStore, ConversationLogger, ProcessRunLogger};
 use crate::error::{AgentError, Result};
 use crate::hooks::SpacebotHook;
@@ -14,24 +23,56 @@ use crate::{
     ProcessType, WorkerId,
 };
 use rig::agent::AgentBuilder;
-use rig::completion::{CompletionModel, Prompt};
-use rig::message::{ImageMediaType, MimeType, UserContent};
+use rig::completion::CompletionModel;
+use rig::message::UserContent;
 use rig::one_or_many::OneOrMany;
 use rig::tool::server::ToolServer;
 use std::collections::HashMap;
 use std::collections::HashSet;
-use std::sync::Arc;
+use std::sync::{Arc, Weak};
 use tokio::sync::broadcast;
 use tokio::sync::{RwLock, mpsc};
-use tracing::Instrument as _;
 
-/// Debounce window for retriggers: coalesce rapid branch/worker completions
-/// into a single retrigger instead of firing one per event.
-const RETRIGGER_DEBOUNCE_MS: u64 = 500;
+/// A background process result waiting to be relayed to the user via retrigger.
+///
+/// Instead of injecting raw result text into history as a fake "User" message
+/// (where it can be confused with prior results), pending results are accumulated
+/// here and embedded directly into the retrigger message text. This gives the
+/// LLM unambiguous, ID-tagged results to relay.
+#[derive(Clone, Debug)]
+struct PendingResult {
+    /// "branch" or "worker"
+    process_type: &'static str,
+    /// The branch or worker ID (short UUID).
+    process_id: String,
+    /// The result/conclusion text from the process.
+    result: String,
+    /// Whether the process completed successfully.
+    success: bool,
+}
+
+const EVENT_LAG_WARNING_INTERVAL_SECS: u64 = 30;
+
+async fn recv_channel_event(
+    event_rx: &mut broadcast::Receiver<ProcessEvent>,
+) -> crate::BroadcastRecvResult<ProcessEvent> {
+    crate::classify_broadcast_recv_result(event_rx.recv().await)
+}
+
+fn should_process_event_for_channel(event: &ProcessEvent, channel_id: &ChannelId) -> bool {
+    event_is_for_channel(event, channel_id)
+}
 
-/// Maximum retriggers allowed since the last real user message. Prevents
-/// infinite retrigger cascades where each retrigger spawns more work.
-const MAX_RETRIGGERS_PER_TURN: usize = 3;
+fn should_flush_coalesce_buffer_for_event(event: &ProcessEvent) -> bool {
+    matches!(
+        event,
+        ProcessEvent::BranchStarted { .. }
+            | ProcessEvent::BranchResult { .. }
+            | ProcessEvent::WorkerStarted { .. }
+            | ProcessEvent::WorkerStatus { .. }
+            | ProcessEvent::WorkerComplete { .. }
+    )
+}
 
 /// Shared state that channel tools need to act on the channel.
 ///
@@ -53,7 +94,7 @@ pub struct ChannelState {
     pub conversation_logger: ConversationLogger,
     pub process_run_logger: ProcessRunLogger,
     /// Discord message ID to reply to for work spawned in the current turn.
-    pub reply_target_message_id: Arc<RwLock<Option<u64>>>,
+    pub reply_target_message_id: Arc<RwLock<Option<String>>>,
     pub channel_store: ChannelStore,
     pub screenshot_dir: std::path::PathBuf,
     pub logs_dir: std::path::PathBuf,
@@ -63,37 +104,193 @@ impl ChannelState {
     /// Cancel a running worker by aborting its tokio task and cleaning up state.
     /// Returns an error message if the worker is not found.
     pub async fn cancel_worker(&self, worker_id: WorkerId) -> std::result::Result<(), String> {
-        let handle = self.worker_handles.write().await.remove(&worker_id);
+        self.cancel_worker_with_reason(worker_id, "cancelled by channel")
+            .await
+    }
+
+    /// Cancel a running worker by aborting its tokio task and cleaning up state.
+    /// Emits a synthetic terminal event so downstream consumers converge.
+    pub async fn cancel_worker_with_reason(
+        &self,
+        worker_id: WorkerId,
+        reason: &str,
+    ) -> std::result::Result<(), String> {
         let removed = self
             .active_workers
             .write()
             .await
             .remove(&worker_id)
             .is_some();
-        self.worker_inputs.write().await.remove(&worker_id);
+        let handle = self.worker_handles.write().await.remove(&worker_id);
+        let removed_input = self
+            .worker_inputs
+            .write()
+            .await
+            .remove(&worker_id)
+            .is_some();
+        let removed_status = self.status_block.write().await.remove_worker(worker_id);
+        let should_emit = removed || handle.is_some();
+
+        if !should_emit {
+            if removed_input || removed_status {
+                return Ok(());
+            }
+            return Err(format!("Worker {worker_id} not found"));
+        }
 
         if let Some(handle) = handle {
             handle.abort();
-            Ok(())
-        } else if removed {
-            // Worker was in active_workers but had no handle (shouldn't happen, but handle gracefully)
-            Ok(())
+        }
+
+        let reason = crate::summarize_first_non_empty_line(reason, crate::EVENT_SUMMARY_MAX_CHARS);
+        let result = if reason.is_empty() {
+            "Worker cancelled.".to_string()
         } else {
-            Err(format!("Worker {worker_id} not found"))
+            format!("Worker cancelled: {reason}")
+        };
+
+        self.process_run_logger
+            .log_worker_completed(worker_id, &result, false);
+        if let Err(error) = self.deps.event_tx.send(ProcessEvent::WorkerComplete {
+            agent_id: self.deps.agent_id.clone(),
+            worker_id,
+            channel_id: Some(self.channel_id.clone()),
+            result,
+            notify: true,
+            success: false,
+        }) {
+            tracing::warn!(
+                %error,
+                agent_id = %self.deps.agent_id,
+                worker_id = %worker_id,
+                channel_id = %self.channel_id,
+                "failed to emit synthetic worker completion event"
+            );
         }
+
+        Ok(())
     }
 
     /// Cancel a running branch by aborting its tokio task.
     /// Returns an error message if the branch is not found.
     pub async fn cancel_branch(&self, branch_id: BranchId) -> std::result::Result<(), String> {
+        self.cancel_branch_with_reason(branch_id, "cancelled by channel")
+            .await
+    }
+
+    /// Cancel a running branch by aborting its tokio task.
+    /// Emits a synthetic terminal result so channel state converges.
+    pub async fn cancel_branch_with_reason(
+        &self,
+        branch_id: BranchId,
+        reason: &str,
+    ) -> std::result::Result<(), String> {
         let handle = self.active_branches.write().await.remove(&branch_id);
-        if let Some(handle) = handle {
-            handle.abort();
-            Ok(())
+        let removed_status = self.status_block.write().await.remove_branch(branch_id);
+        let Some(handle) = handle else {
+            if removed_status {
+                return Ok(());
+            }
+            return Err(format!("Branch {branch_id} not found"));
+        };
+
+        handle.abort();
+        let reason = crate::summarize_first_non_empty_line(reason, crate::EVENT_SUMMARY_MAX_CHARS);
+        let conclusion = if reason.is_empty() {
+            "Branch cancelled.".to_string()
         } else {
-            Err(format!("Branch {branch_id} not found"))
+            format!("Branch cancelled: {reason}")
+        };
+        self.process_run_logger
+            .log_branch_completed(branch_id, &conclusion);
+        if let Err(error) = self.deps.event_tx.send(ProcessEvent::BranchResult {
+            agent_id: self.deps.agent_id.clone(),
+            branch_id,
+            channel_id: self.channel_id.clone(),
+            conclusion,
+        }) {
+            tracing::warn!(
+                %error,
+                agent_id = %self.deps.agent_id,
+                branch_id = %branch_id,
+                channel_id = %self.channel_id,
+                "failed to emit synthetic branch result event"
+            );
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone)]
+pub struct ChannelControlHandle {
+    inner: Arc<ChannelControlState>,
+}
+
+struct ChannelControlState {
+    state: ChannelState,
+}
+
+#[derive(Clone)]
+pub struct WeakChannelControlHandle {
+    inner: Weak<ChannelControlState>,
+}
+
+impl ChannelControlHandle {
+    pub fn new(state: ChannelState) -> Self {
+        Self {
+            inner: Arc::new(ChannelControlState { state }),
+        }
+    }
+
+    pub fn downgrade(&self) -> WeakChannelControlHandle {
+        WeakChannelControlHandle {
+            inner: Arc::downgrade(&self.inner),
+        }
+    }
+
+    pub async fn cancel_worker_with_reason(
+        &self,
+        worker_id: WorkerId,
+        reason: &str,
+    ) -> ControlActionResult {
+        match self
+            .inner
+            .state
+            .cancel_worker_with_reason(worker_id, reason)
+            .await
+        {
+            Ok(()) => ControlActionResult::Cancelled,
+            Err(_) => ControlActionResult::NotFound,
         }
     }
+
+    pub async fn cancel_branch_with_reason(
+        &self,
+        branch_id: BranchId,
+        reason: &str,
+    ) -> ControlActionResult {
+        match self
+            .inner
+            .state
+            .cancel_branch_with_reason(branch_id, reason)
+            .await
+        {
+            Ok(()) => ControlActionResult::Cancelled,
+            Err(_) => ControlActionResult::NotFound,
+        }
+    }
+}
+
+impl WeakChannelControlHandle {
+    pub fn dangling() -> Self {
+        Self { inner: Weak::new() }
+    }
+
+    pub fn upgrade(&self) -> Option<ChannelControlHandle> {
+        self.inner
+            .upgrade()
+            .map(|inner| ChannelControlHandle { inner })
+    }
 }
 
 impl std::fmt::Debug for ChannelState {
@@ -123,6 +320,8 @@ pub struct Channel {
     pub self_tx: mpsc::Sender<InboundMessage>,
     /// Conversation ID from the first message (for synthetic re-trigger messages).
     pub conversation_id: Option<String>,
+    /// Adapter source captured from the first non-system message.
+    pub source_adapter: Option<String>,
     /// Conversation context (platform, channel name, server) captured from the first message.
     pub conversation_context: Option<String>,
     /// Context monitor that triggers background compaction.
@@ -132,7 +331,7 @@ pub struct Channel {
     /// Branch IDs for silent memory persistence branches (results not injected into history).
     memory_persistence_branches: HashSet<BranchId>,
     /// Optional Discord reply target captured when each branch was started.
-    branch_reply_targets: HashMap<BranchId, u64>,
+    branch_reply_targets: HashMap<BranchId, String>,
     /// Buffer for coalescing rapid-fire messages.
     coalesce_buffer: Vec<InboundMessage>,
     /// Deadline for flushing the coalesce buffer.
@@ -145,19 +344,18 @@ pub struct Channel {
     pending_retrigger_metadata: HashMap<String, serde_json::Value>,
     /// Deadline for firing the pending retrigger (debounce timer).
     retrigger_deadline: Option<tokio::time::Instant>,
+    /// Background process results waiting to be embedded in the next retrigger.
+    /// Accumulated during the debounce window and drained when the retrigger fires.
+    pending_results: Vec<PendingResult>,
     /// Optional send_agent_message tool (only when agent has active links).
     send_agent_message_tool: Option<crate::tools::SendAgentMessageTool>,
-    /// Turn counter for link channels (used for safety cap).
-    link_turn_count: u32,
-    /// Originating channel that triggered this link conversation (for routing conclusions back).
-    originating_channel: Option<String>,
-    /// Messaging adapter name from the originating channel (e.g. "webchat", "discord").
-    /// Used by `route_link_conclusion` to set the correct `source` on injected messages.
-    originating_source: Option<String>,
-    /// Set after `conclude_link` fires. Prevents the channel from processing
-    /// further messages, stopping the ping-pong that happens when both sides
-    /// keep responding to each other after the task is done.
-    link_concluded: bool,
+    /// Channel-local reply mode toggle.
+    /// When true, suppress unsolicited replies unless explicitly invoked.
+    listen_only_mode: bool,
+    /// Session-scoped override used when persistence is unavailable/failed.
+    listen_only_session_override: Option<bool>,
+    /// Handle exposed to the supervision control plane.
+    control_handle: ChannelControlHandle,
 }
 
 impl Channel {
@@ -215,29 +413,26 @@ impl Channel {
         // concurrent channels sharing per-turn add/remove cycles.
         let tool_server = ToolServer::new().run();
 
-        // Construct the send_agent_message tool if this agent has links and a messaging manager.
+        // Construct the send_agent_message tool if this agent has links.
         let send_agent_message_tool = {
             let has_links =
                 !crate::links::links_for_agent(&deps.links.load(), &deps.agent_id).is_empty();
-            match (&deps.messaging_manager, has_links) {
-                (Some(mm), true) => Some(crate::tools::SendAgentMessageTool::new(
+            if has_links {
+                Some(crate::tools::SendAgentMessageTool::new(
                     deps.agent_id.clone(),
-                    deps.agent_names
-                        .get(deps.agent_id.as_ref())
-                        .cloned()
-                        .unwrap_or_else(|| deps.agent_id.to_string()),
-                    id.clone(),
                     deps.links.clone(),
-                    mm.clone(),
-                    channel_store.clone(),
-                    deps.event_tx.clone(),
                     deps.agent_names.clone(),
-                )),
-                _ => None,
+                    deps.task_store_registry.clone(),
+                    ConversationLogger::new(deps.sqlite_pool.clone()),
+                ))
+            } else {
+                None
             }
         };
 
         let self_tx = message_tx.clone();
+        let resolved_listen_only_mode = deps.runtime_config.channel_config.load().listen_only_mode;
+        let control_handle = ChannelControlHandle::new(state.clone());
         let channel = Self {
             id: id.clone(),
             title: None,
@@ -250,6 +445,7 @@ impl Channel {
             response_tx,
             self_tx,
             conversation_id: None,
+            source_adapter: None,
             conversation_context: None,
             compactor,
             message_count: 0,
@@ -261,11 +457,11 @@ impl Channel {
             pending_retrigger: false,
             pending_retrigger_metadata: HashMap::new(),
             retrigger_deadline: None,
+            pending_results: Vec::new(),
             send_agent_message_tool,
-            link_turn_count: 0,
-            originating_channel: None,
-            originating_source: None,
-            link_concluded: false,
+            listen_only_mode: resolved_listen_only_mode,
+            listen_only_session_override: None,
+            control_handle,
         };
 
         (channel, message_tx)
@@ -280,9 +476,361 @@ impl Channel {
             .unwrap_or(self.deps.agent_id.as_ref())
     }
 
+    fn current_adapter(&self) -> Option<&str> {
+        self.source_adapter
+            .as_deref()
+            .or_else(|| {
+                self.conversation_id
+                    .as_deref()
+                    .and_then(|conversation_id| conversation_id.split(':').next())
+            })
+            .filter(|adapter| !adapter.is_empty())
+    }
+
+    fn sync_listen_only_mode_from_runtime(&mut self) {
+        if let Some(override_mode) = self.listen_only_session_override {
+            self.listen_only_mode = override_mode;
+            return;
+        }
+        let runtime_default = self
+            .deps
+            .runtime_config
+            .channel_config
+            .load()
+            .listen_only_mode;
+        let explicit_listen_only = **self.deps.runtime_config.channel_listen_only_explicit.load();
+        let settings_store = self
+            .deps
+            .runtime_config
+            .settings
+            .load()
+            .as_ref()
+            .as_ref()
+            .cloned();
+        self.listen_only_mode = if explicit_listen_only.is_some() {
+            runtime_default
+        } else if let Some(settings_store) = settings_store {
+            match settings_store.channel_listen_only_mode_for(self.id.as_ref()) {
+                Ok(Some(enabled)) => enabled,
+                Ok(None) => runtime_default,
+                Err(error) => {
+                    tracing::warn!(
+                        %error,
+                        channel_id = %self.id,
+                        "failed to sync channel-scoped listen_only_mode setting"
+                    );
+                    runtime_default
+                }
+            }
+        } else {
+            runtime_default
+        };
+    }
+
+    fn set_listen_only_mode(&mut self, enabled: bool) -> bool {
+        let mut persisted = false;
+        let settings_store = self
+            .deps
+            .runtime_config
+            .settings
+            .load()
+            .as_ref()
+            .as_ref()
+            .cloned();
+        if let Some(settings_store) = settings_store {
+            match settings_store.set_channel_listen_only_mode_for(self.id.as_ref(), enabled) {
+                Ok(()) => persisted = true,
+                Err(error) => {
+                    tracing::warn!(
+                        %error,
+                        channel_id = %self.id,
+                        listen_only_mode = enabled,
+                        "failed to persist listen_only_mode setting"
+                    );
+                }
+            }
+        } else {
+            tracing::warn!(
+                channel_id = %self.id,
+                listen_only_mode = enabled,
+                "settings store unavailable; listen_only_mode is session-scoped"
+            );
+        }
+
+        self.listen_only_mode = enabled;
+        self.listen_only_session_override = if persisted { None } else { Some(enabled) };
+        persisted
+    }
+
+    fn persist_inbound_user_message(&self, message: &InboundMessage, raw_text: &str) {
+        if message.source == "system" {
+            return;
+        }
+        let sender_name = message
+            .metadata
+            .get("sender_display_name")
+            .and_then(|v| v.as_str())
+            .unwrap_or(&message.sender_id);
+        self.state.conversation_logger.log_user_message(
+            &self.state.channel_id,
+            sender_name,
+            &message.sender_id,
+            raw_text,
+            &message.metadata,
+        );
+        self.state
+            .channel_store
+            .upsert(&message.conversation_id, &message.metadata);
+    }
+
+    fn suppress_plaintext_fallback(&self) -> bool {
+        matches!(self.current_adapter(), Some("email"))
+    }
+
+    /// Return a handle that allows external supervision to cancel this channel's
+    /// workers and branches without direct access to Channel internals.
+    pub fn control_handle(&self) -> ChannelControlHandle {
+        self.control_handle.clone()
+    }
+
+    fn rewrite_tool_routed_command_prompt(&self, raw_text: &str) -> Option<String> {
+        match raw_text.trim() {
+            "/tasks" => Some(
+                "use channel tools to fetch my ready tasks (limit 10) and reply exactly with:\n\
+                 - header: tasks (ready):\n\
+                 - each line: - #<task_number> [<priority>] <title>\n\
+                 if no tasks are ready, reply exactly: tasks (ready): none"
+                    .to_string(),
+            ),
+            "/today" => Some(
+                "use channel tools to build a local tasks snapshot and reply exactly in this format:\n\
+                 - first line: today (local tasks snapshot):\n\
+                 - section 1: in-progress tasks (up to 5), each line:   #<task_number> [<priority>] <title>\n\
+                 - section 2: up next ready tasks (up to 5), each line:   #<task_number> [<priority>] <title>\n\
+                 if a section is empty use:\n\
+                 - in progress: none\n\
+                 - up next (ready): none"
+                    .to_string(),
+            ),
+            "/digest" => Some(
+                "using available tools and channel context, generate a concise day digest from local 00:00 to now with exactly this order:\n\
+                 1) top decisions\n\
+                 2) key convo themes\n\
+                 3) open loops\n\
+                 keep it practical and concise; if there are no meaningful updates, reply exactly: no material updates today."
+                    .to_string(),
+            ),
+            _ => None,
+        }
+    }
+
+    fn compute_listen_mode_invocation(
+        &self,
+        message: &InboundMessage,
+        raw_text: &str,
+    ) -> (bool, bool, bool) {
+        let text = raw_text.trim();
+        let invoked_by_command = text.starts_with('/');
+        let invoked_by_mention = match message.source.as_str() {
+            "telegram" => {
+                let text_lower = text.to_lowercase();
+                message
+                    .metadata
+                    .get("telegram_bot_username")
+                    .and_then(|v| v.as_str())
+                    .map(|username| {
+                        let mention = format!("@{}", username.to_lowercase());
+                        text_lower.match_indices(&mention).any(|(start, _)| {
+                            let end = start + mention.len();
+                            let before_ok = start == 0
+                                || text_lower[..start].chars().next_back().is_none_or(
+                                    |character| {
+                                        !(character.is_ascii_alphanumeric() || character == '_')
+                                    },
+                                );
+                            let after_ok = end == text_lower.len()
+                                || text_lower[end..].chars().next().is_none_or(|character| {
+                                    !(character.is_ascii_alphanumeric() || character == '_')
+                                });
+                            before_ok && after_ok
+                        })
+                    })
+                    .unwrap_or(false)
+            }
+            "discord" => message
+                .metadata
+                .get("discord_mentioned_bot")
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false),
+            "slack" => message
+                .metadata
+                .get("slack_mentions_or_replies_to_bot")
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false),
+            "twitch" => message
+                .metadata
+                .get("twitch_mentions_or_replies_to_bot")
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false),
+            _ => false,
+        };
+        let invoked_by_reply = match message.source.as_str() {
+            // Use bot-specific reply metadata; generic reply_to_is_bot can
+            // match unrelated bots and cause false invokes.
+            "discord" => message
+                .metadata
+                .get("discord_reply_to_bot")
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false),
+            "telegram" => {
+                let reply_to_is_bot = message
+                    .metadata
+                    .get("reply_to_is_bot")
+                    .and_then(|v| v.as_bool())
+                    .unwrap_or(false);
+                let bot_username = message
+                    .metadata
+                    .get("telegram_bot_username")
+                    .and_then(|v| v.as_str())
+                    .map(str::to_lowercase);
+                let reply_username = message
+                    .metadata
+                    .get("reply_to_username")
+                    .and_then(|v| v.as_str())
+                    .map(str::to_lowercase);
+                reply_to_is_bot
+                    && reply_username
+                        .zip(bot_username)
+                        .is_some_and(|(reply, bot)| bot == reply)
+            }
+            _ => message
+                .metadata
+                .get("reply_to_is_bot")
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false),
+        };
+
+        (invoked_by_command, invoked_by_mention, invoked_by_reply)
+    }
+
+    async fn send_builtin_text(&mut self, text: String, log_label: &str) {
+        if let Err(error) = self
+            .response_tx
+            .send(OutboundResponse::Text(text.clone()))
+            .await
+        {
+            tracing::error!(%error, channel_id = %self.id, %log_label, "failed to send built-in reply");
+            return;
+        }
+        self.state.conversation_logger.log_bot_message_with_name(
+            &self.state.channel_id,
+            &text,
+            Some(self.agent_display_name()),
+        );
+    }
+
+    async fn try_handle_builtin_ops_commands(
+        &mut self,
+        raw_text: &str,
+        message: &InboundMessage,
+    ) -> Result<bool> {
+        if message.source == "system" {
+            return Ok(false);
+        }
+        let supported_source = matches!(
+            message.source.as_str(),
+            "telegram" | "discord" | "slack" | "twitch"
+        );
+        if !supported_source {
+            return Ok(false);
+        }
+
+        let text = raw_text.trim();
+        if !text.starts_with('/') {
+            return Ok(false);
+        }
+
+        let temporal_context = TemporalContext::from_runtime(self.deps.runtime_config.as_ref());
+        let now_line = temporal_context.current_time_line();
+
+        match text {
+            "/status" => {
+                let routing = self.deps.runtime_config.routing.load();
+                let channel_model = routing.resolve(ProcessType::Channel, None).to_string();
+                let branch_model = routing.resolve(ProcessType::Branch, None).to_string();
+                let mode = if self.listen_only_mode {
+                    "quiet"
+                } else {
+                    "active"
+                };
+                let adapter = self.current_adapter().unwrap_or("unknown");
+                let body = format!(
+                    "status\n\
+                     - agent: {}\n\
+                     - channel: {}\n\
+                     - adapter: {}\n\
+                     - mode: {} (quiet => only command/@mention/reply-to-bot)\n\
+                     - channel model: {}\n\
+                     - branch model: {}\n\
+                     - time: {}",
+                    self.deps.agent_id,
+                    self.id,
+                    adapter,
+                    mode,
+                    channel_model,
+                    branch_model,
+                    now_line
+                );
+                self.send_builtin_text(body, "status").await;
+                return Ok(true);
+            }
+            "/quiet" => {
+                let persisted = self.set_listen_only_mode(true);
+                let body = if persisted {
+                    "quiet mode enabled. i'll only reply to commands, @mentions, or replies to my message."
+                        .to_string()
+                } else {
+                    "quiet mode enabled for this session, but persistence failed; it may revert after restart.".to_string()
+                };
+                self.send_builtin_text(body, "quiet").await;
+                return Ok(true);
+            }
+            "/active" => {
+                let persisted = self.set_listen_only_mode(false);
+                let body = if persisted {
+                    "active mode enabled. i'll respond normally in this chat.".to_string()
+                } else {
+                    "active mode enabled for this session, but persistence failed; it may revert after restart.".to_string()
+                };
+                self.send_builtin_text(body, "active").await;
+                return Ok(true);
+            }
+            "/help" => {
+                let lines = [
+                    "commands:".to_string(),
+                    "- /status: current mode, models, binding snapshot".to_string(),
+                    "- /today: in-progress + ready task snapshot".to_string(),
+                    "- /tasks: ready task list".to_string(),
+                    "- /digest: one-shot day digest (00:00 -> now)".to_string(),
+                    "- /quiet: listen-only mode".to_string(),
+                    "- /active: normal reply mode".to_string(),
+                    "- /agent-id: runtime agent id".to_string(),
+                ];
+                let body = lines.join("\n");
+                self.send_builtin_text(body, "help").await;
+                return Ok(true);
+            }
+            _ => {}
+        }
+
+        Ok(false)
+    }
+
     /// Run the channel event loop.
     pub async fn run(mut self) -> Result<()> {
         tracing::info!(channel_id = %self.id, "channel started");
+        let mut lagged_events_since_warning: u64 = 0;
+        let mut last_lag_warning: Option<std::time::Instant> = None;
 
         loop {
             // Compute next deadline from coalesce and retrigger timers
@@ -319,13 +867,52 @@ impl Channel {
                         }
                     }
                 }
-                Ok(event) = self.event_rx.recv() => {
-                    // Events bypass coalescing - flush buffer first if needed
-                    if let Err(error) = self.flush_coalesce_buffer().await {
-                        tracing::error!(%error, channel_id = %self.id, "error flushing coalesce buffer");
-                    }
-                    if let Err(error) = self.handle_event(event).await {
-                        tracing::error!(%error, channel_id = %self.id, "error handling event");
+                event = recv_channel_event(&mut self.event_rx) => {
+                    match event {
+                        crate::BroadcastRecvResult::Event(event) => {
+                            if !should_process_event_for_channel(&event, &self.id) {
+                                continue;
+                            }
+                            // Worker/branch lifecycle events bypass coalescing.
+                            if should_flush_coalesce_buffer_for_event(&event)
+                                && let Err(error) = self.flush_coalesce_buffer().await
+                            {
+                                tracing::error!(
+                                    %error,
+                                    channel_id = %self.id,
+                                    "error flushing coalesce buffer"
+                                );
+                            }
+                            if let Err(error) = self.handle_event(event).await {
+                                tracing::error!(%error, channel_id = %self.id, "error handling event");
+                            }
+                        }
+                        crate::BroadcastRecvResult::Lagged(skipped) => {
+                            #[cfg(feature = "metrics")]
+                            crate::telemetry::Metrics::global()
+                                .event_receiver_lagged_events_total
+                                .with_label_values(&[&*self.deps.agent_id, "channel_control"])
+                                .inc_by(skipped);
+
+                            if let Some(skipped) = crate::drain_lag_warning_count(
+                                &mut lagged_events_since_warning,
+                                &mut last_lag_warning,
+                                skipped,
+                                std::time::Duration::from_secs(
+                                    EVENT_LAG_WARNING_INTERVAL_SECS,
+                                ),
+                            ) {
+                                tracing::warn!(
+                                    channel_id = %self.id,
+                                    skipped,
+                                    "channel event receiver lagged, dropping old events"
+                                );
+                            }
+                        }
+                        crate::BroadcastRecvResult::Closed => {
+                            tracing::info!(channel_id = %self.id, "channel event bus closed, stopping channel");
+                            break;
+                        }
                     }
                 }
                 _ = tokio::time::sleep(sleep_duration), if next_deadline.is_some() => {
@@ -371,13 +958,18 @@ impl Channel {
         if message.source == "system" {
             return false;
         }
-        // Internal link channels are stateful handshakes between two agents.
-        // Coalescing can merge conclusion + follow-up messages into one turn and
-        // bypass per-message guards, so process link messages immediately.
-        if message.conversation_id.starts_with("link:") {
+        if config.multi_user_only && self.is_dm() {
             return false;
         }
-        if config.multi_user_only && self.is_dm() {
+        // Built-in slash commands should execute immediately and never be batched.
+        let looks_like_command = match &message.content {
+            crate::MessageContent::Text(text) => text.trim_start().starts_with('/'),
+            crate::MessageContent::Media { text, .. } => text
+                .as_deref()
+                .is_some_and(|value| value.trim_start().starts_with('/')),
+            crate::MessageContent::Interaction { .. } => false,
+        };
+        if looks_like_command {
             return false;
         }
         true
@@ -464,16 +1056,21 @@ impl Channel {
     /// with a coalesce hint telling the LLM this is a fast-moving conversation.
     #[tracing::instrument(skip(self, messages), fields(channel_id = %self.id, agent_id = %self.deps.agent_id, message_count = messages.len()))]
     async fn handle_message_batch(&mut self, messages: Vec<InboundMessage>) -> Result<()> {
+        // Apply runtime-config updates immediately without requiring a restart.
+        self.sync_listen_only_mode_from_runtime();
+
         let message_count = messages.len();
-        let first_timestamp = messages
-            .first()
-            .map(|m| m.timestamp)
+        let batch_start_timestamp = messages
+            .iter()
+            .map(|message| message.timestamp)
+            .min()
             .unwrap_or_else(chrono::Utc::now);
-        let last_timestamp = messages
-            .last()
-            .map(|m| m.timestamp)
-            .unwrap_or(first_timestamp);
-        let elapsed = last_timestamp.signed_duration_since(first_timestamp);
+        let batch_tail_timestamp = messages
+            .iter()
+            .map(|message| message.timestamp)
+            .max()
+            .unwrap_or(batch_start_timestamp);
+        let elapsed = batch_tail_timestamp.signed_duration_since(batch_start_timestamp);
         let elapsed_secs = elapsed.num_milliseconds() as f64 / 1000.0;
 
         tracing::info!(
@@ -495,6 +1092,13 @@ impl Channel {
             self.conversation_id = Some(first.conversation_id.clone());
         }
 
+        if self.source_adapter.is_none()
+            && let Some(first) = messages.first()
+            && first.source != "system"
+        {
+            self.source_adapter = Some(first.source.clone());
+        }
+
         // Capture conversation context from the first message
         if self.conversation_context.is_none()
             && let Some(first) = messages.first()
@@ -502,24 +1106,12 @@ impl Channel {
             let prompt_engine = self.deps.runtime_config.prompts.load();
             let server_name = first
                 .metadata
-                .get("discord_guild_name")
-                .and_then(|v| v.as_str())
-                .or_else(|| {
-                    first
-                        .metadata
-                        .get("telegram_chat_title")
-                        .and_then(|v| v.as_str())
-                });
+                .get(crate::metadata_keys::SERVER_NAME)
+                .and_then(|v| v.as_str());
             let channel_name = first
                 .metadata
-                .get("discord_channel_name")
-                .and_then(|v| v.as_str())
-                .or_else(|| {
-                    first
-                        .metadata
-                        .get("telegram_chat_type")
-                        .and_then(|v| v.as_str())
-                });
+                .get(crate::metadata_keys::CHANNEL_NAME)
+                .and_then(|v| v.as_str());
             self.conversation_context = Some(prompt_engine.render_conversation_context(
                 &first.source,
                 server_name,
@@ -528,8 +1120,10 @@ impl Channel {
         }
 
         // Persist each message to conversation log (individual audit trail)
-        let mut user_contents: Vec<UserContent> = Vec::new();
+        let mut pending_batch_entries: Vec<(String, Vec<_>)> = Vec::new();
         let mut conversation_id = String::new();
+        let temporal_context = TemporalContext::from_runtime(self.deps.runtime_config.as_ref());
+        let mut batch_has_invoke = false;
 
         for message in &messages {
             if message.source != "system" {
@@ -550,6 +1144,13 @@ impl Channel {
                     }
                 };
 
+                if self.listen_only_mode {
+                    let (invoked_by_command, invoked_by_mention, invoked_by_reply) =
+                        self.compute_listen_mode_invocation(message, &raw_text);
+                    batch_has_invoke |=
+                        invoked_by_command || invoked_by_mention || invoked_by_reply;
+                }
+
                 self.state.conversation_logger.log_user_message(
                     &self.state.channel_id,
                     sender_name,
@@ -563,11 +1164,11 @@ impl Channel {
 
                 conversation_id = message.conversation_id.clone();
 
-                // Format with relative timestamp
-                let relative_secs = message
-                    .timestamp
-                    .signed_duration_since(first_timestamp)
-                    .num_seconds();
+                // Include both absolute and relative time context.
+                let relative_secs = batch_tail_timestamp
+                    .signed_duration_since(message.timestamp)
+                    .num_seconds()
+                    .max(0);
                 let relative_text = if relative_secs < 1 {
                     "just now".to_string()
                 } else if relative_secs < 60 {
@@ -575,27 +1176,44 @@ impl Channel {
                 } else {
                     format!("{}m ago", relative_secs / 60)
                 };
+                let absolute_timestamp = temporal_context.format_timestamp(message.timestamp);
 
-                let display_name = message
-                    .metadata
-                    .get("sender_display_name")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or(&message.sender_id);
+                let display_name = message_display_name(message);
 
-                let formatted_text =
-                    format!("[{}] ({}): {}", display_name, relative_text, raw_text);
+                let formatted_text = format_batched_user_message(
+                    display_name,
+                    &absolute_timestamp,
+                    &relative_text,
+                    &raw_text,
+                );
 
-                // Download attachments for this message
-                if !attachments.is_empty() {
-                    let attachment_content = download_attachments(&self.deps, &attachments).await;
-                    for content in attachment_content {
-                        user_contents.push(content);
-                    }
-                }
+                pending_batch_entries.push((formatted_text, attachments));
+            }
+        }
+
+        if self.listen_only_mode && !batch_has_invoke {
+            tracing::debug!(
+                channel_id = %self.id,
+                message_count,
+                "listen-first mode: suppressing unsolicited coalesced batch"
+            );
+            // Keep passive memory capture behavior aligned with single-message flow.
+            self.message_count += message_count;
+            self.check_memory_persistence().await;
+            return Ok(());
+        }
 
-                user_contents.push(UserContent::text(formatted_text));
+        let mut user_contents: Vec<UserContent> = Vec::new();
+        for (formatted_text, attachments) in pending_batch_entries {
+            if !attachments.is_empty() {
+                let attachment_content = download_attachments(&self.deps, &attachments).await;
+                for content in attachment_content {
+                    user_contents.push(content);
+                }
             }
+            user_contents.push(UserContent::text(formatted_text));
         }
+
         // Separate text and non-text (image/audio) content
         let mut text_parts = Vec::new();
         let mut attachment_parts = Vec::new();
@@ -619,18 +1237,17 @@ impl Channel {
 
         {
             let mut reply_target = self.state.reply_target_message_id.write().await;
-            *reply_target = messages.iter().rev().find_map(extract_discord_message_id);
+            *reply_target = messages.iter().rev().find_map(extract_message_id);
         }
 
         // Run agent turn with any image/audio attachments preserved
-        let source = messages.first().map(|m| m.source.clone());
-        let (result, skip_flag, replied_flag, _conclude_flag, _conclude_summary) = self
+        let (result, skip_flag, replied_flag, _) = self
             .run_agent_turn(
                 &combined_text,
                 &system_prompt,
                 &conversation_id,
                 attachment_parts,
-                source,
+                false, // not a retrigger
             )
             .await?;
 
@@ -666,15 +1283,18 @@ impl Channel {
         let browser_enabled = rc.browser_config.load().enabled;
         let web_search_enabled = rc.brave_search_key.load().is_some();
         let opencode_enabled = rc.opencode.load().enabled;
+        let sandbox_enabled = self.deps.sandbox.containment_active();
         let worker_capabilities = prompt_engine.render_worker_capabilities(
             browser_enabled,
             web_search_enabled,
             opencode_enabled,
         )?;
 
+        let temporal_context = TemporalContext::from_runtime(rc.as_ref());
+        let current_time_line = temporal_context.current_time_line();
         let status_text = {
             let status = self.state.status_block.read().await;
-            status.render()
+            status.render_with_time_context(Some(&current_time_line))
         };
 
         // Render coalesce hint
@@ -686,7 +1306,10 @@ impl Channel {
         let available_channels = self.build_available_channels().await;
 
         let org_context = self.build_org_context(&prompt_engine);
-        let link_context = self.build_link_context(&prompt_engine);
+
+        let adapter_prompt = self
+            .current_adapter()
+            .and_then(|adapter| prompt_engine.render_channel_adapter_prompt(adapter));
 
         let empty_to_none = |s: String| if s.is_empty() { None } else { Some(s) };
 
@@ -699,8 +1322,9 @@ impl Channel {
             empty_to_none(status_text),
             coalesce_hint,
             available_channels,
+            sandbox_enabled,
             org_context,
-            link_context,
+            adapter_prompt,
         )
     }
 
@@ -711,6 +1335,9 @@ impl Channel {
     /// memory_save. The tools act on the channel's shared state directly.
     #[tracing::instrument(skip(self, message), fields(channel_id = %self.id, agent_id = %self.deps.agent_id, message_id = %message.id))]
     async fn handle_message(&mut self, message: InboundMessage) -> Result<()> {
+        // Apply runtime-config updates immediately without requiring a restart.
+        self.sync_listen_only_mode_from_runtime();
+
         tracing::info!(
             channel_id = %self.id,
             message_id = %message.id,
@@ -722,6 +1349,10 @@ impl Channel {
             self.conversation_id = Some(message.conversation_id.clone());
         }
 
+        if self.source_adapter.is_none() && message.source != "system" {
+            self.source_adapter = Some(message.source.clone());
+        }
+
         let (raw_text, attachments) = match &message.content {
             crate::MessageContent::Text(text) => (text.clone(), Vec::new()),
             crate::MessageContent::Media { text, attachments } => {
@@ -731,58 +1362,52 @@ impl Channel {
             crate::MessageContent::Interaction { .. } => (message.content.to_string(), Vec::new()),
         };
 
-        let user_text = format_user_message(&raw_text, &message);
+        self.persist_inbound_user_message(&message, &raw_text);
 
-        let attachment_content = if !attachments.is_empty() {
-            download_attachments(&self.deps, &attachments).await
-        } else {
-            Vec::new()
-        };
+        // Deterministic built-in command: bypass model output drift for agent identity checks.
+        if message.source != "system" && raw_text.trim() == "/agent-id" {
+            self.send_builtin_text(self.deps.agent_id.to_string(), "agent-id")
+                .await;
+            return Ok(());
+        }
 
-        // Emit AgentMessageReceived event for internal agent-to-agent messages
-        if message.source == "internal"
-            && let Some(from_agent_id) = message
-                .metadata
-                .get("from_agent_id")
-                .and_then(|v| v.as_str())
-        {
-            self.deps
-                .event_tx
-                .send(ProcessEvent::AgentMessageReceived {
-                    from_agent_id: Arc::from(from_agent_id),
-                    to_agent_id: self.deps.agent_id.clone(),
-                    link_id: message.conversation_id.clone(),
-                    channel_id: self.id.clone(),
-                })
-                .ok();
+        // Deterministic liveness ping for Telegram mentions.
+        // This avoids model/provider flakiness for simple "you there?" style checks.
+        if message.source == "telegram" {
+            let text = raw_text.trim().to_lowercase();
+            let (_, has_mention, _) = self.compute_listen_mode_invocation(&message, &raw_text);
+            let looks_like_ping = text.contains("you here")
+                || text.contains("ping")
+                || text.ends_with(" yo")
+                || text == "yo"
+                || text.contains("alive")
+                || text.contains("there?");
+
+            if has_mention && looks_like_ping {
+                self.send_builtin_text("yeah i'm here".to_string(), "telegram-ping")
+                    .await;
+                return Ok(());
+            }
         }
 
-        // Persist user messages (skip system re-triggers)
-        let is_link_conclusion = message.metadata.contains_key("link_conclusion");
-        if is_link_conclusion {
-            // Link conclusion messages are internal control messages used to
-            // retrigger the originating channel. Do not persist them to the
-            // visible conversation timeline.
-            tracing::debug!(
-                channel_id = %self.id,
-                "received link conclusion control message"
-            );
-        } else if message.source != "system" {
-            let sender_name = message
-                .metadata
-                .get("sender_display_name")
-                .and_then(|v| v.as_str())
-                .unwrap_or(&message.sender_id);
-            self.state.conversation_logger.log_user_message(
-                &self.state.channel_id,
-                sender_name,
-                &message.sender_id,
-                &raw_text,
-                &message.metadata,
-            );
-            self.state
-                .channel_store
-                .upsert(&message.conversation_id, &message.metadata);
+        // Deterministic ping ack for Discord quiet-mode mentions/replies to avoid
+        // flaky model behavior (e.g. skipping or over-formatting simple liveness checks).
+        if message.source == "discord" && self.listen_only_mode {
+            let text = raw_text.trim().to_lowercase();
+            let (_, invoked_by_mention, invoked_by_reply) =
+                self.compute_listen_mode_invocation(&message, &raw_text);
+            let directed = invoked_by_mention || invoked_by_reply;
+            let looks_like_ping = text.contains("you here")
+                || text.contains("ping")
+                || text.ends_with(" yo")
+                || text == "yo"
+                || text.contains("alive")
+                || text.contains("there?");
+            if directed && looks_like_ping {
+                self.send_builtin_text("yeah i'm here".to_string(), "discord-ping")
+                    .await;
+                return Ok(());
+            }
         }
 
         // Capture conversation context from the first message (platform, channel, server)
@@ -790,24 +1415,12 @@ impl Channel {
             let prompt_engine = self.deps.runtime_config.prompts.load();
             let server_name = message
                 .metadata
-                .get("discord_guild_name")
-                .and_then(|v| v.as_str())
-                .or_else(|| {
-                    message
-                        .metadata
-                        .get("telegram_chat_title")
-                        .and_then(|v| v.as_str())
-                });
+                .get(crate::metadata_keys::SERVER_NAME)
+                .and_then(|v| v.as_str());
             let channel_name = message
                 .metadata
-                .get("discord_channel_name")
-                .and_then(|v| v.as_str())
-                .or_else(|| {
-                    message
-                        .metadata
-                        .get("telegram_chat_type")
-                        .and_then(|v| v.as_str())
-                });
+                .get(crate::metadata_keys::CHANNEL_NAME)
+                .and_then(|v| v.as_str());
             self.conversation_context = Some(prompt_engine.render_conversation_context(
                 &message.source,
                 server_name,
@@ -815,136 +1428,169 @@ impl Channel {
             )?);
         }
 
-        // On link channels, seed conversation history with the original outgoing message
-        // so the agent has context for what it previously said when the reply arrives.
-        if message.source == "internal" {
-            // Capture the originating channel and adapter source for routing conclusions back
-            if self.originating_channel.is_none() {
-                self.originating_channel = message
-                    .metadata
-                    .get("originating_channel")
-                    .and_then(|v| v.as_str())
-                    .map(String::from);
-                self.originating_source = message
-                    .metadata
-                    .get("originating_source")
-                    .and_then(|v| v.as_str())
-                    .map(String::from);
-            }
-
-            if let Some(original) = message
-                .metadata
-                .get("original_sent_message")
-                .and_then(|v| v.as_str())
-            {
-                let history = self.state.history.read().await;
-                let is_first_message = history.is_empty();
-                drop(history);
-
-                if is_first_message {
-                    let mut history = self.state.history.write().await;
-                    history.push(rig::message::Message::Assistant {
-                        id: None,
-                        content: rig::OneOrMany::one(rig::message::AssistantContent::text(
-                            original,
-                        )),
-                    });
-                    drop(history);
-
-                    // Persist so the message appears in the dashboard timeline
-                    self.state.conversation_logger.log_bot_message_with_name(
-                        &self.state.channel_id,
-                        original,
-                        Some(self.agent_display_name()),
-                    );
-                }
-            }
+        if self
+            .try_handle_builtin_ops_commands(&raw_text, &message)
+            .await?
+        {
+            return Ok(());
         }
 
-        // Drop messages on concluded link channels
-        let is_link_channel = message.conversation_id.starts_with("link:");
-        if is_link_channel && self.link_concluded {
-            // Late-arriving link conclusions should still cascade up the chain.
-            // This handles races where a parent link concludes before a child
-            // link finishes and reports back.
-            if is_link_conclusion {
-                let summary = message
-                    .metadata
-                    .get("link_conclusion_summary")
-                    .and_then(|value| value.as_str())
-                    .or_else(|| {
-                        raw_text.split_once('\n').and_then(|(header, body)| {
-                            if header.starts_with("[Link conversation with ")
-                                && header.ends_with(" concluded]")
-                            {
-                                Some(body)
-                            } else {
-                                None
-                            }
-                        })
-                    })
-                    .unwrap_or(raw_text.as_str());
+        let rewritten_text = if message.source == "system" {
+            raw_text.clone()
+        } else {
+            self.rewrite_tool_routed_command_prompt(&raw_text)
+                .unwrap_or_else(|| raw_text.clone())
+        };
 
-                self.route_link_conclusion(summary, &message).await;
-            }
+        let temporal_context = TemporalContext::from_runtime(self.deps.runtime_config.as_ref());
+        let message_timestamp = temporal_context.format_timestamp(message.timestamp);
+        let user_text = format_user_message(&rewritten_text, &message, &message_timestamp);
 
-            tracing::debug!(
-                channel_id = %self.id,
-                "dropping message on concluded link channel"
-            );
-            return Ok(());
-        }
+        let mut invoked_by_command = false;
+        let mut invoked_by_mention = false;
+        let mut invoked_by_reply = false;
 
-        // Track link channel turns for safety cap
-        if is_link_channel && message.source != "system" {
-            self.link_turn_count += 1;
-        }
+        // Listen-first guardrail:
+        // ingest all messages, but only reply when explicitly invoked.
+        if self.listen_only_mode && message.source != "system" {
+            (invoked_by_command, invoked_by_mention, invoked_by_reply) =
+                self.compute_listen_mode_invocation(&message, &raw_text);
 
-        // Safety cap: force-conclude link conversations at 20 turns
-        const LINK_MAX_TURNS: u32 = 20;
-        if is_link_channel && self.link_turn_count > LINK_MAX_TURNS {
-            tracing::warn!(
-                channel_id = %self.id,
-                turns = self.link_turn_count,
-                "link conversation hit safety cap, dropping message"
-            );
-            return Ok(());
+            if !invoked_by_command && !invoked_by_mention && !invoked_by_reply {
+                tracing::debug!(
+                    channel_id = %self.id,
+                    source = %message.source,
+                    "listen-first mode: suppressing unsolicited reply"
+                );
+                // In quiet/listen-first mode we still want passive memory capture.
+                // Count suppressed user messages so auto memory persistence branches
+                // continue to run on interval without requiring explicit invokes.
+                self.message_count += 1;
+                self.check_memory_persistence().await;
+                return Ok(());
+            }
         }
 
         let system_prompt = self.build_system_prompt().await?;
 
         {
             let mut reply_target = self.state.reply_target_message_id.write().await;
-            *reply_target = extract_discord_message_id(&message);
+            *reply_target = extract_message_id(&message);
         }
 
         let is_retrigger = message.source == "system";
-
-        let message_source = if is_retrigger {
-            None
+        let attachment_content = if !attachments.is_empty() {
+            download_attachments(&self.deps, &attachments).await
         } else {
-            Some(message.source.clone())
+            Vec::new()
         };
 
-        let (result, skip_flag, replied_flag, conclude_flag, conclude_summary) = self
+        let (result, skip_flag, replied_flag, retrigger_reply_preserved) = self
             .run_agent_turn(
                 &user_text,
                 &system_prompt,
                 &message.conversation_id,
                 attachment_content,
-                message_source,
+                is_retrigger,
             )
             .await?;
 
         self.handle_agent_result(result, &skip_flag, &replied_flag, is_retrigger)
             .await;
 
-        // Handle link conversation conclusion
-        let concluded = conclude_flag.load(std::sync::atomic::Ordering::Relaxed);
-        if concluded {
-            let summary = conclude_summary.read().await.clone().unwrap_or_default();
-            self.route_link_conclusion(&summary, &message).await;
-            self.link_concluded = true;
+        // Safety-net: in quiet mode, explicit mention/reply should never be dropped silently.
+        if self.listen_only_mode
+            && !is_retrigger
+            && !invoked_by_command
+            && (invoked_by_mention || invoked_by_reply)
+            && skip_flag.load(std::sync::atomic::Ordering::Relaxed)
+            && !replied_flag.load(std::sync::atomic::Ordering::Relaxed)
+            && matches!(
+                message.source.as_str(),
+                "discord" | "telegram" | "slack" | "twitch"
+            )
+        {
+            self.send_builtin_text(
+                "yeah i'm here — tell me what you need.".to_string(),
+                "quiet-mode-fallback",
+            )
+            .await;
+        }
+
+        // After retrigger turns, persist a fallback summary only when we don't
+        // already have the LLM's actual relay text in history.
+        //
+        // PromptCancelled + reply tool is now handled in apply_history_after_turn:
+        // it extracts the reply content from tool args and records that exact
+        // assistant message (while dropping scaffolding). In that common success
+        // path, we skip summary injection to avoid replacing user-visible wording
+        // with raw worker output.
+        //
+        // If relay failed (replied=false), or if we couldn't extract a clean
+        // reply content payload, this fallback preserves a compact background
+        // result record for the next user turn.
+        if is_retrigger {
+            let replied = replied_flag.load(std::sync::atomic::Ordering::Relaxed);
+            if replied && retrigger_reply_preserved {
+                tracing::debug!(
+                    channel_id = %self.id,
+                    "skipping retrigger summary injection; relay reply already preserved"
+                );
+            } else {
+                // Extract the result summaries from the metadata we attached in
+                // flush_pending_retrigger, so we record only the substance (not
+                // the retrigger instructions/template scaffolding).
+                let summary = message
+                    .metadata
+                    .get("retrigger_result_summary")
+                    .and_then(|v| v.as_str())
+                    .unwrap_or("[background work completed]");
+
+                let record = if replied {
+                    summary.to_string()
+                } else {
+                    tracing::warn!(
+                        channel_id = %self.id,
+                        "retrigger relay failed, preserving result in history for next turn"
+                    );
+                    format!(
+                        "[background work completed but relay to user failed — include this in your next response]\n{summary}"
+                    )
+                };
+
+                let mut history = self.state.history.write().await;
+                // Replace the synthetic bridge message (if present) with the summary
+                // to avoid consecutive assistant messages in history.
+                let replaced = pop_retrigger_bridge_message(&mut history);
+                tracing::debug!(
+                    channel_id = %self.id,
+                    replaced_bridge = replaced,
+                    replied,
+                    "injecting retrigger summary into history"
+                );
+                history.push(rig::message::Message::Assistant {
+                    id: None,
+                    content: OneOrMany::one(rig::message::AssistantContent::text(record)),
+                });
+            }
+
+            // Mark the completed items as relayed in the status block so their
+            // full result summaries stop appearing on subsequent turns. This
+            // prevents the LLM from re-summarising stale worker/branch results.
+            if replied
+                && let Some(ids) = message
+                    .metadata
+                    .get("retrigger_process_ids")
+                    .and_then(|v| serde_json::from_value::<Vec<String>>(v.clone()).ok())
+            {
+                let mut status = self.state.status_block.write().await;
+                status.mark_relayed(&ids);
+                tracing::debug!(
+                    channel_id = %self.id,
+                    count = ids.len(),
+                    "marked retrigger results as relayed in status block"
+                );
+            }
         }
 
         // Check context size and trigger compaction if needed
@@ -1059,149 +1705,6 @@ impl Channel {
         prompt_engine.render_org_context(org_context).ok()
     }
 
-    /// Build link context for the current channel if it's an internal agent-to-agent channel.
-    fn build_link_context(&self, prompt_engine: &crate::prompts::PromptEngine) -> Option<String> {
-        // Link channels have conversation IDs starting with "link:"
-        let conversation_id = self.conversation_id.as_deref()?;
-        if !conversation_id.starts_with("link:") {
-            return None;
-        }
-
-        let agent_id = self.deps.agent_id.as_ref();
-        let all_links = self.deps.links.load();
-
-        // Find the link that matches this agent's side of the link channel
-        let link = all_links
-            .iter()
-            .find(|link| link.channel_id_for(agent_id) == conversation_id)?;
-
-        let is_from = link.from_agent_id == agent_id;
-        let other_agent_id = if is_from {
-            &link.to_agent_id
-        } else {
-            &link.from_agent_id
-        };
-
-        let role = match link.kind {
-            crate::links::LinkKind::Hierarchical if is_from => "manages",
-            crate::links::LinkKind::Hierarchical => "reports to",
-            crate::links::LinkKind::Peer => "peer",
-        };
-
-        let link_context = crate::prompts::engine::LinkContext {
-            agent_name: self
-                .deps
-                .agent_names
-                .get(other_agent_id.as_str())
-                .cloned()
-                .unwrap_or_else(|| other_agent_id.clone()),
-            relationship: role.to_string(),
-        };
-
-        prompt_engine.render_link_context(link_context).ok()
-    }
-
-    /// Route a link conversation conclusion back to the originating channel.
-    ///
-    /// Injects a system message into the channel that originally called
-    /// `send_agent_message`, then stops processing further messages on this
-    /// link channel.
-    async fn route_link_conclusion(&self, summary: &str, last_message: &crate::InboundMessage) {
-        // Derive the peer agent name from the link channel conversation_id
-        let peer_agent = self
-            .conversation_id
-            .as_deref()
-            .and_then(|cid| cid.strip_prefix("link:"))
-            .and_then(|rest| {
-                // Format is "link:{self}:{peer}", skip past self
-                let parts: Vec<&str> = rest.splitn(2, ':').collect();
-                parts.get(1).copied()
-            })
-            .map(|id| {
-                self.deps
-                    .agent_names
-                    .get(id)
-                    .cloned()
-                    .unwrap_or_else(|| id.to_string())
-            })
-            .unwrap_or_else(|| "agent".to_string());
-
-        // Route conclusion to the originating channel (the one that called send_agent_message)
-        if let Some(originating) = &self.originating_channel {
-            if let Some(mm) = &self.deps.messaging_manager {
-                let conclusion_text = format!(
-                    "[Link conversation with {} concluded]\n{}",
-                    peer_agent, summary
-                );
-
-                // Link-to-link conclusions are internal control messages and must
-                // stay on the internal routing path. For non-link destinations,
-                // use the captured adapter source.
-                let source = if originating.starts_with("link:") {
-                    "internal".to_string()
-                } else {
-                    self.originating_source.clone().unwrap_or_else(|| {
-                        originating
-                            .split(':')
-                            .next()
-                            .unwrap_or("webchat")
-                            .to_string()
-                    })
-                };
-
-                let mut metadata = std::collections::HashMap::new();
-                metadata.insert("link_conclusion".into(), serde_json::json!(true));
-                metadata.insert("link_conclusion_summary".into(), serde_json::json!(summary));
-                metadata.insert("link_conclusion_peer".into(), serde_json::json!(peer_agent));
-
-                let conclusion_message = crate::InboundMessage {
-                    id: uuid::Uuid::new_v4().to_string(),
-                    source,
-                    conversation_id: originating.clone(),
-                    sender_id: peer_agent.clone(),
-                    agent_id: Some(self.deps.agent_id.clone()),
-                    content: crate::MessageContent::Text(conclusion_text),
-                    timestamp: chrono::Utc::now(),
-                    metadata,
-                    formatted_author: Some(format!("[{}]", peer_agent)),
-                };
-
-                if let Err(error) = mm.inject_message(conclusion_message).await {
-                    tracing::error!(
-                        %error,
-                        originating_channel = %originating,
-                        "failed to route link conclusion to originating channel"
-                    );
-                } else {
-                    tracing::info!(
-                        originating_channel = %originating,
-                        peer = %peer_agent,
-                        "routed link conclusion to originating channel"
-                    );
-                }
-            }
-        } else {
-            tracing::debug!(
-                channel_id = %self.id,
-                "link conversation concluded but no originating channel to notify"
-            );
-        }
-
-        // Also try to propagate originating_channel via the reply metadata so
-        // the peer's side can also conclude back to the same originating channel
-        if let Some(from_agent) = last_message
-            .metadata
-            .get("from_agent_id")
-            .and_then(|v| v.as_str())
-        {
-            tracing::info!(
-                from = %from_agent,
-                channel_id = %self.id,
-                "link conversation concluded"
-            );
-        }
-    }
-
     /// Assemble the full system prompt using the PromptEngine.
     async fn build_system_prompt(&self) -> crate::error::Result<String> {
         let rc = &self.deps.runtime_config;
@@ -1215,21 +1718,27 @@ impl Channel {
         let browser_enabled = rc.browser_config.load().enabled;
         let web_search_enabled = rc.brave_search_key.load().is_some();
         let opencode_enabled = rc.opencode.load().enabled;
+        let sandbox_enabled = self.deps.sandbox.containment_active();
         let worker_capabilities = prompt_engine.render_worker_capabilities(
             browser_enabled,
             web_search_enabled,
             opencode_enabled,
         )?;
 
+        let temporal_context = TemporalContext::from_runtime(rc.as_ref());
+        let current_time_line = temporal_context.current_time_line();
         let status_text = {
             let status = self.state.status_block.read().await;
-            status.render()
+            status.render_with_time_context(Some(&current_time_line))
         };
 
         let available_channels = self.build_available_channels().await;
 
         let org_context = self.build_org_context(&prompt_engine);
-        let link_context = self.build_link_context(&prompt_engine);
+
+        let adapter_prompt = self
+            .current_adapter()
+            .and_then(|adapter| prompt_engine.render_channel_adapter_prompt(adapter));
 
         let empty_to_none = |s: String| if s.is_empty() { None } else { Some(s) };
 
@@ -1242,41 +1751,40 @@ impl Channel {
             empty_to_none(status_text),
             None, // coalesce_hint - only set for batched messages
             available_channels,
+            sandbox_enabled,
             org_context,
-            link_context,
+            adapter_prompt,
         )
     }
 
     /// Register per-turn tools, run the LLM agentic loop, and clean up.
     ///
-    /// Returns the prompt result and skip flag for the caller to dispatch.
+    /// Returns the prompt result and per-turn flags for the caller to dispatch.
     #[allow(clippy::type_complexity)]
-    #[tracing::instrument(skip(self, user_text, system_prompt, attachment_content, message_source), fields(channel_id = %self.id, agent_id = %self.deps.agent_id))]
+    #[tracing::instrument(skip(self, user_text, system_prompt, attachment_content), fields(channel_id = %self.id, agent_id = %self.deps.agent_id))]
     async fn run_agent_turn(
         &self,
         user_text: &str,
         system_prompt: &str,
         conversation_id: &str,
         attachment_content: Vec<UserContent>,
-        message_source: Option<String>,
+        is_retrigger: bool,
     ) -> Result<(
         std::result::Result<String, rig::completion::PromptError>,
         crate::tools::SkipFlag,
         crate::tools::RepliedFlag,
-        crate::tools::ConcludeLinkFlag,
-        crate::tools::ConcludeLinkSummary,
+        bool,
     )> {
         let skip_flag = crate::tools::new_skip_flag();
         let replied_flag = crate::tools::new_replied_flag();
+        let allow_direct_reply = !self.suppress_plaintext_fallback();
 
-        // Only provide conclude_link on link channels
-        let is_link_channel = conversation_id.starts_with("link:");
-        let (conclude_flag, conclude_summary) = crate::tools::new_conclude_link();
-        let conclude_link_args = if is_link_channel {
-            Some((conclude_flag.clone(), conclude_summary.clone()))
-        } else {
-            None
-        };
+        // Set the originating channel on the delegation tool so task completion
+        // notifications route back to this conversation.
+        let send_agent_message_tool = self
+            .send_agent_message_tool
+            .clone()
+            .map(|tool| tool.with_originating_channel(conversation_id.to_string()));
 
         if let Err(error) = crate::tools::add_channel_tools(
             &self.tool_server,
@@ -1286,11 +1794,8 @@ impl Channel {
             skip_flag.clone(),
             replied_flag.clone(),
             self.deps.cron_tool.clone(),
-            self.send_agent_message_tool.clone(),
-            conclude_link_args,
-            message_source,
-            self.originating_channel.clone(),
-            self.originating_source.clone(),
+            send_agent_message_tool,
+            allow_direct_reply,
         )
         .await
         {
@@ -1300,7 +1805,11 @@ impl Channel {
 
         let rc = &self.deps.runtime_config;
         let routing = rc.routing.load();
-        let max_turns = **rc.max_turns.load();
+        let max_turns = if is_retrigger {
+            RETRIGGER_MAX_TURNS
+        } else {
+            **rc.max_turns.load()
+        };
         let model_name = routing.resolve(ProcessType::Channel, None);
         let model = SpacebotModel::make(&self.deps.llm_manager, model_name)
             .with_context(&*self.deps.agent_id, "channel")
@@ -1327,6 +1836,29 @@ impl Channel {
             drop(history);
         }
 
+        // For retrigger turns, inject a synthetic assistant acknowledgment so the
+        // LLM sees proper user/assistant role alternation. Without this, the API
+        // receives back-to-back user messages (the original user prompt preserved
+        // from the prior turn + the retrigger system message), which causes some
+        // models to return empty responses or get confused about whose turn it is.
+        if is_retrigger {
+            let mut history = self.state.history.write().await;
+            // Only inject if the last message is a user message (avoid double-stacking
+            // if history already ends with an assistant message).
+            let needs_bridge = history
+                .last()
+                .is_some_and(|m| matches!(m, rig::message::Message::User { .. }));
+            if needs_bridge {
+                history.push(rig::message::Message::Assistant {
+                    id: None,
+                    content: OneOrMany::one(rig::message::AssistantContent::text(
+                        "[acknowledged — working on it in background]",
+                    )),
+                });
+            }
+            drop(history);
+        }
+
         // Clone history out so the write lock is released before the agentic loop.
         // The branch tool needs a read lock on history to clone it for the branch,
         // and holding a write lock across the entire agentic loop would deadlock.
@@ -1336,43 +1868,54 @@ impl Channel {
         };
         let history_len_before = history.len();
 
-        let mut result = agent
-            .prompt(user_text)
-            .with_history(&mut history)
-            .with_hook(self.hook.clone())
-            .await;
+        let mut result = self.hook.prompt_once(&agent, &mut history, user_text).await;
 
         // If the LLM responded with text that looks like tool call syntax, it failed
-        // to use the tool calling API. Inject a correction and give it one more try.
-        if let Ok(ref response) = result
-            && extract_reply_from_tool_syntax(response.trim()).is_some()
-        {
-            tracing::warn!(channel_id = %self.id, "LLM emitted tool syntax as text, retrying with correction");
+        // to use the tool calling API. Inject a correction and retry a couple
+        // times so the model can recover by calling `reply` or `skip`.
+        const TOOL_SYNTAX_RECOVERY_MAX_ATTEMPTS: usize = 2;
+        let mut recovery_attempts = 0;
+        while let Ok(ref response) = result {
+            if !crate::tools::should_block_user_visible_text(response)
+                || recovery_attempts >= TOOL_SYNTAX_RECOVERY_MAX_ATTEMPTS
+            {
+                break;
+            }
+
+            recovery_attempts += 1;
+            tracing::warn!(
+                channel_id = %self.id,
+                attempt = recovery_attempts,
+                "LLM emitted blocked structured output, retrying with correction"
+            );
+
             let prompt_engine = self.deps.runtime_config.prompts.load();
             let correction = prompt_engine.render_system_tool_syntax_correction()?;
-            result = agent
-                .prompt(&correction)
-                .with_history(&mut history)
-                .with_hook(self.hook.clone())
+            result = self
+                .hook
+                .prompt_once(&agent, &mut history, &correction)
                 .await;
         }
 
-        {
+        let retrigger_reply_preserved = {
             let mut guard = self.state.history.write().await;
-            apply_history_after_turn(&result, &mut guard, history, history_len_before, &self.id);
-        }
+            apply_history_after_turn(
+                &result,
+                &mut guard,
+                history,
+                history_len_before,
+                &self.id,
+                is_retrigger,
+            )
+        };
 
-        if let Err(error) = crate::tools::remove_channel_tools(&self.tool_server).await {
+        if let Err(error) =
+            crate::tools::remove_channel_tools(&self.tool_server, allow_direct_reply).await
+        {
             tracing::warn!(%error, "failed to remove channel tools");
         }
 
-        Ok((
-            result,
-            skip_flag,
-            replied_flag,
-            conclude_flag,
-            conclude_summary,
-        ))
+        Ok((result, skip_flag, replied_flag, retrigger_reply_preserved))
     }
 
     /// Dispatch the LLM result: send fallback text, log errors, clean up typing.
@@ -1393,6 +1936,8 @@ impl Channel {
             Ok(response) => {
                 let skipped = skip_flag.load(std::sync::atomic::Ordering::Relaxed);
                 let replied = replied_flag.load(std::sync::atomic::Ordering::Relaxed);
+                let suppress_plaintext_fallback = self.suppress_plaintext_fallback();
+                let adapter = self.current_adapter().unwrap_or("unknown");
 
                 if skipped && is_retrigger {
                     // The LLM skipped on a retrigger turn. This means a worker
@@ -1401,11 +1946,147 @@ impl Channel {
                     // fallback since the user hasn't seen the result yet.
                     let text = response.trim();
                     if !text.is_empty() {
+                        if crate::tools::should_block_user_visible_text(text) {
+                            tracing::warn!(
+                                channel_id = %self.id,
+                                "blocked retrigger fallback output containing structured or tool syntax"
+                            );
+                        } else if let Some(leak) = crate::secrets::scrub::scan_for_leaks(text) {
+                            tracing::warn!(
+                                channel_id = %self.id,
+                                leak_prefix = %&leak[..leak.len().min(8)],
+                                "blocked retrigger fallback output matching secret pattern"
+                            );
+                        } else if suppress_plaintext_fallback {
+                            tracing::info!(
+                                channel_id = %self.id,
+                                adapter,
+                                "suppressing retrigger plaintext fallback for adapter; explicit reply tool call required"
+                            );
+                        } else {
+                            tracing::info!(
+                                channel_id = %self.id,
+                                response_len = text.len(),
+                                "LLM skipped on retrigger but produced text, sending as fallback"
+                            );
+                            let extracted = extract_reply_from_tool_syntax(text);
+                            let source = self
+                                .conversation_id
+                                .as_deref()
+                                .and_then(|conversation_id| conversation_id.split(':').next())
+                                .unwrap_or("unknown");
+                            let final_text = crate::tools::reply::normalize_discord_mention_tokens(
+                                extracted.as_deref().unwrap_or(text),
+                                source,
+                            );
+                            if !final_text.is_empty() {
+                                if extracted.is_some() {
+                                    tracing::warn!(channel_id = %self.id, "extracted reply from malformed tool syntax in retrigger fallback");
+                                }
+                                self.state
+                                    .conversation_logger
+                                    .log_bot_message(&self.state.channel_id, &final_text);
+                                if let Err(error) = self
+                                    .response_tx
+                                    .send(OutboundResponse::Text(final_text))
+                                    .await
+                                {
+                                    tracing::error!(%error, channel_id = %self.id, "failed to send retrigger fallback reply");
+                                }
+                            }
+                        }
+                    } else {
+                        tracing::warn!(
+                            channel_id = %self.id,
+                            "LLM skipped on retrigger with no text — worker/branch result may not have been relayed"
+                        );
+                    }
+                } else if skipped {
+                    tracing::debug!(channel_id = %self.id, "channel turn skipped (no response)");
+                } else if replied {
+                    tracing::debug!(channel_id = %self.id, "channel turn replied via tool (fallback suppressed)");
+                } else if is_retrigger {
+                    // On retrigger turns the LLM should use the reply tool, but
+                    // some models return the result as raw text instead. Send it
+                    // as a fallback so the user still gets the worker/branch output.
+                    let text = response.trim();
+                    if !text.is_empty() {
+                        if crate::tools::should_block_user_visible_text(text) {
+                            tracing::warn!(
+                                channel_id = %self.id,
+                                "blocked retrigger output containing structured or tool syntax"
+                            );
+                        } else if let Some(leak) = crate::secrets::scrub::scan_for_leaks(text) {
+                            tracing::warn!(
+                                channel_id = %self.id,
+                                leak_prefix = %&leak[..leak.len().min(8)],
+                                "blocked retrigger output matching secret pattern"
+                            );
+                        } else if suppress_plaintext_fallback {
+                            tracing::info!(
+                                channel_id = %self.id,
+                                adapter,
+                                "suppressing retrigger plaintext output for adapter; explicit reply tool call required"
+                            );
+                        } else {
+                            tracing::info!(
+                                channel_id = %self.id,
+                                response_len = text.len(),
+                                "retrigger produced text without reply tool, sending as fallback"
+                            );
+                            let extracted = extract_reply_from_tool_syntax(text);
+                            let source = self
+                                .conversation_id
+                                .as_deref()
+                                .and_then(|conversation_id| conversation_id.split(':').next())
+                                .unwrap_or("unknown");
+                            let final_text = crate::tools::reply::normalize_discord_mention_tokens(
+                                extracted.as_deref().unwrap_or(text),
+                                source,
+                            );
+                            if !final_text.is_empty() {
+                                self.state
+                                    .conversation_logger
+                                    .log_bot_message(&self.state.channel_id, &final_text);
+                                if let Err(error) = self
+                                    .response_tx
+                                    .send(OutboundResponse::Text(final_text))
+                                    .await
+                                {
+                                    tracing::error!(%error, channel_id = %self.id, "failed to send retrigger fallback reply");
+                                }
+                            }
+                        }
+                    } else {
+                        tracing::debug!(
+                            channel_id = %self.id,
+                            "retrigger turn produced no text and no reply tool call"
+                        );
+                    }
+                } else {
+                    // If the LLM returned text without using the reply tool, send it
+                    // directly. Some models respond with text instead of tool calls.
+                    // When the text looks like tool call syntax (e.g. "[reply]\n{\"content\": \"hi\"}"),
+                    // attempt to extract the reply content and send that instead.
+                    let text = response.trim();
+                    if crate::tools::should_block_user_visible_text(text) {
+                        tracing::warn!(
+                            channel_id = %self.id,
+                            "blocked fallback output containing structured or tool syntax"
+                        );
+                    } else if let Some(leak) = crate::secrets::scrub::scan_for_leaks(text) {
+                        tracing::warn!(
+                            channel_id = %self.id,
+                            leak_prefix = %&leak[..leak.len().min(8)],
+                            "blocked fallback output matching secret pattern"
+                        );
+                    } else if suppress_plaintext_fallback {
                         tracing::info!(
                             channel_id = %self.id,
-                            response_len = text.len(),
-                            "LLM skipped on retrigger but produced text, sending as fallback"
+                            adapter,
+                            "suppressing plaintext fallback for adapter; explicit reply tool call required"
                         );
+                    } else {
                         let extracted = extract_reply_from_tool_syntax(text);
                         let source = self
                             .conversation_id
@@ -1418,71 +2099,21 @@ impl Channel {
                         );
                         if !final_text.is_empty() {
                             if extracted.is_some() {
-                                tracing::warn!(channel_id = %self.id, "extracted reply from malformed tool syntax in retrigger fallback");
+                                tracing::warn!(channel_id = %self.id, "extracted reply from malformed tool syntax in LLM text output");
                             }
-                            self.state
-                                .conversation_logger
-                                .log_bot_message(&self.state.channel_id, &final_text);
+                            self.state.conversation_logger.log_bot_message_with_name(
+                                &self.state.channel_id,
+                                &final_text,
+                                Some(self.agent_display_name()),
+                            );
                             if let Err(error) = self
                                 .response_tx
                                 .send(OutboundResponse::Text(final_text))
                                 .await
                             {
-                                tracing::error!(%error, channel_id = %self.id, "failed to send retrigger fallback reply");
+                                tracing::error!(%error, channel_id = %self.id, "failed to send fallback reply");
                             }
                         }
-                    } else {
-                        tracing::warn!(
-                            channel_id = %self.id,
-                            "LLM skipped on retrigger with no text — worker/branch result may not have been relayed"
-                        );
-                    }
-                } else if skipped {
-                    tracing::debug!(channel_id = %self.id, "channel turn skipped (no response)");
-                } else if replied {
-                    tracing::debug!(channel_id = %self.id, "channel turn replied via tool (fallback suppressed)");
-                } else if is_retrigger {
-                    // On retrigger turns, suppress fallback text. The LLM should
-                    // use the reply tool explicitly if it has something to say, or
-                    // the skip tool if not. Raw text output from retriggers is
-                    // almost always internal acknowledgment, not a real response.
-                    tracing::debug!(
-                        channel_id = %self.id,
-                        response_len = response.len(),
-                        "retrigger turn fallback suppressed (LLM did not use reply/skip tool)"
-                    );
-                } else {
-                    // If the LLM returned text without using the reply tool, send it
-                    // directly. Some models respond with text instead of tool calls.
-                    // When the text looks like tool call syntax (e.g. "[reply]\n{\"content\": \"hi\"}"),
-                    // attempt to extract the reply content and send that instead.
-                    let text = response.trim();
-                    let extracted = extract_reply_from_tool_syntax(text);
-                    let source = self
-                        .conversation_id
-                        .as_deref()
-                        .and_then(|conversation_id| conversation_id.split(':').next())
-                        .unwrap_or("unknown");
-                    let final_text = crate::tools::reply::normalize_discord_mention_tokens(
-                        extracted.as_deref().unwrap_or(text),
-                        source,
-                    );
-                    if !final_text.is_empty() {
-                        if extracted.is_some() {
-                            tracing::warn!(channel_id = %self.id, "extracted reply from malformed tool syntax in LLM text output");
-                        }
-                        self.state.conversation_logger.log_bot_message_with_name(
-                            &self.state.channel_id,
-                            &final_text,
-                            Some(self.agent_display_name()),
-                        );
-                        if let Err(error) = self
-                            .response_tx
-                            .send(OutboundResponse::Text(final_text))
-                            .await
-                        {
-                            tracing::error!(%error, channel_id = %self.id, "failed to send fallback reply");
-                        }
                     }
 
                     tracing::debug!(channel_id = %self.id, "channel turn completed");
@@ -1512,11 +2143,13 @@ impl Channel {
 
     /// Handle a process event (branch results, worker completions, status updates).
     async fn handle_event(&mut self, event: ProcessEvent) -> Result<()> {
+        // Keep mode aligned with live settings updates while this worker runs.
+        self.sync_listen_only_mode_from_runtime();
+
         // Only process events targeted at this channel
         if !event_is_for_channel(&event, &self.id) {
             return Ok(());
         }
-
         // Update status block
         {
             let mut status = self.state.status_block.write().await;
@@ -1537,7 +2170,8 @@ impl Channel {
             } => {
                 run_logger.log_branch_started(channel_id, *branch_id, description);
                 if let Some(message_id) = reply_to_message_id {
-                    self.branch_reply_targets.insert(*branch_id, *message_id);
+                    self.branch_reply_targets
+                        .insert(*branch_id, message_id.clone());
                 }
             }
             ProcessEvent::BranchResult {
@@ -1545,11 +2179,27 @@ impl Channel {
                 conclusion,
                 ..
             } => {
-                run_logger.log_branch_completed(*branch_id, conclusion);
+                let reply_target_message_id = self.branch_reply_targets.get(branch_id).cloned();
+                let was_active = self
+                    .state
+                    .active_branches
+                    .write()
+                    .await
+                    .remove(branch_id)
+                    .is_some();
+                let was_memory_persistence = self.memory_persistence_branches.remove(branch_id);
+                if !was_active {
+                    if was_memory_persistence {
+                        tracing::info!(
+                            branch_id = %branch_id,
+                            "stale memory-persistence branch completion ignored"
+                        );
+                    }
+                    self.branch_reply_targets.remove(branch_id);
+                    return Ok(());
+                }
 
-                // Remove from active branches
-                let mut branches = self.state.active_branches.write().await;
-                branches.remove(branch_id);
+                run_logger.log_branch_completed(*branch_id, conclusion);
 
                 #[cfg(feature = "metrics")]
                 crate::telemetry::Metrics::global()
@@ -1560,62 +2210,120 @@ impl Channel {
                 // Memory persistence branches complete silently — no history
                 // injection, no re-trigger. The work (memory saves) already
                 // happened inside the branch via tool calls.
-                if self.memory_persistence_branches.remove(branch_id) {
-                    self.branch_reply_targets.remove(branch_id);
+                if was_memory_persistence {
                     tracing::info!(branch_id = %branch_id, "memory persistence branch completed");
                 } else {
-                    // Regular branch: inject conclusion into history
-                    let mut history = self.state.history.write().await;
-                    let branch_message = format!("[Branch result]: {conclusion}");
-                    history.push(rig::message::Message::from(branch_message));
+                    // Regular branch: accumulate result for the next retrigger.
+                    // The result text will be embedded directly in the retrigger
+                    // message so the LLM knows exactly which process produced it.
+                    self.pending_results.push(PendingResult {
+                        process_type: "branch",
+                        process_id: branch_id.to_string(),
+                        result: conclusion.clone(),
+                        success: true,
+                    });
                     should_retrigger = true;
 
-                    if let Some(message_id) = self.branch_reply_targets.remove(branch_id) {
+                    if let Some(message_id) = reply_target_message_id {
                         retrigger_metadata.insert(
-                            "discord_reply_to_message_id".to_string(),
+                            crate::metadata_keys::REPLY_TO_MESSAGE_ID.to_string(),
                             serde_json::Value::from(message_id),
                         );
                     }
 
-                    tracing::info!(branch_id = %branch_id, "branch result incorporated");
+                    tracing::info!(branch_id = %branch_id, "branch result queued for retrigger");
                 }
+                self.branch_reply_targets.remove(branch_id);
             }
             ProcessEvent::WorkerStarted {
                 worker_id,
                 channel_id,
                 task,
+                worker_type,
+                interactive,
                 ..
             } => {
-                run_logger.log_worker_started(channel_id.as_ref(), *worker_id, task);
+                run_logger.log_worker_started(
+                    channel_id.as_ref(),
+                    *worker_id,
+                    task,
+                    worker_type,
+                    &self.deps.agent_id,
+                    *interactive,
+                );
             }
             ProcessEvent::WorkerStatus {
                 worker_id, status, ..
             } => {
                 run_logger.log_worker_status(*worker_id, status);
             }
+            ProcessEvent::WorkerIdle { worker_id, .. } => {
+                run_logger.log_worker_idle(*worker_id);
+            }
             ProcessEvent::WorkerComplete {
                 worker_id,
                 result,
                 notify,
+                success,
                 ..
             } => {
-                run_logger.log_worker_completed(*worker_id, result);
+                // Use worker_handles as the source of truth for active workers.
+                // (active_workers is never populated because Worker is consumed by .run())
+                if self
+                    .state
+                    .worker_handles
+                    .write()
+                    .await
+                    .remove(worker_id)
+                    .is_none()
+                {
+                    return Ok(());
+                }
 
-                let mut workers = self.state.active_workers.write().await;
-                workers.remove(worker_id);
-                drop(workers);
+                run_logger.log_worker_completed(*worker_id, result, *success);
 
-                self.state.worker_handles.write().await.remove(worker_id);
+                self.state.active_workers.write().await.remove(worker_id);
                 self.state.worker_inputs.write().await.remove(worker_id);
 
                 if *notify {
-                    let mut history = self.state.history.write().await;
-                    let worker_message = format!("[Worker completed]: {result}");
-                    history.push(rig::message::Message::from(worker_message));
+                    // Accumulate result for the next retrigger instead of
+                    // injecting into history as a fake user message.
+                    self.pending_results.push(PendingResult {
+                        process_type: "worker",
+                        process_id: worker_id.to_string(),
+                        result: result.clone(),
+                        success: *success,
+                    });
                     should_retrigger = true;
                 }
 
-                tracing::info!(worker_id = %worker_id, "worker completed");
+                tracing::info!(worker_id = %worker_id, "worker completed, result queued for retrigger");
+            }
+            ProcessEvent::OpenCodeSessionCreated {
+                worker_id,
+                session_id,
+                port,
+                ..
+            } => {
+                run_logger.log_opencode_metadata(*worker_id, session_id, *port);
+            }
+            ProcessEvent::WorkerInitialResult {
+                worker_id, result, ..
+            } => {
+                // Interactive worker completed a task (initial or follow-up)
+                // but stays alive for more input. Deliver the result to the
+                // channel without removing the worker from the active set.
+                self.pending_results.push(PendingResult {
+                    process_type: "worker",
+                    process_id: worker_id.to_string(),
+                    result: result.clone(),
+                    success: true,
+                });
+                should_retrigger = true;
+                tracing::info!(
+                    worker_id = %worker_id,
+                    "interactive worker result queued for retrigger"
+                );
             }
             _ => {}
         }
@@ -1631,6 +2339,28 @@ impl Channel {
                     max = MAX_RETRIGGERS_PER_TURN,
                     "retrigger cap reached, suppressing further retriggers until next user message"
                 );
+                // Drain any pending results into history as assistant messages
+                // so they aren't silently lost when the cap prevents a retrigger.
+                if !self.pending_results.is_empty() {
+                    let results = std::mem::take(&mut self.pending_results);
+                    let mut history = self.state.history.write().await;
+                    for r in &results {
+                        let status = if r.success { "completed" } else { "failed" };
+                        let summary = format!(
+                            "[Background {} {} {}]: {}",
+                            r.process_type, r.process_id, status, r.result
+                        );
+                        history.push(rig::message::Message::Assistant {
+                            id: None,
+                            content: OneOrMany::one(rig::message::AssistantContent::text(summary)),
+                        });
+                    }
+                    tracing::info!(
+                        channel_id = %self.id,
+                        count = results.len(),
+                        "injected capped results into history as assistant messages"
+                    );
+                }
             } else {
                 self.pending_retrigger = true;
                 // Merge metadata (later events override earlier ones for the same key)
@@ -1649,43 +2379,124 @@ impl Channel {
 
     /// Flush the pending retrigger: send a synthetic system message to re-trigger
     /// the channel LLM so it can process background results and respond.
+    ///
+    /// Drains `pending_results` and embeds them directly in the retrigger message
+    /// so the LLM sees exactly which process(es) completed and what they returned.
+    /// No result text is left floating in history as an ambiguous user message.
+    ///
+    /// Results are drained only after the synthetic message is queued
+    /// successfully. On transient failures, retrigger state is kept and retried
+    /// so background results are not silently lost.
     async fn flush_pending_retrigger(&mut self) {
         self.retrigger_deadline = None;
 
         if !self.pending_retrigger {
             return;
         }
-        self.pending_retrigger = false;
-        let metadata = std::mem::take(&mut self.pending_retrigger_metadata);
 
         let Some(conversation_id) = &self.conversation_id else {
+            tracing::warn!(
+                channel_id = %self.id,
+                "retrigger pending but conversation_id is missing, dropping pending results"
+            );
+            self.pending_retrigger = false;
+            self.pending_retrigger_metadata.clear();
+            self.pending_results.clear();
             return;
         };
 
-        self.retrigger_count += 1;
-        tracing::info!(
-            channel_id = %self.id,
-            retrigger_count = self.retrigger_count,
-            "firing debounced retrigger"
-        );
+        if self.pending_results.is_empty() {
+            tracing::warn!(
+                channel_id = %self.id,
+                "retrigger fired but no pending results to relay"
+            );
+            self.pending_retrigger = false;
+            self.pending_retrigger_metadata.clear();
+            return;
+        }
+
+        let result_count = self.pending_results.len();
+
+        // Build per-result summaries for the template.
+        let result_items: Vec<_> = self
+            .pending_results
+            .iter()
+            .map(|r| crate::prompts::engine::RetriggerResult {
+                process_type: r.process_type.to_string(),
+                process_id: r.process_id.clone(),
+                success: r.success,
+                result: r.result.clone(),
+            })
+            .collect();
 
         let retrigger_message = match self
             .deps
             .runtime_config
             .prompts
             .load()
-            .render_system_retrigger()
+            .render_system_retrigger(&result_items)
         {
             Ok(message) => message,
             Err(error) => {
-                tracing::error!(%error, "failed to render retrigger message");
+                tracing::error!(
+                    channel_id = %self.id,
+                    %error,
+                    "failed to render retrigger message, retrying"
+                );
+                self.retrigger_deadline = Some(
+                    tokio::time::Instant::now()
+                        + std::time::Duration::from_millis(RETRIGGER_DEBOUNCE_MS),
+                );
                 return;
             }
         };
 
+        // Build a compact summary of the results to inject into history after
+        // a successful relay. This goes into metadata so handle_message can
+        // pull it out without re-parsing the template.
+        let result_summary = self
+            .pending_results
+            .iter()
+            .map(|r| {
+                let status = if r.success { "completed" } else { "failed" };
+                // Truncate very long results for the history record — the user
+                // already saw the full version via the reply tool.
+                let truncated = if r.result.len() > 500 {
+                    let boundary = r.result.floor_char_boundary(500);
+                    format!("{}... [truncated]", &r.result[..boundary])
+                } else {
+                    r.result.clone()
+                };
+                format!(
+                    "[{} {} {}]: {}",
+                    r.process_type, r.process_id, status, truncated
+                )
+            })
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        // Collect the process IDs so we can mark them as relayed in the
+        // status block after the retrigger turn completes successfully.
+        let retrigger_process_ids: Vec<String> = self
+            .pending_results
+            .iter()
+            .map(|r| r.process_id.clone())
+            .collect();
+
+        let mut metadata = self.pending_retrigger_metadata.clone();
+        metadata.insert(
+            "retrigger_result_summary".to_string(),
+            serde_json::Value::String(result_summary),
+        );
+        metadata.insert(
+            "retrigger_process_ids".to_string(),
+            serde_json::json!(retrigger_process_ids),
+        );
+
         let synthetic = InboundMessage {
             id: uuid::Uuid::new_v4().to_string(),
             source: "system".into(),
+            adapter: None,
             conversation_id: conversation_id.clone(),
             sender_id: "system".into(),
             agent_id: None,
@@ -1694,15 +2505,50 @@ impl Channel {
             metadata,
             formatted_author: None,
         };
-        if let Err(error) = self.self_tx.try_send(synthetic) {
-            tracing::warn!(%error, "failed to re-trigger channel after process completion");
+        match self.self_tx.try_send(synthetic) {
+            Ok(()) => {
+                self.retrigger_count += 1;
+                tracing::info!(
+                    channel_id = %self.id,
+                    retrigger_count = self.retrigger_count,
+                    result_count,
+                    "firing debounced retrigger with {} result(s)",
+                    result_count,
+                );
+
+                self.pending_retrigger = false;
+                self.pending_retrigger_metadata.clear();
+                self.pending_results.clear();
+            }
+            Err(tokio::sync::mpsc::error::TrySendError::Full(_)) => {
+                tracing::warn!(
+                    channel_id = %self.id,
+                    result_count,
+                    "channel self queue is full, retrying retrigger"
+                );
+                self.retrigger_deadline = Some(
+                    tokio::time::Instant::now()
+                        + std::time::Duration::from_millis(RETRIGGER_DEBOUNCE_MS),
+                );
+            }
+            Err(tokio::sync::mpsc::error::TrySendError::Closed(_)) => {
+                tracing::warn!(
+                    channel_id = %self.id,
+                    "failed to re-trigger channel: queue is closed, dropping pending results"
+                );
+                self.pending_retrigger = false;
+                self.pending_retrigger_metadata.clear();
+                self.pending_results.clear();
+            }
         }
     }
 
     /// Get the current status block as a string.
     pub async fn get_status(&self) -> String {
+        let temporal_context = TemporalContext::from_runtime(self.deps.runtime_config.as_ref());
+        let current_time_line = temporal_context.current_time_line();
         let status = self.state.status_block.read().await;
-        status.render()
+        status.render_with_time_context(Some(&current_time_line))
     }
 
     /// Check if a memory persistence branch should be spawned based on message count.
@@ -1740,666 +2586,68 @@ impl Channel {
     }
 }
 
-/// Spawn a branch from a ChannelState. Used by the BranchTool.
-pub async fn spawn_branch_from_state(
-    state: &ChannelState,
-    description: impl Into<String>,
-) -> std::result::Result<BranchId, AgentError> {
-    let description = description.into();
-    let rc = &state.deps.runtime_config;
-    let prompt_engine = rc.prompts.load();
-    let system_prompt = prompt_engine
-        .render_branch_prompt(
-            &rc.instance_dir.display().to_string(),
-            &rc.workspace_dir.display().to_string(),
-        )
-        .map_err(|e| AgentError::Other(anyhow::anyhow!("{e}")))?;
-
-    spawn_branch(
-        state,
-        &description,
-        &description,
-        &system_prompt,
-        &description,
-        "branch",
-    )
-    .await
-}
-
-/// Spawn a silent memory persistence branch.
-///
-/// Uses the same branching infrastructure as regular branches but with a
-/// dedicated prompt focused on memory recall + save. The result is not injected
-/// into channel history — the channel handles these branch IDs specially.
-async fn spawn_memory_persistence_branch(
-    state: &ChannelState,
-    deps: &AgentDeps,
-) -> std::result::Result<BranchId, AgentError> {
-    let prompt_engine = deps.runtime_config.prompts.load();
-    let system_prompt = prompt_engine
-        .render_static("memory_persistence")
-        .map_err(|e| AgentError::Other(anyhow::anyhow!("{e}")))?;
-    let prompt = prompt_engine
-        .render_system_memory_persistence()
-        .map_err(|e| AgentError::Other(anyhow::anyhow!("{e}")))?;
-
-    spawn_branch(
-        state,
-        "memory persistence",
-        &prompt,
-        &system_prompt,
-        "persisting memories...",
-        "memory_persistence_branch",
-    )
-    .await
-}
-
-fn ensure_dispatch_readiness(state: &ChannelState, dispatch_type: &'static str) {
-    let readiness = state.deps.runtime_config.work_readiness();
-    if readiness.ready {
-        return;
-    }
-
-    let reason = readiness
-        .reason
-        .map(|value| value.as_str())
-        .unwrap_or("unknown");
-    tracing::warn!(
-        agent_id = %state.deps.agent_id,
-        channel_id = %state.channel_id,
-        dispatch_type,
-        reason,
-        warmup_state = ?readiness.warmup_state,
-        embedding_ready = readiness.embedding_ready,
-        bulletin_age_secs = ?readiness.bulletin_age_secs,
-        stale_after_secs = readiness.stale_after_secs,
-        "dispatch requested before readiness contract was satisfied"
-    );
-
-    #[cfg(feature = "metrics")]
-    crate::telemetry::Metrics::global()
-        .dispatch_while_cold_count
-        .with_label_values(&[&*state.deps.agent_id, dispatch_type, reason])
-        .inc();
-
-    let warmup_config = **state.deps.runtime_config.warmup.load();
-    let should_trigger = readiness.warmup_state != crate::config::WarmupState::Warming
-        && (readiness.reason != Some(crate::config::WorkReadinessReason::EmbeddingNotReady)
-            || warmup_config.eager_embedding_load);
-
-    if should_trigger {
-        crate::agent::cortex::trigger_forced_warmup(state.deps.clone(), dispatch_type);
-    }
-}
-
-/// Shared branch spawning logic.
-///
-/// Checks the branch limit, clones history, creates a Branch, spawns it as
-/// a tokio task, and registers it in the channel's active branches and status block.
-async fn spawn_branch(
-    state: &ChannelState,
-    description: &str,
-    prompt: &str,
-    system_prompt: &str,
-    status_label: &str,
-    dispatch_type: &'static str,
-) -> std::result::Result<BranchId, AgentError> {
-    let max_branches = **state.deps.runtime_config.max_concurrent_branches.load();
-    {
-        let branches = state.active_branches.read().await;
-        if branches.len() >= max_branches {
-            return Err(AgentError::BranchLimitReached {
-                channel_id: state.channel_id.to_string(),
-                max: max_branches,
-            });
-        }
-    }
-    ensure_dispatch_readiness(state, dispatch_type);
-
-    let history = {
-        let h = state.history.read().await;
-        h.clone()
-    };
-
-    let tool_server = crate::tools::create_branch_tool_server(
-        state.deps.memory_search.clone(),
-        state.conversation_logger.clone(),
-        state.channel_store.clone(),
-    );
-    let branch_max_turns = **state.deps.runtime_config.branch_max_turns.load();
-
-    let branch = Branch::new(
-        state.channel_id.clone(),
-        description,
-        state.deps.clone(),
-        system_prompt,
-        history,
-        tool_server,
-        branch_max_turns,
-    );
-
-    let branch_id = branch.id;
-    let prompt = prompt.to_owned();
-
-    let branch_span = tracing::info_span!(
-        "branch.run",
-        branch_id = %branch_id,
-        channel_id = %state.channel_id,
-        description = %description,
-    );
-    let handle = tokio::spawn(
-        async move {
-            if let Err(error) = branch.run(&prompt).await {
-                tracing::error!(branch_id = %branch_id, %error, "branch failed");
-            }
-        }
-        .instrument(branch_span),
-    );
-
-    {
-        let mut branches = state.active_branches.write().await;
-        branches.insert(branch_id, handle);
-    }
-
-    {
-        let mut status = state.status_block.write().await;
-        status.add_branch(branch_id, status_label);
-    }
-
-    #[cfg(feature = "metrics")]
-    crate::telemetry::Metrics::global()
-        .active_branches
-        .with_label_values(&[&*state.deps.agent_id])
-        .inc();
-
-    state
-        .deps
-        .event_tx
-        .send(crate::ProcessEvent::BranchStarted {
-            agent_id: state.deps.agent_id.clone(),
-            branch_id,
-            channel_id: state.channel_id.clone(),
-            description: status_label.to_string(),
-            reply_to_message_id: *state.reply_target_message_id.read().await,
-        })
-        .ok();
-
-    tracing::info!(branch_id = %branch_id, description = %status_label, "branch spawned");
-
-    Ok(branch_id)
-}
-
-/// Check whether the channel has capacity for another worker.
-async fn check_worker_limit(state: &ChannelState) -> std::result::Result<(), AgentError> {
-    let max_workers = **state.deps.runtime_config.max_concurrent_workers.load();
-    let workers = state.active_workers.read().await;
-    if workers.len() >= max_workers {
-        return Err(AgentError::WorkerLimitReached {
-            channel_id: state.channel_id.to_string(),
-            max: max_workers,
-        });
-    }
-    Ok(())
-}
-
-/// Spawn a worker from a ChannelState. Used by the SpawnWorkerTool.
-pub async fn spawn_worker_from_state(
-    state: &ChannelState,
-    task: impl Into<String>,
-    interactive: bool,
-    suggested_skills: &[&str],
-) -> std::result::Result<WorkerId, AgentError> {
-    check_worker_limit(state).await?;
-    ensure_dispatch_readiness(state, "worker");
-    let task = task.into();
-
-    let rc = &state.deps.runtime_config;
-    let prompt_engine = rc.prompts.load();
-    let worker_system_prompt = prompt_engine
-        .render_worker_prompt(
-            &rc.instance_dir.display().to_string(),
-            &rc.workspace_dir.display().to_string(),
-        )
-        .map_err(|e| AgentError::Other(anyhow::anyhow!("{e}")))?;
-    let skills = rc.skills.load();
-    let browser_config = (**rc.browser_config.load()).clone();
-    let brave_search_key = (**rc.brave_search_key.load()).clone();
-
-    // Append skills listing to worker system prompt. Suggested skills are
-    // flagged so the worker knows the channel's intent, but it can read any
-    // skill it decides is relevant via the read_skill tool.
-    let system_prompt = match skills.render_worker_skills(suggested_skills, &prompt_engine) {
-        Ok(skills_prompt) if !skills_prompt.is_empty() => {
-            format!("{worker_system_prompt}\n\n{skills_prompt}")
-        }
-        Ok(_) => worker_system_prompt,
-        Err(error) => {
-            tracing::warn!(%error, "failed to render worker skills listing, spawning without skills context");
-            worker_system_prompt
+#[cfg(test)]
+mod tests {
+    use super::{recv_channel_event, should_process_event_for_channel};
+    use crate::memory::MemoryType;
+    use crate::{AgentId, ChannelId, ProcessEvent, ProcessId};
+    use std::sync::Arc;
+
+    #[tokio::test]
+    async fn channel_event_loop_continues_after_lagged_broadcast() {
+        let (event_tx, mut event_rx) = tokio::sync::broadcast::channel::<ProcessEvent>(2);
+        let agent_id: AgentId = Arc::from("agent");
+        let channel_id: ChannelId = Arc::from("channel");
+        let process_id = ProcessId::Channel(channel_id);
+
+        for status in ["one", "two", "three"] {
+            event_tx
+                .send(ProcessEvent::StatusUpdate {
+                    agent_id: agent_id.clone(),
+                    process_id: process_id.clone(),
+                    status: status.to_string(),
+                })
+                .ok();
         }
-    };
 
-    let worker = if interactive {
-        let (worker, input_tx) = Worker::new_interactive(
-            Some(state.channel_id.clone()),
-            &task,
-            &system_prompt,
-            state.deps.clone(),
-            browser_config.clone(),
-            state.screenshot_dir.clone(),
-            brave_search_key.clone(),
-            state.logs_dir.clone(),
+        let first = recv_channel_event(&mut event_rx).await;
+        assert!(
+            matches!(first, crate::BroadcastRecvResult::Lagged(skipped) if skipped > 0),
+            "expected lagged receive, got {first:?}"
         );
-        let worker_id = worker.id;
-        state
-            .worker_inputs
-            .write()
-            .await
-            .insert(worker_id, input_tx);
-        worker
-    } else {
-        Worker::new(
-            Some(state.channel_id.clone()),
-            &task,
-            &system_prompt,
-            state.deps.clone(),
-            browser_config,
-            state.screenshot_dir.clone(),
-            brave_search_key,
-            state.logs_dir.clone(),
-        )
-    };
-
-    let worker_id = worker.id;
-
-    let worker_span = tracing::info_span!(
-        "worker.run",
-        worker_id = %worker_id,
-        channel_id = %state.channel_id,
-        task = %task,
-    );
-    let handle = spawn_worker_task(
-        worker_id,
-        state.deps.event_tx.clone(),
-        state.deps.agent_id.clone(),
-        Some(state.channel_id.clone()),
-        worker.run().instrument(worker_span),
-    );
-
-    state.worker_handles.write().await.insert(worker_id, handle);
-
-    {
-        let mut status = state.status_block.write().await;
-        status.add_worker(worker_id, &task, false);
-    }
-
-    state
-        .deps
-        .event_tx
-        .send(crate::ProcessEvent::WorkerStarted {
-            agent_id: state.deps.agent_id.clone(),
-            worker_id,
-            channel_id: Some(state.channel_id.clone()),
-            task: task.clone(),
-        })
-        .ok();
 
-    tracing::info!(worker_id = %worker_id, task = %task, "worker spawned");
-
-    Ok(worker_id)
-}
-
-/// Spawn an OpenCode-backed worker for coding tasks.
-///
-/// Instead of a Rig agent loop, this spawns an OpenCode subprocess that has its
-/// own codebase exploration, context management, and tool suite. The worker
-/// communicates with OpenCode via HTTP + SSE.
-pub async fn spawn_opencode_worker_from_state(
-    state: &ChannelState,
-    task: impl Into<String>,
-    directory: &str,
-    interactive: bool,
-) -> std::result::Result<crate::WorkerId, AgentError> {
-    check_worker_limit(state).await?;
-    ensure_dispatch_readiness(state, "opencode_worker");
-    let task = task.into();
-    let directory = std::path::PathBuf::from(directory);
-
-    let rc = &state.deps.runtime_config;
-    let opencode_config = rc.opencode.load();
-
-    if !opencode_config.enabled {
-        return Err(AgentError::Other(anyhow::anyhow!(
-            "OpenCode workers are not enabled in config"
-        )));
-    }
-
-    let server_pool = rc.opencode_server_pool.clone();
-
-    let worker = if interactive {
-        let (worker, input_tx) = crate::opencode::OpenCodeWorker::new_interactive(
-            Some(state.channel_id.clone()),
-            state.deps.agent_id.clone(),
-            &task,
-            directory,
-            server_pool,
-            state.deps.event_tx.clone(),
+        let second = recv_channel_event(&mut event_rx).await;
+        assert!(
+            matches!(
+                second,
+                crate::BroadcastRecvResult::Event(ProcessEvent::StatusUpdate { .. })
+            ),
+            "expected next event after lagged receive, got {second:?}"
         );
-        let worker_id = worker.id;
-        state
-            .worker_inputs
-            .write()
-            .await
-            .insert(worker_id, input_tx);
-        worker
-    } else {
-        crate::opencode::OpenCodeWorker::new(
-            Some(state.channel_id.clone()),
-            state.deps.agent_id.clone(),
-            &task,
-            directory,
-            server_pool,
-            state.deps.event_tx.clone(),
-        )
-    };
-
-    let worker_id = worker.id;
-
-    let worker_span = tracing::info_span!(
-        "worker.run",
-        worker_id = %worker_id,
-        channel_id = %state.channel_id,
-        task = %task,
-        worker_type = "opencode",
-    );
-    let handle = spawn_worker_task(
-        worker_id,
-        state.deps.event_tx.clone(),
-        state.deps.agent_id.clone(),
-        Some(state.channel_id.clone()),
-        async move {
-            let result = worker.run().await?;
-            Ok::<String, anyhow::Error>(result.result_text)
-        }
-        .instrument(worker_span),
-    );
-
-    state.worker_handles.write().await.insert(worker_id, handle);
-
-    let opencode_task = format!("[opencode] {task}");
-    {
-        let mut status = state.status_block.write().await;
-        status.add_worker(worker_id, &opencode_task, false);
-    }
-
-    state
-        .deps
-        .event_tx
-        .send(crate::ProcessEvent::WorkerStarted {
-            agent_id: state.deps.agent_id.clone(),
-            worker_id,
-            channel_id: Some(state.channel_id.clone()),
-            task: opencode_task,
-        })
-        .ok();
-
-    tracing::info!(worker_id = %worker_id, task = %task, "OpenCode worker spawned");
-
-    Ok(worker_id)
-}
-
-/// Spawn a future as a tokio task that sends a `WorkerComplete` event on completion.
-///
-/// Handles both success and error cases, logging failures and sending the
-/// appropriate event. Used by both builtin workers and OpenCode workers.
-/// Returns the JoinHandle so the caller can store it for cancellation.
-fn spawn_worker_task<F, E>(
-    worker_id: WorkerId,
-    event_tx: broadcast::Sender<ProcessEvent>,
-    agent_id: crate::AgentId,
-    channel_id: Option<ChannelId>,
-    future: F,
-) -> tokio::task::JoinHandle<()>
-where
-    F: std::future::Future<Output = std::result::Result<String, E>> + Send + 'static,
-    E: std::fmt::Display + Send + 'static,
-{
-    tokio::spawn(async move {
-        #[cfg(feature = "metrics")]
-        let worker_start = std::time::Instant::now();
-
-        #[cfg(feature = "metrics")]
-        crate::telemetry::Metrics::global()
-            .active_workers
-            .with_label_values(&[&*agent_id])
-            .inc();
-
-        let (result_text, notify) = match future.await {
-            Ok(text) => (text, true),
-            Err(error) => {
-                tracing::error!(worker_id = %worker_id, %error, "worker failed");
-                (format!("Worker failed: {error}"), true)
-            }
-        };
-        #[cfg(feature = "metrics")]
-        {
-            let metrics = crate::telemetry::Metrics::global();
-            metrics
-                .active_workers
-                .with_label_values(&[&*agent_id])
-                .dec();
-            metrics
-                .worker_duration_seconds
-                .with_label_values(&[&*agent_id, "builtin"])
-                .observe(worker_start.elapsed().as_secs_f64());
-        }
-
-        let _ = event_tx.send(ProcessEvent::WorkerComplete {
-            agent_id,
-            worker_id,
-            channel_id,
-            result: result_text,
-            notify,
-        });
-    })
-}
-
-/// Some models emit tool call syntax as plain text instead of making actual tool calls.
-/// When the text starts with a tool-like prefix (e.g. `[reply]`, `(reply)`), try to
-/// extract the reply content so we can send it cleanly instead of showing raw JSON.
-/// Returns `None` if the text doesn't match or can't be parsed — the caller falls
-/// back to sending the original text as-is.
-fn extract_reply_from_tool_syntax(text: &str) -> Option<String> {
-    // Match patterns like "[reply]\n{...}" or "(reply)\n{...}" (with optional whitespace)
-    let tool_prefixes = [
-        "[reply]",
-        "(reply)",
-        "[react]",
-        "(react)",
-        "[skip]",
-        "(skip)",
-        "[branch]",
-        "(branch)",
-        "[spawn_worker]",
-        "(spawn_worker)",
-        "[route]",
-        "(route)",
-        "[cancel]",
-        "(cancel)",
-    ];
-
-    let lower = text.to_lowercase();
-    let matched_prefix = tool_prefixes.iter().find(|p| lower.starts_with(*p))?;
-    let is_reply = matched_prefix.contains("reply");
-    let is_skip = matched_prefix.contains("skip");
-
-    // For skip, just return empty — the user shouldn't see anything
-    if is_skip {
-        return Some(String::new());
-    }
-
-    // For non-reply tools (react, branch, etc.), suppress entirely
-    if !is_reply {
-        return Some(String::new());
-    }
-
-    // Try to extract "content" from the JSON payload after the prefix
-    let rest = text[matched_prefix.len()..].trim();
-    if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(rest)
-        && let Some(content) = parsed.get("content").and_then(|v| v.as_str())
-    {
-        return Some(content.to_string());
-    }
-
-    // If we can't parse JSON, the rest might just be the message itself (no JSON wrapper)
-    if !rest.is_empty() && !rest.starts_with('{') {
-        return Some(rest.to_string());
-    }
-
-    None
-}
-
-/// Format a user message with sender attribution from message metadata.
-///
-/// In multi-user channels, this lets the LLM distinguish who said what.
-/// System-generated messages (re-triggers) are passed through as-is.
-fn format_user_message(raw_text: &str, message: &InboundMessage) -> String {
-    if message.source == "system" {
-        return raw_text.to_string();
-    }
-
-    // Use platform-formatted author if available, fall back to metadata
-    let display_name = message
-        .formatted_author
-        .as_deref()
-        .or_else(|| {
-            message
-                .metadata
-                .get("sender_display_name")
-                .and_then(|v| v.as_str())
-        })
-        .unwrap_or(&message.sender_id);
-
-    let bot_tag = if message
-        .metadata
-        .get("sender_is_bot")
-        .and_then(|v| v.as_bool())
-        .unwrap_or(false)
-    {
-        " (bot)"
-    } else {
-        ""
-    };
-
-    let reply_context = message
-        .metadata
-        .get("reply_to_author")
-        .and_then(|v| v.as_str())
-        .map(|author| {
-            let content_preview = message
-                .metadata
-                .get("reply_to_text")
-                .or_else(|| message.metadata.get("reply_to_content"))
-                .and_then(|v| v.as_str())
-                .unwrap_or("");
-            if content_preview.is_empty() {
-                format!(" (replying to {author})")
-            } else {
-                format!(" (replying to {author}: \"{content_preview}\")")
-            }
-        })
-        .unwrap_or_default();
-
-    format!("{display_name}{bot_tag}{reply_context}: {raw_text}")
-}
-
-fn extract_discord_message_id(message: &InboundMessage) -> Option<u64> {
-    if message.source != "discord" {
-        return None;
     }
 
-    message
-        .metadata
-        .get("discord_message_id")
-        .and_then(|value| value.as_u64())
-}
+    #[tokio::test]
+    async fn channel_event_loop_stops_when_event_bus_closes() {
+        let (event_tx, mut event_rx) = tokio::sync::broadcast::channel::<ProcessEvent>(2);
+        drop(event_tx);
 
-/// Check if a ProcessEvent is targeted at a specific channel.
-///
-/// Events from branches and workers carry a channel_id. We only process events
-/// that originated from this channel — otherwise broadcast events from one
-/// channel's workers would leak into sibling channels (e.g. threads).
-fn event_is_for_channel(event: &ProcessEvent, channel_id: &ChannelId) -> bool {
-    match event {
-        ProcessEvent::BranchResult {
-            channel_id: event_channel,
-            ..
-        } => event_channel == channel_id,
-        ProcessEvent::WorkerComplete {
-            channel_id: event_channel,
-            ..
-        } => event_channel.as_ref() == Some(channel_id),
-        ProcessEvent::WorkerStatus {
-            channel_id: event_channel,
-            ..
-        } => event_channel.as_ref() == Some(channel_id),
-        // Status block updates, tool events, etc. — match on agent_id which
-        // is already filtered by the event bus subscription. Let them through.
-        _ => true,
+        let event = recv_channel_event(&mut event_rx).await;
+        assert!(matches!(event, crate::BroadcastRecvResult::Closed));
     }
-}
-
-/// Image MIME types we support for vision.
-const IMAGE_MIME_PREFIXES: &[&str] = &["image/jpeg", "image/png", "image/gif", "image/webp"];
-
-/// Text-based MIME types where we inline the content.
-const TEXT_MIME_PREFIXES: &[&str] = &[
-    "text/",
-    "application/json",
-    "application/xml",
-    "application/javascript",
-    "application/typescript",
-    "application/toml",
-    "application/yaml",
-];
-
-/// Download attachments and convert them to LLM-ready UserContent parts.
-///
-/// Images become `UserContent::Image` (base64). Text files get inlined.
-/// Other file types get a metadata-only description.
-async fn download_attachments(
-    deps: &AgentDeps,
-    attachments: &[crate::Attachment],
-) -> Vec<UserContent> {
-    let http = deps.llm_manager.http_client();
-    let mut parts = Vec::new();
 
-    for attachment in attachments {
-        let is_image = IMAGE_MIME_PREFIXES
-            .iter()
-            .any(|p| attachment.mime_type.starts_with(p));
-        let is_text = TEXT_MIME_PREFIXES
-            .iter()
-            .any(|p| attachment.mime_type.starts_with(p));
-
-        let content = if is_image {
-            download_image_attachment(http, attachment).await
-        } else if is_text {
-            download_text_attachment(http, attachment).await
-        } else if attachment.mime_type.starts_with("audio/") {
-            transcribe_audio_attachment(deps, http, attachment).await
-        } else {
-            let size_str = attachment
-                .size_bytes
-                .map(|s| format!("{:.1} KB", s as f64 / 1024.0))
-                .unwrap_or_else(|| "unknown size".into());
-            UserContent::text(format!(
-                "[Attachment: {} ({}, {})]",
-                attachment.filename, attachment.mime_type, size_str
-            ))
+    #[test]
+    fn channel_coalesce_ignores_unrelated_memory_saved_events() {
+        let channel_id: ChannelId = Arc::from("channel-a");
+        let event = ProcessEvent::MemorySaved {
+            agent_id: Arc::from("agent"),
+            memory_id: "memory-1".to_string(),
+            channel_id: Some(Arc::from("channel-b")),
+            memory_type: MemoryType::Fact,
+            importance: 0.8,
+            content_summary: "saved memory".to_string(),
         };
 
-        parts.push(content);
+        assert!(!should_process_event_for_channel(&event, &channel_id));
     }
 
     parts
@@ -2491,7 +2739,15 @@ async fn transcribe_audio_attachment(
     }
 
     let (provider_id, model_name) = match deps.llm_manager.resolve_model(voice_model) {
-        Ok(parts) => parts,
+        Ok(parts) => {
+            tracing::debug!(
+                provider = %parts.0,
+                model = %parts.1,
+                voice_config = %voice_model,
+                "resolved voice model for transcription"
+            );
+            parts
+        }
         Err(error) => {
             tracing::warn!(%error, model = %voice_model, "invalid voice model route");
             return UserContent::text(format!(
@@ -2502,7 +2758,15 @@ async fn transcribe_audio_attachment(
     };
 
     let provider = match deps.llm_manager.get_provider(&provider_id) {
-        Ok(provider) => provider,
+        Ok(provider) => {
+            tracing::debug!(
+                provider = %provider_id,
+                base_url = %provider.base_url,
+                api_type = ?provider.api_type,
+                "got provider for voice transcription"
+            );
+            provider
+        }
         Err(error) => {
             tracing::warn!(%error, provider = %provider_id, "voice provider not configured");
             return UserContent::text(format!(
@@ -2527,6 +2791,11 @@ async fn transcribe_audio_attachment(
         "{}/v1/chat/completions",
         provider.base_url.trim_end_matches('/')
     );
+    tracing::debug!(
+        endpoint = %endpoint,
+        model = %model_name,
+        "sending voice transcription request"
+    );
     let body = serde_json::json!({
         "model": model_name,
         "messages": [{
@@ -2789,204 +3058,85 @@ mod tests {
 
     /// On success, the full post-turn history is written back.
     #[test]
-    fn ok_writes_history_back() {
-        let mut guard = make_history(&["hello"]);
-        let history = make_history(&["hello", "hi there", "how are you?"]);
-        let len_before = 1;
-
-        apply_history_after_turn(
-            &Ok("hi there".to_string()),
-            &mut guard,
-            history.clone(),
-            len_before,
-            "test",
-        );
+    fn channel_coalesce_ignores_unrelated_compaction_events() {
+        let channel_id: ChannelId = Arc::from("channel-a");
+        let event = ProcessEvent::CompactionTriggered {
+            agent_id: Arc::from("agent"),
+            channel_id: Arc::from("channel-b"),
+            threshold_reached: 0.85,
+        };
 
-        assert_eq!(guard, history);
+        assert!(!should_process_event_for_channel(&event, &channel_id));
     }
 
-    /// MaxTurnsError carries consistent history (tool results included) — write it back.
     #[test]
-    fn max_turns_writes_history_back() {
-        let mut guard = make_history(&["hello"]);
-        let history = make_history(&["hello", "hi there", "how are you?"]);
-        let len_before = 1;
-
-        let err = Err(PromptError::MaxTurnsError {
-            max_turns: 5,
-            chat_history: Box::new(history.clone()),
-            prompt: Box::new(user_msg("prompt")),
-        });
-
-        apply_history_after_turn(&err, &mut guard, history.clone(), len_before, "test");
-
-        assert_eq!(guard, history);
-    }
+    fn channel_coalesce_processes_related_worker_events() {
+        let channel_id: ChannelId = Arc::from("channel-a");
+        let event = ProcessEvent::WorkerStatus {
+            agent_id: Arc::from("agent"),
+            worker_id: uuid::Uuid::new_v4(),
+            channel_id: Some(channel_id.clone()),
+            status: "running".to_string(),
+        };
 
-    /// PromptCancelled carries history missing tool results — roll back to snapshot.
-    #[test]
-    fn prompt_cancelled_rolls_back() {
-        let initial = make_history(&["hello", "thinking..."]);
-        let mut guard = initial.clone();
-        // Rig appended a tool-call message before cancelling — simulated by
-        // the longer history passed as `history`.
-        let mut history = initial.clone();
-        history.push(user_msg("[dangling tool-call]"));
-        let len_before = initial.len();
-
-        let err = Err(PromptError::PromptCancelled {
-            chat_history: Box::new(history.clone()),
-            reason: "reply delivered".to_string(),
-        });
-
-        apply_history_after_turn(&err, &mut guard, history, len_before, "test");
-
-        assert_eq!(
-            guard, initial,
-            "history should be rolled back to pre-turn snapshot"
-        );
+        assert!(should_process_event_for_channel(&event, &channel_id));
     }
 
-    /// Hard completion errors also roll back to prevent dangling tool-calls.
     #[test]
-    fn completion_error_rolls_back() {
-        let initial = make_history(&["hello", "thinking..."]);
-        let mut guard = initial.clone();
-        let mut history = initial.clone();
-        history.push(user_msg("[dangling tool-call]"));
-        let len_before = initial.len();
-
-        let err = Err(PromptError::CompletionError(
-            CompletionError::ResponseError("API error".to_string()),
-        ));
-
-        apply_history_after_turn(&err, &mut guard, history, len_before, "test");
+    fn channel_coalesce_processes_related_branch_events() {
+        let channel_id: ChannelId = Arc::from("channel-a");
+        let event = ProcessEvent::BranchResult {
+            agent_id: Arc::from("agent"),
+            branch_id: uuid::Uuid::new_v4(),
+            channel_id: channel_id.clone(),
+            conclusion: "done".to_string(),
+        };
 
-        assert_eq!(
-            guard, initial,
-            "history should be rolled back after hard error"
-        );
+        assert!(should_process_event_for_channel(&event, &channel_id));
     }
 
-    /// ToolError (tool not found) rolls back — same catch-all arm as hard errors.
     #[test]
-    fn tool_error_rolls_back() {
-        let initial = make_history(&["hello", "thinking..."]);
-        let mut guard = initial.clone();
-        let mut history = initial.clone();
-        history.push(user_msg("[dangling tool-call]"));
-        let len_before = initial.len();
-
-        let err = Err(PromptError::ToolError(ToolSetError::ToolNotFoundError(
-            "nonexistent_tool".to_string(),
-        )));
-
-        apply_history_after_turn(&err, &mut guard, history, len_before, "test");
-
-        assert_eq!(
-            guard, initial,
-            "history should be rolled back after tool error"
-        );
-    }
-
-    /// Rollback on empty history is a no-op and must not panic.
-    #[test]
-    fn rollback_on_empty_history_is_noop() {
-        let mut guard: Vec<Message> = vec![];
-        let history: Vec<Message> = vec![];
-        let len_before = 0;
-
-        let err = Err(PromptError::PromptCancelled {
-            chat_history: Box::new(history.clone()),
-            reason: "reply delivered".to_string(),
-        });
-
-        apply_history_after_turn(&err, &mut guard, history, len_before, "test");
+    fn worker_complete_event_matches_own_channel() {
+        let channel_id: ChannelId = Arc::from("channel-a");
+        let event = ProcessEvent::WorkerComplete {
+            agent_id: Arc::from("agent"),
+            worker_id: uuid::Uuid::new_v4(),
+            channel_id: Some(channel_id.clone()),
+            result: "done".to_string(),
+            notify: true,
+            success: true,
+        };
 
-        assert!(
-            guard.is_empty(),
-            "empty history should stay empty after rollback"
-        );
+        assert!(should_process_event_for_channel(&event, &channel_id));
     }
 
-    /// Rollback when nothing was appended is also a no-op (len unchanged).
     #[test]
-    fn rollback_when_nothing_appended_is_noop() {
-        let initial = make_history(&["hello", "thinking..."]);
-        let mut guard = initial.clone();
-        // history has same length as before — Rig cancelled before appending anything
-        let history = initial.clone();
-        let len_before = initial.len();
-
-        let err = Err(PromptError::PromptCancelled {
-            chat_history: Box::new(history.clone()),
-            reason: "skip delivered".to_string(),
-        });
-
-        apply_history_after_turn(&err, &mut guard, history, len_before, "test");
-
-        assert_eq!(
-            guard, initial,
-            "history should be unchanged when nothing was appended"
-        );
+    fn worker_complete_event_ignored_for_other_channel() {
+        let channel_id: ChannelId = Arc::from("channel-a");
+        let event = ProcessEvent::WorkerComplete {
+            agent_id: Arc::from("agent"),
+            worker_id: uuid::Uuid::new_v4(),
+            channel_id: Some(Arc::from("channel-b")),
+            result: "done".to_string(),
+            notify: true,
+            success: true,
+        };
+
+        assert!(!should_process_event_for_channel(&event, &channel_id));
     }
 
-    /// After rollback, the next turn starts clean with no dangling messages.
     #[test]
-    fn next_turn_is_clean_after_prompt_cancelled() {
-        let initial = make_history(&["hello", "thinking..."]);
-        let mut guard = initial.clone();
-        let mut poisoned_history = initial.clone();
-        poisoned_history.push(user_msg("[dangling tool-call without result]"));
-        let len_before = initial.len();
-
-        // First turn: cancelled (reply tool fired)
-        apply_history_after_turn(
-            &Err(PromptError::PromptCancelled {
-                chat_history: Box::new(poisoned_history.clone()),
-                reason: "reply delivered".to_string(),
-            }),
-            &mut guard,
-            poisoned_history,
-            len_before,
-            "test",
-        );
-
-        // Second turn: new user message appended, successful response
-        guard.push(user_msg("follow-up question"));
-        let len_before2 = guard.len();
-        let mut history2 = guard.clone();
-        history2.push(assistant_msg("clean response"));
-
-        apply_history_after_turn(
-            &Ok("clean response".to_string()),
-            &mut guard,
-            history2.clone(),
-            len_before2,
-            "test",
-        );
+    fn worker_complete_event_ignored_when_no_channel() {
+        let channel_id: ChannelId = Arc::from("channel-a");
+        let event = ProcessEvent::WorkerComplete {
+            agent_id: Arc::from("agent"),
+            worker_id: uuid::Uuid::new_v4(),
+            channel_id: None,
+            result: "done".to_string(),
+            notify: true,
+            success: true,
+        };
 
-        assert_eq!(
-            guard, history2,
-            "second turn should succeed with clean history"
-        );
-        // Crucially: no dangling tool-call in history
-        let has_dangling = guard.iter().any(|m| {
-            if let Message::User { content } = m {
-                content.iter().any(|c| {
-                    if let rig::message::UserContent::Text(t) = c {
-                        t.text.contains("dangling")
-                    } else {
-                        false
-                    }
-                })
-            } else {
-                false
-            }
-        });
-        assert!(
-            !has_dangling,
-            "no dangling tool-call messages in history after rollback"
-        );
+        assert!(!should_process_event_for_channel(&event, &channel_id));
     }
 }
diff --git a/src/agent/channel_attachments.rs b/src/agent/channel_attachments.rs
new file mode 100644
index 000000000..7a7c98f98
--- /dev/null
+++ b/src/agent/channel_attachments.rs
@@ -0,0 +1,440 @@
+//! Attachment download and processing for channel messages.
+//!
+//! Handles image, text, and audio attachments — downloading from URLs,
+//! base64 encoding for vision models, inlining text content, and
+//! transcribing audio via the configured voice model.
+
+use crate::AgentDeps;
+use crate::config::ApiType;
+use rig::message::{ImageMediaType, MimeType, UserContent};
+
+/// Image MIME types we support for vision.
+const IMAGE_MIME_PREFIXES: &[&str] = &["image/jpeg", "image/png", "image/gif", "image/webp"];
+
+/// Text-based MIME types where we inline the content.
+const TEXT_MIME_PREFIXES: &[&str] = &[
+    "text/",
+    "application/json",
+    "application/xml",
+    "application/javascript",
+    "application/typescript",
+    "application/toml",
+    "application/yaml",
+];
+
+/// Download attachments and convert them to LLM-ready UserContent parts.
+///
+/// Images become `UserContent::Image` (base64). Text files get inlined.
+/// Other file types get a metadata-only description.
+pub(crate) async fn download_attachments(
+    deps: &AgentDeps,
+    attachments: &[crate::Attachment],
+) -> Vec<UserContent> {
+    let http = deps.llm_manager.http_client();
+    let mut parts = Vec::new();
+
+    for attachment in attachments {
+        let is_image = IMAGE_MIME_PREFIXES
+            .iter()
+            .any(|p| attachment.mime_type.starts_with(p));
+        let is_text = TEXT_MIME_PREFIXES
+            .iter()
+            .any(|p| attachment.mime_type.starts_with(p));
+
+        let content = if is_image {
+            download_image_attachment(http, attachment).await
+        } else if is_text {
+            download_text_attachment(http, attachment).await
+        } else if attachment.mime_type.starts_with("audio/") {
+            transcribe_audio_attachment(deps, http, attachment).await
+        } else {
+            let size_str = attachment
+                .size_bytes
+                .map(|s| format!("{:.1} KB", s as f64 / 1024.0))
+                .unwrap_or_else(|| "unknown size".into());
+            UserContent::text(format!(
+                "[Attachment: {} ({}, {})]",
+                attachment.filename, attachment.mime_type, size_str
+            ))
+        };
+
+        parts.push(content);
+    }
+
+    parts
+}
+
+/// Download raw bytes from an attachment URL, including auth if present.
+///
+/// When `auth_header` is set (Slack), uses a no-redirect client and manually
+/// follows redirects so the `Authorization` header isn't silently stripped on
+/// cross-origin redirects. For public URLs (Discord/Telegram), uses a plain GET.
+async fn download_attachment_bytes(
+    http: &reqwest::Client,
+    attachment: &crate::Attachment,
+) -> std::result::Result<Vec<u8>, String> {
+    if attachment.auth_header.is_some() {
+        download_attachment_bytes_with_auth(attachment).await
+    } else {
+        let response = http
+            .get(&attachment.url)
+            .send()
+            .await
+            .map_err(|e| e.to_string())?;
+        if !response.status().is_success() {
+            return Err(format!("HTTP {}", response.status()));
+        }
+        response
+            .bytes()
+            .await
+            .map(|b| b.to_vec())
+            .map_err(|e| e.to_string())
+    }
+}
+
+/// Slack-specific download: manually follows redirects, only forwarding the
+/// Authorization header when the redirect target shares the same host as the
+/// original URL. This prevents credential leakage on cross-origin redirects.
+async fn download_attachment_bytes_with_auth(
+    attachment: &crate::Attachment,
+) -> std::result::Result<Vec<u8>, String> {
+    let client = reqwest::Client::builder()
+        .redirect(reqwest::redirect::Policy::none())
+        .timeout(std::time::Duration::from_secs(60))
+        .build()
+        .map_err(|e| format!("failed to build HTTP client: {e}"))?;
+
+    let auth = attachment.auth_header.as_deref().unwrap_or_default();
+    let original_url =
+        reqwest::Url::parse(&attachment.url).map_err(|e| format!("invalid attachment URL: {e}"))?;
+    let original_host = original_url.host_str().unwrap_or_default().to_owned();
+    let mut current_url = original_url;
+
+    for hop in 0..5 {
+        let same_host = current_url.host_str().unwrap_or_default() == original_host;
+
+        let mut request = client.get(current_url.clone());
+        if same_host {
+            request = request.header(reqwest::header::AUTHORIZATION, auth);
+        }
+
+        tracing::debug!(hop, url = %current_url, same_host, "following attachment redirect");
+
+        let response = request.send().await.map_err(|e| e.to_string())?;
+        let status = response.status();
+
+        if status.is_redirection() {
+            let location = response
+                .headers()
+                .get(reqwest::header::LOCATION)
+                .ok_or_else(|| format!("redirect without Location header ({status})"))?;
+            let location_str = location
+                .to_str()
+                .map_err(|e| format!("invalid Location header: {e}"))?;
+            current_url = current_url
+                .join(location_str)
+                .map_err(|e| format!("invalid redirect URL: {e}"))?;
+            continue;
+        }
+
+        if !status.is_success() {
+            return Err(format!("HTTP {}", status));
+        }
+
+        return response
+            .bytes()
+            .await
+            .map(|b| b.to_vec())
+            .map_err(|e| e.to_string());
+    }
+
+    Err("too many redirects".into())
+}
+
+/// Download an image attachment and encode it as base64 for the LLM.
+async fn download_image_attachment(
+    http: &reqwest::Client,
+    attachment: &crate::Attachment,
+) -> UserContent {
+    let bytes = match download_attachment_bytes(http, attachment).await {
+        Ok(b) => b,
+        Err(error) => {
+            tracing::warn!(%error, filename = %attachment.filename, "failed to download image");
+            return UserContent::text(format!(
+                "[Failed to download image: {}]",
+                attachment.filename
+            ));
+        }
+    };
+
+    use base64::Engine as _;
+    let base64_data = base64::engine::general_purpose::STANDARD.encode(&bytes);
+    let media_type = ImageMediaType::from_mime_type(&attachment.mime_type);
+
+    tracing::info!(
+        filename = %attachment.filename,
+        mime = %attachment.mime_type,
+        size = bytes.len(),
+        "downloaded image attachment"
+    );
+
+    UserContent::image_base64(base64_data, media_type, None)
+}
+
+/// Download an audio attachment and transcribe it with the configured voice model.
+async fn transcribe_audio_attachment(
+    deps: &AgentDeps,
+    http: &reqwest::Client,
+    attachment: &crate::Attachment,
+) -> UserContent {
+    let bytes = match download_attachment_bytes(http, attachment).await {
+        Ok(b) => b,
+        Err(error) => {
+            tracing::warn!(%error, filename = %attachment.filename, "failed to download audio");
+            return UserContent::text(format!(
+                "[Failed to download audio: {}]",
+                attachment.filename
+            ));
+        }
+    };
+
+    tracing::info!(
+        filename = %attachment.filename,
+        mime = %attachment.mime_type,
+        size = bytes.len(),
+        "downloaded audio attachment"
+    );
+
+    let routing = deps.runtime_config.routing.load();
+    let voice_model = routing.voice.trim();
+    if voice_model.is_empty() {
+        return UserContent::text(format!(
+            "[Audio attachment received but no voice model is configured in routing.voice: {}]",
+            attachment.filename
+        ));
+    }
+
+    let (provider_id, model_name) = match deps.llm_manager.resolve_model(voice_model) {
+        Ok(parts) => parts,
+        Err(error) => {
+            tracing::warn!(%error, model = %voice_model, "invalid voice model route");
+            return UserContent::text(format!(
+                "[Audio transcription failed for {}: invalid voice model '{}']",
+                attachment.filename, voice_model
+            ));
+        }
+    };
+
+    let provider = match deps.llm_manager.get_provider(&provider_id) {
+        Ok(provider) => provider,
+        Err(error) => {
+            tracing::warn!(%error, provider = %provider_id, "voice provider not configured");
+            return UserContent::text(format!(
+                "[Audio transcription failed for {}: provider '{}' is not configured]",
+                attachment.filename, provider_id
+            ));
+        }
+    };
+
+    if provider.api_type == ApiType::Anthropic {
+        return UserContent::text(format!(
+            "[Audio transcription failed for {}: provider '{}' does not support input_audio on this endpoint]",
+            attachment.filename, provider_id
+        ));
+    }
+
+    let format = audio_format_for_attachment(attachment);
+    use base64::Engine as _;
+    let base64_audio = base64::engine::general_purpose::STANDARD.encode(&bytes);
+
+    let endpoint = format!(
+        "{}/v1/chat/completions",
+        provider.base_url.trim_end_matches('/')
+    );
+    let body = serde_json::json!({
+        "model": model_name,
+        "messages": [{
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "Transcribe this audio verbatim. Return only the transcription text."
+                },
+                {
+                    "type": "input_audio",
+                    "input_audio": {
+                        "data": base64_audio,
+                        "format": format,
+                    }
+                }
+            ]
+        }],
+        "temperature": 0
+    });
+
+    let response = match deps
+        .llm_manager
+        .http_client()
+        .post(&endpoint)
+        .header("authorization", format!("Bearer {}", provider.api_key))
+        .header("content-type", "application/json")
+        .json(&body)
+        .send()
+        .await
+    {
+        Ok(response) => response,
+        Err(error) => {
+            tracing::warn!(%error, model = %voice_model, "voice transcription request failed");
+            return UserContent::text(format!(
+                "[Audio transcription failed for {}]",
+                attachment.filename
+            ));
+        }
+    };
+
+    let status = response.status();
+    let response_body = match response.json::<serde_json::Value>().await {
+        Ok(body) => body,
+        Err(error) => {
+            tracing::warn!(%error, model = %voice_model, "invalid transcription response");
+            return UserContent::text(format!(
+                "[Audio transcription failed for {}]",
+                attachment.filename
+            ));
+        }
+    };
+
+    if !status.is_success() {
+        let message = response_body["error"]["message"]
+            .as_str()
+            .unwrap_or("unknown error");
+        tracing::warn!(
+            status = %status,
+            model = %voice_model,
+            error = %message,
+            "voice transcription provider returned error"
+        );
+        return UserContent::text(format!(
+            "[Audio transcription failed for {}: {}]",
+            attachment.filename, message
+        ));
+    }
+
+    let transcript = extract_transcript_text(&response_body);
+    if transcript.is_empty() {
+        tracing::warn!(model = %voice_model, "empty transcription returned");
+        return UserContent::text(format!(
+            "[Audio transcription returned empty text for {}]",
+            attachment.filename
+        ));
+    }
+
+    UserContent::text(format!(
+        "<voice_transcript name=\"{}\" mime=\"{}\">\n{}\n</voice_transcript>",
+        attachment.filename, attachment.mime_type, transcript
+    ))
+}
+
+fn audio_format_for_attachment(attachment: &crate::Attachment) -> &'static str {
+    let mime = attachment.mime_type.to_lowercase();
+    if mime.contains("mpeg") || mime.contains("mp3") {
+        return "mp3";
+    }
+    if mime.contains("wav") {
+        return "wav";
+    }
+    if mime.contains("flac") {
+        return "flac";
+    }
+    if mime.contains("aac") {
+        return "aac";
+    }
+    if mime.contains("ogg") {
+        return "ogg";
+    }
+    if mime.contains("mp4") || mime.contains("m4a") {
+        return "m4a";
+    }
+
+    match attachment
+        .filename
+        .rsplit('.')
+        .next()
+        .unwrap_or_default()
+        .to_lowercase()
+        .as_str()
+    {
+        "mp3" => "mp3",
+        "wav" => "wav",
+        "flac" => "flac",
+        "aac" => "aac",
+        "m4a" | "mp4" => "m4a",
+        "oga" | "ogg" => "ogg",
+        _ => "ogg",
+    }
+}
+
+fn extract_transcript_text(body: &serde_json::Value) -> String {
+    if let Some(text) = body["choices"][0]["message"]["content"].as_str() {
+        return text.trim().to_string();
+    }
+
+    let Some(parts) = body["choices"][0]["message"]["content"].as_array() else {
+        return String::new();
+    };
+
+    parts
+        .iter()
+        .filter_map(|part| {
+            if part["type"].as_str() == Some("text") {
+                part["text"].as_str().map(str::trim)
+            } else {
+                None
+            }
+        })
+        .filter(|text| !text.is_empty())
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+/// Download a text attachment and inline its content for the LLM.
+async fn download_text_attachment(
+    http: &reqwest::Client,
+    attachment: &crate::Attachment,
+) -> UserContent {
+    let bytes = match download_attachment_bytes(http, attachment).await {
+        Ok(b) => b,
+        Err(error) => {
+            tracing::warn!(%error, filename = %attachment.filename, "failed to download text file");
+            return UserContent::text(format!(
+                "[Failed to download file: {}]",
+                attachment.filename
+            ));
+        }
+    };
+
+    let content = String::from_utf8_lossy(&bytes).into_owned();
+
+    // Truncate very large files to avoid blowing up context
+    let truncated = if content.len() > 50_000 {
+        let end = content.floor_char_boundary(50_000);
+        format!(
+            "{}...\n[truncated — {} bytes total]",
+            &content[..end],
+            content.len()
+        )
+    } else {
+        content
+    };
+
+    tracing::info!(
+        filename = %attachment.filename,
+        mime = %attachment.mime_type,
+        "downloaded text attachment"
+    );
+
+    UserContent::text(format!(
+        "<file name=\"{}\" mime=\"{}\">\n{}\n</file>",
+        attachment.filename, attachment.mime_type, truncated
+    ))
+}
diff --git a/src/agent/channel_dispatch.rs b/src/agent/channel_dispatch.rs
new file mode 100644
index 000000000..d6df99e11
--- /dev/null
+++ b/src/agent/channel_dispatch.rs
@@ -0,0 +1,824 @@
+//! Branch and worker spawning for channels.
+//!
+//! Contains the public entry points that channel tools use to create
+//! background processes: `spawn_branch_from_state`, `spawn_worker_from_state`,
+//! and `spawn_opencode_worker_from_state`.
+
+use crate::agent::branch::Branch;
+use crate::agent::channel::ChannelState;
+use crate::agent::channel_prompt::{TemporalContext, build_worker_task_with_temporal_context};
+use crate::agent::worker::Worker;
+use crate::error::{AgentError, Error as SpacebotError};
+use crate::{AgentDeps, BranchId, ChannelId, ProcessEvent, WorkerId};
+use futures::FutureExt as _;
+use std::sync::Arc;
+use tokio::sync::broadcast;
+use tracing::Instrument as _;
+
+/// Validate worker capacity for a channel based on current active worker count.
+pub(crate) fn reserve_worker_slot_local(
+    active_worker_count: usize,
+    channel_id: &Arc<str>,
+    max_workers: usize,
+) -> std::result::Result<(), AgentError> {
+    if active_worker_count >= max_workers {
+        return Err(AgentError::WorkerLimitReached {
+            channel_id: channel_id.to_string(),
+            max: max_workers,
+        });
+    }
+
+    Ok(())
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum WorkerCompletionKind {
+    Success,
+    Cancelled,
+    Failed,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum WorkerCompletionError {
+    Cancelled { reason: String },
+    Failed { message: String },
+}
+
+impl WorkerCompletionError {
+    pub(crate) fn failed(message: impl Into<String>) -> Self {
+        Self::Failed {
+            message: message.into(),
+        }
+    }
+
+    fn from_spacebot_error(error: SpacebotError) -> Self {
+        match error {
+            SpacebotError::Agent(agent_error) => match *agent_error {
+                AgentError::Cancelled { reason } => Self::Cancelled { reason },
+                other => Self::Failed {
+                    message: other.to_string(),
+                },
+            },
+            other => Self::Failed {
+                message: other.to_string(),
+            },
+        }
+    }
+}
+
+fn classify_worker_completion_result(
+    result: std::result::Result<String, WorkerCompletionError>,
+) -> (String, WorkerCompletionKind) {
+    match result {
+        Ok(text) => (text, WorkerCompletionKind::Success),
+        Err(WorkerCompletionError::Cancelled { reason }) => (
+            format!("Worker cancelled: {reason}"),
+            WorkerCompletionKind::Cancelled,
+        ),
+        Err(WorkerCompletionError::Failed { message }) => (
+            format!("Worker failed: {message}"),
+            WorkerCompletionKind::Failed,
+        ),
+    }
+}
+
+fn completion_flags(kind: WorkerCompletionKind) -> (bool, bool) {
+    let notify = true;
+    let success = matches!(kind, WorkerCompletionKind::Success);
+    (notify, success)
+}
+
+/// Normalize worker completion into event payload fields.
+pub(crate) fn map_worker_completion_result(
+    result: std::result::Result<String, WorkerCompletionError>,
+) -> (String, bool, bool) {
+    let (result_text, kind) = classify_worker_completion_result(result);
+    let (notify, success) = completion_flags(kind);
+    (result_text, notify, success)
+}
+
+/// Spawn a branch from a ChannelState. Used by the BranchTool.
+pub async fn spawn_branch_from_state(
+    state: &ChannelState,
+    description: impl Into<String>,
+) -> std::result::Result<BranchId, AgentError> {
+    let description = description.into();
+    let rc = &state.deps.runtime_config;
+    let prompt_engine = rc.prompts.load();
+    let system_prompt = prompt_engine
+        .render_branch_prompt(
+            &rc.instance_dir.display().to_string(),
+            &rc.workspace_dir.display().to_string(),
+        )
+        .map_err(|e| AgentError::Other(anyhow::anyhow!("{e}")))?;
+
+    spawn_branch(
+        state,
+        &description,
+        &description,
+        &system_prompt,
+        &description,
+        "branch",
+    )
+    .await
+}
+
+/// Spawn a silent memory persistence branch.
+///
+/// Uses the same branching infrastructure as regular branches but with a
+/// dedicated prompt focused on memory recall + save. The result is not injected
+/// into channel history — the channel handles these branch IDs specially.
+pub(crate) async fn spawn_memory_persistence_branch(
+    state: &ChannelState,
+    deps: &AgentDeps,
+) -> std::result::Result<BranchId, AgentError> {
+    let prompt_engine = deps.runtime_config.prompts.load();
+    let system_prompt = prompt_engine
+        .render_static("memory_persistence")
+        .map_err(|e| AgentError::Other(anyhow::anyhow!("{e}")))?;
+    let prompt = prompt_engine
+        .render_system_memory_persistence()
+        .map_err(|e| AgentError::Other(anyhow::anyhow!("{e}")))?;
+
+    spawn_branch(
+        state,
+        "memory persistence",
+        &prompt,
+        &system_prompt,
+        "persisting memories...",
+        "memory_persistence_branch",
+    )
+    .await
+}
+
+fn ensure_dispatch_readiness(state: &ChannelState, dispatch_type: &'static str) {
+    let readiness = state.deps.runtime_config.work_readiness();
+    if readiness.ready {
+        return;
+    }
+
+    let reason = readiness
+        .reason
+        .map(|value| value.as_str())
+        .unwrap_or("unknown");
+    tracing::warn!(
+        agent_id = %state.deps.agent_id,
+        channel_id = %state.channel_id,
+        dispatch_type,
+        reason,
+        warmup_state = ?readiness.warmup_state,
+        embedding_ready = readiness.embedding_ready,
+        bulletin_age_secs = ?readiness.bulletin_age_secs,
+        stale_after_secs = readiness.stale_after_secs,
+        "dispatch requested before readiness contract was satisfied"
+    );
+
+    #[cfg(feature = "metrics")]
+    crate::telemetry::Metrics::global()
+        .dispatch_while_cold_count
+        .with_label_values(&[&*state.deps.agent_id, dispatch_type, reason])
+        .inc();
+
+    let warmup_config = **state.deps.runtime_config.warmup.load();
+    let should_trigger = readiness.warmup_state != crate::config::WarmupState::Warming
+        && (readiness.reason != Some(crate::config::WorkReadinessReason::EmbeddingNotReady)
+            || warmup_config.eager_embedding_load);
+
+    if should_trigger {
+        crate::agent::cortex::trigger_forced_warmup(state.deps.clone(), dispatch_type);
+    }
+}
+
+/// Shared branch spawning logic.
+///
+/// Checks the branch limit, clones history, creates a Branch, spawns it as
+/// a tokio task, and registers it in the channel's active branches and status block.
+async fn spawn_branch(
+    state: &ChannelState,
+    description: &str,
+    prompt: &str,
+    system_prompt: &str,
+    status_label: &str,
+    dispatch_type: &'static str,
+) -> std::result::Result<BranchId, AgentError> {
+    let max_branches = **state.deps.runtime_config.max_concurrent_branches.load();
+    {
+        let branches = state.active_branches.read().await;
+        if branches.len() >= max_branches {
+            return Err(AgentError::BranchLimitReached {
+                channel_id: state.channel_id.to_string(),
+                max: max_branches,
+            });
+        }
+    }
+    ensure_dispatch_readiness(state, dispatch_type);
+
+    let history = {
+        let h = state.history.read().await;
+        h.clone()
+    };
+
+    let tool_server = crate::tools::create_branch_tool_server(
+        Some(state.clone()),
+        state.deps.agent_id.clone(),
+        state.deps.task_store.clone(),
+        state.deps.memory_search.clone(),
+        state.deps.runtime_config.clone(),
+        state.deps.memory_event_tx.clone(),
+        state.conversation_logger.clone(),
+        state.channel_store.clone(),
+        crate::conversation::ProcessRunLogger::new(state.deps.sqlite_pool.clone()),
+    );
+    let branch_max_turns = **state.deps.runtime_config.branch_max_turns.load();
+
+    let branch = Branch::new(
+        state.channel_id.clone(),
+        description,
+        state.deps.clone(),
+        system_prompt,
+        history,
+        tool_server,
+        branch_max_turns,
+    );
+
+    let branch_id = branch.id;
+    let prompt = prompt.to_owned();
+
+    // Capture what the spawned task needs to notify the channel on failure.
+    // branch.run() only sends BranchResult on the success path, so the
+    // spawner must handle failures to prevent orphaned branches (see #279).
+    let event_tx = state.deps.event_tx.clone();
+    let agent_id = state.deps.agent_id.clone();
+    let channel_id = state.channel_id.clone();
+    let secrets_snapshot = state.deps.runtime_config.secrets.load().clone();
+
+    let branch_span = tracing::info_span!(
+        "branch.run",
+        branch_id = %branch_id,
+        channel_id = %state.channel_id,
+        description = %description,
+    );
+    let handle = tokio::spawn(
+        async move {
+            if let Err(error) = branch.run(&prompt).await {
+                tracing::error!(branch_id = %branch_id, %error, "branch failed");
+                // Scrub the failure message in case the error contains secrets
+                // (e.g. from failed tool calls echoing back prompt content).
+                // Layer 1: exact-match redaction of known secrets from the store.
+                // Layer 2: regex-based redaction of unknown secret patterns.
+                let raw = format!("Branch failed: {error}");
+                let conclusion = if let Some(store) = secrets_snapshot.as_ref() {
+                    crate::secrets::scrub::scrub_with_store(&raw, store)
+                } else {
+                    raw
+                };
+                let conclusion = crate::secrets::scrub::scrub_leaks(&conclusion);
+                let _ = event_tx.send(crate::ProcessEvent::BranchResult {
+                    agent_id,
+                    branch_id,
+                    channel_id,
+                    conclusion,
+                });
+            }
+        }
+        .instrument(branch_span),
+    );
+
+    {
+        let mut branches = state.active_branches.write().await;
+        branches.insert(branch_id, handle);
+    }
+
+    {
+        let mut status = state.status_block.write().await;
+        status.add_branch(branch_id, status_label);
+    }
+
+    #[cfg(feature = "metrics")]
+    crate::telemetry::Metrics::global()
+        .active_branches
+        .with_label_values(&[&*state.deps.agent_id])
+        .inc();
+
+    state
+        .deps
+        .event_tx
+        .send(crate::ProcessEvent::BranchStarted {
+            agent_id: state.deps.agent_id.clone(),
+            branch_id,
+            channel_id: state.channel_id.clone(),
+            description: status_label.to_string(),
+            reply_to_message_id: state.reply_target_message_id.read().await.clone(),
+        })
+        .ok();
+
+    tracing::info!(branch_id = %branch_id, description = %status_label, "branch spawned");
+
+    Ok(branch_id)
+}
+
+/// Check whether the channel has capacity for another worker.
+async fn check_worker_limit(state: &ChannelState) -> std::result::Result<(), AgentError> {
+    let max_workers = **state.deps.runtime_config.max_concurrent_workers.load();
+    let active_worker_count = state.active_workers.read().await.len();
+    reserve_worker_slot_local(active_worker_count, &state.channel_id, max_workers)
+}
+
+/// Spawn a worker from a ChannelState. Used by the SpawnWorkerTool.
+pub async fn spawn_worker_from_state(
+    state: &ChannelState,
+    task: impl Into<String>,
+    interactive: bool,
+    suggested_skills: &[&str],
+) -> std::result::Result<WorkerId, AgentError> {
+    check_worker_limit(state).await?;
+    ensure_dispatch_readiness(state, "worker");
+    let task = task.into();
+
+    let rc = &state.deps.runtime_config;
+    let prompt_engine = rc.prompts.load();
+    let temporal_context = TemporalContext::from_runtime(rc.as_ref());
+    let worker_task =
+        build_worker_task_with_temporal_context(&task, &temporal_context, &prompt_engine)
+            .map_err(|error| AgentError::Other(anyhow::anyhow!("{error}")))?;
+    let sandbox_enabled = state.deps.sandbox.mode_enabled();
+    let sandbox_containment_active = state.deps.sandbox.containment_active();
+    let sandbox_read_allowlist = state.deps.sandbox.prompt_read_allowlist();
+    let sandbox_write_allowlist = state.deps.sandbox.prompt_write_allowlist();
+    // Collect tool secret names so the worker template can list available credentials.
+    let secrets_guard = rc.secrets.load();
+    let tool_secret_names = match (*secrets_guard).as_ref() {
+        Some(store) => store.tool_secret_names(),
+        None => Vec::new(),
+    };
+
+    let worker_system_prompt = prompt_engine
+        .render_worker_prompt(
+            &rc.instance_dir.display().to_string(),
+            &rc.workspace_dir.display().to_string(),
+            sandbox_enabled,
+            sandbox_containment_active,
+            sandbox_read_allowlist,
+            sandbox_write_allowlist,
+            &tool_secret_names,
+        )
+        .map_err(|e| AgentError::Other(anyhow::anyhow!("{e}")))?;
+    let skills = rc.skills.load();
+    let browser_config = (**rc.browser_config.load()).clone();
+    let brave_search_key = (**rc.brave_search_key.load()).clone();
+
+    // Append skills listing to worker system prompt. Suggested skills are
+    // flagged so the worker knows the channel's intent, but it can read any
+    // skill it decides is relevant via the read_skill tool.
+    let system_prompt = match skills.render_worker_skills(suggested_skills, &prompt_engine) {
+        Ok(skills_prompt) if !skills_prompt.is_empty() => {
+            format!("{worker_system_prompt}\n\n{skills_prompt}")
+        }
+        Ok(_) => worker_system_prompt,
+        Err(error) => {
+            tracing::warn!(%error, "failed to render worker skills listing, spawning without skills context");
+            worker_system_prompt
+        }
+    };
+
+    let worker = if interactive {
+        let (worker, input_tx) = Worker::new_interactive(
+            Some(state.channel_id.clone()),
+            &worker_task,
+            &system_prompt,
+            state.deps.clone(),
+            browser_config.clone(),
+            state.screenshot_dir.clone(),
+            brave_search_key.clone(),
+            state.logs_dir.clone(),
+        );
+        let worker_id = worker.id;
+        state
+            .worker_inputs
+            .write()
+            .await
+            .insert(worker_id, input_tx);
+        worker
+    } else {
+        Worker::new(
+            Some(state.channel_id.clone()),
+            &worker_task,
+            &system_prompt,
+            state.deps.clone(),
+            browser_config,
+            state.screenshot_dir.clone(),
+            brave_search_key,
+            state.logs_dir.clone(),
+        )
+    };
+
+    let worker_id = worker.id;
+
+    let worker_span = tracing::info_span!(
+        "worker.run",
+        worker_id = %worker_id,
+        channel_id = %state.channel_id,
+        task = %task,
+    );
+    let secrets_store = state.deps.runtime_config.secrets.load().as_ref().clone();
+    let handle = spawn_worker_task(
+        worker_id,
+        state.deps.event_tx.clone(),
+        state.deps.agent_id.clone(),
+        Some(state.channel_id.clone()),
+        secrets_store,
+        worker.run().instrument(worker_span),
+    );
+
+    state.worker_handles.write().await.insert(worker_id, handle);
+
+    {
+        let mut status = state.status_block.write().await;
+        status.add_worker(worker_id, &task, false, interactive);
+    }
+
+    state
+        .deps
+        .event_tx
+        .send(crate::ProcessEvent::WorkerStarted {
+            agent_id: state.deps.agent_id.clone(),
+            worker_id,
+            channel_id: Some(state.channel_id.clone()),
+            task: task.clone(),
+            worker_type: "builtin".into(),
+            interactive,
+        })
+        .ok();
+
+    tracing::info!(worker_id = %worker_id, task = %task, interactive, "worker spawned");
+
+    Ok(worker_id)
+}
+
+/// Spawn an OpenCode-backed worker for coding tasks.
+///
+/// Instead of a Rig agent loop, this spawns an OpenCode subprocess that has its
+/// own codebase exploration, context management, and tool suite. The worker
+/// communicates with OpenCode via HTTP + SSE.
+pub async fn spawn_opencode_worker_from_state(
+    state: &ChannelState,
+    task: impl Into<String>,
+    directory: &str,
+    interactive: bool,
+) -> std::result::Result<crate::WorkerId, AgentError> {
+    check_worker_limit(state).await?;
+    ensure_dispatch_readiness(state, "opencode_worker");
+    let task = task.into();
+    let directory = expand_tilde(directory);
+
+    let rc = &state.deps.runtime_config;
+    let prompt_engine = rc.prompts.load();
+    let temporal_context = TemporalContext::from_runtime(rc.as_ref());
+    let worker_task =
+        build_worker_task_with_temporal_context(&task, &temporal_context, &prompt_engine)
+            .map_err(|error| AgentError::Other(anyhow::anyhow!("{error}")))?;
+    let opencode_config = rc.opencode.load();
+
+    if !opencode_config.enabled {
+        return Err(AgentError::Other(anyhow::anyhow!(
+            "OpenCode workers are not enabled in config"
+        )));
+    }
+
+    let server_pool = rc.opencode_server_pool.load().clone();
+
+    let oc_secrets_store = state.deps.runtime_config.secrets.load().as_ref().clone();
+
+    let worker = if interactive {
+        let (worker, input_tx) = crate::opencode::OpenCodeWorker::new_interactive(
+            Some(state.channel_id.clone()),
+            state.deps.agent_id.clone(),
+            &worker_task,
+            directory,
+            server_pool,
+            state.deps.event_tx.clone(),
+        );
+        let worker_id = worker.id;
+        state
+            .worker_inputs
+            .write()
+            .await
+            .insert(worker_id, input_tx);
+        match &oc_secrets_store {
+            Some(store) => worker.with_secrets_store(store.clone()),
+            None => worker,
+        }
+    } else {
+        let worker = crate::opencode::OpenCodeWorker::new(
+            Some(state.channel_id.clone()),
+            state.deps.agent_id.clone(),
+            &worker_task,
+            directory,
+            server_pool,
+            state.deps.event_tx.clone(),
+        );
+        match &oc_secrets_store {
+            Some(store) => worker.with_secrets_store(store.clone()),
+            None => worker,
+        }
+    };
+
+    let worker_id = worker.id;
+
+    let worker_span = tracing::info_span!(
+        "worker.run",
+        worker_id = %worker_id,
+        channel_id = %state.channel_id,
+        task = %task,
+        worker_type = "opencode",
+    );
+    let sqlite_pool = state.deps.sqlite_pool.clone();
+    let handle = spawn_worker_task(
+        worker_id,
+        state.deps.event_tx.clone(),
+        state.deps.agent_id.clone(),
+        Some(state.channel_id.clone()),
+        oc_secrets_store,
+        async move {
+            let result = worker.run().await.map_err(SpacebotError::from)?;
+
+            // Persist the transcript built from SSE events so the worker detail
+            // view can show the full conversation (text + tool calls + results).
+            if !result.transcript.is_empty() {
+                let blob = crate::conversation::worker_transcript::serialize_steps(
+                    &result.transcript,
+                );
+                let tool_calls = result.tool_calls;
+                let wid = worker_id.to_string();
+                let pool = sqlite_pool.clone();
+                tokio::spawn(async move {
+                    if let Err(error) = sqlx::query(
+                        "UPDATE worker_runs SET transcript = ?, tool_calls = ? WHERE id = ?",
+                    )
+                    .bind(&blob)
+                    .bind(tool_calls)
+                    .bind(&wid)
+                    .execute(&pool)
+                    .await
+                    {
+                        tracing::warn!(%error, worker_id = wid, "failed to persist OpenCode transcript");
+                    }
+                });
+            }
+
+            Ok::<String, SpacebotError>(result.result_text)
+        }
+        .instrument(worker_span),
+    );
+
+    state.worker_handles.write().await.insert(worker_id, handle);
+
+    let opencode_task = format!("[opencode] {task}");
+    {
+        let mut status = state.status_block.write().await;
+        status.add_worker(worker_id, &opencode_task, false, interactive);
+    }
+
+    state
+        .deps
+        .event_tx
+        .send(crate::ProcessEvent::WorkerStarted {
+            agent_id: state.deps.agent_id.clone(),
+            worker_id,
+            channel_id: Some(state.channel_id.clone()),
+            task: opencode_task,
+            worker_type: "opencode".into(),
+            interactive,
+        })
+        .ok();
+
+    tracing::info!(worker_id = %worker_id, task = %task, interactive, "OpenCode worker spawned");
+
+    Ok(worker_id)
+}
+
+/// Spawn a future as a tokio task that sends a `WorkerComplete` event on completion.
+///
+/// Handles both success and error cases, logging failures and sending the
+/// appropriate event. Used by both builtin workers and OpenCode workers.
+/// Returns the JoinHandle so the caller can store it for cancellation.
+///
+/// The result text is scrubbed through the secret store's tool secret values
+/// before being sent via the event — tool secret values are replaced with
+/// `[REDACTED:<name>]` so they never propagate to channel context.
+pub(crate) fn spawn_worker_task<F>(
+    worker_id: WorkerId,
+    event_tx: broadcast::Sender<ProcessEvent>,
+    agent_id: crate::AgentId,
+    channel_id: Option<ChannelId>,
+    secrets_store: Option<Arc<crate::secrets::store::SecretsStore>>,
+    future: F,
+) -> tokio::task::JoinHandle<()>
+where
+    F: std::future::Future<Output = crate::Result<String>> + Send + 'static,
+{
+    tokio::spawn(async move {
+        #[cfg(feature = "metrics")]
+        let worker_start = std::time::Instant::now();
+
+        #[cfg(feature = "metrics")]
+        crate::telemetry::Metrics::global()
+            .active_workers
+            .with_label_values(&[&*agent_id])
+            .inc();
+
+        let outcome = std::panic::AssertUnwindSafe(future).catch_unwind().await;
+        let worker_result: std::result::Result<String, WorkerCompletionError> = match outcome {
+            Ok(Ok(text)) => {
+                // Scrub tool secret values from the result before it reaches
+                // the channel. The channel never sees raw secret values.
+                // Layer 1: exact-match redaction of known secrets from the store.
+                // Layer 2: regex-based redaction of unknown secret patterns.
+                let scrubbed = if let Some(store) = &secrets_store {
+                    crate::secrets::scrub::scrub_with_store(&text, store)
+                } else {
+                    text
+                };
+                let scrubbed = crate::secrets::scrub::scrub_leaks(&scrubbed);
+                Ok(scrubbed)
+            }
+            Ok(Err(error)) => {
+                let failure = WorkerCompletionError::from_spacebot_error(error);
+                match failure {
+                    WorkerCompletionError::Cancelled { .. } => Err(failure),
+                    WorkerCompletionError::Failed { message } => {
+                        let scrubbed = if let Some(store) = &secrets_store {
+                            crate::secrets::scrub::scrub_with_store(&message, store)
+                        } else {
+                            message
+                        };
+                        let scrubbed = crate::secrets::scrub::scrub_leaks(&scrubbed);
+                        Err(WorkerCompletionError::Failed { message: scrubbed })
+                    }
+                }
+            }
+            Err(panic_payload) => {
+                let panic_message = crate::agent::panic_payload_to_string(&*panic_payload);
+                tracing::error!(
+                    worker_id = %worker_id,
+                    panic_message = %panic_message,
+                    "worker task panicked"
+                );
+                Err(WorkerCompletionError::failed(format!(
+                    "worker task panicked: {panic_message}"
+                )))
+            }
+        };
+        let (result_text, kind) = classify_worker_completion_result(worker_result);
+        match kind {
+            WorkerCompletionKind::Success => {}
+            WorkerCompletionKind::Cancelled => {
+                tracing::info!(worker_id = %worker_id, result = %result_text, "worker cancelled");
+            }
+            WorkerCompletionKind::Failed => {
+                tracing::error!(worker_id = %worker_id, result = %result_text, "worker failed");
+            }
+        };
+        let (notify, success) = completion_flags(kind);
+        #[cfg(feature = "metrics")]
+        {
+            let metrics = crate::telemetry::Metrics::global();
+            metrics
+                .active_workers
+                .with_label_values(&[&*agent_id])
+                .dec();
+            metrics
+                .worker_duration_seconds
+                .with_label_values(&[&*agent_id, "builtin"])
+                .observe(worker_start.elapsed().as_secs_f64());
+        }
+
+        let _ = event_tx.send(ProcessEvent::WorkerComplete {
+            agent_id,
+            worker_id,
+            channel_id,
+            result: result_text,
+            notify,
+            success,
+        });
+    })
+}
+
+/// Expand a leading `~` or `~/` in a path to the user's home directory.
+///
+/// LLMs consistently produce tilde-prefixed paths because that's what appears
+/// in conversation context. `std::path::Path::canonicalize()` doesn't expand
+/// tildes (that's a shell feature), so paths like `~/Projects/foo` fail with
+/// "directory does not exist". This handles the common cases.
+fn expand_tilde(path: &str) -> std::path::PathBuf {
+    if path == "~" {
+        dirs::home_dir().unwrap_or_else(|| std::path::PathBuf::from("/"))
+    } else if let Some(rest) = path.strip_prefix("~/") {
+        dirs::home_dir()
+            .unwrap_or_else(|| std::path::PathBuf::from("/"))
+            .join(rest)
+    } else {
+        std::path::PathBuf::from(path)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{WorkerCompletionError, map_worker_completion_result, spawn_worker_task};
+    use crate::{ProcessEvent, WorkerId};
+    use std::sync::Arc;
+    use std::time::Duration;
+    use tokio::sync::broadcast;
+    use uuid::Uuid;
+
+    #[test]
+    fn cancelled_errors_are_classified_as_cancelled_results() {
+        let (text, notify, success) =
+            map_worker_completion_result(Err(WorkerCompletionError::Cancelled {
+                reason: "user requested".to_string(),
+            }));
+        assert_eq!(text, "Worker cancelled: user requested");
+        assert!(notify);
+        assert!(!success);
+    }
+
+    #[tokio::test]
+    async fn spawn_worker_task_emits_cancelled_completion_event() {
+        let (event_tx, mut event_rx) = broadcast::channel(8);
+        let worker_id: WorkerId = Uuid::new_v4();
+
+        let handle = spawn_worker_task(
+            worker_id,
+            event_tx,
+            Arc::<str>::from("agent"),
+            Some(Arc::<str>::from("channel")),
+            None,
+            async {
+                Err::<String, crate::Error>(
+                    crate::error::AgentError::Cancelled {
+                        reason: "user requested".to_string(),
+                    }
+                    .into(),
+                )
+            },
+        );
+
+        let event = tokio::time::timeout(Duration::from_secs(2), event_rx.recv())
+            .await
+            .expect("worker completion event should be delivered")
+            .expect("broadcast receive should succeed");
+        handle.await.expect("worker task should join cleanly");
+
+        match event {
+            ProcessEvent::WorkerComplete {
+                worker_id: completed_worker_id,
+                result,
+                notify,
+                success,
+                ..
+            } => {
+                assert_eq!(completed_worker_id, worker_id);
+                assert_eq!(result, "Worker cancelled: user requested");
+                assert!(notify);
+                assert!(!success);
+            }
+            other => panic!("unexpected event: {other:?}"),
+        }
+    }
+
+    #[tokio::test]
+    async fn spawn_worker_task_carries_channel_id() {
+        let (event_tx, mut event_rx) = broadcast::channel(8);
+        let worker_id: WorkerId = Uuid::new_v4();
+        let channel_id: crate::ChannelId = Arc::from("test-channel");
+
+        let handle = spawn_worker_task(
+            worker_id,
+            event_tx,
+            Arc::<str>::from("agent"),
+            Some(channel_id.clone()),
+            None,
+            async { Ok::<String, crate::Error>("result".to_string()) },
+        );
+
+        let event = tokio::time::timeout(Duration::from_secs(2), event_rx.recv())
+            .await
+            .expect("worker completion event should be delivered")
+            .expect("broadcast receive should succeed");
+        handle.await.expect("worker task should join cleanly");
+
+        match event {
+            ProcessEvent::WorkerComplete {
+                channel_id: event_channel_id,
+                worker_id: completed_worker_id,
+                success,
+                ..
+            } => {
+                assert_eq!(completed_worker_id, worker_id);
+                assert_eq!(event_channel_id, Some(channel_id));
+                assert!(success);
+            }
+            other => panic!("unexpected event: {other:?}"),
+        }
+    }
+}
diff --git a/src/agent/channel_history.rs b/src/agent/channel_history.rs
new file mode 100644
index 000000000..72bfaaccd
--- /dev/null
+++ b/src/agent/channel_history.rs
@@ -0,0 +1,1157 @@
+//! History management and message formatting for channels.
+//!
+//! Pure functions that operate on `rig::message::Message` vectors —
+//! history reconciliation after LLM turns, user message formatting,
+//! reply extraction from cancelled turns, and event filtering.
+
+use crate::{ChannelId, InboundMessage, ProcessEvent};
+
+/// Write history back after the agentic loop completes.
+///
+/// On success or `MaxTurnsError`, the history Rig built is consistent and safe
+/// to keep.
+///
+/// On `PromptCancelled` (e.g. reply tool fired), Rig's carried history has
+/// the user prompt + the assistant's tool-call message but no tool results.
+/// Writing it back wholesale would leave a dangling tool-call that poisons
+/// every subsequent turn. Instead, we preserve only the **first user text
+/// message** Rig appended (the real user prompt), while discarding assistant
+/// tool-call messages and tool-result user messages.
+///
+/// On hard errors, we truncate to the pre-turn snapshot since the history
+/// state is unpredictable.
+///
+/// `MaxTurnsError` is safe — Rig pushes all tool results into a `User` message
+/// before raising it, so history is consistent.
+///
+/// Returns true when a retrigger PromptCancelled turn had a reply tool call
+/// extracted and persisted as a clean assistant text message.
+pub(crate) fn apply_history_after_turn(
+    result: &std::result::Result<String, rig::completion::PromptError>,
+    guard: &mut Vec<rig::message::Message>,
+    history: Vec<rig::message::Message>,
+    history_len_before: usize,
+    channel_id: &str,
+    is_retrigger: bool,
+) -> bool {
+    match result {
+        Ok(_) | Err(rig::completion::PromptError::MaxTurnsError { .. }) => {
+            *guard = history;
+            false
+        }
+        Err(rig::completion::PromptError::PromptCancelled { .. }) => {
+            let new_messages = &history[history_len_before..];
+
+            // Rig appended the user prompt and possibly an assistant tool-call
+            // message to history before cancellation.
+            //
+            // Retrigger turns use a synthetic system user prompt, so we never
+            // preserve user text there. Instead, keep only a clean assistant
+            // message extracted from reply tool args when available.
+            if is_retrigger {
+                let replaced_bridge = pop_retrigger_bridge_message(guard);
+                if let Some(reply_content) =
+                    extract_reply_content_from_cancelled_history(new_messages)
+                {
+                    guard.push(rig::message::Message::Assistant {
+                        id: None,
+                        content: rig::OneOrMany::one(rig::message::AssistantContent::text(
+                            reply_content,
+                        )),
+                    });
+
+                    tracing::debug!(
+                        channel_id = %channel_id,
+                        total_new = new_messages.len(),
+                        replaced_bridge,
+                        "preserved retrigger assistant reply after PromptCancelled"
+                    );
+                    return true;
+                }
+
+                tracing::debug!(
+                    channel_id = %channel_id,
+                    total_new = new_messages.len(),
+                    replaced_bridge,
+                    "discarding retrigger PromptCancelled messages (no reply content found)"
+                );
+                return false;
+            }
+
+            // For regular turns we preserve:
+            // 1. The first user text message (the actual user prompt)
+            // 2. A clean assistant text message extracted from the reply tool call
+            //
+            // We discard: dangling tool calls (without results), tool-result user
+            // messages, and internal correction prompts.
+            let mut preserved = 0usize;
+
+            // Preserve the user text message
+            if let Some(message) = new_messages.iter().find(|m| is_user_text_message(m)) {
+                guard.push(message.clone());
+                preserved += 1;
+            }
+
+            // Extract and preserve the reply content from the assistant's tool call.
+            // The assistant message contains ToolCall(reply, {content: "..."}), but
+            // we can't store the tool call without its result (it would poison future
+            // turns). Instead, extract the content and push a clean text-only message.
+            if let Some(reply_content) = extract_reply_content_from_cancelled_history(new_messages)
+            {
+                guard.push(rig::message::Message::Assistant {
+                    id: None,
+                    content: rig::OneOrMany::one(rig::message::AssistantContent::text(
+                        reply_content,
+                    )),
+                });
+                preserved += 1;
+            }
+
+            tracing::debug!(
+                channel_id = %channel_id,
+                total_new = new_messages.len(),
+                preserved,
+                discarded = new_messages.len() - preserved,
+                "preserved user message and assistant reply after PromptCancelled"
+            );
+
+            false
+        }
+        Err(_) => {
+            // Hard errors: history state is unpredictable, truncate to snapshot.
+            tracing::debug!(
+                channel_id = %channel_id,
+                rolled_back = history.len().saturating_sub(history_len_before),
+                "rolling back history after failed turn"
+            );
+            guard.truncate(history_len_before);
+            false
+        }
+    }
+}
+
+pub(crate) fn pop_retrigger_bridge_message(history: &mut Vec<rig::message::Message>) -> bool {
+    if history.last().is_some_and(is_retrigger_bridge_message) {
+        history.pop();
+        true
+    } else {
+        false
+    }
+}
+
+fn is_retrigger_bridge_message(message: &rig::message::Message) -> bool {
+    match message {
+        rig::message::Message::Assistant { content, .. } => content.iter().any(|item| {
+            matches!(
+                item,
+                rig::message::AssistantContent::Text(text)
+                    if text.text.contains("[acknowledged")
+            )
+        }),
+        _ => false,
+    }
+}
+
+/// Extract reply content from a cancelled turn's assistant message.
+///
+/// When the reply tool fires, Rig's history contains an Assistant message with
+/// a ToolCall for `reply` with args like `{"content": "Hey there!"}`. This
+/// extracts that content string so we can inject a clean text-only assistant
+/// message into history (the tool call itself can't be preserved since it has
+/// no matching result).
+fn extract_reply_content_from_cancelled_history(
+    new_messages: &[rig::message::Message],
+) -> Option<String> {
+    for message in new_messages {
+        if let rig::message::Message::Assistant { content, .. } = message {
+            for item in content.iter() {
+                if let rig::message::AssistantContent::ToolCall(tool_call) = item
+                    && tool_call.function.name == "reply"
+                {
+                    // Extract the "content" field from the reply tool args
+                    if let Some(content_value) = tool_call.function.arguments.get("content")
+                        && let Some(text) = content_value.as_str()
+                    {
+                        return Some(text.to_string());
+                    }
+                }
+            }
+        }
+    }
+    None
+}
+
+/// Returns true if a message is a User message containing only text content
+/// (i.e., an actual user prompt, not a tool result).
+fn is_user_text_message(message: &rig::message::Message) -> bool {
+    match message {
+        rig::message::Message::User { content } => content
+            .iter()
+            .all(|c| matches!(c, rig::message::UserContent::Text(_))),
+        _ => false,
+    }
+}
+
+/// Some models emit tool call syntax as plain text instead of making actual tool calls.
+/// When the text starts with a tool-like prefix (e.g. `[reply]`, `(reply)`), try to
+/// extract the reply content so we can send it cleanly instead of showing raw JSON.
+/// Returns `None` if the text doesn't match or can't be parsed — the caller falls
+/// back to sending the original text as-is.
+pub(crate) fn extract_reply_from_tool_syntax(text: &str) -> Option<String> {
+    // Match patterns like "[reply]\n{...}" or "(reply)\n{...}" (with optional whitespace)
+    let tool_prefixes = [
+        "[reply]",
+        "(reply)",
+        "[react]",
+        "(react)",
+        "[skip]",
+        "(skip)",
+        "[branch]",
+        "(branch)",
+        "[spawn_worker]",
+        "(spawn_worker)",
+        "[route]",
+        "(route)",
+        "[cancel]",
+        "(cancel)",
+    ];
+
+    let lower = text.to_lowercase();
+    let matched_prefix = tool_prefixes.iter().find(|p| lower.starts_with(*p))?;
+    let is_reply = matched_prefix.contains("reply");
+    let is_skip = matched_prefix.contains("skip");
+
+    // For skip, just return empty — the user shouldn't see anything
+    if is_skip {
+        return Some(String::new());
+    }
+
+    // For non-reply tools (react, branch, etc.), suppress entirely
+    if !is_reply {
+        return Some(String::new());
+    }
+
+    // Try to extract "content" from the JSON payload after the prefix
+    let rest = text[matched_prefix.len()..].trim();
+    if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(rest)
+        && let Some(content) = parsed.get("content").and_then(|v| v.as_str())
+    {
+        return Some(content.to_string());
+    }
+
+    // If we can't parse JSON, the rest might just be the message itself (no JSON wrapper)
+    if !rest.is_empty() && !rest.starts_with('{') {
+        return Some(rest.to_string());
+    }
+
+    None
+}
+
+/// Format a user message with sender attribution from message metadata.
+///
+/// In multi-user channels, this lets the LLM distinguish who said what.
+/// System-generated messages (re-triggers) are passed through as-is.
+pub(crate) fn message_display_name(message: &InboundMessage) -> &str {
+    message
+        .formatted_author
+        .as_deref()
+        .or_else(|| {
+            message
+                .metadata
+                .get("sender_display_name")
+                .and_then(|v| v.as_str())
+        })
+        .unwrap_or(&message.sender_id)
+}
+
+pub(crate) fn format_user_message(
+    raw_text: &str,
+    message: &InboundMessage,
+    timestamp_text: &str,
+) -> String {
+    if message.source == "system" {
+        // System messages should never be empty, but guard against it
+        return if raw_text.trim().is_empty() {
+            "[system event]".to_string()
+        } else {
+            raw_text.to_string()
+        };
+    }
+
+    let display_name = message_display_name(message);
+
+    let bot_tag = if message
+        .metadata
+        .get("sender_is_bot")
+        .and_then(|v| v.as_bool())
+        .unwrap_or(false)
+    {
+        " (bot)"
+    } else {
+        ""
+    };
+
+    let reply_context = message
+        .metadata
+        .get("reply_to_author")
+        .and_then(|v| v.as_str())
+        .map(|author| {
+            let content_preview = message
+                .metadata
+                .get(crate::metadata_keys::REPLY_TO_TEXT)
+                .and_then(|v| v.as_str())
+                .unwrap_or("");
+            if content_preview.is_empty() {
+                format!(" (replying to {author})")
+            } else {
+                format!(" (replying to {author}: \"{content_preview}\")")
+            }
+        })
+        .unwrap_or_default();
+
+    // If raw_text is empty or just whitespace, use a placeholder to avoid
+    // sending empty text content blocks to the LLM API.
+    let text_content = if raw_text.trim().is_empty() {
+        "[attachment or empty message]"
+    } else {
+        raw_text
+    };
+
+    format!("{display_name}{bot_tag}{reply_context} [{timestamp_text}]: {text_content}")
+}
+
+pub(crate) fn format_batched_user_message(
+    display_name: &str,
+    absolute_timestamp: &str,
+    relative_text: &str,
+    raw_text: &str,
+) -> String {
+    let text_content = if raw_text.trim().is_empty() {
+        "[attachment or empty message]"
+    } else {
+        raw_text
+    };
+    format!("[{display_name}] ({absolute_timestamp}; {relative_text}): {text_content}")
+}
+
+pub(crate) fn extract_message_id(message: &InboundMessage) -> Option<String> {
+    message
+        .metadata
+        .get(crate::metadata_keys::MESSAGE_ID)
+        .and_then(|value| match value {
+            serde_json::Value::String(s) => Some(s.clone()),
+            serde_json::Value::Number(n) => Some(n.to_string()),
+            _ => None,
+        })
+}
+
+/// Check if a ProcessEvent is targeted at a specific channel.
+///
+/// Events from branches and workers carry a channel_id. We only process events
+/// that originated from this channel — otherwise broadcast events from one
+/// channel's workers would leak into sibling channels (e.g. threads).
+pub(crate) fn event_is_for_channel(event: &ProcessEvent, channel_id: &ChannelId) -> bool {
+    match event {
+        ProcessEvent::BranchStarted {
+            channel_id: event_channel,
+            ..
+        }
+        | ProcessEvent::BranchResult {
+            channel_id: event_channel,
+            ..
+        } => event_channel == channel_id,
+        ProcessEvent::WorkerStarted {
+            channel_id: event_channel,
+            ..
+        }
+        | ProcessEvent::WorkerComplete {
+            channel_id: event_channel,
+            ..
+        }
+        | ProcessEvent::WorkerStatus {
+            channel_id: event_channel,
+            ..
+        }
+        | ProcessEvent::ToolStarted {
+            channel_id: event_channel,
+            ..
+        }
+        | ProcessEvent::ToolCompleted {
+            channel_id: event_channel,
+            ..
+        }
+        | ProcessEvent::MemorySaved {
+            channel_id: event_channel,
+            ..
+        }
+        | ProcessEvent::WorkerPermission {
+            channel_id: event_channel,
+            ..
+        }
+        | ProcessEvent::WorkerQuestion {
+            channel_id: event_channel,
+            ..
+        } => event_channel.as_ref() == Some(channel_id),
+        ProcessEvent::CompactionTriggered {
+            channel_id: event_channel,
+            ..
+        }
+        | ProcessEvent::AgentMessageSent {
+            channel_id: event_channel,
+            ..
+        }
+        | ProcessEvent::AgentMessageReceived {
+            channel_id: event_channel,
+            ..
+        } => event_channel == channel_id,
+        ProcessEvent::TextDelta {
+            channel_id: event_channel,
+            ..
+        } => event_channel.as_ref() == Some(channel_id),
+        ProcessEvent::WorkerIdle {
+            channel_id: event_channel,
+            ..
+        }
+        | ProcessEvent::WorkerInitialResult {
+            channel_id: event_channel,
+            ..
+        } => event_channel.as_ref() == Some(channel_id),
+        ProcessEvent::OpenCodeSessionCreated { .. }
+        | ProcessEvent::OpenCodePartUpdated { .. }
+        | ProcessEvent::StatusUpdate { .. }
+        | ProcessEvent::TaskUpdated { .. } => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{apply_history_after_turn, event_is_for_channel};
+    use crate::{ChannelId, ProcessEvent, ProcessId};
+    use rig::completion::{CompletionError, PromptError};
+    use rig::message::Message;
+    use rig::tool::ToolSetError;
+    use std::sync::Arc;
+
+    fn user_msg(text: &str) -> Message {
+        Message::User {
+            content: rig::OneOrMany::one(rig::message::UserContent::text(text)),
+        }
+    }
+
+    fn assistant_msg(text: &str) -> Message {
+        Message::Assistant {
+            id: None,
+            content: rig::OneOrMany::one(rig::message::AssistantContent::text(text)),
+        }
+    }
+
+    fn make_history(msgs: &[&str]) -> Vec<Message> {
+        msgs.iter()
+            .enumerate()
+            .map(|(i, text)| {
+                if i % 2 == 0 {
+                    user_msg(text)
+                } else {
+                    assistant_msg(text)
+                }
+            })
+            .collect()
+    }
+
+    /// On success, the full post-turn history is written back.
+    #[test]
+    fn ok_writes_history_back() {
+        let mut guard = make_history(&["hello"]);
+        let history = make_history(&["hello", "hi there", "how are you?"]);
+        let len_before = 1;
+
+        apply_history_after_turn(
+            &Ok("hi there".to_string()),
+            &mut guard,
+            history.clone(),
+            len_before,
+            "test",
+            false,
+        );
+
+        assert_eq!(guard, history);
+    }
+
+    /// MaxTurnsError carries consistent history (tool results included) — write it back.
+    #[test]
+    fn max_turns_writes_history_back() {
+        let mut guard = make_history(&["hello"]);
+        let history = make_history(&["hello", "hi there", "how are you?"]);
+        let len_before = 1;
+
+        let err = Err(PromptError::MaxTurnsError {
+            max_turns: 5,
+            chat_history: Box::new(history.clone()),
+            prompt: Box::new(user_msg("prompt")),
+        });
+
+        apply_history_after_turn(&err, &mut guard, history.clone(), len_before, "test", false);
+
+        assert_eq!(guard, history);
+    }
+
+    /// PromptCancelled preserves user text messages and extracts reply content
+    /// from the assistant's tool call, discarding the dangling tool call itself.
+    #[test]
+    fn prompt_cancelled_preserves_user_and_reply() {
+        let initial = make_history(&["hello", "thinking..."]);
+        let mut guard = initial.clone();
+        // Simulate what Rig does: push user prompt + assistant reply tool-call
+        let mut history = initial.clone();
+        history.push(user_msg("new user prompt")); // should be preserved
+        history.push(Message::Assistant {
+            id: None,
+            content: rig::OneOrMany::one(rig::message::AssistantContent::tool_call(
+                "call_1",
+                "reply",
+                serde_json::json!({"content": "Hey there!"}),
+            )),
+        });
+        let len_before = initial.len();
+
+        let err = Err(PromptError::PromptCancelled {
+            chat_history: Box::new(history.clone()),
+            reason: "reply delivered".to_string(),
+        });
+
+        apply_history_after_turn(&err, &mut guard, history, len_before, "test", false);
+
+        // User prompt and reply content should be preserved, tool-call structure discarded
+        let mut expected = initial;
+        expected.push(user_msg("new user prompt"));
+        expected.push(assistant_msg("Hey there!"));
+        assert_eq!(
+            guard, expected,
+            "user text message and reply content should be preserved"
+        );
+    }
+
+    /// PromptCancelled extracts reply content and discards tool-result User messages.
+    #[test]
+    fn prompt_cancelled_extracts_reply_discards_tool_results() {
+        let initial = make_history(&["hello", "thinking..."]);
+        let mut guard = initial.clone();
+        let mut history = initial.clone();
+        history.push(user_msg("new user prompt")); // preserved
+        // Simulate an assistant tool-call followed by a tool-result user message
+        history.push(Message::Assistant {
+            id: None,
+            content: rig::OneOrMany::one(rig::message::AssistantContent::tool_call(
+                "call_1",
+                "reply",
+                serde_json::json!({"content": "hello"}),
+            )),
+        });
+        // A tool-result message is a User message with ToolResult content —
+        // is_user_text_message returns false for these, so they get discarded.
+        history.push(Message::User {
+            content: rig::OneOrMany::one(rig::message::UserContent::ToolResult(
+                rig::message::ToolResult {
+                    id: "call_1".to_string(),
+                    call_id: None,
+                    content: rig::OneOrMany::one(rig::message::ToolResultContent::text("ok")),
+                },
+            )),
+        });
+        let len_before = initial.len();
+
+        let err = Err(PromptError::PromptCancelled {
+            chat_history: Box::new(history.clone()),
+            reason: "reply delivered".to_string(),
+        });
+
+        apply_history_after_turn(&err, &mut guard, history, len_before, "test", false);
+
+        let mut expected = initial;
+        expected.push(user_msg("new user prompt"));
+        expected.push(assistant_msg("hello"));
+        assert_eq!(
+            guard, expected,
+            "reply content should be extracted, tool-result messages discarded"
+        );
+    }
+
+    /// PromptCancelled preserves only the first user prompt and drops any
+    /// internal correction prompts that may have been appended on retry.
+    #[test]
+    fn prompt_cancelled_preserves_only_first_user_prompt() {
+        let initial = make_history(&["hello", "thinking..."]);
+        let mut guard = initial.clone();
+        let mut history = initial.clone();
+        history.push(user_msg("real user prompt")); // preserved
+        history.push(assistant_msg("bad tool syntax"));
+        history.push(user_msg("Please proceed and use the available tools.")); // dropped (correction)
+        history.push(Message::Assistant {
+            id: None,
+            content: rig::OneOrMany::one(rig::message::AssistantContent::tool_call(
+                "call_1",
+                "reply",
+                serde_json::json!({"content": "Got it!"}),
+            )),
+        });
+        let len_before = initial.len();
+
+        let err = Err(PromptError::PromptCancelled {
+            chat_history: Box::new(history.clone()),
+            reason: "reply delivered".to_string(),
+        });
+
+        apply_history_after_turn(&err, &mut guard, history, len_before, "test", false);
+
+        let mut expected = initial;
+        expected.push(user_msg("real user prompt"));
+        expected.push(assistant_msg("Got it!"));
+        assert_eq!(
+            guard, expected,
+            "only the first user prompt and final reply should be preserved"
+        );
+    }
+
+    /// PromptCancelled on retrigger turns preserves only the assistant relay
+    /// text extracted from the reply tool args and drops retrigger scaffolding.
+    #[test]
+    fn prompt_cancelled_retrigger_preserves_reply_only() {
+        let initial = make_history(&["hello", "thinking..."]);
+        let mut guard = initial.clone();
+        guard.push(assistant_msg(
+            "[acknowledged — working on it in background]",
+        ));
+
+        let mut history = guard.clone();
+        history.push(user_msg("[System: 1 background process completed...]"));
+        history.push(Message::Assistant {
+            id: None,
+            content: rig::OneOrMany::one(rig::message::AssistantContent::tool_call(
+                "call_1",
+                "reply",
+                serde_json::json!({"content": "Relayed branch result to user."}),
+            )),
+        });
+        let len_before = guard.len();
+
+        let err = Err(PromptError::PromptCancelled {
+            chat_history: Box::new(history.clone()),
+            reason: "reply delivered".to_string(),
+        });
+
+        let preserved =
+            apply_history_after_turn(&err, &mut guard, history, len_before, "test", true);
+
+        let mut expected = initial;
+        expected.push(assistant_msg("Relayed branch result to user."));
+        assert!(
+            preserved,
+            "retrigger PromptCancelled should report reply preservation"
+        );
+        assert_eq!(
+            guard, expected,
+            "retrigger history should keep only the extracted relay text"
+        );
+    }
+
+    /// PromptCancelled retrigger turns with no reply tool call remove the
+    /// synthetic bridge and preserve no new messages.
+    #[test]
+    fn prompt_cancelled_retrigger_without_reply_discards_scaffolding() {
+        let initial = make_history(&["hello", "thinking..."]);
+        let mut guard = initial.clone();
+        guard.push(assistant_msg(
+            "[acknowledged — working on it in background]",
+        ));
+
+        let mut history = guard.clone();
+        history.push(user_msg("[System: 1 background process completed...]"));
+        history.push(assistant_msg("relay attempt without tool call"));
+        let len_before = guard.len();
+
+        let err = Err(PromptError::PromptCancelled {
+            chat_history: Box::new(history.clone()),
+            reason: "reply delivered".to_string(),
+        });
+
+        let preserved =
+            apply_history_after_turn(&err, &mut guard, history, len_before, "test", true);
+
+        assert!(
+            !preserved,
+            "retrigger PromptCancelled should report no reply preservation"
+        );
+        assert_eq!(
+            guard, initial,
+            "retrigger scaffolding should be removed when no reply payload exists"
+        );
+    }
+
+    /// Hard completion errors also roll back to prevent dangling tool-calls.
+    #[test]
+    fn completion_error_rolls_back() {
+        let initial = make_history(&["hello", "thinking..."]);
+        let mut guard = initial.clone();
+        let mut history = initial.clone();
+        history.push(user_msg("[dangling tool-call]"));
+        let len_before = initial.len();
+
+        let err = Err(PromptError::CompletionError(
+            CompletionError::ResponseError("API error".to_string()),
+        ));
+
+        apply_history_after_turn(&err, &mut guard, history, len_before, "test", false);
+
+        assert_eq!(
+            guard, initial,
+            "history should be rolled back after hard error"
+        );
+    }
+
+    /// ToolError (tool not found) rolls back — same catch-all arm as hard errors.
+    #[test]
+    fn tool_error_rolls_back() {
+        let initial = make_history(&["hello", "thinking..."]);
+        let mut guard = initial.clone();
+        let mut history = initial.clone();
+        history.push(user_msg("[dangling tool-call]"));
+        let len_before = initial.len();
+
+        let err = Err(PromptError::ToolError(ToolSetError::ToolNotFoundError(
+            "nonexistent_tool".to_string(),
+        )));
+
+        apply_history_after_turn(&err, &mut guard, history, len_before, "test", false);
+
+        assert_eq!(
+            guard, initial,
+            "history should be rolled back after tool error"
+        );
+    }
+
+    /// Rollback on empty history is a no-op and must not panic.
+    #[test]
+    fn rollback_on_empty_history_is_noop() {
+        let mut guard: Vec<Message> = vec![];
+        let history: Vec<Message> = vec![];
+        let len_before = 0;
+
+        let err = Err(PromptError::PromptCancelled {
+            chat_history: Box::new(history.clone()),
+            reason: "reply delivered".to_string(),
+        });
+
+        apply_history_after_turn(&err, &mut guard, history, len_before, "test", false);
+
+        assert!(
+            guard.is_empty(),
+            "empty history should stay empty after rollback"
+        );
+    }
+
+    /// Rollback when nothing was appended is also a no-op (len unchanged).
+    #[test]
+    fn rollback_when_nothing_appended_is_noop() {
+        let initial = make_history(&["hello", "thinking..."]);
+        let mut guard = initial.clone();
+        // history has same length as before — Rig cancelled before appending anything
+        let history = initial.clone();
+        let len_before = initial.len();
+
+        let err = Err(PromptError::PromptCancelled {
+            chat_history: Box::new(history.clone()),
+            reason: "skip delivered".to_string(),
+        });
+
+        apply_history_after_turn(&err, &mut guard, history, len_before, "test", false);
+
+        assert_eq!(
+            guard, initial,
+            "history should be unchanged when nothing was appended"
+        );
+    }
+
+    /// After PromptCancelled, the next turn starts clean with user messages
+    /// preserved but no dangling assistant tool-calls.
+    #[test]
+    fn next_turn_is_clean_after_prompt_cancelled() {
+        let initial = make_history(&["hello", "thinking..."]);
+        let mut guard = initial.clone();
+        let mut poisoned_history = initial.clone();
+        // Rig appends: user prompt + assistant tool-call (dangling, no result)
+        poisoned_history.push(user_msg("what's up"));
+        poisoned_history.push(Message::Assistant {
+            id: None,
+            content: rig::OneOrMany::one(rig::message::AssistantContent::tool_call(
+                "call_1",
+                "reply",
+                serde_json::json!({"content": "hey!"}),
+            )),
+        });
+        let len_before = initial.len();
+
+        // First turn: cancelled (reply tool fired) — not a retrigger
+        apply_history_after_turn(
+            &Err(PromptError::PromptCancelled {
+                chat_history: Box::new(poisoned_history.clone()),
+                reason: "reply delivered".to_string(),
+            }),
+            &mut guard,
+            poisoned_history,
+            len_before,
+            "test",
+            false,
+        );
+
+        // User prompt and reply content preserved, tool-call structure discarded
+        assert_eq!(
+            guard.len(),
+            initial.len() + 2,
+            "user prompt and assistant reply should be preserved"
+        );
+        assert!(
+            matches!(&guard[guard.len() - 2], Message::User { .. }),
+            "second-to-last message should be the preserved user prompt"
+        );
+        assert!(
+            matches!(&guard[guard.len() - 1], Message::Assistant { .. }),
+            "last message should be the extracted reply content"
+        );
+
+        // Second turn: new user message appended, successful response
+        guard.push(user_msg("follow-up question"));
+        let len_before2 = guard.len();
+        let mut history2 = guard.clone();
+        history2.push(assistant_msg("clean response"));
+
+        apply_history_after_turn(
+            &Ok("clean response".to_string()),
+            &mut guard,
+            history2.clone(),
+            len_before2,
+            "test",
+            false,
+        );
+
+        assert_eq!(
+            guard, history2,
+            "second turn should succeed with clean history"
+        );
+        // No dangling tool-call assistant messages in history
+        let has_dangling = guard.iter().any(|m| {
+            if let Message::Assistant { content, .. } = m {
+                content
+                    .iter()
+                    .any(|c| matches!(c, rig::message::AssistantContent::ToolCall(_)))
+            } else {
+                false
+            }
+        });
+        assert!(
+            !has_dangling,
+            "no dangling tool-call messages in history after rollback"
+        );
+    }
+
+    #[test]
+    fn format_user_message_handles_empty_text() {
+        use super::format_user_message;
+        use crate::{Arc, InboundMessage};
+        use chrono::Utc;
+        use std::collections::HashMap;
+
+        // Test empty text with user message
+        let message = InboundMessage {
+            id: "test".to_string(),
+            agent_id: Some(Arc::from("test_agent")),
+            sender_id: "user123".to_string(),
+            conversation_id: "conv".to_string(),
+            content: crate::MessageContent::Text("".to_string()),
+            source: "discord".to_string(),
+            adapter: Some("discord".to_string()),
+            metadata: HashMap::new(),
+            formatted_author: Some("TestUser".to_string()),
+            timestamp: Utc::now(),
+        };
+
+        let formatted = format_user_message("", &message, "2026-02-26 12:00:00 UTC");
+        assert!(
+            !formatted.trim().is_empty(),
+            "formatted message should not be empty"
+        );
+        assert!(
+            formatted.contains("[attachment or empty message]"),
+            "should use placeholder for empty text"
+        );
+
+        // Test whitespace-only text
+        let formatted_ws = format_user_message("   ", &message, "2026-02-26 12:00:00 UTC");
+        assert!(
+            formatted_ws.contains("[attachment or empty message]"),
+            "should use placeholder for whitespace-only text"
+        );
+
+        // Test empty system message
+        let system_message = InboundMessage {
+            id: "test".to_string(),
+            agent_id: Some(Arc::from("test_agent")),
+            sender_id: "system".to_string(),
+            conversation_id: "conv".to_string(),
+            content: crate::MessageContent::Text("".to_string()),
+            source: "system".to_string(),
+            adapter: None,
+            metadata: HashMap::new(),
+            formatted_author: None,
+            timestamp: Utc::now(),
+        };
+
+        let formatted_sys = format_user_message("", &system_message, "2026-02-26 12:00:00 UTC");
+        assert_eq!(
+            formatted_sys, "[system event]",
+            "system messages should use [system event] placeholder"
+        );
+
+        // Test normal message with text
+        let formatted_normal = format_user_message("hello", &message, "2026-02-26 12:00:00 UTC");
+        assert!(
+            formatted_normal.contains("hello"),
+            "normal messages should preserve text"
+        );
+        assert!(
+            formatted_normal.contains("[2026-02-26 12:00:00 UTC]"),
+            "normal messages should include absolute timestamp context"
+        );
+        assert!(
+            !formatted_normal.contains("[attachment or empty message]"),
+            "normal messages should not use placeholder"
+        );
+    }
+
+    #[test]
+    fn message_display_name_uses_consistent_fallback_order() {
+        use super::message_display_name;
+        use crate::{Arc, InboundMessage};
+        use chrono::Utc;
+        use std::collections::HashMap;
+
+        let mut metadata_only = HashMap::new();
+        metadata_only.insert(
+            "sender_display_name".to_string(),
+            serde_json::Value::String("Metadata User".to_string()),
+        );
+        let metadata_message = InboundMessage {
+            id: "metadata".to_string(),
+            agent_id: Some(Arc::from("test_agent")),
+            sender_id: "sender123".to_string(),
+            conversation_id: "conv".to_string(),
+            content: crate::MessageContent::Text("hello".to_string()),
+            source: "discord".to_string(),
+            adapter: Some("discord".to_string()),
+            metadata: metadata_only,
+            formatted_author: None,
+            timestamp: Utc::now(),
+        };
+        assert_eq!(message_display_name(&metadata_message), "Metadata User");
+
+        let mut both_metadata = HashMap::new();
+        both_metadata.insert(
+            "sender_display_name".to_string(),
+            serde_json::Value::String("Metadata User".to_string()),
+        );
+        let formatted_author_message = InboundMessage {
+            id: "formatted".to_string(),
+            agent_id: Some(Arc::from("test_agent")),
+            sender_id: "sender123".to_string(),
+            conversation_id: "conv".to_string(),
+            content: crate::MessageContent::Text("hello".to_string()),
+            source: "discord".to_string(),
+            adapter: Some("discord".to_string()),
+            metadata: both_metadata,
+            formatted_author: Some("Formatted Author".to_string()),
+            timestamp: Utc::now(),
+        };
+        assert_eq!(
+            message_display_name(&formatted_author_message),
+            "Formatted Author"
+        );
+
+        let sender_fallback_message = InboundMessage {
+            id: "fallback".to_string(),
+            agent_id: Some(Arc::from("test_agent")),
+            sender_id: "sender123".to_string(),
+            conversation_id: "conv".to_string(),
+            content: crate::MessageContent::Text("hello".to_string()),
+            source: "discord".to_string(),
+            adapter: Some("discord".to_string()),
+            metadata: HashMap::new(),
+            formatted_author: None,
+            timestamp: Utc::now(),
+        };
+        assert_eq!(message_display_name(&sender_fallback_message), "sender123");
+    }
+
+    #[test]
+    fn worker_task_temporal_context_preamble_includes_absolute_dates() {
+        let prompt_engine =
+            crate::prompts::PromptEngine::new("en").expect("prompt engine should initialize");
+        let temporal_context = crate::agent::channel_prompt::TemporalContext {
+            now_utc: chrono::DateTime::parse_from_rfc3339("2026-02-26T20:30:00Z")
+                .expect("valid RFC3339 timestamp")
+                .with_timezone(&chrono::Utc),
+            timezone: crate::agent::channel_prompt::TemporalTimezone::Named {
+                timezone_name: "America/New_York".to_string(),
+                timezone: "America/New_York"
+                    .parse()
+                    .expect("valid timezone identifier"),
+            },
+        };
+
+        let worker_task = crate::agent::channel_prompt::build_worker_task_with_temporal_context(
+            "Run the migration checks",
+            &temporal_context,
+            &prompt_engine,
+        )
+        .expect("worker task preamble should render");
+        assert!(
+            worker_task.contains("Current local date/time:"),
+            "worker task should include local time context"
+        );
+        assert!(
+            worker_task.contains("Current UTC date/time:"),
+            "worker task should include UTC time context"
+        );
+        assert!(
+            worker_task.contains("Run the migration checks"),
+            "worker task should preserve the original task body"
+        );
+    }
+
+    #[test]
+    fn temporal_context_uses_cron_timezone_when_user_timezone_is_invalid() {
+        let resolved = crate::agent::channel_prompt::TemporalContext::resolve_timezone_from_names(
+            Some("Not/A-Real-Tz".to_string()),
+            Some("America/Los_Angeles".to_string()),
+        );
+        match resolved {
+            crate::agent::channel_prompt::TemporalTimezone::Named { timezone_name, .. } => {
+                assert_eq!(timezone_name, "America/Los_Angeles");
+            }
+            crate::agent::channel_prompt::TemporalTimezone::SystemLocal => {
+                panic!("expected cron timezone fallback, got system local")
+            }
+        }
+    }
+
+    #[test]
+    fn format_batched_message_includes_absolute_and_relative_time() {
+        let formatted = super::format_batched_user_message(
+            "alice",
+            "2026-02-26 15:04:05 PST (America/Los_Angeles, UTC-08:00)",
+            "12s ago",
+            "ship it",
+        );
+        assert!(
+            formatted.contains("2026-02-26 15:04:05 PST"),
+            "batched formatting should include absolute timestamp"
+        );
+        assert!(
+            formatted.contains("12s ago"),
+            "batched formatting should include relative timestamp hint"
+        );
+        assert!(
+            formatted.contains("ship it"),
+            "batched formatting should include original message text"
+        );
+    }
+
+    #[test]
+    fn format_batched_message_uses_placeholder_for_empty_text() {
+        let formatted = super::format_batched_user_message(
+            "alice",
+            "2026-02-26 15:04:05 PST (America/Los_Angeles, UTC-08:00)",
+            "just now",
+            "   ",
+        );
+        assert!(
+            formatted.contains("[attachment or empty message]"),
+            "batched formatting should use placeholder for empty/whitespace text"
+        );
+    }
+
+    #[test]
+    fn event_filter_scopes_tool_events_by_channel() {
+        let channel_id: ChannelId = Arc::from("channel-a");
+        let other_channel: ChannelId = Arc::from("channel-b");
+        let process_id = ProcessId::Worker(uuid::Uuid::new_v4());
+
+        let related_event = ProcessEvent::ToolStarted {
+            agent_id: Arc::from("agent"),
+            process_id: process_id.clone(),
+            channel_id: Some(channel_id.clone()),
+            tool_name: "memory_save".to_string(),
+            args: "{}".to_string(),
+        };
+        let unrelated_event = ProcessEvent::ToolStarted {
+            agent_id: Arc::from("agent"),
+            process_id,
+            channel_id: Some(other_channel),
+            tool_name: "memory_save".to_string(),
+            args: "{}".to_string(),
+        };
+
+        assert!(event_is_for_channel(&related_event, &channel_id));
+        assert!(!event_is_for_channel(&unrelated_event, &channel_id));
+    }
+
+    #[test]
+    fn event_filter_scopes_agent_message_events_by_channel() {
+        let channel_id: ChannelId = Arc::from("channel-a");
+        let related_event = ProcessEvent::AgentMessageReceived {
+            from_agent_id: Arc::from("agent-a"),
+            to_agent_id: Arc::from("agent-b"),
+            link_id: "link-1".to_string(),
+            channel_id: channel_id.clone(),
+        };
+        let unrelated_event = ProcessEvent::AgentMessageReceived {
+            from_agent_id: Arc::from("agent-a"),
+            to_agent_id: Arc::from("agent-b"),
+            link_id: "link-1".to_string(),
+            channel_id: Arc::from("channel-b"),
+        };
+
+        assert!(event_is_for_channel(&related_event, &channel_id));
+        assert!(!event_is_for_channel(&unrelated_event, &channel_id));
+    }
+
+    #[test]
+    fn text_delta_events_are_filtered_by_channel_id() {
+        let target_channel: ChannelId = Arc::from("webchat:target");
+
+        let matching_event = ProcessEvent::TextDelta {
+            agent_id: Arc::from("agent"),
+            process_id: ProcessId::Channel(target_channel.clone()),
+            channel_id: Some(target_channel.clone()),
+            text_delta: "hel".to_string(),
+            aggregated_text: "hel".to_string(),
+        };
+        assert!(event_is_for_channel(&matching_event, &target_channel));
+
+        let other_event = ProcessEvent::TextDelta {
+            agent_id: Arc::from("agent"),
+            process_id: ProcessId::Channel(Arc::from("webchat:other")),
+            channel_id: Some(Arc::from("webchat:other")),
+            text_delta: "hel".to_string(),
+            aggregated_text: "hello".to_string(),
+        };
+        assert!(!event_is_for_channel(&other_event, &target_channel));
+
+        let unscoped_event = ProcessEvent::TextDelta {
+            agent_id: Arc::from("agent"),
+            process_id: ProcessId::Channel(Arc::from("webchat:none")),
+            channel_id: None,
+            text_delta: "hel".to_string(),
+            aggregated_text: "hello".to_string(),
+        };
+        assert!(!event_is_for_channel(&unscoped_event, &target_channel));
+    }
+}
diff --git a/src/agent/channel_prompt.rs b/src/agent/channel_prompt.rs
new file mode 100644
index 000000000..196a249c0
--- /dev/null
+++ b/src/agent/channel_prompt.rs
@@ -0,0 +1,143 @@
+//! System prompt assembly and temporal context for channels.
+//!
+//! Contains `TemporalContext` for timezone-aware timestamps and
+//! all the prompt-building methods that assemble the channel's
+//! system prompt from identity, memory bulletin, skills, status, etc.
+
+use crate::error::Result;
+use chrono::{DateTime, Local, Utc};
+use chrono_tz::Tz;
+
+/// Debounce window for retriggers: coalesce rapid branch/worker completions
+/// into a single retrigger instead of firing one per event.
+pub(crate) const RETRIGGER_DEBOUNCE_MS: u64 = 500;
+
+/// Maximum retriggers allowed since the last real user message. Prevents
+/// infinite retrigger cascades where each retrigger spawns more work.
+pub(crate) const MAX_RETRIGGERS_PER_TURN: usize = 3;
+
+/// Max LLM turns for retrigger relay. Retriggers are simple relay tasks —
+/// the LLM just needs to call the reply tool once. A low cap avoids wasting
+/// tokens on retries when the model struggles with the retrigger format.
+pub(crate) const RETRIGGER_MAX_TURNS: usize = 3;
+
+#[derive(Debug, Clone)]
+pub(crate) enum TemporalTimezone {
+    Named { timezone_name: String, timezone: Tz },
+    SystemLocal,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct TemporalContext {
+    pub(crate) now_utc: DateTime<Utc>,
+    pub(crate) timezone: TemporalTimezone,
+}
+
+impl TemporalContext {
+    pub(crate) fn from_runtime(runtime_config: &crate::config::RuntimeConfig) -> Self {
+        let now_utc = Utc::now();
+        let user_timezone = runtime_config.user_timezone.load().as_ref().clone();
+        let cron_timezone = runtime_config.cron_timezone.load().as_ref().clone();
+
+        Self {
+            now_utc,
+            timezone: Self::resolve_timezone_from_names(user_timezone, cron_timezone),
+        }
+    }
+
+    pub(crate) fn resolve_timezone_from_names(
+        user_timezone: Option<String>,
+        cron_timezone: Option<String>,
+    ) -> TemporalTimezone {
+        if let Some(timezone_name) = user_timezone {
+            match timezone_name.parse::<Tz>() {
+                Ok(timezone) => {
+                    return TemporalTimezone::Named {
+                        timezone_name,
+                        timezone,
+                    };
+                }
+                Err(_) => {
+                    let cron_timezone_candidate =
+                        cron_timezone.as_deref().unwrap_or("none configured");
+                    tracing::warn!(
+                        timezone = %timezone_name,
+                        cron_timezone = %cron_timezone_candidate,
+                        "invalid runtime timezone for channel temporal context, will try cron_timezone then fall back to system local"
+                    );
+                }
+            }
+        }
+
+        if let Some(timezone_name) = cron_timezone {
+            match timezone_name.parse::<Tz>() {
+                Ok(timezone) => {
+                    return TemporalTimezone::Named {
+                        timezone_name,
+                        timezone,
+                    };
+                }
+                Err(error) => {
+                    tracing::warn!(
+                        timezone = %timezone_name,
+                        error = %error,
+                        "invalid cron_timezone for channel temporal context, falling back to system local"
+                    );
+                }
+            }
+        }
+
+        TemporalTimezone::SystemLocal
+    }
+
+    pub(crate) fn format_timestamp(&self, timestamp: DateTime<Utc>) -> String {
+        match &self.timezone {
+            TemporalTimezone::Named {
+                timezone_name,
+                timezone,
+            } => {
+                let local_timestamp = timestamp.with_timezone(timezone);
+                format!(
+                    "{} ({}, UTC{})",
+                    local_timestamp.format("%Y-%m-%d %H:%M:%S %Z"),
+                    timezone_name,
+                    local_timestamp.format("%:z")
+                )
+            }
+            TemporalTimezone::SystemLocal => {
+                let local_timestamp = timestamp.with_timezone(&Local);
+                format!(
+                    "{} (system local, UTC{})",
+                    local_timestamp.format("%Y-%m-%d %H:%M:%S %Z"),
+                    local_timestamp.format("%:z")
+                )
+            }
+        }
+    }
+
+    pub(crate) fn current_time_line(&self) -> String {
+        format!(
+            "{}; UTC {}",
+            self.format_timestamp(self.now_utc),
+            self.now_utc.format("%Y-%m-%d %H:%M:%S UTC")
+        )
+    }
+
+    pub(crate) fn worker_task_preamble(
+        &self,
+        prompt_engine: &crate::prompts::PromptEngine,
+    ) -> Result<String> {
+        let local_time = self.format_timestamp(self.now_utc);
+        let utc_time = self.now_utc.format("%Y-%m-%d %H:%M:%S UTC").to_string();
+        prompt_engine.render_system_worker_time_context(&local_time, &utc_time)
+    }
+}
+
+pub(crate) fn build_worker_task_with_temporal_context(
+    task: &str,
+    temporal_context: &TemporalContext,
+    prompt_engine: &crate::prompts::PromptEngine,
+) -> Result<String> {
+    let preamble = temporal_context.worker_task_preamble(prompt_engine)?;
+    Ok(format!("{preamble}\n\n{task}"))
+}
diff --git a/src/agent/compactor.rs b/src/agent/compactor.rs
index ac3dbab28..04567da89 100644
--- a/src/agent/compactor.rs
+++ b/src/agent/compactor.rs
@@ -5,14 +5,16 @@
 //! + memory extraction) happens in the spawned worker, not here.
 
 use crate::error::Result;
+use crate::hooks::SpacebotHook;
 use crate::llm::SpacebotModel;
-use crate::{AgentDeps, ChannelId, ProcessType};
+use crate::{AgentDeps, ChannelId, ProcessId, ProcessType};
 use rig::agent::AgentBuilder;
-use rig::completion::{CompletionModel as _, Prompt as _};
+use rig::completion::CompletionModel;
 use rig::message::{AssistantContent, Message, UserContent};
-use rig::tool::server::{ToolServer, ToolServerHandle};
+use rig::tool::server::ToolServerHandle;
 use std::sync::Arc;
 use tokio::sync::RwLock;
+use uuid::Uuid;
 
 /// Programmatic monitor that watches channel context size and triggers compaction.
 pub struct Compactor {
@@ -70,6 +72,21 @@ impl Compactor {
                 ?action,
                 "compaction triggered"
             );
+            if let Err(error) = self
+                .deps
+                .event_tx
+                .send(crate::ProcessEvent::CompactionTriggered {
+                    agent_id: self.deps.agent_id.clone(),
+                    channel_id: self.channel_id.clone(),
+                    threshold_reached: usage,
+                })
+            {
+                tracing::debug!(
+                    channel_id = %self.channel_id,
+                    %error,
+                    "failed to emit compaction-triggered event"
+                );
+            }
 
             match action {
                 CompactionAction::EmergencyTruncate => {
@@ -119,7 +136,8 @@ impl Compactor {
         };
 
         tokio::spawn(async move {
-            let result = run_compaction(&deps, &compactor_prompt, &history, fraction).await;
+            let result =
+                run_compaction(&deps, &compactor_prompt, &history, &channel_id, fraction).await;
 
             match result {
                 Ok(turns_compacted) => {
@@ -181,6 +199,7 @@ async fn run_compaction(
     deps: &AgentDeps,
     compactor_prompt: &str,
     history: &Arc<RwLock<Vec<Message>>>,
+    channel_id: &ChannelId,
     fraction: f32,
 ) -> Result<usize> {
     // 1. Read and remove the oldest messages from history
@@ -202,17 +221,17 @@ async fn run_compaction(
 
     // 3. Run the compaction LLM to produce summary + extracted memories
     let routing = deps.runtime_config.routing.load();
-    let model_name = routing.resolve(ProcessType::Worker, None).to_string();
+    let model_name = routing.resolve(ProcessType::Compactor, None).to_string();
     let model = SpacebotModel::make(&deps.llm_manager, &model_name)
         .with_context(&*deps.agent_id, "compactor")
         .with_routing((**routing).clone());
 
     // Give the compaction worker memory_save so it can directly persist memories
-    let tool_server: ToolServerHandle = ToolServer::new()
-        .tool(crate::tools::MemorySaveTool::new(
-            deps.memory_search.clone(),
-        ))
-        .run();
+    let tool_server: ToolServerHandle = crate::tools::create_cortex_tool_server(
+        deps.agent_id.clone(),
+        deps.memory_event_tx.clone(),
+        deps.memory_search.clone(),
+    );
 
     let agent = AgentBuilder::new(model)
         .preamble(compactor_prompt)
@@ -220,10 +239,17 @@ async fn run_compaction(
         .tool_server_handle(tool_server)
         .build();
 
+    let hook = SpacebotHook::new(
+        deps.agent_id.clone(),
+        ProcessId::Worker(Uuid::new_v4()),
+        ProcessType::Compactor,
+        Some(channel_id.clone()),
+        deps.event_tx.clone(),
+    );
+
     let mut compaction_history = Vec::new();
-    let response = agent
-        .prompt(&transcript)
-        .with_history(&mut compaction_history)
+    let response = hook
+        .prompt_once(&agent, &mut compaction_history, &transcript)
         .await;
 
     let summary = match response {
@@ -296,7 +322,21 @@ fn estimate_assistant_content_chars(content: &AssistantContent) -> usize {
         AssistantContent::ToolCall(tc) => {
             tc.function.name.len() + tc.function.arguments.to_string().len()
         }
-        AssistantContent::Reasoning(r) => r.reasoning.iter().map(|s| s.len()).sum(),
+        AssistantContent::Reasoning(r) => r
+            .content
+            .iter()
+            .map(|content| match content {
+                rig::message::ReasoningContent::Text { text, signature } => {
+                    text.len() + signature.as_ref().map_or(0, String::len)
+                }
+                rig::message::ReasoningContent::Encrypted(data) => data.len(),
+                rig::message::ReasoningContent::Redacted { data } => data.len(),
+                rig::message::ReasoningContent::Summary(summary) => summary.len(),
+                // Future variants default to 0; update this match when new variants are added
+                #[allow(unreachable_patterns)]
+                _ => 0,
+            })
+            .sum(),
         AssistantContent::Image(_) => 500,
     }
 }
diff --git a/src/agent/cortex.rs b/src/agent/cortex.rs
index 21d67b4ce..8cb091745 100644
--- a/src/agent/cortex.rs
+++ b/src/agent/cortex.rs
@@ -9,21 +9,32 @@
 //! The cortex also observes system-wide activity via signals for future use in
 //! health monitoring and memory consolidation.
 
+use crate::agent::channel_dispatch::{WorkerCompletionError, map_worker_completion_result};
+use crate::agent::process_control::{
+    ControlActionResult, DetachedWorkerControl, ProcessControlRegistry,
+};
+use crate::agent::worker::Worker;
 use crate::error::Result;
 use crate::hooks::CortexHook;
 use crate::llm::SpacebotModel;
 use crate::memory::search::{SearchConfig, SearchMode, SearchSort};
 use crate::memory::types::{Association, MemoryType, RelationType};
-use crate::{AgentDeps, ProcessEvent, ProcessType};
+use crate::tasks::{TaskStatus, UpdateTaskInput};
+use crate::{
+    AgentDeps, AgentId, BranchId, ChannelId, ProcessEvent, ProcessId, ProcessType, WorkerId,
+};
 
+use futures::FutureExt as _;
 use rig::agent::AgentBuilder;
-use rig::completion::{CompletionModel, Prompt};
+use rig::completion::{CompletionModel, Prompt, TypedPrompt};
 use serde::Serialize;
 use sqlx::{Row as _, SqlitePool};
 
+use std::collections::{HashMap, VecDeque};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicU8, Ordering};
 use std::time::{Duration, Instant};
-use tokio::sync::RwLock;
+use tokio::sync::{RwLock, broadcast};
 
 fn update_warmup_status<F>(deps: &AgentDeps, update: F)
 where
@@ -49,12 +60,509 @@ fn should_execute_warmup(warmup_config: crate::config::WarmupConfig, force: bool
     warmup_config.enabled || force
 }
 
+fn should_generate_bulletin_from_bulletin_loop(
+    warmup_config: crate::config::WarmupConfig,
+    status: &crate::config::WarmupStatus,
+) -> bool {
+    // If warmup is disabled, bulletin_loop remains the source of truth.
+    if !warmup_config.enabled {
+        return true;
+    }
+
+    let age_secs = bulletin_age_secs(status.last_refresh_unix_ms).or(status.bulletin_age_secs);
+
+    let Some(age_secs) = age_secs else {
+        // No recorded bulletin refresh yet — let bulletin loop generate one.
+        return true;
+    };
+
+    // Warmup loop already refreshes bulletin on this cadence. If the cached
+    // bulletin is still fresher than warmup cadence, skip duplicate synthesis.
+    age_secs >= warmup_config.refresh_secs.max(1)
+}
+
+const SIGNAL_BUFFER_CAPACITY: usize = 100;
+const BULLETIN_REFRESH_FAILURE_BACKOFF_BASE_SECS: u64 = 30;
+const BULLETIN_REFRESH_FAILURE_BACKOFF_MAX_SECS: u64 = 600;
+const BULLETIN_REFRESH_CIRCUIT_OPEN_THRESHOLD: u32 = 3;
+const BULLETIN_REFRESH_CIRCUIT_OPEN_SECS: u64 = 1800;
+
+fn bulletin_refresh_failure_backoff(consecutive_failures: u32) -> Duration {
+    let exponent = consecutive_failures.saturating_sub(1).min(5);
+    let multiplier = 1_u64 << exponent;
+    let seconds = BULLETIN_REFRESH_FAILURE_BACKOFF_BASE_SECS
+        .saturating_mul(multiplier)
+        .min(BULLETIN_REFRESH_FAILURE_BACKOFF_MAX_SECS);
+    Duration::from_secs(seconds)
+}
+
+fn record_bulletin_refresh_failure(
+    bulletin_refresh_failures: &mut u32,
+    bulletin_refresh_circuit_open: &mut bool,
+    next_bulletin_refresh_allowed_at: &mut Instant,
+    now: Instant,
+) -> (Duration, bool) {
+    *bulletin_refresh_failures = bulletin_refresh_failures.saturating_add(1);
+    let backoff = bulletin_refresh_failure_backoff(*bulletin_refresh_failures);
+    *next_bulletin_refresh_allowed_at = now + backoff;
+
+    let mut circuit_opened = false;
+    if *bulletin_refresh_failures >= BULLETIN_REFRESH_CIRCUIT_OPEN_THRESHOLD {
+        if !*bulletin_refresh_circuit_open {
+            *bulletin_refresh_circuit_open = true;
+            circuit_opened = true;
+        }
+        let circuit_cooldown = Duration::from_secs(BULLETIN_REFRESH_CIRCUIT_OPEN_SECS);
+        let circuit_recovery_at = now + circuit_cooldown;
+        if circuit_recovery_at > *next_bulletin_refresh_allowed_at {
+            *next_bulletin_refresh_allowed_at = circuit_recovery_at;
+        }
+    }
+
+    (backoff, circuit_opened)
+}
+
+fn maybe_close_bulletin_refresh_circuit(
+    bulletin_refresh_failures: &mut u32,
+    bulletin_refresh_circuit_open: &mut bool,
+    next_bulletin_refresh_allowed_at: &mut Instant,
+    now: Instant,
+) -> bool {
+    if !*bulletin_refresh_circuit_open || now < *next_bulletin_refresh_allowed_at {
+        return false;
+    }
+
+    *bulletin_refresh_failures = 0;
+    *bulletin_refresh_circuit_open = false;
+    *next_bulletin_refresh_allowed_at = now;
+    true
+}
+
+fn has_completed_initial_warmup(status: &crate::config::WarmupStatus) -> bool {
+    status.last_refresh_unix_ms.is_some()
+        && matches!(status.state, crate::config::WarmupState::Warm)
+}
+
+fn apply_cancelled_warmup_status(
+    status: &mut crate::config::WarmupStatus,
+    reason: &str,
+    force: bool,
+) -> bool {
+    if !matches!(status.state, crate::config::WarmupState::Warming) {
+        return false;
+    }
+
+    status.state = crate::config::WarmupState::Degraded;
+    status.last_error = Some(format!(
+        "warmup cancelled before completion (reason: {reason}, forced: {force})"
+    ));
+    status.bulletin_age_secs = bulletin_age_secs(status.last_refresh_unix_ms);
+    true
+}
+
+struct WarmupRunGuard<'a> {
+    deps: &'a AgentDeps,
+    reason: &'a str,
+    force: bool,
+    committed: bool,
+}
+
+impl<'a> WarmupRunGuard<'a> {
+    fn new(deps: &'a AgentDeps, reason: &'a str, force: bool) -> Self {
+        Self {
+            deps,
+            reason,
+            force,
+            committed: false,
+        }
+    }
+
+    fn mark_committed(&mut self) {
+        self.committed = true;
+    }
+}
+
+impl Drop for WarmupRunGuard<'_> {
+    fn drop(&mut self) {
+        if self.committed {
+            return;
+        }
+
+        update_warmup_status(self.deps, |status| {
+            if apply_cancelled_warmup_status(status, self.reason, self.force) {
+                tracing::warn!(
+                    reason = self.reason,
+                    forced = self.force,
+                    "warmup run ended without terminal status; demoted state to degraded"
+                );
+            }
+        });
+    }
+}
+
+async fn maybe_generate_bulletin_under_lock<F, Fut>(
+    warmup_lock: &tokio::sync::Mutex<()>,
+    warmup_config: &arc_swap::ArcSwap<crate::config::WarmupConfig>,
+    warmup_status: &arc_swap::ArcSwap<crate::config::WarmupStatus>,
+    generate: F,
+) -> BulletinRefreshOutcome
+where
+    F: FnOnce() -> Fut,
+    Fut: std::future::Future<Output = bool>,
+{
+    let _warmup_guard = warmup_lock.lock().await;
+    let warmup_config = **warmup_config.load();
+    let status = warmup_status.load().as_ref().clone();
+    let age_secs = bulletin_age_secs(status.last_refresh_unix_ms).or(status.bulletin_age_secs);
+    let refresh_secs = warmup_config.refresh_secs.max(1);
+
+    if should_generate_bulletin_from_bulletin_loop(warmup_config, &status) {
+        if generate().await {
+            BulletinRefreshOutcome::Generated
+        } else {
+            BulletinRefreshOutcome::Failed
+        }
+    } else {
+        tracing::debug!(
+            warmup_enabled = warmup_config.enabled,
+            age_secs = ?age_secs,
+            refresh_secs,
+            "skipping bulletin loop generation because warmup bulletin is fresh"
+        );
+        BulletinRefreshOutcome::SkippedFresh
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum BulletinRefreshOutcome {
+    Generated,
+    SkippedFresh,
+    Failed,
+}
+
+impl BulletinRefreshOutcome {
+    fn is_success(self) -> bool {
+        !matches!(self, Self::Failed)
+    }
+
+    fn generated(self) -> bool {
+        matches!(self, Self::Generated)
+    }
+}
+
+const BRANCH_LATENCY_WINDOW_SIZE: usize = 32;
+
+#[derive(Debug, Clone)]
+struct WorkerTracker {
+    worker_id: WorkerId,
+    channel_id: Option<ChannelId>,
+    worker_type: String,
+    started_at: Instant,
+    last_activity_at: Instant,
+    /// When true the worker is idle (waiting for follow-up input) and should
+    /// NOT be killed by the supervisor timeout.
+    is_idle: bool,
+}
+
+#[derive(Debug, Clone)]
+struct BranchTracker {
+    branch_id: BranchId,
+    channel_id: ChannelId,
+    started_at: Instant,
+}
+
+#[derive(Debug, Clone)]
+enum KillTarget {
+    Worker(WorkerTracker),
+    Branch(BranchTracker),
+}
+
+#[derive(Debug, Clone, Default)]
+struct BreakerState {
+    failure_count: u32,
+    tripped: bool,
+}
+
+#[derive(Debug, Clone)]
+struct BreakerTripEvent {
+    key: String,
+    failure_count: u32,
+}
+
+#[derive(Debug, Default)]
+struct HealthRuntimeState {
+    worker_trackers: HashMap<WorkerId, WorkerTracker>,
+    branch_trackers: HashMap<BranchId, BranchTracker>,
+    branch_latency_window_ms: VecDeque<u64>,
+    breaker_state: HashMap<String, BreakerState>,
+    pending_breaker_trip_events: Vec<BreakerTripEvent>,
+    lagged_control_since_last_tick: bool,
+}
+
+impl HealthRuntimeState {
+    fn track_worker_start(
+        &mut self,
+        worker_id: WorkerId,
+        channel_id: Option<ChannelId>,
+        worker_type: String,
+    ) {
+        let now = Instant::now();
+        self.worker_trackers.insert(
+            worker_id,
+            WorkerTracker {
+                worker_id,
+                channel_id,
+                worker_type,
+                started_at: now,
+                last_activity_at: now,
+                is_idle: false,
+            },
+        );
+    }
+
+    fn track_worker_idle(&mut self, worker_id: WorkerId) {
+        if let Some(tracker) = self.worker_trackers.get_mut(&worker_id) {
+            tracker.is_idle = true;
+        }
+    }
+
+    fn track_worker_activity(&mut self, worker_id: WorkerId) {
+        if let Some(tracker) = self.worker_trackers.get_mut(&worker_id) {
+            tracker.last_activity_at = Instant::now();
+            // Any activity means the worker is no longer idle.
+            tracker.is_idle = false;
+        }
+    }
+
+    fn track_worker_complete(&mut self, worker_id: WorkerId, success: bool, threshold: u8) {
+        let Some(worker_type) = self
+            .worker_trackers
+            .remove(&worker_id)
+            .map(|tracker| tracker.worker_type)
+        else {
+            return;
+        };
+        self.update_breaker(
+            format!("worker_type:{worker_type}"),
+            !success,
+            threshold.max(1),
+        );
+    }
+
+    fn track_branch_start(&mut self, branch_id: BranchId, channel_id: ChannelId) {
+        self.branch_trackers.insert(
+            branch_id,
+            BranchTracker {
+                branch_id,
+                channel_id,
+                started_at: Instant::now(),
+            },
+        );
+    }
+
+    fn track_branch_complete(&mut self, branch_id: BranchId) {
+        if let Some(tracker) = self.branch_trackers.remove(&branch_id) {
+            let elapsed = tracker.started_at.elapsed().as_millis() as u64;
+            self.branch_latency_window_ms.push_back(elapsed);
+            while self.branch_latency_window_ms.len() > BRANCH_LATENCY_WINDOW_SIZE {
+                self.branch_latency_window_ms.pop_front();
+            }
+        }
+    }
+
+    fn track_tool_completed(&mut self, tool_name: &str, result: &str, threshold: u8) {
+        let Some(structured_success) = parse_structured_success_flag(result) else {
+            return;
+        };
+
+        self.update_breaker(
+            format!("tool:{tool_name}"),
+            !structured_success,
+            threshold.max(1),
+        );
+    }
+
+    fn mark_control_receiver_lag(&mut self) {
+        self.lagged_control_since_last_tick = true;
+    }
+
+    fn update_breaker(&mut self, key: String, failure: bool, threshold: u8) {
+        let state = self.breaker_state.entry(key.clone()).or_default();
+        if failure {
+            state.failure_count = state.failure_count.saturating_add(1);
+            if !state.tripped && state.failure_count >= threshold as u32 {
+                state.tripped = true;
+                self.pending_breaker_trip_events.push(BreakerTripEvent {
+                    key,
+                    failure_count: state.failure_count,
+                });
+            }
+            return;
+        }
+
+        state.failure_count = 0;
+        state.tripped = false;
+    }
+}
+
+fn parse_structured_success_flag(result: &str) -> Option<bool> {
+    let trimmed = result.trim();
+    if !trimmed.starts_with('{') || trimmed.len() > 16_384 {
+        return None;
+    }
+
+    let value: serde_json::Value = serde_json::from_str(trimmed).ok()?;
+    let object = value.as_object()?;
+    if let Some(success) = object.get("success").and_then(|value| value.as_bool()) {
+        return Some(success);
+    }
+    object.get("ok").and_then(|value| value.as_bool())
+}
+
+fn kill_target_last_activity(target: &KillTarget) -> Instant {
+    match target {
+        KillTarget::Worker(tracker) => tracker.last_activity_at,
+        KillTarget::Branch(tracker) => tracker.started_at,
+    }
+}
+
+fn kill_target_id(target: &KillTarget) -> u128 {
+    match target {
+        KillTarget::Worker(tracker) => tracker.worker_id.as_u128(),
+        KillTarget::Branch(tracker) => tracker.branch_id.as_u128(),
+    }
+}
+
+fn build_kill_targets(
+    overdue_workers: Vec<WorkerTracker>,
+    overdue_branches: Vec<BranchTracker>,
+) -> Vec<KillTarget> {
+    let mut targets = Vec::with_capacity(overdue_workers.len() + overdue_branches.len());
+    targets.extend(overdue_workers.into_iter().map(KillTarget::Worker));
+    targets.extend(overdue_branches.into_iter().map(KillTarget::Branch));
+    targets.sort_by(|left, right| {
+        let left_activity = kill_target_last_activity(left);
+        let right_activity = kill_target_last_activity(right);
+        if left_activity == right_activity {
+            kill_target_id(left).cmp(&kill_target_id(right))
+        } else {
+            left_activity.cmp(&right_activity)
+        }
+    });
+    targets
+}
+
+fn is_terminal_control_result(result: ControlActionResult) -> bool {
+    matches!(
+        result,
+        ControlActionResult::Cancelled
+            | ControlActionResult::AlreadyTerminal
+            | ControlActionResult::NotFound
+    )
+}
+
+fn is_cancelled_control_result(result: ControlActionResult) -> bool {
+    matches!(result, ControlActionResult::Cancelled)
+}
+
+fn take_lagged_control_flag(state: &mut HealthRuntimeState) -> bool {
+    let lagged = state.lagged_control_since_last_tick;
+    state.lagged_control_since_last_tick = false;
+    lagged
+}
+
+fn detached_timeout_transition(
+    metadata: &serde_json::Value,
+    retry_limit: u8,
+) -> (u64, bool, TaskStatus) {
+    let current_timeout_count = metadata
+        .get("supervisor_timeout_count")
+        .and_then(serde_json::Value::as_u64)
+        .unwrap_or(0);
+    let next_timeout_count = current_timeout_count.saturating_add(1);
+    let exhausted = next_timeout_count > retry_limit as u64;
+    let status = if exhausted {
+        TaskStatus::Backlog
+    } else {
+        TaskStatus::Ready
+    };
+    (next_timeout_count, exhausted, status)
+}
+
+fn claim_detached_completion(lifecycle: &std::sync::atomic::AtomicU8) -> bool {
+    loop {
+        let current = lifecycle.load(Ordering::Acquire);
+        let claimable = current == crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_ACTIVE
+            || current == crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_KILLING;
+        if !claimable {
+            return false;
+        }
+
+        if lifecycle
+            .compare_exchange(
+                current,
+                crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_COMPLETING,
+                Ordering::AcqRel,
+                Ordering::Acquire,
+            )
+            .is_ok()
+        {
+            return true;
+        }
+    }
+}
+
+#[doc(hidden)]
+pub async fn register_detached_worker_for_pickup(
+    process_control_registry: &ProcessControlRegistry,
+    task_store: &crate::tasks::TaskStore,
+    agent_id: &AgentId,
+    task_number: i64,
+    worker_id: WorkerId,
+) -> anyhow::Result<(Arc<AtomicU8>, tokio::sync::oneshot::Receiver<()>)> {
+    let (cancel_tx, cancel_rx) = tokio::sync::oneshot::channel();
+    let lifecycle = Arc::new(AtomicU8::new(
+        crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_ACTIVE,
+    ));
+
+    process_control_registry
+        .register_detached_worker(DetachedWorkerControl::new(
+            worker_id,
+            agent_id.clone(),
+            task_number,
+            cancel_tx,
+            lifecycle.clone(),
+        ))
+        .await;
+
+    if let Err(error) = task_store
+        .update(
+            agent_id,
+            task_number,
+            UpdateTaskInput {
+                worker_id: Some(worker_id.to_string()),
+                ..Default::default()
+            },
+        )
+        .await
+    {
+        process_control_registry
+            .unregister_detached_worker(worker_id)
+            .await;
+        return Err(error.into());
+    }
+
+    Ok((lifecycle, cancel_rx))
+}
+
 /// The cortex observes system-wide activity and maintains the memory bulletin.
 pub struct Cortex {
     pub deps: AgentDeps,
     pub hook: CortexHook,
     /// Recent activity signals (rolling window).
-    pub signal_buffer: Arc<RwLock<Vec<Signal>>>,
+    pub signal_buffer: Arc<RwLock<VecDeque<Signal>>>,
+    /// Runtime supervision state for timeout enforcement and breaker signals.
+    health_runtime_state: Arc<RwLock<HealthRuntimeState>>,
     /// System prompt loaded from prompts/CORTEX.md.
     pub system_prompt: String,
 }
@@ -62,30 +570,106 @@ pub struct Cortex {
 /// A high-level activity signal (not raw conversation).
 #[derive(Debug, Clone)]
 pub enum Signal {
-    /// Channel started.
-    ChannelStarted { channel_id: String },
-    /// Channel ended.
-    ChannelEnded { channel_id: String },
+    /// Branch started.
+    BranchStarted {
+        branch_id: BranchId,
+        channel_id: ChannelId,
+        description: String,
+    },
+    /// Branch produced a result.
+    BranchResult {
+        branch_id: BranchId,
+        channel_id: ChannelId,
+        conclusion: String,
+    },
+    /// Worker started.
+    WorkerStarted {
+        worker_id: WorkerId,
+        channel_id: Option<ChannelId>,
+        task_summary: String,
+        worker_type: String,
+    },
+    /// Worker status update.
+    WorkerStatus {
+        worker_id: WorkerId,
+        channel_id: Option<ChannelId>,
+        status: String,
+    },
+    /// Worker completed.
+    WorkerCompleted {
+        worker_id: WorkerId,
+        channel_id: Option<ChannelId>,
+        success: bool,
+        result_summary: String,
+    },
+    /// Tool execution started.
+    ToolStarted {
+        process_id: ProcessId,
+        channel_id: Option<ChannelId>,
+        tool_name: String,
+    },
+    /// Tool execution completed.
+    ToolCompleted {
+        process_id: ProcessId,
+        channel_id: Option<ChannelId>,
+        tool_name: String,
+        result_summary: String,
+    },
     /// Memory was saved.
     MemorySaved {
-        memory_type: String,
+        memory_id: String,
+        channel_id: Option<ChannelId>,
+        memory_type: MemoryType,
         content_summary: String,
         importance: f32,
     },
-    /// Worker completed.
-    WorkerCompleted {
-        task_summary: String,
-        result_summary: String,
+    /// Compaction threshold was reached.
+    CompactionTriggered {
+        channel_id: ChannelId,
+        threshold_reached: f32,
+    },
+    /// Generic status update.
+    StatusUpdate {
+        process_id: ProcessId,
+        status: String,
+    },
+    /// Worker requested a permission decision.
+    WorkerPermission {
+        worker_id: WorkerId,
+        channel_id: Option<ChannelId>,
+        permission_id: String,
+        description: String,
+    },
+    /// Worker asked one or more questions.
+    WorkerQuestion {
+        worker_id: WorkerId,
+        channel_id: Option<ChannelId>,
+        question_id: String,
+        question_count: usize,
     },
-    /// Compaction occurred.
-    Compaction {
-        channel_id: String,
-        turns_compacted: i64,
+    /// Agent sent a linked message.
+    AgentMessageSent {
+        from_agent_id: AgentId,
+        to_agent_id: AgentId,
+        channel_id: ChannelId,
     },
-    /// Error occurred.
-    Error {
-        component: String,
-        error_summary: String,
+    /// Agent received a linked message.
+    AgentMessageReceived {
+        from_agent_id: AgentId,
+        to_agent_id: AgentId,
+        channel_id: ChannelId,
+    },
+    /// Task lifecycle update.
+    TaskUpdated {
+        task_number: i64,
+        status: String,
+        action: String,
+    },
+    /// Streaming text delta emitted by a process.
+    TextDelta {
+        process_id: ProcessId,
+        channel_id: Option<ChannelId>,
+        text_summary: String,
     },
 }
 
@@ -218,73 +802,641 @@ impl Cortex {
         Self {
             deps,
             hook,
-            signal_buffer: Arc::new(RwLock::new(Vec::with_capacity(100))),
+            signal_buffer: Arc::new(RwLock::new(VecDeque::with_capacity(SIGNAL_BUFFER_CAPACITY))),
+            health_runtime_state: Arc::new(RwLock::new(HealthRuntimeState::default())),
             system_prompt: system_prompt.into(),
         }
     }
 
     /// Process a process event and extract signals.
     pub async fn observe(&self, event: ProcessEvent) {
-        let signal = match &event {
-            ProcessEvent::MemorySaved { memory_id, .. } => Some(Signal::MemorySaved {
-                memory_type: "unknown".into(),
-                content_summary: format!("memory {}", memory_id),
-                importance: 0.5,
-            }),
-            ProcessEvent::WorkerComplete { result, .. } => Some(Signal::WorkerCompleted {
-                task_summary: "completed task".into(),
-                result_summary: result.lines().next().unwrap_or("done").into(),
-            }),
-            ProcessEvent::CompactionTriggered {
+        self.observe_health_event(&event).await;
+        let Some(signal) = signal_from_event(event) else {
+            return;
+        };
+        let buffer_len = {
+            let mut buffer = self.signal_buffer.write().await;
+            push_signal_into_buffer(&mut buffer, signal);
+            buffer.len()
+        };
+
+        tracing::trace!(buffer_len, "cortex received signal");
+    }
+
+    async fn observe_health_event(&self, event: &ProcessEvent) {
+        let threshold = self
+            .deps
+            .runtime_config
+            .cortex
+            .load()
+            .circuit_breaker_threshold;
+        let mut state = self.health_runtime_state.write().await;
+
+        match event {
+            ProcessEvent::WorkerStarted {
+                worker_id,
+                channel_id,
+                worker_type,
+                ..
+            } => state.track_worker_start(*worker_id, channel_id.clone(), worker_type.clone()),
+            ProcessEvent::WorkerComplete {
+                worker_id, success, ..
+            } => state.track_worker_complete(*worker_id, *success, threshold),
+            ProcessEvent::WorkerIdle { worker_id, .. } => state.track_worker_idle(*worker_id),
+            ProcessEvent::WorkerStatus { worker_id, .. } => {
+                state.track_worker_activity(*worker_id);
+            }
+            ProcessEvent::ToolStarted {
+                process_id: ProcessId::Worker(worker_id),
+                ..
+            } => {
+                state.track_worker_activity(*worker_id);
+            }
+            ProcessEvent::ToolCompleted {
+                process_id,
+                tool_name,
+                result,
+                ..
+            } => {
+                if let ProcessId::Worker(worker_id) = process_id {
+                    state.track_worker_activity(*worker_id);
+                }
+                state.track_tool_completed(tool_name, result, threshold);
+            }
+            ProcessEvent::BranchStarted {
+                branch_id,
                 channel_id,
-                threshold_reached,
                 ..
-            } => Some(Signal::Compaction {
-                channel_id: channel_id.to_string(),
-                turns_compacted: (*threshold_reached * 100.0) as i64,
-            }),
-            _ => None,
+            } => state.track_branch_start(*branch_id, channel_id.clone()),
+            ProcessEvent::BranchResult { branch_id, .. } => state.track_branch_complete(*branch_id),
+            _ => {}
+        }
+    }
+
+    pub async fn mark_control_receiver_lag(&self) {
+        self.health_runtime_state
+            .write()
+            .await
+            .mark_control_receiver_lag();
+    }
+
+    /// Run one supervision tick: emit pending breaker trips and enforce
+    /// lag-aware timeout cancellation with a bounded kill budget.
+    pub async fn run_health_tick(&self, logger: &CortexLogger) -> Result<()> {
+        let cortex_config = **self.deps.runtime_config.cortex.load();
+        let worker_timeout = Duration::from_secs(cortex_config.worker_timeout_secs.max(1));
+        let branch_timeout = Duration::from_secs(cortex_config.branch_timeout_secs.max(1));
+        let kill_budget = cortex_config.supervisor_kill_budget_per_tick;
+
+        let pruned_dead_channels = self
+            .deps
+            .process_control_registry
+            .prune_dead_channels()
+            .await;
+
+        let now = Instant::now();
+        let (lagged_control, pending_breaker_trips, overdue_workers, overdue_branches) = {
+            let mut state = self.health_runtime_state.write().await;
+            let lagged_control = take_lagged_control_flag(&mut state);
+
+            let pending_breaker_trips = std::mem::take(&mut state.pending_breaker_trip_events);
+
+            let overdue_workers = if lagged_control {
+                Vec::new()
+            } else {
+                state
+                    .worker_trackers
+                    .values()
+                    .filter(|tracker| {
+                        !tracker.is_idle
+                            && now.duration_since(tracker.last_activity_at) >= worker_timeout
+                    })
+                    .cloned()
+                    .collect()
+            };
+
+            let overdue_branches = if lagged_control {
+                Vec::new()
+            } else {
+                state
+                    .branch_trackers
+                    .values()
+                    .filter(|tracker| now.duration_since(tracker.started_at) >= branch_timeout)
+                    .cloned()
+                    .collect()
+            };
+
+            (
+                lagged_control,
+                pending_breaker_trips,
+                overdue_workers,
+                overdue_branches,
+            )
         };
 
-        if let Some(signal) = signal {
-            let mut buffer = self.signal_buffer.write().await;
-            buffer.push(signal);
+        for trip in pending_breaker_trips {
+            logger.log(
+                "circuit_breaker_tripped",
+                &format!("Circuit breaker tripped for {}", trip.key),
+                Some(serde_json::json!({
+                    "key": trip.key,
+                    "failure_count": trip.failure_count,
+                    "threshold": cortex_config.circuit_breaker_threshold,
+                    "action_taken": "observe_only",
+                })),
+            );
+        }
+
+        if lagged_control {
+            logger.log(
+                "health_check",
+                "Skipped timeout cancellation due to lagged control receiver",
+                Some(serde_json::json!({
+                    "kill_skipped_due_to_lag": true,
+                    "kill_budget": kill_budget,
+                    "pruned_dead_channels": pruned_dead_channels,
+                })),
+            );
+            return Ok(());
+        }
+
+        let targets = build_kill_targets(overdue_workers, overdue_branches);
 
-            if buffer.len() > 100 {
-                buffer.remove(0);
+        let mut terminal_worker_ids = Vec::new();
+        let mut terminal_branch_ids = Vec::new();
+        let mut kill_attempts = 0_usize;
+        let mut kill_actions = 0_usize;
+
+        for target in targets.into_iter().take(kill_budget) {
+            kill_attempts = kill_attempts.saturating_add(1);
+            let result = match target.clone() {
+                KillTarget::Worker(tracker) => {
+                    let idle_secs = now.duration_since(tracker.last_activity_at).as_secs();
+                    let reason = format!(
+                        "idle for {}s, exceeded {}s timeout (supervisor)",
+                        idle_secs,
+                        worker_timeout.as_secs()
+                    );
+                    if let Some(channel_id) = &tracker.channel_id {
+                        self.deps
+                            .process_control_registry
+                            .cancel_channel_worker(channel_id, tracker.worker_id, &reason)
+                            .await
+                    } else {
+                        self.deps
+                            .process_control_registry
+                            .cancel_detached_worker(tracker.worker_id, &reason)
+                            .await
+                    }
+                }
+                KillTarget::Branch(tracker) => {
+                    let reason =
+                        format!("timed out after {}s (supervisor)", branch_timeout.as_secs());
+                    self.deps
+                        .process_control_registry
+                        .cancel_channel_branch(&tracker.channel_id, tracker.branch_id, &reason)
+                        .await
+                }
+            };
+
+            if !is_terminal_control_result(result) {
+                continue;
             }
 
-            tracing::debug!("cortex received signal, buffer size: {}", buffer.len());
+            match target {
+                KillTarget::Worker(tracker) => {
+                    terminal_worker_ids.push(tracker.worker_id);
+                    if is_cancelled_control_result(result) {
+                        let idle_secs = now.duration_since(tracker.last_activity_at).as_secs();
+                        let lifetime_secs = now.duration_since(tracker.started_at).as_secs();
+                        logger.log(
+                            "worker_killed",
+                            &format!("Worker {} cancelled by supervisor", tracker.worker_id),
+                            Some(serde_json::json!({
+                                "worker_id": tracker.worker_id.to_string(),
+                                "channel_id": tracker.channel_id.as_deref(),
+                                "idle_secs": idle_secs,
+                                "lifetime_secs": lifetime_secs,
+                                "timeout_secs": worker_timeout.as_secs(),
+                                "reason": "idle_timeout",
+                            })),
+                        );
+                        kill_actions = kill_actions.saturating_add(1);
+                    }
+                }
+                KillTarget::Branch(tracker) => {
+                    terminal_branch_ids.push(tracker.branch_id);
+                    if is_cancelled_control_result(result) {
+                        logger.log(
+                            "branch_killed",
+                            &format!("Branch {} cancelled by supervisor", tracker.branch_id),
+                            Some(serde_json::json!({
+                                "branch_id": tracker.branch_id.to_string(),
+                                "channel_id": tracker.channel_id.as_ref(),
+                                "timeout_secs": branch_timeout.as_secs(),
+                                "reason": "timeout",
+                            })),
+                        );
+                        kill_actions = kill_actions.saturating_add(1);
+                    }
+                }
+            };
         }
-    }
 
-    /// Run periodic consolidation (future: health monitoring, memory maintenance).
-    pub async fn run_consolidation(&self) -> Result<()> {
-        tracing::info!("cortex running consolidation");
+        if !terminal_worker_ids.is_empty() || !terminal_branch_ids.is_empty() {
+            let mut state = self.health_runtime_state.write().await;
+            for worker_id in terminal_worker_ids {
+                state.worker_trackers.remove(&worker_id);
+            }
+            for branch_id in terminal_branch_ids {
+                state.branch_trackers.remove(&branch_id);
+            }
+        }
+
+        logger.log(
+            "health_check",
+            "Cortex supervision health tick completed",
+            Some(serde_json::json!({
+                "kill_skipped_due_to_lag": false,
+                "kill_budget": kill_budget,
+                "kill_attempts": kill_attempts,
+                "kill_actions": kill_actions,
+                "worker_timeout_secs": worker_timeout.as_secs(),
+                "branch_timeout_secs": branch_timeout.as_secs(),
+                "pruned_dead_channels": pruned_dead_channels,
+            })),
+        );
+
         Ok(())
     }
 }
 
-/// Spawn the cortex bulletin loop for an agent.
+fn summarize_signal_text(value: &str) -> String {
+    crate::summarize_first_non_empty_line(value, crate::EVENT_SUMMARY_MAX_CHARS)
+}
+
+fn signal_from_event(event: ProcessEvent) -> Option<Signal> {
+    Some(match event {
+        ProcessEvent::BranchStarted {
+            branch_id,
+            channel_id,
+            description,
+            ..
+        } => Signal::BranchStarted {
+            branch_id,
+            channel_id,
+            description: summarize_signal_text(&description),
+        },
+        ProcessEvent::BranchResult {
+            branch_id,
+            channel_id,
+            conclusion,
+            ..
+        } => Signal::BranchResult {
+            branch_id,
+            channel_id,
+            conclusion: summarize_signal_text(&conclusion),
+        },
+        ProcessEvent::WorkerStarted {
+            worker_id,
+            channel_id,
+            task,
+            worker_type,
+            ..
+        } => Signal::WorkerStarted {
+            worker_id,
+            channel_id,
+            task_summary: summarize_signal_text(&task),
+            worker_type,
+        },
+        ProcessEvent::WorkerStatus {
+            worker_id,
+            channel_id,
+            status,
+            ..
+        } => Signal::WorkerStatus {
+            worker_id,
+            channel_id,
+            status: summarize_signal_text(&status),
+        },
+        ProcessEvent::WorkerComplete {
+            worker_id,
+            channel_id,
+            result,
+            success,
+            ..
+        } => Signal::WorkerCompleted {
+            worker_id,
+            channel_id,
+            success,
+            result_summary: summarize_signal_text(&result),
+        },
+        ProcessEvent::ToolStarted {
+            process_id,
+            channel_id,
+            tool_name,
+            ..
+        } => Signal::ToolStarted {
+            process_id,
+            channel_id,
+            tool_name,
+        },
+        ProcessEvent::ToolCompleted {
+            process_id,
+            channel_id,
+            tool_name,
+            result,
+            ..
+        } => Signal::ToolCompleted {
+            process_id,
+            channel_id,
+            tool_name,
+            result_summary: summarize_signal_text(&result),
+        },
+        ProcessEvent::MemorySaved {
+            memory_id,
+            channel_id,
+            memory_type,
+            importance,
+            content_summary,
+            ..
+        } => Signal::MemorySaved {
+            memory_id,
+            channel_id,
+            memory_type,
+            content_summary,
+            importance,
+        },
+        ProcessEvent::CompactionTriggered {
+            channel_id,
+            threshold_reached,
+            ..
+        } => Signal::CompactionTriggered {
+            channel_id,
+            threshold_reached,
+        },
+        ProcessEvent::StatusUpdate {
+            process_id, status, ..
+        } => Signal::StatusUpdate {
+            process_id,
+            status: summarize_signal_text(&status),
+        },
+        ProcessEvent::WorkerPermission {
+            worker_id,
+            channel_id,
+            permission_id,
+            description,
+            ..
+        } => Signal::WorkerPermission {
+            worker_id,
+            channel_id,
+            permission_id,
+            description: summarize_signal_text(&description),
+        },
+        ProcessEvent::WorkerQuestion {
+            worker_id,
+            channel_id,
+            question_id,
+            questions,
+            ..
+        } => Signal::WorkerQuestion {
+            worker_id,
+            channel_id,
+            question_id,
+            question_count: questions.len(),
+        },
+        ProcessEvent::AgentMessageSent {
+            from_agent_id,
+            to_agent_id,
+            channel_id,
+            ..
+        } => Signal::AgentMessageSent {
+            from_agent_id,
+            to_agent_id,
+            channel_id,
+        },
+        ProcessEvent::AgentMessageReceived {
+            from_agent_id,
+            to_agent_id,
+            channel_id,
+            ..
+        } => Signal::AgentMessageReceived {
+            from_agent_id,
+            to_agent_id,
+            channel_id,
+        },
+        ProcessEvent::TaskUpdated {
+            task_number,
+            status,
+            action,
+            ..
+        } => Signal::TaskUpdated {
+            task_number,
+            status: summarize_signal_text(&status),
+            action,
+        },
+        ProcessEvent::TextDelta {
+            process_id,
+            channel_id,
+            text_delta,
+            ..
+        } => Signal::TextDelta {
+            process_id,
+            channel_id,
+            text_summary: summarize_signal_text(&text_delta),
+        },
+        ProcessEvent::WorkerIdle {
+            worker_id,
+            channel_id,
+            ..
+        } => Signal::WorkerStatus {
+            worker_id,
+            channel_id,
+            status: "idle".to_string(),
+        },
+        // UI-only events — no cortex signal needed.
+        ProcessEvent::OpenCodeSessionCreated { .. }
+        | ProcessEvent::OpenCodePartUpdated { .. }
+        | ProcessEvent::WorkerInitialResult { .. } => return None,
+    })
+}
+
+fn push_signal_into_buffer(buffer: &mut VecDeque<Signal>, signal: Signal) {
+    if let Some(previous) = buffer.back_mut()
+        && coalesce_signal(previous, &signal)
+    {
+        return;
+    }
+
+    buffer.push_back(signal);
+    if buffer.len() > SIGNAL_BUFFER_CAPACITY {
+        buffer.pop_front();
+    }
+}
+
+fn coalesce_signal(previous: &mut Signal, next: &Signal) -> bool {
+    match (previous, next) {
+        (
+            Signal::StatusUpdate {
+                process_id: previous_process_id,
+                status: previous_status,
+            },
+            Signal::StatusUpdate {
+                process_id: next_process_id,
+                status: next_status,
+            },
+        ) if previous_process_id == next_process_id => {
+            *previous_status = next_status.clone();
+            true
+        }
+        (
+            Signal::WorkerStatus {
+                worker_id: previous_worker_id,
+                channel_id: previous_channel_id,
+                status: previous_status,
+            },
+            Signal::WorkerStatus {
+                worker_id: next_worker_id,
+                channel_id: next_channel_id,
+                status: next_status,
+            },
+        ) if previous_worker_id == next_worker_id && previous_channel_id == next_channel_id => {
+            *previous_status = next_status.clone();
+            true
+        }
+        (
+            Signal::TaskUpdated {
+                task_number: previous_task_number,
+                status: previous_status,
+                action: previous_action,
+            },
+            Signal::TaskUpdated {
+                task_number: next_task_number,
+                status: next_status,
+                action: next_action,
+            },
+        ) if previous_task_number == next_task_number => {
+            *previous_status = next_status.clone();
+            *previous_action = next_action.clone();
+            true
+        }
+        (
+            Signal::TextDelta {
+                process_id: previous_process_id,
+                channel_id: previous_channel_id,
+                text_summary: previous_text_summary,
+            },
+            Signal::TextDelta {
+                process_id: next_process_id,
+                channel_id: next_channel_id,
+                text_summary: next_text_summary,
+            },
+        ) if previous_process_id == next_process_id && previous_channel_id == next_channel_id => {
+            *previous_text_summary = next_text_summary.clone();
+            true
+        }
+        _ => false,
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ReceiverClosedBehavior {
+    StopLoop,
+    DisableStream,
+}
+
+#[derive(Debug, Clone)]
+enum CortexReceiverOutcome {
+    Observe(ProcessEvent),
+    Lagged { dropped: u64 },
+    StopLoop,
+    DisableStream,
+}
+
+fn handle_cortex_receiver_result(
+    result: std::result::Result<ProcessEvent, broadcast::error::RecvError>,
+    receiver_name: &'static str,
+    close_behavior: ReceiverClosedBehavior,
+    lagged_since_last_warning: &mut u64,
+    last_lag_warning: &mut Option<Instant>,
+    warning_interval_secs: u64,
+) -> CortexReceiverOutcome {
+    match crate::classify_broadcast_recv_result(result) {
+        crate::BroadcastRecvResult::Event(event) => CortexReceiverOutcome::Observe(event),
+        crate::BroadcastRecvResult::Lagged(count) => {
+            if let Some(dropped) = crate::drain_lag_warning_count(
+                lagged_since_last_warning,
+                last_lag_warning,
+                count,
+                Duration::from_secs(warning_interval_secs),
+            ) {
+                tracing::warn!(
+                    receiver = receiver_name,
+                    dropped,
+                    "cortex event receiver lagged, dropping old events"
+                );
+            }
+            CortexReceiverOutcome::Lagged { dropped: count }
+        }
+        crate::BroadcastRecvResult::Closed => match close_behavior {
+            ReceiverClosedBehavior::StopLoop => {
+                tracing::warn!(
+                    receiver = receiver_name,
+                    "cortex event bus closed, stopping cortex loop"
+                );
+                CortexReceiverOutcome::StopLoop
+            }
+            ReceiverClosedBehavior::DisableStream => {
+                tracing::warn!(
+                    receiver = receiver_name,
+                    "cortex memory event bus closed, continuing without memory events"
+                );
+                CortexReceiverOutcome::DisableStream
+            }
+        },
+    }
+}
+
+/// Spawn the cortex runtime loop for an agent.
 ///
-/// Generates a memory bulletin immediately on startup, then refreshes on a
-/// configurable interval. The bulletin is stored in `RuntimeConfig::memory_bulletin`
-/// and injected into every channel's system prompt.
-pub fn spawn_bulletin_loop(deps: AgentDeps, logger: CortexLogger) -> tokio::task::JoinHandle<()> {
+/// The loop observes process events and runs periodic cortex maintenance ticks.
+/// Bulletin generation and profile refresh happen inside this tick loop.
+pub fn spawn_cortex_loop(deps: AgentDeps, logger: CortexLogger) -> tokio::task::JoinHandle<()> {
     tokio::spawn(async move {
-        if let Err(error) = run_bulletin_loop(&deps, &logger).await {
-            tracing::error!(%error, "cortex bulletin loop exited with error");
+        let prompt_engine = deps.runtime_config.prompts.load();
+        let system_prompt = match prompt_engine.render_static("cortex") {
+            Ok(prompt) => prompt,
+            Err(error) => {
+                tracing::warn!(%error, "failed to render cortex prompt, using empty preamble");
+                String::new()
+            }
+        };
+        drop(prompt_engine);
+
+        let cortex = Cortex::new(deps.clone(), system_prompt);
+        let mut event_rx = deps.event_tx.subscribe();
+        let mut memory_event_rx = deps.memory_event_tx.subscribe();
+        if let Err(error) =
+            run_cortex_loop(&cortex, &logger, &mut event_rx, &mut memory_event_rx).await
+        {
+            tracing::error!(%error, "cortex loop exited with error");
         }
     })
 }
 
+/// Backwards-compatible alias while callers migrate to `spawn_cortex_loop`.
+pub fn spawn_bulletin_loop(deps: AgentDeps, logger: CortexLogger) -> tokio::task::JoinHandle<()> {
+    spawn_cortex_loop(deps, logger)
+}
+
 /// Spawn the warmup loop for an agent.
 ///
 /// Warmup runs asynchronously and never blocks channel responsiveness.
 pub fn spawn_warmup_loop(deps: AgentDeps, logger: CortexLogger) -> tokio::task::JoinHandle<()> {
     tokio::spawn(async move {
         tracing::info!("warmup loop started");
-        let mut completed_initial_pass = false;
+        let mut completed_initial_pass =
+            has_completed_initial_warmup(deps.runtime_config.warmup_status.load().as_ref());
 
         loop {
             let warmup_config = **deps.runtime_config.warmup.load();
@@ -299,6 +1451,11 @@ pub fn spawn_warmup_loop(deps: AgentDeps, logger: CortexLogger) -> tokio::task::
                 continue;
             }
 
+            if !completed_initial_pass {
+                completed_initial_pass =
+                    has_completed_initial_warmup(deps.runtime_config.warmup_status.load().as_ref());
+            }
+
             let sleep_secs = if completed_initial_pass {
                 warmup_config.refresh_secs.max(1)
             } else {
@@ -306,6 +1463,14 @@ pub fn spawn_warmup_loop(deps: AgentDeps, logger: CortexLogger) -> tokio::task::
             };
             tokio::time::sleep(Duration::from_secs(sleep_secs)).await;
 
+            if !completed_initial_pass {
+                completed_initial_pass =
+                    has_completed_initial_warmup(deps.runtime_config.warmup_status.load().as_ref());
+                if completed_initial_pass {
+                    continue;
+                }
+            }
+
             let reason = if completed_initial_pass {
                 "scheduled"
             } else {
@@ -337,6 +1502,7 @@ pub async fn run_warmup_once(deps: &AgentDeps, logger: &CortexLogger, reason: &s
         status.last_error = None;
         status.bulletin_age_secs = bulletin_age_secs(status.last_refresh_unix_ms);
     });
+    let mut terminal_state_guard = WarmupRunGuard::new(deps, reason, force);
 
     let mut errors = Vec::new();
     let mut embedding_ready = false;
@@ -369,6 +1535,7 @@ pub async fn run_warmup_once(deps: &AgentDeps, logger: &CortexLogger, reason: &s
             status.last_error = None;
             status.bulletin_age_secs = Some(0);
         });
+        terminal_state_guard.mark_committed();
         logger.log(
             "warmup_succeeded",
             "Warmup pass completed",
@@ -386,6 +1553,7 @@ pub async fn run_warmup_once(deps: &AgentDeps, logger: &CortexLogger, reason: &s
             status.last_error = Some(last_error.clone());
             status.bulletin_age_secs = bulletin_age_secs(status.last_refresh_unix_ms);
         });
+        terminal_state_guard.mark_committed();
         logger.log(
             "warmup_failed",
             "Warmup pass failed",
@@ -420,19 +1588,48 @@ pub fn trigger_forced_warmup(deps: AgentDeps, dispatch_type: &'static str) {
     });
 }
 
-async fn run_bulletin_loop(deps: &AgentDeps, logger: &CortexLogger) -> anyhow::Result<()> {
-    tracing::info!("cortex bulletin loop started");
+fn spawn_bulletin_refresh_task(
+    deps: AgentDeps,
+    logger: CortexLogger,
+) -> tokio::task::JoinHandle<BulletinRefreshOutcome> {
+    tokio::spawn(async move {
+        let bulletin_outcome = maybe_generate_bulletin_under_lock(
+            deps.runtime_config.warmup_lock.as_ref(),
+            &deps.runtime_config.warmup,
+            &deps.runtime_config.warmup_status,
+            || generate_bulletin(&deps, &logger),
+        )
+        .await;
+        if bulletin_outcome.generated() {
+            generate_profile(&deps, &logger).await;
+        }
+        bulletin_outcome
+    })
+}
+
+async fn run_cortex_loop(
+    cortex: &Cortex,
+    logger: &CortexLogger,
+    event_rx: &mut broadcast::Receiver<ProcessEvent>,
+    memory_event_rx: &mut broadcast::Receiver<ProcessEvent>,
+) -> anyhow::Result<()> {
+    tracing::info!("cortex loop started");
 
     const MAX_RETRIES: u32 = 3;
     const RETRY_DELAY_SECS: u64 = 15;
+    const LAG_WARNING_INTERVAL_SECS: u64 = 30;
 
-    // Run immediately on startup, with retries
+    // Run bulletin generation immediately on startup, with retries.
     for attempt in 0..=MAX_RETRIES {
-        let bulletin_ok = {
-            let _warmup_guard = deps.runtime_config.warmup_lock.lock().await;
-            generate_bulletin(deps, logger).await
-        };
-        if bulletin_ok {
+        let bulletin_outcome = maybe_generate_bulletin_under_lock(
+            cortex.deps.runtime_config.warmup_lock.as_ref(),
+            &cortex.deps.runtime_config.warmup,
+            &cortex.deps.runtime_config.warmup_status,
+            || generate_bulletin(&cortex.deps, logger),
+        )
+        .await;
+
+        if bulletin_outcome.is_success() {
             break;
         }
         if attempt < MAX_RETRIES {
@@ -454,20 +1651,199 @@ async fn run_bulletin_loop(deps: &AgentDeps, logger: &CortexLogger) -> anyhow::R
         }
     }
 
-    // Generate initial profile after bulletin
-    generate_profile(deps, logger).await;
+    // Generate an initial profile after startup bulletin synthesis.
+    generate_profile(&cortex.deps, logger).await;
+    let mut last_bulletin_refresh = Instant::now();
+    let mut tick_interval_secs = cortex
+        .deps
+        .runtime_config
+        .cortex
+        .load()
+        .tick_interval_secs
+        .max(1);
+    let mut tick_period = Duration::from_secs(tick_interval_secs);
+    let mut tick_timer =
+        tokio::time::interval_at(tokio::time::Instant::now() + tick_period, tick_period);
+    tick_timer.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
+    let mut lagged_since_last_warning_control: u64 = 0;
+    let mut last_lag_warning_control: Option<Instant> = None;
+    let mut lagged_since_last_warning_memory: u64 = 0;
+    let mut last_lag_warning_memory: Option<Instant> = None;
+    let mut memory_event_stream_open = true;
+    let mut refresh_task: Option<tokio::task::JoinHandle<BulletinRefreshOutcome>> = None;
+    let mut bulletin_refresh_failures: u32 = 0;
+    let mut bulletin_refresh_circuit_open = false;
+    let mut next_bulletin_refresh_allowed_at = Instant::now();
 
     loop {
-        let cortex_config = **deps.runtime_config.cortex.load();
-        let interval = cortex_config.bulletin_interval_secs;
+        tokio::select! {
+            biased;
+            event = event_rx.recv() => {
+                match handle_cortex_receiver_result(
+                    event,
+                    "control",
+                    ReceiverClosedBehavior::StopLoop,
+                    &mut lagged_since_last_warning_control,
+                    &mut last_lag_warning_control,
+                    LAG_WARNING_INTERVAL_SECS,
+                ) {
+                    CortexReceiverOutcome::Observe(event) => cortex.observe(event).await,
+                    CortexReceiverOutcome::Lagged { dropped } => {
+                        cortex.mark_control_receiver_lag().await;
+                        #[cfg(feature = "metrics")]
+                        crate::telemetry::Metrics::global()
+                            .event_receiver_lagged_events_total
+                            .with_label_values(&[&*cortex.deps.agent_id, "cortex_control"])
+                            .inc_by(dropped);
+                        #[cfg(not(feature = "metrics"))]
+                        let _ = dropped;
+                    }
+                    CortexReceiverOutcome::StopLoop => {
+                        if let Some(task) = refresh_task.take() {
+                            task.abort();
+                        }
+                        return Ok(());
+                    }
+                    CortexReceiverOutcome::DisableStream => unreachable!("control stream cannot disable itself"),
+                }
+            },
+            event = memory_event_rx.recv(), if memory_event_stream_open => {
+                match handle_cortex_receiver_result(
+                    event,
+                    "memory",
+                    ReceiverClosedBehavior::DisableStream,
+                    &mut lagged_since_last_warning_memory,
+                    &mut last_lag_warning_memory,
+                    LAG_WARNING_INTERVAL_SECS,
+                ) {
+                    CortexReceiverOutcome::Observe(event) => cortex.observe(event).await,
+                    CortexReceiverOutcome::Lagged { dropped } => {
+                        #[cfg(feature = "metrics")]
+                        crate::telemetry::Metrics::global()
+                            .event_receiver_lagged_events_total
+                            .with_label_values(&[&*cortex.deps.agent_id, "cortex_memory"])
+                            .inc_by(dropped);
+                        #[cfg(not(feature = "metrics"))]
+                        let _ = dropped;
+                    }
+                    CortexReceiverOutcome::StopLoop => {
+                        if let Some(task) = refresh_task.take() {
+                            task.abort();
+                        }
+                        return Ok(());
+                    }
+                    CortexReceiverOutcome::DisableStream => {
+                        memory_event_stream_open = false;
+                    }
+                }
+            },
+            _ = tick_timer.tick() => {
+                if let Err(error) = cortex.run_health_tick(logger).await {
+                    tracing::warn!(%error, "cortex health tick failed");
+                }
 
-        tokio::time::sleep(Duration::from_secs(interval)).await;
+                if refresh_task
+                    .as_ref()
+                    .is_some_and(tokio::task::JoinHandle::is_finished)
+                    && let Some(task) = refresh_task.take()
+                {
+                    match task.await {
+                        Ok(outcome) => {
+                            let now = Instant::now();
+                            if outcome.is_success() {
+                                last_bulletin_refresh = now;
+                                bulletin_refresh_failures = 0;
+                                bulletin_refresh_circuit_open = false;
+                                next_bulletin_refresh_allowed_at = now;
+                            } else {
+                                let (backoff, circuit_opened) = record_bulletin_refresh_failure(
+                                    &mut bulletin_refresh_failures,
+                                    &mut bulletin_refresh_circuit_open,
+                                    &mut next_bulletin_refresh_allowed_at,
+                                    now,
+                                );
+                                if circuit_opened {
+                                    let cooldown_secs =
+                                        next_bulletin_refresh_allowed_at.duration_since(now).as_secs();
+                                    tracing::warn!(
+                                        failures = bulletin_refresh_failures,
+                                        cooldown_secs,
+                                        backoff_secs = backoff.as_secs(),
+                                        "cortex bulletin refresh circuit opened after consecutive failures"
+                                    );
+                                } else {
+                                    tracing::warn!(
+                                        failures = bulletin_refresh_failures,
+                                        backoff_secs = backoff.as_secs(),
+                                        "cortex bulletin refresh failed; applying retry backoff"
+                                    );
+                                }
+                            }
+                        }
+                        Err(error) => {
+                            let now = Instant::now();
+                            let (backoff, circuit_opened) = record_bulletin_refresh_failure(
+                                &mut bulletin_refresh_failures,
+                                &mut bulletin_refresh_circuit_open,
+                                &mut next_bulletin_refresh_allowed_at,
+                                now,
+                            );
+                            if circuit_opened {
+                                let cooldown_secs =
+                                    next_bulletin_refresh_allowed_at.duration_since(now).as_secs();
+                                tracing::warn!(
+                                    %error,
+                                    failures = bulletin_refresh_failures,
+                                    cooldown_secs,
+                                    backoff_secs = backoff.as_secs(),
+                                    "cortex bulletin refresh circuit opened after task failure"
+                                );
+                            } else {
+                                tracing::warn!(
+                                    %error,
+                                    failures = bulletin_refresh_failures,
+                                    backoff_secs = backoff.as_secs(),
+                                    "cortex bulletin refresh task failed"
+                                );
+                            }
+                        }
+                    }
+                }
 
-        {
-            let _warmup_guard = deps.runtime_config.warmup_lock.lock().await;
-            generate_bulletin(deps, logger).await;
+                let cortex_config = **cortex.deps.runtime_config.cortex.load();
+                let bulletin_interval = Duration::from_secs(cortex_config.bulletin_interval_secs.max(1));
+                let now = Instant::now();
+                if maybe_close_bulletin_refresh_circuit(
+                    &mut bulletin_refresh_failures,
+                    &mut bulletin_refresh_circuit_open,
+                    &mut next_bulletin_refresh_allowed_at,
+                    now,
+                ) {
+                    tracing::info!("cortex bulletin refresh circuit closed; retries re-enabled");
+                }
+                if refresh_task.is_none()
+                    && !bulletin_refresh_circuit_open
+                    && last_bulletin_refresh.elapsed() >= bulletin_interval
+                    && now >= next_bulletin_refresh_allowed_at
+                {
+                    refresh_task = Some(spawn_bulletin_refresh_task(
+                        cortex.deps.clone(),
+                        logger.clone(),
+                    ));
+                }
+
+                let updated_tick_interval_secs = cortex_config.tick_interval_secs.max(1);
+                if updated_tick_interval_secs != tick_interval_secs {
+                    tick_interval_secs = updated_tick_interval_secs;
+                    tick_period = Duration::from_secs(tick_interval_secs);
+                    tick_timer = tokio::time::interval_at(
+                        tokio::time::Instant::now() + tick_period,
+                        tick_period,
+                    );
+                    tick_timer.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
+                }
+            }
         }
-        generate_profile(deps, logger).await;
     }
 }
 
@@ -587,9 +1963,58 @@ async fn gather_bulletin_sections(deps: &AgentDeps) -> String {
         output.push('\n');
     }
 
+    // Append active tasks (non-done) from the task store.
+    match gather_active_tasks(deps).await {
+        Ok(section) if !section.is_empty() => output.push_str(&section),
+        Err(error) => {
+            tracing::warn!(%error, "failed to gather active tasks for bulletin");
+        }
+        _ => {}
+    }
+
     output
 }
 
+/// Query the task store for non-done tasks and format them as a bulletin section.
+async fn gather_active_tasks(deps: &AgentDeps) -> anyhow::Result<String> {
+    use crate::tasks::TaskStatus;
+
+    let mut all_tasks = Vec::new();
+    for status in &[
+        TaskStatus::InProgress,
+        TaskStatus::Ready,
+        TaskStatus::Backlog,
+        TaskStatus::PendingApproval,
+    ] {
+        let tasks = deps
+            .task_store
+            .list(&deps.agent_id, Some(*status), None, 20)
+            .await?;
+        all_tasks.extend(tasks);
+    }
+
+    if all_tasks.is_empty() {
+        return Ok(String::new());
+    }
+
+    let mut output = String::from("### Active Tasks\n\n");
+    for task in &all_tasks {
+        let subtask_progress = if task.subtasks.is_empty() {
+            String::new()
+        } else {
+            let done = task.subtasks.iter().filter(|s| s.completed).count();
+            format!(" [{}/{}]", done, task.subtasks.len())
+        };
+        output.push_str(&format!(
+            "- #{} [{}] ({}) {}{}\n",
+            task.task_number, task.status, task.priority, task.title, subtask_progress,
+        ));
+    }
+    output.push('\n');
+
+    Ok(output)
+}
+
 /// Generate a memory bulletin and store it in RuntimeConfig.
 ///
 /// Programmatically queries the memory store across multiple dimensions
@@ -638,13 +2063,18 @@ pub async fn generate_bulletin(deps: &AgentDeps, logger: &CortexLogger) -> bool
     };
 
     let routing = deps.runtime_config.routing.load();
-    let model_name = routing.resolve(ProcessType::Branch, None).to_string();
+    let model_name = routing.resolve(ProcessType::Cortex, None).to_string();
     let model = SpacebotModel::make(&deps.llm_manager, &model_name)
         .with_context(&*deps.agent_id, "cortex")
         .with_routing((**routing).clone());
 
-    // No tools needed — the LLM just synthesizes the pre-gathered data
-    let agent = AgentBuilder::new(model).preamble(&bulletin_prompt).build();
+    // No tools needed — the LLM just synthesizes the pre-gathered data.
+    // Attach CortexHook so observation/termination semantics stay consistent
+    // with other process types.
+    let agent = AgentBuilder::new(model)
+        .preamble(&bulletin_prompt)
+        .hook(CortexHook::new())
+        .build();
 
     let synthesis_prompt = match prompt_engine
         .render_system_cortex_synthesis(cortex_config.bulletin_max_words, &raw_sections)
@@ -764,7 +2194,7 @@ impl AgentProfileRow {
 }
 
 /// LLM response shape for profile generation.
-#[derive(serde::Deserialize)]
+#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
 struct ProfileLlmResponse {
     display_name: Option<String>,
     status: Option<String>,
@@ -818,88 +2248,69 @@ async fn generate_profile(deps: &AgentDeps, logger: &CortexLogger) {
     };
 
     let routing = deps.runtime_config.routing.load();
-    let model_name = routing.resolve(ProcessType::Branch, None).to_string();
+    let model_name = routing.resolve(ProcessType::Cortex, None).to_string();
     let model = SpacebotModel::make(&deps.llm_manager, &model_name)
         .with_context(&*deps.agent_id, "cortex")
         .with_routing((**routing).clone());
 
-    let agent = AgentBuilder::new(model).preamble(&profile_prompt).build();
+    let agent = AgentBuilder::new(model)
+        .preamble(&profile_prompt)
+        .hook(CortexHook::new())
+        .build();
 
-    match agent.prompt(&synthesis_prompt).await {
-        Ok(response) => {
-            // Strip markdown code fences if the LLM wraps the JSON
-            let cleaned = response
-                .trim()
-                .trim_start_matches("```json")
-                .trim_start_matches("```")
-                .trim_end_matches("```")
-                .trim();
-
-            match serde_json::from_str::<ProfileLlmResponse>(cleaned) {
-                Ok(profile_data) => {
-                    let duration_ms = started.elapsed().as_millis() as u64;
-                    let agent_id = &deps.agent_id;
-
-                    // Use the agent ID as a stable avatar seed
-                    let avatar_seed = agent_id.to_string();
-
-                    if let Err(error) = sqlx::query(
-                        "INSERT INTO agent_profile (agent_id, display_name, status, bio, avatar_seed, generated_at, updated_at) \
-                         VALUES (?, ?, ?, ?, ?, datetime('now'), datetime('now')) \
-                         ON CONFLICT(agent_id) DO UPDATE SET \
-                         display_name = excluded.display_name, \
-                         status = excluded.status, \
-                         bio = excluded.bio, \
-                         avatar_seed = excluded.avatar_seed, \
-                         updated_at = datetime('now')",
-                    )
-                    .bind(agent_id.as_ref())
-                    .bind(&profile_data.display_name)
-                    .bind(&profile_data.status)
-                    .bind(&profile_data.bio)
-                    .bind(&avatar_seed)
-                    .execute(&deps.sqlite_pool)
-                    .await
-                    {
-                        tracing::warn!(%error, "failed to persist agent profile");
-                        return;
-                    }
+    match agent
+        .prompt_typed::<ProfileLlmResponse>(&synthesis_prompt)
+        .await
+    {
+        Ok(profile_data) => {
+            let duration_ms = started.elapsed().as_millis() as u64;
+            let agent_id = &deps.agent_id;
 
-                    tracing::info!(
-                        display_name = ?profile_data.display_name,
-                        status = ?profile_data.status,
-                        duration_ms,
-                        "agent profile generated"
-                    );
-                    logger.log(
-                        "profile_generated",
-                        &format!(
-                            "Profile generated: {} — \"{}\" ({duration_ms}ms)",
-                            profile_data.display_name.as_deref().unwrap_or("unnamed"),
-                            profile_data.status.as_deref().unwrap_or("no status"),
-                        ),
-                        Some(serde_json::json!({
-                            "display_name": profile_data.display_name,
-                            "status": profile_data.status,
-                            "duration_ms": duration_ms,
-                            "model": model_name,
-                        })),
-                    );
-                }
-                Err(error) => {
-                    tracing::warn!(%error, raw = %cleaned, "failed to parse profile LLM response as JSON");
-                    logger.log(
-                        "profile_failed",
-                        &format!(
-                            "Profile generation failed: could not parse LLM response — {error}"
-                        ),
-                        Some(serde_json::json!({
-                            "error": error.to_string(),
-                            "raw_response": cleaned,
-                        })),
-                    );
-                }
+            // Use the agent ID as a stable avatar seed
+            let avatar_seed = agent_id.to_string();
+
+            if let Err(error) = sqlx::query(
+                "INSERT INTO agent_profile (agent_id, display_name, status, bio, avatar_seed, generated_at, updated_at) \
+                 VALUES (?, ?, ?, ?, ?, datetime('now'), datetime('now')) \
+                 ON CONFLICT(agent_id) DO UPDATE SET \
+                 display_name = excluded.display_name, \
+                 status = excluded.status, \
+                 bio = excluded.bio, \
+                 avatar_seed = excluded.avatar_seed, \
+                 updated_at = datetime('now')",
+            )
+            .bind(agent_id.as_ref())
+            .bind(&profile_data.display_name)
+            .bind(&profile_data.status)
+            .bind(&profile_data.bio)
+            .bind(&avatar_seed)
+            .execute(&deps.sqlite_pool)
+            .await
+            {
+                tracing::warn!(%error, "failed to persist agent profile");
+                return;
             }
+
+            tracing::info!(
+                display_name = ?profile_data.display_name,
+                status = ?profile_data.status,
+                duration_ms,
+                "agent profile generated"
+            );
+            logger.log(
+                "profile_generated",
+                &format!(
+                    "Profile generated: {} — \"{}\" ({duration_ms}ms)",
+                    profile_data.display_name.as_deref().unwrap_or("unnamed"),
+                    profile_data.status.as_deref().unwrap_or("no status"),
+                ),
+                Some(serde_json::json!({
+                    "display_name": profile_data.display_name,
+                    "status": profile_data.status,
+                    "duration_ms": duration_ms,
+                    "model": model_name,
+                })),
+            );
         }
         Err(error) => {
             let duration_ms = started.elapsed().as_millis() as u64;
@@ -935,6 +2346,728 @@ pub fn spawn_association_loop(
     })
 }
 
+/// Spawn a background loop that picks up ready tasks when idle.
+pub fn spawn_ready_task_loop(deps: AgentDeps, logger: CortexLogger) -> tokio::task::JoinHandle<()> {
+    tokio::spawn(async move {
+        if let Err(error) = run_ready_task_loop(&deps, &logger).await {
+            tracing::error!(%error, "cortex ready-task loop exited with error");
+        }
+    })
+}
+
+async fn run_ready_task_loop(deps: &AgentDeps, logger: &CortexLogger) -> anyhow::Result<()> {
+    tracing::info!("cortex ready-task loop started");
+
+    // Let startup settle before first pickup attempt.
+    tokio::time::sleep(Duration::from_secs(10)).await;
+
+    loop {
+        let interval = deps.runtime_config.cortex.load().tick_interval_secs;
+        tokio::time::sleep(Duration::from_secs(interval.max(5))).await;
+
+        if let Err(error) = pickup_one_ready_task(deps, logger).await {
+            tracing::warn!(%error, "ready-task pickup pass failed");
+        }
+    }
+}
+
+async fn pickup_one_ready_task(deps: &AgentDeps, logger: &CortexLogger) -> anyhow::Result<()> {
+    let Some(task) = deps.task_store.claim_next_ready(&deps.agent_id).await? else {
+        return Ok(());
+    };
+
+    logger.log(
+        "task_pickup_started",
+        &format!("Picked up ready task #{}", task.task_number),
+        Some(serde_json::json!({
+            "task_number": task.task_number,
+            "title": task.title,
+        })),
+    );
+
+    let prompt_engine = deps.runtime_config.prompts.load();
+    let sandbox_enabled = deps.sandbox.mode_enabled();
+    let sandbox_containment_active = deps.sandbox.containment_active();
+    let sandbox_read_allowlist = deps.sandbox.prompt_read_allowlist();
+    let sandbox_write_allowlist = deps.sandbox.prompt_write_allowlist();
+
+    // Collect tool secret names so the worker template can list available credentials.
+    let secrets_guard = deps.runtime_config.secrets.load();
+    let tool_secret_names = match (*secrets_guard).as_ref() {
+        Some(store) => store.tool_secret_names(),
+        None => Vec::new(),
+    };
+
+    let worker_system_prompt = prompt_engine
+        .render_worker_prompt(
+            &deps.runtime_config.instance_dir.display().to_string(),
+            &deps.runtime_config.workspace_dir.display().to_string(),
+            sandbox_enabled,
+            sandbox_containment_active,
+            sandbox_read_allowlist,
+            sandbox_write_allowlist,
+            &tool_secret_names,
+        )
+        .map_err(|error| anyhow::anyhow!("failed to render worker prompt: {error}"))?;
+
+    let mut task_prompt = format!("Execute task #{}: {}", task.task_number, task.title);
+    if let Some(description) = &task.description {
+        task_prompt.push_str("\n\nDescription:\n");
+        task_prompt.push_str(description);
+    }
+    if !task.subtasks.is_empty() {
+        task_prompt.push_str("\n\nSubtasks:\n");
+        for (index, subtask) in task.subtasks.iter().enumerate() {
+            let marker = if subtask.completed { "[x]" } else { "[ ]" };
+            task_prompt.push_str(&format!("{}. {} {}\n", index + 1, marker, subtask.title));
+        }
+    }
+
+    let screenshot_dir = deps
+        .runtime_config
+        .workspace_dir
+        .join(".spacebot")
+        .join("screenshots");
+    let logs_dir = deps
+        .runtime_config
+        .workspace_dir
+        .join(".spacebot")
+        .join("logs");
+    if let Err(error) = std::fs::create_dir_all(&screenshot_dir) {
+        tracing::warn!(%error, path = %screenshot_dir.display(), "failed to create screenshot directory");
+    }
+    if let Err(error) = std::fs::create_dir_all(&logs_dir) {
+        tracing::warn!(%error, path = %logs_dir.display(), "failed to create logs directory");
+    }
+
+    let browser_config = (**deps.runtime_config.browser_config.load()).clone();
+    let brave_search_key = (**deps.runtime_config.brave_search_key.load()).clone();
+    let worker = Worker::new(
+        None,
+        task_prompt,
+        worker_system_prompt,
+        deps.clone(),
+        browser_config,
+        screenshot_dir,
+        brave_search_key,
+        logs_dir,
+    );
+
+    let worker_id = worker.id;
+    let (detached_worker_lifecycle, mut detached_cancel_rx) = register_detached_worker_for_pickup(
+        &deps.process_control_registry,
+        deps.task_store.as_ref(),
+        &deps.agent_id,
+        task.task_number,
+        worker_id,
+    )
+    .await?;
+
+    let _ = deps.event_tx.send(ProcessEvent::TaskUpdated {
+        agent_id: deps.agent_id.clone(),
+        task_number: task.task_number,
+        status: "in_progress".to_string(),
+        action: "updated".to_string(),
+    });
+
+    let task_description = format!("task #{}: {}", task.task_number, task.title);
+
+    let _ = deps.event_tx.send(ProcessEvent::WorkerStarted {
+        agent_id: deps.agent_id.clone(),
+        worker_id,
+        channel_id: None,
+        task: task_description.clone(),
+        worker_type: "task".to_string(),
+        interactive: false,
+    });
+
+    // Log to worker_runs directly — task workers have no parent channel, so the
+    // channel event handler won't persist them.
+    let run_logger = crate::conversation::history::ProcessRunLogger::new(deps.sqlite_pool.clone());
+    run_logger.log_worker_started(
+        None,
+        worker_id,
+        &task_description,
+        "task",
+        &deps.agent_id,
+        false,
+    );
+
+    let task_store = deps.task_store.clone();
+    let agent_id = deps.agent_id.to_string();
+    let event_tx = deps.event_tx.clone();
+    let logger = logger.clone();
+    let injection_tx = deps.injection_tx.clone();
+    let links = deps.links.clone();
+    let agent_names = deps.agent_names.clone();
+    let sqlite_pool = deps.sqlite_pool.clone();
+    let secrets_snapshot = deps.runtime_config.secrets.load().clone();
+    let process_control_registry = deps.process_control_registry.clone();
+    let runtime_config = deps.runtime_config.clone();
+    tokio::spawn(async move {
+        // Scrub known secrets and unknown leak patterns from all worker output
+        // before persisting, logging, or emitting events.
+        let scrub = |text: String| -> String {
+            let scrubbed = if let Some(store) = secrets_snapshot.as_ref() {
+                crate::secrets::scrub::scrub_with_store(&text, store)
+            } else {
+                text
+            };
+            crate::secrets::scrub::scrub_leaks(&scrubbed)
+        };
+
+        let worker_execution = async {
+            let worker_future = std::panic::AssertUnwindSafe(worker.run()).catch_unwind();
+            tokio::pin!(worker_future);
+
+            let worker_result = tokio::select! {
+                biased;
+                result = &mut worker_future => {
+                    Some(result)
+                }
+                _ = &mut detached_cancel_rx => worker_future.as_mut().now_or_never(),
+            };
+
+            if let Some(worker_result) = worker_result {
+                let completion_won = claim_detached_completion(&detached_worker_lifecycle);
+                if completion_won {
+                    match worker_result {
+                        Ok(Ok(raw_result_text)) => {
+                            let result_text = scrub(raw_result_text);
+                            let db_updated = task_store
+                                .update(
+                                    &agent_id,
+                                    task.task_number,
+                                    UpdateTaskInput {
+                                        status: Some(TaskStatus::Done),
+                                        ..Default::default()
+                                    },
+                                )
+                                .await;
+
+                            if let Err(ref error) = db_updated {
+                                tracing::warn!(
+                                    %error,
+                                    task_number = task.task_number,
+                                    "failed to mark picked-up task done"
+                                );
+                                run_logger.log_worker_completed(worker_id, &result_text, false);
+                                logger.log(
+                                    "task_pickup_completed_persist_failure",
+                                    &format!(
+                                        "Picked-up task #{} completed but could not persist done state: {error}",
+                                        task.task_number
+                                    ),
+                                    Some(serde_json::json!({
+                                        "task_number": task.task_number,
+                                        "worker_id": worker_id.to_string(),
+                                    })),
+                                );
+                                let _ = event_tx.send(ProcessEvent::WorkerComplete {
+                                    agent_id: Arc::from(agent_id.as_str()),
+                                    worker_id,
+                                    channel_id: None,
+                                    result: result_text,
+                                    notify: true,
+                                    success: false,
+                                });
+                            } else {
+                                run_logger.log_worker_completed(worker_id, &result_text, true);
+                                let _ = event_tx.send(ProcessEvent::TaskUpdated {
+                                    agent_id: Arc::from(agent_id.as_str()),
+                                    task_number: task.task_number,
+                                    status: "done".to_string(),
+                                    action: "updated".to_string(),
+                                });
+
+                                logger.log(
+                                    "task_pickup_completed",
+                                    &format!("Completed picked-up task #{}", task.task_number),
+                                    Some(serde_json::json!({
+                                        "task_number": task.task_number,
+                                        "worker_id": worker_id.to_string(),
+                                    })),
+                                );
+
+                                notify_delegation_completion(
+                                    &task,
+                                    &result_text,
+                                    true,
+                                    &agent_id,
+                                    &links,
+                                    &agent_names,
+                                    &sqlite_pool,
+                                    &injection_tx,
+                                )
+                                .await;
+
+                                let _ = event_tx.send(ProcessEvent::WorkerComplete {
+                                    agent_id: Arc::from(agent_id.as_str()),
+                                    worker_id,
+                                    channel_id: None,
+                                    result: result_text,
+                                    notify: true,
+                                    success: true,
+                                });
+                            }
+                        }
+                        Ok(Err(error)) => {
+                            let scrubbed_error = scrub(error.to_string());
+                            let (error_message, _notify, _success) = map_worker_completion_result(
+                                Err(WorkerCompletionError::failed(scrubbed_error.clone())),
+                            );
+                            let worker_complete_message = format!("Worker failed: {error}");
+                            run_logger.log_worker_completed(worker_id, &error_message, false);
+                            let requeue_result = task_store
+                                .update(
+                                    &agent_id,
+                                    task.task_number,
+                                    UpdateTaskInput {
+                                        status: Some(TaskStatus::Ready),
+                                        clear_worker_id: true,
+                                        ..Default::default()
+                                    },
+                                )
+                                .await;
+
+                            if let Err(ref update_error) = requeue_result {
+                                tracing::warn!(
+                                    %update_error,
+                                    task_number = task.task_number,
+                                    "failed to return task to ready after failure"
+                                );
+                                logger.log(
+                                    "task_pickup_failed_to_persist",
+                                    &format!(
+                                        "Picked-up task #{} failed but could not persist failure state: {error}",
+                                        task.task_number
+                                    ),
+                                    Some(serde_json::json!({
+                                        "task_number": task.task_number,
+                                        "worker_id": worker_id.to_string(),
+                                        "error": error.to_string(),
+                                    })),
+                                );
+                            } else {
+                                let _ = event_tx.send(ProcessEvent::TaskUpdated {
+                                    agent_id: Arc::from(agent_id.as_str()),
+                                    task_number: task.task_number,
+                                    status: "ready".to_string(),
+                                    action: "updated".to_string(),
+                                });
+
+                                logger.log(
+                                    "task_pickup_failed",
+                                    &format!(
+                                        "Picked-up task #{} failed: {error}",
+                                        task.task_number
+                                    ),
+                                    Some(serde_json::json!({
+                                        "task_number": task.task_number,
+                                        "worker_id": worker_id.to_string(),
+                                        "error": error.to_string(),
+                                    })),
+                                );
+
+                                notify_delegation_completion(
+                                    &task,
+                                    &error_message,
+                                    false,
+                                    &agent_id,
+                                    &links,
+                                    &agent_names,
+                                    &sqlite_pool,
+                                    &injection_tx,
+                                )
+                                .await;
+                            }
+
+                            let _ = event_tx.send(ProcessEvent::WorkerComplete {
+                                agent_id: Arc::from(agent_id.as_str()),
+                                worker_id,
+                                channel_id: None,
+                                result: worker_complete_message,
+                                notify: true,
+                                success: false,
+                            });
+                        }
+                        Err(panic_payload) => {
+                            let scrubbed_panic =
+                                scrub(crate::agent::panic_payload_to_string(&*panic_payload));
+                            let (error_message, _notify, _success) =
+                                map_worker_completion_result(Err(WorkerCompletionError::failed(
+                                    format!("worker task panicked: {scrubbed_panic}"),
+                                )));
+                            run_logger.log_worker_completed(worker_id, &error_message, false);
+                            let requeue_result = task_store
+                                .update(
+                                    &agent_id,
+                                    task.task_number,
+                                    UpdateTaskInput {
+                                        status: Some(TaskStatus::Ready),
+                                        clear_worker_id: true,
+                                        ..Default::default()
+                                    },
+                                )
+                                .await;
+
+                            if let Err(ref update_error) = requeue_result {
+                                tracing::warn!(
+                                    %update_error,
+                                    task_number = task.task_number,
+                                    "failed to return task to ready after panic"
+                                );
+                                logger.log(
+                                    "task_pickup_panic_persist_failure",
+                                    &format!(
+                                        "Picked-up task #{} panicked and could not persist failure state: {error_message}",
+                                        task.task_number
+                                    ),
+                                    Some(serde_json::json!({
+                                        "task_number": task.task_number,
+                                        "worker_id": worker_id.to_string(),
+                                    })),
+                                );
+                            } else {
+                                let _ = event_tx.send(ProcessEvent::TaskUpdated {
+                                    agent_id: Arc::from(agent_id.as_str()),
+                                    task_number: task.task_number,
+                                    status: "ready".to_string(),
+                                    action: "updated".to_string(),
+                                });
+
+                                notify_delegation_completion(
+                                    &task,
+                                    &error_message,
+                                    false,
+                                    &agent_id,
+                                    &links,
+                                    &agent_names,
+                                    &sqlite_pool,
+                                    &injection_tx,
+                                )
+                                .await;
+                            }
+
+                            let _ = event_tx.send(ProcessEvent::WorkerComplete {
+                                agent_id: Arc::from(agent_id.as_str()),
+                                worker_id,
+                                channel_id: None,
+                                result: error_message,
+                                notify: true,
+                                success: false,
+                            });
+                        }
+                    }
+
+                    let _ = detached_worker_lifecycle.compare_exchange(
+                        crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_COMPLETING,
+                        crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_TERMINAL,
+                        Ordering::AcqRel,
+                        Ordering::Acquire,
+                    );
+                    return;
+                }
+            }
+
+            if detached_worker_lifecycle
+                .compare_exchange(
+                    crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_KILLING,
+                    crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_TERMINAL,
+                    Ordering::AcqRel,
+                    Ordering::Acquire,
+                )
+                .is_ok()
+            {
+                let timeout_retry_limit = runtime_config
+                    .cortex
+                    .load()
+                    .detached_worker_timeout_retry_limit;
+                let (next_timeout_count, exhausted, next_status) =
+                    detached_timeout_transition(&task.metadata, timeout_retry_limit);
+
+                let timeout_message = scrub(format!(
+                    "Worker cancelled by supervisor timeout (attempt {} of {}).",
+                    next_timeout_count, timeout_retry_limit
+                ));
+                let update_result = task_store
+                    .update(
+                        &agent_id,
+                        task.task_number,
+                        UpdateTaskInput {
+                            status: Some(next_status),
+                            clear_worker_id: true,
+                            metadata: Some(serde_json::json!({
+                                "supervisor_timeout_count": next_timeout_count,
+                                "supervisor_timeout_exhausted": exhausted,
+                            })),
+                            ..Default::default()
+                        },
+                    )
+                    .await;
+
+                match update_result {
+                    Ok(Some(_)) => {
+                        run_logger.log_worker_completed(worker_id, &timeout_message, false);
+                        let _ = event_tx.send(ProcessEvent::TaskUpdated {
+                            agent_id: Arc::from(agent_id.as_str()),
+                            task_number: task.task_number,
+                            status: next_status.as_str().to_string(),
+                            action: "updated".to_string(),
+                        });
+                        logger.log(
+                            "task_pickup_timeout",
+                            &format!(
+                                "Detached worker timeout for task #{} (count: {}, exhausted: {})",
+                                task.task_number, next_timeout_count, exhausted
+                            ),
+                            Some(serde_json::json!({
+                                "task_number": task.task_number,
+                                "worker_id": worker_id.to_string(),
+                                "supervisor_timeout_count": next_timeout_count,
+                                "supervisor_timeout_exhausted": exhausted,
+                                "retry_limit": timeout_retry_limit,
+                            })),
+                        );
+
+                        notify_delegation_completion(
+                            &task,
+                            &timeout_message,
+                            false,
+                            &agent_id,
+                            &links,
+                            &agent_names,
+                            &sqlite_pool,
+                            &injection_tx,
+                        )
+                        .await;
+
+                        let _ = event_tx.send(ProcessEvent::WorkerComplete {
+                            agent_id: Arc::from(agent_id.as_str()),
+                            worker_id,
+                            channel_id: None,
+                            result: timeout_message,
+                            notify: true,
+                            success: false,
+                        });
+                    }
+                    Ok(None) => {
+                        tracing::warn!(
+                            task_number = task.task_number,
+                            "failed to update task status after detached timeout cancellation: task missing"
+                        );
+                        run_logger.log_worker_completed(worker_id, &timeout_message, false);
+                        logger.log(
+                                "task_pickup_timeout_persist_failure",
+                                &format!(
+                                    "Detached worker timeout for task #{} but task update returned no row",
+                                    task.task_number
+                                ),
+                                Some(serde_json::json!({
+                                    "task_number": task.task_number,
+                                    "worker_id": worker_id.to_string(),
+                                    "supervisor_timeout_count": next_timeout_count,
+                                    "supervisor_timeout_exhausted": exhausted,
+                                    "retry_limit": timeout_retry_limit,
+                                })),
+                            );
+                        let _ = event_tx.send(ProcessEvent::WorkerComplete {
+                            agent_id: Arc::from(agent_id.as_str()),
+                            worker_id,
+                            channel_id: None,
+                            result: timeout_message.clone(),
+                            notify: true,
+                            success: false,
+                        });
+                    }
+                    Err(update_error) => {
+                        tracing::warn!(
+                            %update_error,
+                            task_number = task.task_number,
+                            "failed to update task status after detached timeout cancellation"
+                        );
+                        run_logger.log_worker_completed(worker_id, &timeout_message, false);
+                        logger.log(
+                            "task_pickup_timeout_persist_failure",
+                            &format!(
+                                "Detached worker timeout for task #{} but failed to persist status",
+                                task.task_number
+                            ),
+                            Some(serde_json::json!({
+                                "task_number": task.task_number,
+                                "worker_id": worker_id.to_string(),
+                                "supervisor_timeout_count": next_timeout_count,
+                                "supervisor_timeout_exhausted": exhausted,
+                                "retry_limit": timeout_retry_limit,
+                            })),
+                        );
+                        let _ = event_tx.send(ProcessEvent::WorkerComplete {
+                            agent_id: Arc::from(agent_id.as_str()),
+                            worker_id,
+                            channel_id: None,
+                            result: timeout_message.clone(),
+                            notify: true,
+                            success: false,
+                        });
+                    }
+                }
+            }
+        };
+
+        let execution_result = std::panic::AssertUnwindSafe(worker_execution)
+            .catch_unwind()
+            .await;
+        if let Err(panic_payload) = execution_result {
+            let panic_message = crate::agent::panic_payload_to_string(&*panic_payload);
+            tracing::warn!(
+                task_number = task.task_number,
+                %panic_message,
+                "detached worker pickup handling panicked; forcing terminal cleanup"
+            );
+        }
+
+        let _ = detached_worker_lifecycle.compare_exchange(
+            crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_COMPLETING,
+            crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_TERMINAL,
+            Ordering::AcqRel,
+            Ordering::Acquire,
+        );
+        let _ = detached_worker_lifecycle.compare_exchange(
+            crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_KILLING,
+            crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_TERMINAL,
+            Ordering::AcqRel,
+            Ordering::Acquire,
+        );
+        let _ = detached_worker_lifecycle.compare_exchange(
+            crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_ACTIVE,
+            crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_TERMINAL,
+            Ordering::AcqRel,
+            Ordering::Acquire,
+        );
+
+        process_control_registry
+            .unregister_detached_worker(worker_id)
+            .await;
+    });
+
+    Ok(())
+}
+
+/// When a task with `metadata.delegating_agent_id` completes or fails, log the
+/// result in the link channel between the two agents and inject a retrigger
+/// system message into the delegating agent's originating channel so the user
+/// gets notified.
+#[allow(clippy::too_many_arguments)]
+async fn notify_delegation_completion(
+    task: &crate::tasks::Task,
+    result_summary: &str,
+    success: bool,
+    executor_agent_id: &str,
+    links: &arc_swap::ArcSwap<Vec<crate::links::AgentLink>>,
+    agent_names: &std::collections::HashMap<String, String>,
+    sqlite_pool: &sqlx::SqlitePool,
+    injection_tx: &tokio::sync::mpsc::Sender<crate::ChannelInjection>,
+) {
+    // Check if this is a delegated task.
+    let delegating_agent_id = task
+        .metadata
+        .get("delegating_agent_id")
+        .and_then(|v| v.as_str());
+
+    let Some(delegating_agent_id) = delegating_agent_id else {
+        return; // Not a delegated task.
+    };
+
+    let originating_channel = task
+        .metadata
+        .get("originating_channel")
+        .and_then(|v| v.as_str());
+
+    let executor_display = agent_names
+        .get(executor_agent_id)
+        .cloned()
+        .unwrap_or_else(|| executor_agent_id.to_string());
+
+    let status_word = if success { "completed" } else { "failed" };
+    let link_message = format!(
+        "{executor_display} {status_word} task #{}: \"{}\"",
+        task.task_number, task.title
+    );
+
+    // Log completion in the link channel on both sides.
+    let all_links = links.load();
+    if let Some(link) =
+        crate::links::find_link_between(&all_links, executor_agent_id, delegating_agent_id)
+    {
+        let conversation_logger =
+            crate::conversation::history::ConversationLogger::new(sqlite_pool.clone());
+        let executor_link_channel = link.channel_id_for(executor_agent_id);
+        let delegator_link_channel = link.channel_id_for(delegating_agent_id);
+        conversation_logger.log_system_message(&executor_link_channel, &link_message);
+        conversation_logger.log_system_message(&delegator_link_channel, &link_message);
+    }
+
+    // Inject a retrigger into the originating channel so the delegating agent
+    // can relay the result to the user.
+    let Some(originating_channel) = originating_channel else {
+        tracing::info!(
+            task_number = task.task_number,
+            delegating_agent_id,
+            "delegated task completed but no originating_channel in metadata, skipping retrigger"
+        );
+        return;
+    };
+
+    // Truncate very long results for the notification message.
+    let truncated_result = if result_summary.len() > 500 {
+        let boundary = result_summary.floor_char_boundary(500);
+        format!("{}... [truncated]", &result_summary[..boundary])
+    } else {
+        result_summary.to_string()
+    };
+
+    let notification_text = format!(
+        "[System] Delegated task #{} {status_word} by {executor_display}: \"{}\"\n\nResult: {truncated_result}",
+        task.task_number, task.title,
+    );
+
+    let injection = crate::ChannelInjection {
+        conversation_id: originating_channel.to_string(),
+        agent_id: delegating_agent_id.to_string(),
+        message: crate::InboundMessage {
+            id: uuid::Uuid::new_v4().to_string(),
+            source: "system".into(),
+            adapter: None,
+            conversation_id: originating_channel.to_string(),
+            sender_id: "system".into(),
+            agent_id: Some(delegating_agent_id.to_string().into()),
+            content: crate::MessageContent::Text(notification_text),
+            timestamp: chrono::Utc::now(),
+            metadata: std::collections::HashMap::new(),
+            formatted_author: None,
+        },
+    };
+
+    if let Err(error) = injection_tx.send(injection).await {
+        tracing::warn!(
+            %error,
+            task_number = task.task_number,
+            originating_channel,
+            delegating_agent_id,
+            "failed to inject delegation completion retrigger"
+        );
+    } else {
+        tracing::info!(
+            task_number = task.task_number,
+            originating_channel,
+            delegating_agent_id,
+            executor_agent_id,
+            success,
+            "injected delegation completion retrigger"
+        );
+    }
+}
+
 async fn run_association_loop(deps: &AgentDeps, logger: &CortexLogger) -> anyhow::Result<()> {
     tracing::info!("cortex association loop started");
 
@@ -1097,7 +3230,29 @@ async fn fetch_memories_for_association(
 
 #[cfg(test)]
 mod tests {
-    use super::should_execute_warmup;
+    use super::{
+        BULLETIN_REFRESH_CIRCUIT_OPEN_SECS, BULLETIN_REFRESH_CIRCUIT_OPEN_THRESHOLD, BranchTracker,
+        BulletinRefreshOutcome, CortexReceiverOutcome, HealthRuntimeState, ReceiverClosedBehavior,
+        Signal, WorkerTracker, apply_cancelled_warmup_status, build_kill_targets,
+        claim_detached_completion, detached_timeout_transition, handle_cortex_receiver_result,
+        has_completed_initial_warmup, is_cancelled_control_result, is_terminal_control_result,
+        maybe_close_bulletin_refresh_circuit, maybe_generate_bulletin_under_lock,
+        parse_structured_success_flag, push_signal_into_buffer, record_bulletin_refresh_failure,
+        should_execute_warmup, should_generate_bulletin_from_bulletin_loop, signal_from_event,
+        summarize_signal_text, take_lagged_control_flag,
+    };
+    use crate::ProcessEvent;
+    use crate::agent::process_control::ControlActionResult;
+    use crate::memory::MemoryType;
+    use crate::tasks::TaskStatus;
+    use crate::tasks::TaskStore;
+    use futures::FutureExt;
+    use futures::future;
+    use sqlx::sqlite::SqlitePoolOptions;
+    use std::collections::VecDeque;
+    use std::sync::Arc;
+    use std::sync::atomic::{AtomicU8, AtomicUsize, Ordering};
+    use std::time::{Duration, Instant};
 
     #[test]
     fn run_warmup_once_semantics_skip_when_disabled_without_force() {
@@ -1128,4 +3283,971 @@ mod tests {
 
         assert!(should_execute_warmup(warmup_config, false));
     }
+
+    #[test]
+    fn initial_warmup_completion_detected_when_status_has_refresh_timestamp() {
+        let status = crate::config::WarmupStatus {
+            state: crate::config::WarmupState::Warm,
+            last_refresh_unix_ms: Some(1_700_000_000_000),
+            ..Default::default()
+        };
+
+        assert!(has_completed_initial_warmup(&status));
+    }
+
+    #[test]
+    fn initial_warmup_completion_not_detected_without_refresh_timestamp() {
+        let status = crate::config::WarmupStatus::default();
+
+        assert!(!has_completed_initial_warmup(&status));
+    }
+
+    #[test]
+    fn initial_warmup_completion_not_detected_when_timestamp_exists_but_state_is_not_warm() {
+        let status = crate::config::WarmupStatus {
+            state: crate::config::WarmupState::Cold,
+            last_refresh_unix_ms: Some(1_700_000_000_000),
+            ..Default::default()
+        };
+
+        assert!(!has_completed_initial_warmup(&status));
+    }
+
+    #[test]
+    fn cancelled_warmup_demotes_warming_state_to_degraded() {
+        let mut status = crate::config::WarmupStatus {
+            state: crate::config::WarmupState::Warming,
+            ..Default::default()
+        };
+
+        let changed = apply_cancelled_warmup_status(&mut status, "startup", false);
+
+        assert!(changed);
+        assert_eq!(status.state, crate::config::WarmupState::Degraded);
+        assert!(
+            status
+                .last_error
+                .as_deref()
+                .is_some_and(|error| error.contains("warmup cancelled before completion"))
+        );
+    }
+
+    #[test]
+    fn cancelled_warmup_does_not_override_terminal_state() {
+        let mut status = crate::config::WarmupStatus {
+            state: crate::config::WarmupState::Warm,
+            last_refresh_unix_ms: Some(1_700_000_000_000),
+            ..Default::default()
+        };
+
+        let changed = apply_cancelled_warmup_status(&mut status, "scheduled", false);
+
+        assert!(!changed);
+        assert_eq!(status.state, crate::config::WarmupState::Warm);
+    }
+
+    #[test]
+    fn bulletin_loop_generation_runs_when_warmup_disabled() {
+        let warmup_config = crate::config::WarmupConfig {
+            enabled: false,
+            ..Default::default()
+        };
+        let status = crate::config::WarmupStatus {
+            bulletin_age_secs: Some(0),
+            ..Default::default()
+        };
+
+        assert!(should_generate_bulletin_from_bulletin_loop(
+            warmup_config,
+            &status
+        ));
+    }
+
+    #[test]
+    fn bulletin_loop_generation_skips_when_warmup_enabled_and_fresh() {
+        let warmup_config = crate::config::WarmupConfig {
+            enabled: true,
+            refresh_secs: 900,
+            ..Default::default()
+        };
+        let status = crate::config::WarmupStatus {
+            bulletin_age_secs: Some(10),
+            ..Default::default()
+        };
+
+        assert!(!should_generate_bulletin_from_bulletin_loop(
+            warmup_config,
+            &status
+        ));
+    }
+
+    #[test]
+    fn bulletin_loop_generation_runs_when_warmup_enabled_and_stale() {
+        let warmup_config = crate::config::WarmupConfig {
+            enabled: true,
+            refresh_secs: 900,
+            ..Default::default()
+        };
+        let status = crate::config::WarmupStatus {
+            bulletin_age_secs: Some(901),
+            ..Default::default()
+        };
+
+        assert!(should_generate_bulletin_from_bulletin_loop(
+            warmup_config,
+            &status
+        ));
+    }
+
+    #[tokio::test]
+    async fn bulletin_loop_generation_lock_snapshot_skips_after_fresh_update() {
+        let warmup_lock = Arc::new(tokio::sync::Mutex::new(()));
+        let warmup_config = Arc::new(arc_swap::ArcSwap::from_pointee(
+            crate::config::WarmupConfig::default(),
+        ));
+        let warmup_status = Arc::new(arc_swap::ArcSwap::from_pointee(
+            crate::config::WarmupStatus {
+                bulletin_age_secs: Some(901), // stale at first
+                ..Default::default()
+            },
+        ));
+
+        let calls = Arc::new(AtomicUsize::new(0));
+
+        // Hold lock so we can update status before helper takes its snapshot.
+        let guard = warmup_lock.as_ref().lock().await;
+
+        let warmup_lock_for_task = Arc::clone(&warmup_lock);
+        let warmup_config_for_task = Arc::clone(&warmup_config);
+        let warmup_status_for_task = Arc::clone(&warmup_status);
+        let calls_for_task = Arc::clone(&calls);
+        let task = tokio::spawn(async move {
+            maybe_generate_bulletin_under_lock(
+                warmup_lock_for_task.as_ref(),
+                warmup_config_for_task.as_ref(),
+                warmup_status_for_task.as_ref(),
+                || async {
+                    calls_for_task.fetch_add(1, Ordering::SeqCst);
+                    true
+                },
+            )
+            .await
+        });
+
+        // Warmup refresh lands before lock is released; helper should observe
+        // fresh status and skip generation.
+        warmup_status.store(Arc::new(crate::config::WarmupStatus {
+            bulletin_age_secs: Some(10),
+            ..Default::default()
+        }));
+        drop(guard);
+
+        let result = task.await.expect("task should join");
+        assert_eq!(result, BulletinRefreshOutcome::SkippedFresh);
+        assert_eq!(calls.load(Ordering::SeqCst), 0);
+    }
+
+    #[test]
+    fn summarize_signal_text_uses_first_non_empty_line() {
+        let text = "\n\nfirst line\nsecond line";
+        assert_eq!(summarize_signal_text(text), "first line");
+    }
+
+    #[test]
+    fn summarize_signal_text_truncates_long_text() {
+        let text = "a".repeat(200);
+        let summary = summarize_signal_text(&text);
+        assert_eq!(summary.chars().count(), crate::EVENT_SUMMARY_MAX_CHARS);
+    }
+
+    #[test]
+    fn signal_from_event_maps_memory_saved_values() {
+        let event = ProcessEvent::MemorySaved {
+            agent_id: Arc::from("agent"),
+            memory_id: "mem-1".to_string(),
+            channel_id: Some(Arc::from("channel-1")),
+            memory_type: MemoryType::Decision,
+            importance: 0.92,
+            content_summary: "persisted decision".to_string(),
+        };
+
+        let signal = signal_from_event(event).expect("MemorySaved should produce a signal");
+        match signal {
+            Signal::MemorySaved {
+                memory_id,
+                channel_id,
+                memory_type,
+                content_summary,
+                importance,
+            } => {
+                assert_eq!(memory_id, "mem-1");
+                assert_eq!(channel_id.as_deref(), Some("channel-1"));
+                assert_eq!(memory_type, MemoryType::Decision);
+                assert_eq!(content_summary, "persisted decision");
+                assert_eq!(importance, 0.92);
+            }
+            _ => panic!("expected memory-saved signal"),
+        }
+    }
+
+    #[test]
+    fn signal_from_event_handles_every_process_event_variant() {
+        let agent_id: crate::AgentId = Arc::from("agent");
+        let channel_id: crate::ChannelId = Arc::from("channel");
+        let worker_id = uuid::Uuid::new_v4();
+        let branch_id = uuid::Uuid::new_v4();
+
+        let events = vec![
+            ProcessEvent::BranchStarted {
+                agent_id: agent_id.clone(),
+                branch_id,
+                channel_id: channel_id.clone(),
+                description: "branch start".to_string(),
+                reply_to_message_id: Some("message-1".to_string()),
+            },
+            ProcessEvent::BranchResult {
+                agent_id: agent_id.clone(),
+                branch_id,
+                channel_id: channel_id.clone(),
+                conclusion: "branch done".to_string(),
+            },
+            ProcessEvent::WorkerStarted {
+                agent_id: agent_id.clone(),
+                worker_id,
+                channel_id: Some(channel_id.clone()),
+                task: "do work".to_string(),
+                worker_type: "shell".to_string(),
+                interactive: false,
+            },
+            ProcessEvent::WorkerStatus {
+                agent_id: agent_id.clone(),
+                worker_id,
+                channel_id: Some(channel_id.clone()),
+                status: "running".to_string(),
+            },
+            ProcessEvent::WorkerComplete {
+                agent_id: agent_id.clone(),
+                worker_id,
+                channel_id: Some(channel_id.clone()),
+                result: "ok".to_string(),
+                notify: false,
+                success: true,
+            },
+            ProcessEvent::ToolStarted {
+                agent_id: agent_id.clone(),
+                process_id: crate::ProcessId::Worker(worker_id),
+                channel_id: Some(channel_id.clone()),
+                tool_name: "shell".to_string(),
+                args: "echo hi".to_string(),
+            },
+            ProcessEvent::ToolCompleted {
+                agent_id: agent_id.clone(),
+                process_id: crate::ProcessId::Worker(worker_id),
+                channel_id: Some(channel_id.clone()),
+                tool_name: "shell".to_string(),
+                result: "done".to_string(),
+            },
+            ProcessEvent::MemorySaved {
+                agent_id: agent_id.clone(),
+                memory_id: "memory-1".to_string(),
+                channel_id: Some(channel_id.clone()),
+                memory_type: MemoryType::Fact,
+                importance: 0.6,
+                content_summary: "saved memory".to_string(),
+            },
+            ProcessEvent::CompactionTriggered {
+                agent_id: agent_id.clone(),
+                channel_id: channel_id.clone(),
+                threshold_reached: 0.86,
+            },
+            ProcessEvent::StatusUpdate {
+                agent_id: agent_id.clone(),
+                process_id: crate::ProcessId::Worker(worker_id),
+                status: "active".to_string(),
+            },
+            ProcessEvent::WorkerPermission {
+                agent_id: agent_id.clone(),
+                worker_id,
+                channel_id: Some(channel_id.clone()),
+                permission_id: "perm-1".to_string(),
+                description: "allow network".to_string(),
+                patterns: vec!["https://example.com".to_string()],
+            },
+            ProcessEvent::WorkerQuestion {
+                agent_id: agent_id.clone(),
+                worker_id,
+                channel_id: Some(channel_id.clone()),
+                question_id: "q-1".to_string(),
+                questions: vec![],
+            },
+            ProcessEvent::AgentMessageSent {
+                from_agent_id: agent_id.clone(),
+                to_agent_id: Arc::from("agent-2"),
+                link_id: "link-1".to_string(),
+                channel_id: channel_id.clone(),
+            },
+            ProcessEvent::AgentMessageReceived {
+                from_agent_id: Arc::from("agent-2"),
+                to_agent_id: agent_id,
+                link_id: "link-1".to_string(),
+                channel_id: channel_id.clone(),
+            },
+            ProcessEvent::TaskUpdated {
+                agent_id: Arc::from("agent"),
+                task_number: 7,
+                status: "created".to_string(),
+                action: "created".to_string(),
+            },
+            ProcessEvent::TextDelta {
+                agent_id: Arc::from("agent"),
+                process_id: crate::ProcessId::Worker(worker_id),
+                channel_id: Some(channel_id.clone()),
+                text_delta: "he".to_string(),
+                aggregated_text: "hello".to_string(),
+            },
+            ProcessEvent::WorkerIdle {
+                agent_id: Arc::from("agent"),
+                worker_id,
+                channel_id: Some(channel_id.clone()),
+            },
+            ProcessEvent::OpenCodeSessionCreated {
+                agent_id: Arc::from("agent"),
+                worker_id,
+                session_id: "session-1".to_string(),
+                port: 19898,
+            },
+            ProcessEvent::OpenCodePartUpdated {
+                agent_id: Arc::from("agent"),
+                worker_id,
+                part: crate::opencode::types::OpenCodePart::Text {
+                    id: "part-1".to_string(),
+                    text: "hello".to_string(),
+                },
+            },
+            ProcessEvent::WorkerInitialResult {
+                agent_id: Arc::from("agent"),
+                worker_id,
+                channel_id: Some(channel_id.clone()),
+                result: "initial result".to_string(),
+            },
+        ];
+
+        for event in events {
+            // Some events (OpenCode UI plumbing) return None — that's fine.
+            let _signal: Option<Signal> = signal_from_event(event);
+        }
+    }
+
+    #[test]
+    fn push_signal_into_buffer_coalesces_status_updates_for_same_process() {
+        let mut buffer = VecDeque::new();
+        let process_id = crate::ProcessId::Worker(uuid::Uuid::new_v4());
+
+        push_signal_into_buffer(
+            &mut buffer,
+            Signal::StatusUpdate {
+                process_id: process_id.clone(),
+                status: "running".to_string(),
+            },
+        );
+        push_signal_into_buffer(
+            &mut buffer,
+            Signal::StatusUpdate {
+                process_id,
+                status: "done".to_string(),
+            },
+        );
+
+        assert_eq!(buffer.len(), 1);
+        match buffer.back() {
+            Some(Signal::StatusUpdate { status, .. }) => assert_eq!(status, "done"),
+            _ => panic!("expected status-update signal"),
+        }
+    }
+
+    #[test]
+    fn push_signal_into_buffer_keeps_distinct_status_updates() {
+        let mut buffer = VecDeque::new();
+
+        push_signal_into_buffer(
+            &mut buffer,
+            Signal::StatusUpdate {
+                process_id: crate::ProcessId::Worker(uuid::Uuid::new_v4()),
+                status: "running".to_string(),
+            },
+        );
+        push_signal_into_buffer(
+            &mut buffer,
+            Signal::StatusUpdate {
+                process_id: crate::ProcessId::Worker(uuid::Uuid::new_v4()),
+                status: "running".to_string(),
+            },
+        );
+
+        assert_eq!(buffer.len(), 2);
+    }
+
+    #[test]
+    fn memory_receiver_closed_disables_stream_without_stopping_loop() {
+        let mut lagged_since_last_warning = 0;
+        let mut last_lag_warning = None;
+
+        let outcome = handle_cortex_receiver_result(
+            Err(tokio::sync::broadcast::error::RecvError::Closed),
+            "memory",
+            ReceiverClosedBehavior::DisableStream,
+            &mut lagged_since_last_warning,
+            &mut last_lag_warning,
+            30,
+        );
+
+        assert!(matches!(outcome, CortexReceiverOutcome::DisableStream));
+    }
+
+    #[test]
+    fn memory_receiver_lagged_continues_loop_and_tracks_drop_count() {
+        let mut lagged_since_last_warning = 0;
+        let mut last_lag_warning = Some(Instant::now());
+
+        let outcome = handle_cortex_receiver_result(
+            Err(tokio::sync::broadcast::error::RecvError::Lagged(7)),
+            "memory",
+            ReceiverClosedBehavior::DisableStream,
+            &mut lagged_since_last_warning,
+            &mut last_lag_warning,
+            30,
+        );
+
+        assert!(matches!(
+            outcome,
+            CortexReceiverOutcome::Lagged { dropped: 7 }
+        ));
+        assert_eq!(lagged_since_last_warning, 7);
+    }
+
+    #[test]
+    fn bulletin_refresh_failure_opens_circuit_at_threshold() {
+        let mut failures = 0_u32;
+        let mut circuit_open = false;
+        let mut next_allowed_at = Instant::now();
+        let now = Instant::now();
+
+        let (_, opened_first) = record_bulletin_refresh_failure(
+            &mut failures,
+            &mut circuit_open,
+            &mut next_allowed_at,
+            now,
+        );
+        assert!(!opened_first);
+        assert!(!circuit_open);
+
+        let (_, opened_second) = record_bulletin_refresh_failure(
+            &mut failures,
+            &mut circuit_open,
+            &mut next_allowed_at,
+            now,
+        );
+        assert!(!opened_second);
+        assert!(!circuit_open);
+
+        let (_, opened_third) = record_bulletin_refresh_failure(
+            &mut failures,
+            &mut circuit_open,
+            &mut next_allowed_at,
+            now,
+        );
+        assert!(opened_third);
+        assert!(circuit_open);
+        assert_eq!(failures, BULLETIN_REFRESH_CIRCUIT_OPEN_THRESHOLD);
+        assert!(
+            next_allowed_at
+                >= now + std::time::Duration::from_secs(BULLETIN_REFRESH_CIRCUIT_OPEN_SECS),
+            "circuit-open cooldown should dominate retry window"
+        );
+    }
+
+    #[test]
+    fn parse_structured_success_flag_requires_json_object_bool() {
+        assert_eq!(
+            parse_structured_success_flag(r#"{"success":false}"#),
+            Some(false)
+        );
+        assert_eq!(parse_structured_success_flag(r#"{"ok":true}"#), Some(true));
+        assert_eq!(parse_structured_success_flag("plain text"), None);
+        assert_eq!(
+            parse_structured_success_flag(r#"{"success":"false"}"#),
+            None
+        );
+    }
+
+    #[test]
+    fn detached_timeout_transition_requeues_until_limit_then_quarantines() {
+        let metadata = serde_json::json!({});
+        let (count1, exhausted1, status1) = detached_timeout_transition(&metadata, 2);
+        assert_eq!(count1, 1);
+        assert!(!exhausted1);
+        assert_eq!(status1, TaskStatus::Ready);
+        assert_eq!(status1.as_str(), "ready");
+
+        let metadata = serde_json::json!({ "supervisor_timeout_count": 2 });
+        let (count2, exhausted2, status2) = detached_timeout_transition(&metadata, 2);
+        assert_eq!(count2, 3);
+        assert!(exhausted2);
+        assert_eq!(status2, TaskStatus::Backlog);
+        assert_eq!(status2.as_str(), "backlog");
+    }
+
+    #[test]
+    fn claim_detached_completion_allows_active_or_killing_exactly_once() {
+        let lifecycle = std::sync::atomic::AtomicU8::new(
+            crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_ACTIVE,
+        );
+        assert!(claim_detached_completion(&lifecycle));
+        assert!(!claim_detached_completion(&lifecycle));
+
+        let lifecycle = std::sync::atomic::AtomicU8::new(
+            crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_KILLING,
+        );
+        assert!(claim_detached_completion(&lifecycle));
+    }
+
+    #[tokio::test]
+    async fn detached_worker_completion_takes_priority_when_cancel_signal_and_worker_finish_simultaneously()
+     {
+        let lifecycle = Arc::new(AtomicU8::new(
+            crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_ACTIVE,
+        ));
+
+        let (_cancel_tx, mut detached_cancel_rx) = tokio::sync::oneshot::channel::<()>();
+        drop(_cancel_tx);
+
+        let worker_future = future::ready::<Result<String, String>>(Ok("done".to_string()));
+        tokio::pin!(worker_future);
+
+        let worker_result = tokio::select! {
+            biased;
+            result = &mut worker_future => Some(result),
+            _ = &mut detached_cancel_rx => worker_future.as_mut().now_or_never(),
+        };
+
+        let completion_won = match worker_result {
+            Some(Ok(result)) => {
+                assert_eq!(result, "done");
+                claim_detached_completion(&lifecycle)
+            }
+            _ => false,
+        };
+
+        assert!(completion_won);
+        assert!(!claim_detached_completion(&lifecycle));
+        assert_eq!(
+            lifecycle.load(Ordering::Acquire),
+            crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_COMPLETING
+        );
+    }
+
+    #[tokio::test]
+    async fn register_detached_worker_for_pickup_registers_entry_and_updates_task_record() {
+        let pool = SqlitePoolOptions::new()
+            .max_connections(1)
+            .connect("sqlite::memory:")
+            .await
+            .expect("failed to create sqlite memory pool");
+
+        sqlx::query(
+            "CREATE TABLE tasks (
+                id TEXT PRIMARY KEY,
+                agent_id TEXT NOT NULL,
+                task_number INTEGER NOT NULL,
+                title TEXT NOT NULL,
+                description TEXT,
+                status TEXT NOT NULL DEFAULT 'backlog',
+                priority TEXT NOT NULL DEFAULT 'medium',
+                subtasks TEXT,
+                metadata TEXT,
+                source_memory_id TEXT,
+                worker_id TEXT,
+                created_by TEXT NOT NULL,
+                approved_at TIMESTAMP,
+                approved_by TEXT,
+                created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                completed_at TIMESTAMP,
+                UNIQUE(agent_id, task_number)
+            )",
+        )
+        .execute(&pool)
+        .await
+        .expect("failed to create tasks table");
+
+        let task_store = TaskStore::new(pool.clone());
+        let registry = crate::agent::process_control::ProcessControlRegistry::new();
+        let agent_id: crate::AgentId = Arc::from("agent-1");
+        let task_number = 2_i64;
+        let worker_id = uuid::Uuid::new_v4();
+
+        sqlx::query(
+            "INSERT INTO tasks (
+                id, agent_id, task_number, title, description, status, priority,
+                subtasks, metadata, source_memory_id, created_by
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        )
+        .bind(uuid::Uuid::new_v4().to_string())
+        .bind(&*agent_id)
+        .bind(task_number)
+        .bind("test task")
+        .bind(Some("description".to_string()))
+        .bind("ready")
+        .bind("medium")
+        .bind("[]")
+        .bind("{}")
+        .bind(Option::<String>::None)
+        .bind("system")
+        .execute(&pool)
+        .await
+        .expect("failed to insert task fixture");
+
+        let (lifecycle, _cancel_rx) = super::register_detached_worker_for_pickup(
+            &registry,
+            &task_store,
+            &agent_id,
+            task_number,
+            worker_id,
+        )
+        .await
+        .expect("bootstrap should succeed");
+        drop(_cancel_rx);
+
+        assert_eq!(
+            lifecycle.load(Ordering::Acquire),
+            crate::agent::process_control::DETACHED_WORKER_LIFECYCLE_ACTIVE
+        );
+        assert!(
+            registry.unregister_detached_worker(worker_id).await,
+            "control entry should exist after successful registration"
+        );
+    }
+
+    #[tokio::test]
+    async fn register_detached_worker_for_pickup_unregisters_control_on_task_update_error() {
+        let pool = SqlitePoolOptions::new()
+            .max_connections(1)
+            .connect("sqlite::memory:")
+            .await
+            .expect("failed to create sqlite memory pool");
+
+        sqlx::query(
+            "CREATE TABLE tasks (
+                id TEXT PRIMARY KEY,
+                agent_id TEXT NOT NULL,
+                task_number INTEGER NOT NULL,
+                title TEXT NOT NULL,
+                description TEXT,
+                status TEXT NOT NULL DEFAULT 'backlog',
+                priority TEXT NOT NULL DEFAULT 'medium',
+                subtasks TEXT,
+                metadata TEXT,
+                source_memory_id TEXT,
+                worker_id TEXT,
+                created_by TEXT NOT NULL,
+                approved_at TIMESTAMP,
+                approved_by TEXT,
+                created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                completed_at TIMESTAMP,
+                UNIQUE(agent_id, task_number)
+            )",
+        )
+        .execute(&pool)
+        .await
+        .expect("failed to create tasks table");
+
+        let task_store = TaskStore::new(pool.clone());
+        let registry = crate::agent::process_control::ProcessControlRegistry::new();
+        let agent_id: crate::AgentId = Arc::from("agent-1");
+        let task_number = 1_i64;
+        let worker_id = uuid::Uuid::new_v4();
+
+        sqlx::query(
+            "INSERT INTO tasks (
+                id, agent_id, task_number, title, description, status, priority,
+                subtasks, metadata, source_memory_id, created_by
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        )
+        .bind(uuid::Uuid::new_v4().to_string())
+        .bind(&*agent_id)
+        .bind(task_number)
+        .bind("test task")
+        .bind(Some("description".to_string()))
+        .bind("ready")
+        .bind("medium")
+        .bind("[]")
+        .bind("{}")
+        .bind(Option::<String>::None)
+        .bind("system")
+        .execute(&pool)
+        .await
+        .expect("failed to insert task fixture");
+
+        sqlx::query("DROP TABLE tasks")
+            .execute(&pool)
+            .await
+            .expect("failed to drop tasks table");
+
+        let result = super::register_detached_worker_for_pickup(
+            &registry,
+            &task_store,
+            &agent_id,
+            task_number,
+            worker_id,
+        )
+        .await;
+
+        assert!(result.is_err());
+        assert!(
+            !registry.unregister_detached_worker(worker_id).await,
+            "detached control entry should have been cleaned up on update failure"
+        );
+    }
+
+    #[test]
+    fn bulletin_refresh_circuit_closes_after_cooldown() {
+        let mut failures = BULLETIN_REFRESH_CIRCUIT_OPEN_THRESHOLD;
+        let mut circuit_open = true;
+        let now = Instant::now();
+        let mut next_allowed_at = now + std::time::Duration::from_millis(5);
+
+        let closed_early = maybe_close_bulletin_refresh_circuit(
+            &mut failures,
+            &mut circuit_open,
+            &mut next_allowed_at,
+            now,
+        );
+        assert!(!closed_early);
+        assert!(circuit_open);
+
+        let closed = maybe_close_bulletin_refresh_circuit(
+            &mut failures,
+            &mut circuit_open,
+            &mut next_allowed_at,
+            now + std::time::Duration::from_millis(10),
+        );
+        assert!(closed);
+        assert!(!circuit_open);
+        assert_eq!(failures, 0);
+    }
+
+    #[test]
+    fn take_lagged_control_flag_clears_after_one_tick() {
+        let mut state = HealthRuntimeState::default();
+        state.mark_control_receiver_lag();
+
+        assert!(take_lagged_control_flag(&mut state));
+        assert!(!take_lagged_control_flag(&mut state));
+    }
+
+    #[test]
+    fn build_kill_targets_orders_oldest_first_and_stable_by_id() {
+        let base = Instant::now();
+        let older = base - Duration::from_secs(20);
+        let newer = base - Duration::from_secs(5);
+        let shared_start = base - Duration::from_secs(10);
+
+        let worker_a = WorkerTracker {
+            worker_id: uuid::Uuid::parse_str("00000000-0000-0000-0000-00000000000a")
+                .expect("valid uuid"),
+            channel_id: Some(Arc::from("channel-a")),
+            worker_type: "builtin".to_string(),
+            started_at: shared_start,
+            last_activity_at: shared_start,
+            is_idle: false,
+        };
+        let worker_b = WorkerTracker {
+            worker_id: uuid::Uuid::parse_str("00000000-0000-0000-0000-00000000000b")
+                .expect("valid uuid"),
+            channel_id: Some(Arc::from("channel-a")),
+            worker_type: "builtin".to_string(),
+            started_at: shared_start,
+            last_activity_at: shared_start,
+            is_idle: false,
+        };
+        let branch_oldest = BranchTracker {
+            branch_id: uuid::Uuid::parse_str("00000000-0000-0000-0000-000000000001")
+                .expect("valid uuid"),
+            channel_id: Arc::from("channel-a"),
+            started_at: older,
+        };
+        let branch_newest = BranchTracker {
+            branch_id: uuid::Uuid::parse_str("00000000-0000-0000-0000-000000000002")
+                .expect("valid uuid"),
+            channel_id: Arc::from("channel-a"),
+            started_at: newer,
+        };
+
+        let targets = build_kill_targets(
+            vec![worker_b.clone(), worker_a.clone()],
+            vec![branch_newest.clone(), branch_oldest.clone()],
+        );
+
+        let ordered_ids: Vec<String> = targets
+            .iter()
+            .map(|target| match target {
+                super::KillTarget::Worker(tracker) => tracker.worker_id.to_string(),
+                super::KillTarget::Branch(tracker) => tracker.branch_id.to_string(),
+            })
+            .collect();
+
+        assert_eq!(
+            ordered_ids,
+            vec![
+                branch_oldest.branch_id.to_string(),
+                worker_a.worker_id.to_string(),
+                worker_b.worker_id.to_string(),
+                branch_newest.branch_id.to_string(),
+            ]
+        );
+    }
+
+    #[test]
+    fn worker_activity_resets_idle_clock() {
+        let mut state = HealthRuntimeState::default();
+        let worker_id = uuid::Uuid::new_v4();
+        state.track_worker_start(worker_id, Some(Arc::from("ch")), "builtin".to_string());
+
+        let tracker_before = state.worker_trackers.get(&worker_id).unwrap().clone();
+        // Simulate time passing by checking that activity updates the timestamp.
+        std::thread::sleep(std::time::Duration::from_millis(10));
+        state.track_worker_activity(worker_id);
+
+        let tracker_after = state.worker_trackers.get(&worker_id).unwrap();
+        assert!(
+            tracker_after.last_activity_at > tracker_before.last_activity_at,
+            "last_activity_at should advance after track_worker_activity"
+        );
+        assert_eq!(
+            tracker_after.started_at, tracker_before.started_at,
+            "started_at should not change"
+        );
+    }
+
+    #[test]
+    fn worker_activity_noop_for_unknown_worker() {
+        let mut state = HealthRuntimeState::default();
+        // Should not panic on unknown worker ID.
+        state.track_worker_activity(uuid::Uuid::new_v4());
+    }
+
+    #[test]
+    fn terminal_control_result_includes_not_found_and_already_terminal() {
+        assert!(is_terminal_control_result(ControlActionResult::Cancelled));
+        assert!(is_terminal_control_result(ControlActionResult::NotFound));
+        assert!(is_terminal_control_result(
+            ControlActionResult::AlreadyTerminal
+        ));
+    }
+
+    #[test]
+    fn cancelled_control_result_only_matches_cancelled() {
+        assert!(is_cancelled_control_result(ControlActionResult::Cancelled));
+        assert!(!is_cancelled_control_result(ControlActionResult::NotFound));
+        assert!(!is_cancelled_control_result(
+            ControlActionResult::AlreadyTerminal
+        ));
+    }
+
+    #[test]
+    fn breaker_trips_only_for_structured_failures_and_resets_on_success() {
+        let mut state = HealthRuntimeState::default();
+        state.track_tool_completed("shell", r#"{"success":false}"#, 2);
+        assert!(state.pending_breaker_trip_events.is_empty());
+
+        state.track_tool_completed("shell", r#"{"success":false}"#, 2);
+        assert_eq!(state.pending_breaker_trip_events.len(), 1);
+        assert_eq!(state.pending_breaker_trip_events[0].key, "tool:shell");
+
+        state.track_tool_completed("shell", "command failed", 2);
+        assert_eq!(state.pending_breaker_trip_events.len(), 1);
+
+        state.track_tool_completed("shell", r#"{"success":true}"#, 2);
+        let breaker = state
+            .breaker_state
+            .get("tool:shell")
+            .expect("breaker state exists");
+        assert_eq!(breaker.failure_count, 0);
+        assert!(!breaker.tripped);
+    }
+
+    #[tokio::test]
+    async fn run_cortex_loop_tick_not_starved_by_events() {
+        use std::time::Duration;
+
+        const TEST_DURATION: Duration = Duration::from_millis(750);
+        const TICK_PERIOD: Duration = Duration::from_millis(25);
+        const MAX_DROPPED_EVENTS_BUDGET: u64 = 512;
+
+        let (event_tx, mut event_rx) = tokio::sync::broadcast::channel::<ProcessEvent>(1024);
+        let event_tx_for_sender = event_tx.clone();
+        let mut tick_timer =
+            tokio::time::interval_at(tokio::time::Instant::now() + TICK_PERIOD, TICK_PERIOD);
+        tick_timer.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
+
+        let sender = tokio::spawn(async move {
+            let agent_id: crate::AgentId = Arc::from("agent");
+            let process_id = crate::ProcessId::Worker(uuid::Uuid::new_v4());
+            let deadline = tokio::time::Instant::now() + TEST_DURATION;
+            while tokio::time::Instant::now() < deadline {
+                for _ in 0..8 {
+                    let _ = event_tx_for_sender.send(ProcessEvent::StatusUpdate {
+                        agent_id: agent_id.clone(),
+                        process_id: process_id.clone(),
+                        status: "busy".to_string(),
+                    });
+                }
+                tokio::task::yield_now().await;
+            }
+        });
+
+        let deadline = tokio::time::Instant::now() + TEST_DURATION + Duration::from_millis(250);
+        let mut tick_count = 0_u64;
+        let mut lagged_dropped_events = 0_u64;
+        let mut receiver_closed = false;
+
+        while tokio::time::Instant::now() < deadline {
+            tokio::select! {
+                _ = tick_timer.tick() => {
+                    tick_count = tick_count.saturating_add(1);
+                }
+                event = event_rx.recv() => {
+                    match event {
+                        Ok(_) => {}
+                        Err(tokio::sync::broadcast::error::RecvError::Lagged(skipped)) => {
+                            lagged_dropped_events = lagged_dropped_events.saturating_add(skipped);
+                        }
+                        Err(tokio::sync::broadcast::error::RecvError::Closed) => {
+                            receiver_closed = true;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        sender.await.expect("sender task should complete");
+        drop(event_tx);
+
+        assert!(
+            !receiver_closed,
+            "receiver should not close while load test sender is active"
+        );
+        assert!(
+            tick_count >= (TEST_DURATION.as_millis() / TICK_PERIOD.as_millis() / 4) as u64,
+            "periodic tick should continue firing under sustained event load"
+        );
+        assert!(
+            lagged_dropped_events <= MAX_DROPPED_EVENTS_BUDGET,
+            "lagged dropped events exceeded budget: {} > {}",
+            lagged_dropped_events,
+            MAX_DROPPED_EVENTS_BUDGET
+        );
+    }
 }
diff --git a/src/agent/cortex_chat.rs b/src/agent/cortex_chat.rs
index ed5ec0033..575bd85cd 100644
--- a/src/agent/cortex_chat.rs
+++ b/src/agent/cortex_chat.rs
@@ -6,8 +6,9 @@
 //! into the system prompt as context.
 
 use crate::conversation::history::ProcessRunLogger;
+use crate::hooks::SpacebotHook;
 use crate::llm::SpacebotModel;
-use crate::{AgentDeps, ProcessType};
+use crate::{AgentDeps, ProcessId, ProcessType};
 
 use rig::agent::{AgentBuilder, HookAction, PromptHook, ToolCallHookAction};
 use rig::completion::{AssistantContent, CompletionModel, CompletionResponse, Message, Prompt};
@@ -17,6 +18,7 @@ use sqlx::SqlitePool;
 use tokio::sync::mpsc;
 
 use std::sync::Arc;
+use std::time::Duration;
 use tokio::sync::Mutex;
 
 /// A persisted cortex chat message.
@@ -49,15 +51,29 @@ pub enum CortexChatEvent {
     Error { message: String },
 }
 
+#[derive(Debug, thiserror::Error)]
+pub enum CortexChatSendError {
+    #[error("cortex chat session is busy")]
+    Busy,
+    #[error(transparent)]
+    Database(#[from] sqlx::Error),
+    #[error(transparent)]
+    Prompt(#[from] crate::error::Error),
+}
+
 /// Prompt hook that forwards tool events to an mpsc channel for SSE streaming.
 #[derive(Clone)]
 struct CortexChatHook {
     event_tx: mpsc::Sender<CortexChatEvent>,
+    spacebot_hook: SpacebotHook,
 }
 
 impl CortexChatHook {
-    fn new(event_tx: mpsc::Sender<CortexChatEvent>) -> Self {
-        Self { event_tx }
+    fn new(event_tx: mpsc::Sender<CortexChatEvent>, spacebot_hook: SpacebotHook) -> Self {
+        Self {
+            event_tx,
+            spacebot_hook,
+        }
     }
 
     async fn send(&self, event: CortexChatEvent) {
@@ -65,34 +81,72 @@ impl CortexChatHook {
     }
 }
 
+fn try_acquire_send_lock(
+    send_lock: &Arc<Mutex<()>>,
+) -> std::result::Result<tokio::sync::OwnedMutexGuard<()>, CortexChatSendError> {
+    send_lock
+        .clone()
+        .try_lock_owned()
+        .map_err(|_| CortexChatSendError::Busy)
+}
+
+async fn persist_and_emit_cortex_chat_error(
+    store: &CortexChatStore,
+    event_tx: &mpsc::Sender<CortexChatEvent>,
+    thread_id: &str,
+    channel_ref: Option<&str>,
+    message: String,
+) {
+    let _ = store
+        .save_message(thread_id, "assistant", &message, channel_ref)
+        .await;
+    let _ = event_tx.send(CortexChatEvent::Error { message }).await;
+}
+
 impl<M: CompletionModel> PromptHook<M> for CortexChatHook {
     async fn on_tool_call(
         &self,
         tool_name: &str,
-        _tool_call_id: Option<String>,
-        _internal_call_id: &str,
-        _args: &str,
+        tool_call_id: Option<String>,
+        internal_call_id: &str,
+        args: &str,
     ) -> ToolCallHookAction {
+        let action = <SpacebotHook as PromptHook<M>>::on_tool_call(
+            &self.spacebot_hook,
+            tool_name,
+            tool_call_id,
+            internal_call_id,
+            args,
+        )
+        .await;
+        if !matches!(action, ToolCallHookAction::Continue) {
+            return action;
+        }
+
         self.send(CortexChatEvent::ToolStarted {
             tool: tool_name.to_string(),
         })
         .await;
-        ToolCallHookAction::Continue
+        action
     }
 
     async fn on_tool_result(
         &self,
         tool_name: &str,
         _tool_call_id: Option<String>,
-        _internal_call_id: &str,
+        internal_call_id: &str,
         _args: &str,
         result: &str,
     ) -> HookAction {
-        let preview = if result.len() > 200 {
-            format!("{}...", &result[..200])
-        } else {
-            result.to_string()
-        };
+        let guard_action = self.spacebot_hook.guard_tool_result(tool_name, result);
+        if !matches!(guard_action, HookAction::Continue) {
+            return guard_action;
+        }
+        let preview = crate::tools::truncate_utf8_ellipsis(result, 200);
+        self.spacebot_hook
+            .emit_tool_completed_event_from_capped(tool_name, preview.clone());
+        self.spacebot_hook
+            .record_tool_result_metrics(tool_name, internal_call_id);
         self.send(CortexChatEvent::ToolCompleted {
             tool: tool_name.to_string(),
             result_preview: preview,
@@ -101,16 +155,22 @@ impl<M: CompletionModel> PromptHook<M> for CortexChatHook {
         HookAction::Continue
     }
 
-    async fn on_completion_call(&self, _prompt: &Message, _history: &[Message]) -> HookAction {
-        HookAction::Continue
+    async fn on_completion_call(&self, prompt: &Message, history: &[Message]) -> HookAction {
+        <SpacebotHook as PromptHook<M>>::on_completion_call(&self.spacebot_hook, prompt, history)
+            .await
     }
 
     async fn on_completion_response(
         &self,
-        _prompt: &Message,
-        _response: &CompletionResponse<M::Response>,
+        prompt: &Message,
+        response: &CompletionResponse<M::Response>,
     ) -> HookAction {
-        HookAction::Continue
+        <SpacebotHook as PromptHook<M>>::on_completion_response(
+            &self.spacebot_hook,
+            prompt,
+            response,
+        )
+        .await
     }
 }
 
@@ -211,7 +271,7 @@ pub struct CortexChatSession {
     pub tool_server: ToolServerHandle,
     pub store: CortexChatStore,
     /// Prevent concurrent sends — only one request at a time per agent.
-    send_lock: Mutex<()>,
+    send_lock: Arc<Mutex<()>>,
 }
 
 impl CortexChatSession {
@@ -220,7 +280,7 @@ impl CortexChatSession {
             deps,
             tool_server,
             store,
-            send_lock: Mutex::new(()),
+            send_lock: Arc::new(Mutex::new(())),
         }
     }
 
@@ -234,8 +294,8 @@ impl CortexChatSession {
         thread_id: &str,
         user_text: &str,
         channel_context_id: Option<&str>,
-    ) -> Result<mpsc::Receiver<CortexChatEvent>, anyhow::Error> {
-        let _guard = self.send_lock.lock().await;
+    ) -> std::result::Result<mpsc::Receiver<CortexChatEvent>, CortexChatSendError> {
+        let send_guard = try_acquire_send_lock(&self.send_lock)?;
 
         // Save the user message
         self.store
@@ -263,10 +323,10 @@ impl CortexChatSession {
 
         // Resolve model and build agent
         let routing = self.deps.runtime_config.routing.load();
-        let model_name = routing.resolve(ProcessType::Branch, None).to_string();
+        let model_name = routing.resolve(ProcessType::Cortex, None).to_string();
         let model = SpacebotModel::make(&self.deps.llm_manager, &model_name)
-            .with_context(&*self.deps.agent_id, "cortex")
-            .with_routing((**routing).clone());
+            .with_context(self.deps.agent_id.as_ref(), "cortex")
+            .with_routing(routing.as_ref().clone());
 
         let agent = AgentBuilder::new(model)
             .preamble(&system_prompt)
@@ -275,25 +335,43 @@ impl CortexChatSession {
             .build();
 
         let (event_tx, event_rx) = mpsc::channel(256);
-        let hook = CortexChatHook::new(event_tx.clone());
+        let spacebot_hook = SpacebotHook::new(
+            self.deps.agent_id.clone(),
+            ProcessId::Worker(uuid::Uuid::new_v4()),
+            ProcessType::Cortex,
+            channel_context_id.map(std::sync::Arc::<str>::from),
+            self.deps.event_tx.clone(),
+        );
+        let hook = CortexChatHook::new(event_tx.clone(), spacebot_hook);
 
         // Clone what the spawned task needs
         let user_text = user_text.to_string();
         let thread_id = thread_id.to_string();
         let channel_context_id = channel_context_id.map(|s| s.to_string());
         let store = self.store.clone();
+        let prompt_timeout = Duration::from_secs(
+            self.deps
+                .runtime_config
+                .cortex
+                .load()
+                .branch_timeout_secs
+                .max(1),
+        );
 
         tokio::spawn(async move {
+            let _send_guard = send_guard;
             let channel_ref = channel_context_id.as_deref();
-
-            let result = agent
-                .prompt(&user_text)
-                .with_hook(hook)
-                .with_history(&mut history)
-                .await;
-
-            match result {
-                Ok(response) => {
+            let prompt_result = tokio::time::timeout(
+                prompt_timeout,
+                agent
+                    .prompt(&user_text)
+                    .with_hook(hook.clone())
+                    .with_history(&mut history),
+            )
+            .await;
+
+            match prompt_result {
+                Ok(Ok(response)) => {
                     let _ = store
                         .save_message(&thread_id, "assistant", &response, channel_ref)
                         .await;
@@ -303,16 +381,34 @@ impl CortexChatSession {
                         })
                         .await;
                 }
-                Err(error) => {
+                Ok(Err(error)) => {
                     let error_text = format!("Cortex chat error: {error}");
-                    let _ = store
-                        .save_message(&thread_id, "assistant", &error_text, channel_ref)
-                        .await;
-                    let _ = event_tx
-                        .send(CortexChatEvent::Error {
-                            message: error_text,
-                        })
-                        .await;
+                    persist_and_emit_cortex_chat_error(
+                        &store,
+                        &event_tx,
+                        &thread_id,
+                        channel_ref,
+                        error_text,
+                    )
+                    .await;
+                }
+                Err(_) => {
+                    tracing::warn!(
+                        timeout_secs = prompt_timeout.as_secs(),
+                        "cortex chat prompt timed out"
+                    );
+                    let error_text = format!(
+                        "Cortex chat timed out after {}s while waiting for a model response.",
+                        prompt_timeout.as_secs()
+                    );
+                    persist_and_emit_cortex_chat_error(
+                        &store,
+                        &event_tx,
+                        &thread_id,
+                        channel_ref,
+                        error_text,
+                    )
+                    .await;
                 }
             }
         });
@@ -329,6 +425,12 @@ impl CortexChatSession {
 
         let identity_context = runtime_config.identity.load().render();
         let memory_bulletin = runtime_config.memory_bulletin.load();
+        let agents_manifest = crate::self_awareness::agents_manifest_for_prompt();
+        let changelog_highlights = crate::self_awareness::changelog_highlights();
+        let runtime_config_snapshot = crate::self_awareness::runtime_snapshot_pretty(
+            self.deps.agent_id.as_ref(),
+            runtime_config,
+        );
 
         let browser_enabled = runtime_config.browser_config.load().enabled;
         let web_search_enabled = runtime_config.brave_search_key.load().is_some();
@@ -352,6 +454,9 @@ impl CortexChatSession {
             empty_to_none(identity_context),
             empty_to_none(memory_bulletin.to_string()),
             channel_transcript,
+            empty_to_none(agents_manifest),
+            empty_to_none(changelog_highlights),
+            empty_to_none(runtime_config_snapshot),
             worker_capabilities,
         )
     }
@@ -406,3 +511,55 @@ impl CortexChatSession {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{CortexChatSendError, try_acquire_send_lock};
+    use std::sync::Arc;
+    use std::time::Duration;
+    use tokio::sync::Mutex;
+
+    #[test]
+    fn preview_utf8_truncates_on_char_boundary() {
+        let text = "🙂🙂🙂";
+        // For max_bytes=5: can fit "🙂" (4 bytes) but not "🙂..." (7 bytes)
+        let preview = crate::tools::truncate_utf8_ellipsis(text, 5);
+        assert_eq!(preview, "🙂");
+        // For max_bytes=10: can fit "🙂..." (7 bytes)
+        let preview = crate::tools::truncate_utf8_ellipsis(text, 10);
+        assert_eq!(preview, "🙂...");
+    }
+
+    #[test]
+    fn preview_utf8_keeps_short_text() {
+        let text = "done";
+        let preview = crate::tools::truncate_utf8_ellipsis(text, 200);
+        assert_eq!(preview, text);
+    }
+
+    #[tokio::test]
+    async fn send_lock_returns_busy_when_already_held() {
+        let send_lock = Arc::new(Mutex::new(()));
+        let _first_guard = try_acquire_send_lock(&send_lock).expect("first lock should succeed");
+        let second = try_acquire_send_lock(&send_lock);
+        assert!(matches!(second, Err(CortexChatSendError::Busy)));
+    }
+
+    #[tokio::test]
+    async fn send_lock_released_after_timeout_path() {
+        let send_lock = Arc::new(Mutex::new(()));
+        let send_guard = try_acquire_send_lock(&send_lock).expect("first lock should succeed");
+        let timed_task = tokio::spawn(async move {
+            let _send_guard = send_guard;
+            tokio::time::timeout(Duration::from_millis(5), std::future::pending::<()>()).await
+        });
+        let timeout_result = timed_task.await.expect("timeout task should complete");
+        assert!(timeout_result.is_err(), "pending prompt should time out");
+
+        let second = try_acquire_send_lock(&send_lock);
+        assert!(
+            second.is_ok(),
+            "single-flight lock should be released after timeout path"
+        );
+    }
+}
diff --git a/src/agent/ingestion.rs b/src/agent/ingestion.rs
index 506baa45c..9ffb7eb78 100644
--- a/src/agent/ingestion.rs
+++ b/src/agent/ingestion.rs
@@ -9,13 +9,15 @@
 //! skipped on the next run.
 
 use crate::AgentDeps;
+use crate::ProcessId;
 use crate::ProcessType;
 use crate::config::IngestionConfig;
+use crate::hooks::SpacebotHook;
 use crate::llm::SpacebotModel;
 
 use anyhow::Context as _;
 use rig::agent::AgentBuilder;
-use rig::completion::{CompletionModel, Prompt};
+use rig::completion::{CompletionModel, PromptError};
 use rig::tool::server::ToolServerHandle;
 use sha2::{Digest, Sha256};
 use sqlx::SqlitePool;
@@ -23,6 +25,7 @@ use sqlx::SqlitePool;
 use std::collections::HashSet;
 use std::path::{Path, PathBuf};
 use std::time::Duration;
+use uuid::Uuid;
 
 /// Spawn the ingestion polling loop for an agent.
 ///
@@ -472,9 +475,15 @@ async fn process_chunk(
         crate::conversation::history::ConversationLogger::new(deps.sqlite_pool.clone());
     let channel_store = crate::conversation::ChannelStore::new(deps.sqlite_pool.clone());
     let tool_server: ToolServerHandle = crate::tools::create_branch_tool_server(
+        None,
+        deps.agent_id.clone(),
+        deps.task_store.clone(),
         deps.memory_search.clone(),
+        deps.runtime_config.clone(),
+        deps.memory_event_tx.clone(),
         conversation_logger,
         channel_store,
+        crate::conversation::ProcessRunLogger::new(deps.sqlite_pool.clone()),
     );
 
     let agent = AgentBuilder::new(model)
@@ -483,11 +492,31 @@ async fn process_chunk(
         .tool_server_handle(tool_server)
         .build();
 
+    let hook = SpacebotHook::new(
+        deps.agent_id.clone(),
+        ProcessId::Branch(Uuid::new_v4()),
+        ProcessType::Branch,
+        None,
+        deps.event_tx.clone(),
+    );
+
     let user_prompt =
         prompt_engine.render_system_ingestion_chunk(filename, chunk_number, total_chunks, chunk)?;
 
     let mut history = Vec::new();
-    match agent.prompt(&user_prompt).with_history(&mut history).await {
+    let result = hook.prompt_once(&agent, &mut history, &user_prompt).await;
+    classify_chunk_prompt_result(result, filename, chunk_number, total_chunks)?;
+
+    Ok(())
+}
+
+fn classify_chunk_prompt_result(
+    result: std::result::Result<String, PromptError>,
+    filename: &str,
+    chunk_number: usize,
+    total_chunks: usize,
+) -> anyhow::Result<()> {
+    match result {
         Ok(response) => {
             tracing::debug!(
                 file = %filename,
@@ -495,20 +524,20 @@ async fn process_chunk(
                 response = %response.chars().take(200).collect::<String>(),
                 "chunk processed"
             );
+            Ok(())
         }
-        Err(rig::completion::PromptError::MaxTurnsError { .. }) => {
+        Err(PromptError::MaxTurnsError { .. }) => {
             tracing::warn!(
                 file = %filename,
                 chunk = %format!("{chunk_number}/{total_chunks}"),
                 "chunk processing hit max turns"
             );
+            Err(anyhow::anyhow!(
+                "chunk processing hit max turns for {filename} ({chunk_number}/{total_chunks})"
+            ))
         }
-        Err(error) => {
-            return Err(error.into());
-        }
+        Err(error) => Err(error.into()),
     }
-
-    Ok(())
 }
 
 #[cfg(test)]
@@ -614,4 +643,22 @@ mod tests {
             "had_failure must stay false when all chunks succeed"
         );
     }
+
+    #[test]
+    fn test_max_turns_classified_as_chunk_failure() {
+        let result = classify_chunk_prompt_result(
+            Err(PromptError::MaxTurnsError {
+                max_turns: 10,
+                chat_history: Box::new(Vec::new()),
+                prompt: Box::new(rig::message::Message::from("chunk prompt")),
+            }),
+            "notes.txt",
+            1,
+            3,
+        );
+        assert!(
+            result.is_err(),
+            "max turns must be treated as chunk failure for retry"
+        );
+    }
 }
diff --git a/src/agent/invariant_harness.rs b/src/agent/invariant_harness.rs
new file mode 100644
index 000000000..7e335c102
--- /dev/null
+++ b/src/agent/invariant_harness.rs
@@ -0,0 +1,231 @@
+//! Invariant-driven fault harness for agent loop regression tests.
+
+use super::channel_dispatch::{
+    WorkerCompletionError, map_worker_completion_result, reserve_worker_slot_local,
+};
+
+use rand::rngs::StdRng;
+use rand::{Rng, SeedableRng};
+
+use std::collections::HashSet;
+use std::sync::Arc;
+
+#[derive(Debug, Clone, Copy)]
+enum HarnessFault {
+    ReserveWorker,
+    CompleteWorker,
+    WorkerFailure,
+    WorkerCancelled,
+    WorkerSuccess,
+    EventLagged,
+    EventClosed,
+    CortexStart,
+    CortexEnd,
+    RetryAttempt,
+}
+
+#[derive(Debug, Default)]
+struct HarnessState {
+    active_workers: HashSet<crate::WorkerId>,
+    max_workers: usize,
+    worker_false_success: bool,
+    lagged_event_kept_running: bool,
+    closed_event_causes_stop: bool,
+    cortex_inflight: usize,
+    retry_attempts: usize,
+}
+
+impl HarnessState {
+    fn new(max_workers: usize) -> Self {
+        Self {
+            max_workers,
+            lagged_event_kept_running: true,
+            closed_event_causes_stop: true,
+            ..Self::default()
+        }
+    }
+
+    fn assert_invariants(&self) {
+        assert!(
+            self.active_workers.len() <= self.max_workers,
+            "active workers exceeded cap"
+        );
+        assert!(
+            !self.worker_false_success,
+            "worker failure was misclassified as success"
+        );
+        assert!(
+            self.lagged_event_kept_running,
+            "channel loop should continue after lagged event receiver errors"
+        );
+        assert!(
+            self.closed_event_causes_stop,
+            "channel loop should stop after closed event receiver"
+        );
+        assert!(
+            self.cortex_inflight <= 1,
+            "cortex single-flight lock invariant violated"
+        );
+        assert!(self.retry_attempts <= 4, "channel retry budget exceeded");
+    }
+
+    fn apply(&mut self, fault: HarnessFault, rng: &mut StdRng) {
+        match fault {
+            HarnessFault::ReserveWorker => {
+                let worker_id = uuid::Uuid::new_v4();
+                let channel_id: Arc<str> = Arc::from("channel");
+                match reserve_worker_slot_local(
+                    self.active_workers.len(),
+                    &channel_id,
+                    self.max_workers,
+                ) {
+                    Ok(()) => {
+                        self.active_workers.insert(worker_id);
+                    }
+                    Err(crate::error::AgentError::WorkerLimitReached { .. }) => {
+                        // Expected when at limit.
+                    }
+                    Err(error) => panic!("unexpected reserve error: {error}"),
+                }
+            }
+            HarnessFault::CompleteWorker => {
+                if !self.active_workers.is_empty() {
+                    let index = rng.random_range(0..self.active_workers.len());
+                    if let Some(worker_id) = self.active_workers.iter().nth(index).copied() {
+                        self.active_workers.remove(&worker_id);
+                    }
+                }
+            }
+            HarnessFault::WorkerFailure => {
+                let (_text, _notify, success) = map_worker_completion_result(Err(
+                    WorkerCompletionError::failed("worker failed"),
+                ));
+                if success {
+                    self.worker_false_success = true;
+                }
+            }
+            HarnessFault::WorkerCancelled => {
+                let (text, _notify, success) =
+                    map_worker_completion_result(Err(WorkerCompletionError::Cancelled {
+                        reason: "user requested".to_string(),
+                    }));
+                if success || !text.starts_with("Worker cancelled:") {
+                    self.worker_false_success = true;
+                }
+            }
+            HarnessFault::WorkerSuccess => {
+                let (_text, _notify, success) = map_worker_completion_result(Ok("ok".to_string()));
+                if !success {
+                    self.worker_false_success = true;
+                }
+            }
+            HarnessFault::EventLagged => {
+                self.lagged_event_kept_running &= matches!(
+                    crate::classify_broadcast_recv_result::<()>(Err(
+                        tokio::sync::broadcast::error::RecvError::Lagged(1),
+                    )),
+                    crate::BroadcastRecvResult::Lagged(_)
+                );
+            }
+            HarnessFault::EventClosed => {
+                self.closed_event_causes_stop &= matches!(
+                    crate::classify_broadcast_recv_result::<()>(Err(
+                        tokio::sync::broadcast::error::RecvError::Closed,
+                    )),
+                    crate::BroadcastRecvResult::Closed
+                );
+            }
+            HarnessFault::CortexStart => {
+                self.cortex_inflight += 1;
+            }
+            HarnessFault::CortexEnd => {
+                self.cortex_inflight = self.cortex_inflight.saturating_sub(1);
+            }
+            HarnessFault::RetryAttempt => {
+                self.retry_attempts += 1;
+            }
+        }
+
+        self.assert_invariants();
+    }
+}
+
+#[test]
+fn deterministic_worker_limit_invariant() {
+    let mut rng = StdRng::seed_from_u64(7);
+    let mut state = HarnessState::new(2);
+    state.apply(HarnessFault::ReserveWorker, &mut rng);
+    state.apply(HarnessFault::ReserveWorker, &mut rng);
+    state.apply(HarnessFault::ReserveWorker, &mut rng);
+    state.apply(HarnessFault::CompleteWorker, &mut rng);
+    state.apply(HarnessFault::ReserveWorker, &mut rng);
+}
+
+#[test]
+fn deterministic_failure_classification_invariant() {
+    let mut rng = StdRng::seed_from_u64(13);
+    let mut state = HarnessState::new(1);
+    state.apply(HarnessFault::WorkerFailure, &mut rng);
+    state.apply(HarnessFault::WorkerCancelled, &mut rng);
+    state.apply(HarnessFault::WorkerSuccess, &mut rng);
+}
+
+#[test]
+fn deterministic_event_receiver_invariant() {
+    let mut rng = StdRng::seed_from_u64(19);
+    let mut state = HarnessState::new(1);
+    state.apply(HarnessFault::EventLagged, &mut rng);
+    state.apply(HarnessFault::EventClosed, &mut rng);
+}
+
+#[test]
+fn deterministic_cortex_single_flight_invariant() {
+    let mut rng = StdRng::seed_from_u64(29);
+    let mut state = HarnessState::new(1);
+    state.apply(HarnessFault::CortexStart, &mut rng);
+    state.apply(HarnessFault::CortexEnd, &mut rng);
+    state.apply(HarnessFault::CortexStart, &mut rng);
+}
+
+#[test]
+#[should_panic(expected = "channel retry budget exceeded")]
+fn deterministic_retry_budget_invariant() {
+    let mut rng = StdRng::seed_from_u64(31);
+    let mut state = HarnessState::new(1);
+    state.apply(HarnessFault::RetryAttempt, &mut rng);
+    state.apply(HarnessFault::RetryAttempt, &mut rng);
+    state.apply(HarnessFault::RetryAttempt, &mut rng);
+    state.apply(HarnessFault::RetryAttempt, &mut rng);
+    state.apply(HarnessFault::RetryAttempt, &mut rng);
+}
+
+#[test]
+fn seeded_fault_sequence_preserves_invariants() {
+    let mut rng = StdRng::seed_from_u64(20260301);
+    let mut state = HarnessState::new(3);
+
+    for _ in 0..300 {
+        let fault = match rng.random_range(0..10) {
+            0 => HarnessFault::ReserveWorker,
+            1 => HarnessFault::CompleteWorker,
+            2 => HarnessFault::WorkerFailure,
+            3 => HarnessFault::WorkerCancelled,
+            4 => HarnessFault::WorkerSuccess,
+            5 => HarnessFault::EventLagged,
+            6 => HarnessFault::EventClosed,
+            7 => HarnessFault::CortexStart,
+            8 => HarnessFault::CortexEnd,
+            _ => HarnessFault::RetryAttempt,
+        };
+
+        // Keep random scenario realistic by ending inflight cortex requests immediately.
+        if matches!(fault, HarnessFault::CortexStart) && state.cortex_inflight > 0 {
+            state.apply(HarnessFault::CortexEnd, &mut rng);
+        }
+        if matches!(fault, HarnessFault::RetryAttempt) && state.retry_attempts >= 4 {
+            continue;
+        }
+
+        state.apply(fault, &mut rng);
+    }
+}
diff --git a/src/agent/process_control.rs b/src/agent/process_control.rs
new file mode 100644
index 000000000..6e6c2b5bd
--- /dev/null
+++ b/src/agent/process_control.rs
@@ -0,0 +1,286 @@
+//! Supervision control plane for channel and detached worker cancellation.
+
+use crate::agent::channel::WeakChannelControlHandle;
+use crate::{AgentId, BranchId, ChannelId, WorkerId};
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicU8, Ordering};
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ControlActionResult {
+    Cancelled,
+    NotFound,
+    AlreadyTerminal,
+}
+
+pub const DETACHED_WORKER_LIFECYCLE_ACTIVE: u8 = 0;
+pub const DETACHED_WORKER_LIFECYCLE_COMPLETING: u8 = 1;
+pub const DETACHED_WORKER_LIFECYCLE_KILLING: u8 = 2;
+pub const DETACHED_WORKER_LIFECYCLE_TERMINAL: u8 = 3;
+
+pub struct DetachedWorkerControl {
+    pub worker_id: WorkerId,
+    pub agent_id: AgentId,
+    pub task_number: i64,
+    pub cancel_tx: Mutex<Option<tokio::sync::oneshot::Sender<()>>>,
+    pub lifecycle: Arc<AtomicU8>,
+}
+
+impl DetachedWorkerControl {
+    pub fn new(
+        worker_id: WorkerId,
+        agent_id: AgentId,
+        task_number: i64,
+        cancel_tx: tokio::sync::oneshot::Sender<()>,
+        lifecycle: Arc<AtomicU8>,
+    ) -> Self {
+        Self {
+            worker_id,
+            agent_id,
+            task_number,
+            cancel_tx: Mutex::new(Some(cancel_tx)),
+            lifecycle,
+        }
+    }
+}
+
+pub struct ProcessControlRegistry {
+    channels: tokio::sync::RwLock<HashMap<ChannelId, WeakChannelControlHandle>>,
+    detached_workers: tokio::sync::RwLock<HashMap<WorkerId, DetachedWorkerControl>>,
+}
+
+impl Default for ProcessControlRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ProcessControlRegistry {
+    pub fn new() -> Self {
+        Self {
+            channels: tokio::sync::RwLock::new(HashMap::new()),
+            detached_workers: tokio::sync::RwLock::new(HashMap::new()),
+        }
+    }
+
+    pub async fn register_channel(&self, channel_id: ChannelId, handle: WeakChannelControlHandle) {
+        self.channels.write().await.insert(channel_id, handle);
+    }
+
+    pub async fn unregister_channel(&self, channel_id: &ChannelId) -> bool {
+        self.channels.write().await.remove(channel_id).is_some()
+    }
+
+    pub async fn prune_dead_channels(&self) -> usize {
+        let mut channels = self.channels.write().await;
+        let before = channels.len();
+        channels.retain(|_, handle| handle.upgrade().is_some());
+        before.saturating_sub(channels.len())
+    }
+
+    pub async fn register_detached_worker(&self, control: DetachedWorkerControl) {
+        self.detached_workers
+            .write()
+            .await
+            .insert(control.worker_id, control);
+    }
+
+    pub async fn unregister_detached_worker(&self, worker_id: WorkerId) -> bool {
+        self.detached_workers
+            .write()
+            .await
+            .remove(&worker_id)
+            .is_some()
+    }
+
+    async fn lookup_channel_handle(
+        &self,
+        channel_id: &ChannelId,
+    ) -> std::result::Result<crate::agent::channel::ChannelControlHandle, ControlActionResult> {
+        let mut channels = self.channels.write().await;
+        let Some(weak_handle) = channels.get(channel_id).cloned() else {
+            return Err(ControlActionResult::NotFound);
+        };
+
+        let Some(handle) = weak_handle.upgrade() else {
+            channels.remove(channel_id);
+            return Err(ControlActionResult::NotFound);
+        };
+
+        Ok(handle)
+    }
+
+    pub async fn cancel_channel_worker(
+        &self,
+        channel_id: &ChannelId,
+        worker_id: WorkerId,
+        reason: &str,
+    ) -> ControlActionResult {
+        let handle = match self.lookup_channel_handle(channel_id).await {
+            Ok(handle) => handle,
+            Err(result) => return result,
+        };
+
+        handle.cancel_worker_with_reason(worker_id, reason).await
+    }
+
+    pub async fn cancel_channel_branch(
+        &self,
+        channel_id: &ChannelId,
+        branch_id: BranchId,
+        reason: &str,
+    ) -> ControlActionResult {
+        let handle = match self.lookup_channel_handle(channel_id).await {
+            Ok(handle) => handle,
+            Err(result) => return result,
+        };
+
+        handle.cancel_branch_with_reason(branch_id, reason).await
+    }
+
+    pub async fn cancel_detached_worker(
+        &self,
+        worker_id: WorkerId,
+        reason: &str,
+    ) -> ControlActionResult {
+        let mut workers = self.detached_workers.write().await;
+        let Some(control) = workers.get_mut(&worker_id) else {
+            return ControlActionResult::NotFound;
+        };
+
+        if control
+            .lifecycle
+            .compare_exchange(
+                DETACHED_WORKER_LIFECYCLE_ACTIVE,
+                DETACHED_WORKER_LIFECYCLE_KILLING,
+                Ordering::AcqRel,
+                Ordering::Acquire,
+            )
+            .is_err()
+        {
+            return ControlActionResult::AlreadyTerminal;
+        }
+
+        let mut cancel_tx_guard = control.cancel_tx.lock().unwrap_or_else(|e| e.into_inner());
+        if let Some(cancel_tx) = cancel_tx_guard.take()
+            && cancel_tx.send(()).is_err()
+        {
+            tracing::debug!(
+                worker_id = %worker_id,
+                "detached worker cancel signal receiver already dropped"
+            );
+        }
+
+        tracing::info!(
+            worker_id = %worker_id,
+            task_number = control.task_number,
+            reason,
+            "supervisor sent detached worker cancel signal"
+        );
+
+        ControlActionResult::Cancelled
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        ControlActionResult, DETACHED_WORKER_LIFECYCLE_ACTIVE, DetachedWorkerControl,
+        ProcessControlRegistry,
+    };
+    use std::sync::Arc;
+    use std::sync::atomic::{AtomicU8, Ordering};
+
+    #[tokio::test]
+    async fn register_and_unregister_detached_worker() {
+        let registry = ProcessControlRegistry::new();
+        let worker_id = uuid::Uuid::new_v4();
+        let lifecycle = Arc::new(AtomicU8::new(DETACHED_WORKER_LIFECYCLE_ACTIVE));
+        let (cancel_tx, _cancel_rx) = tokio::sync::oneshot::channel();
+
+        registry
+            .register_detached_worker(DetachedWorkerControl::new(
+                worker_id,
+                Arc::from("agent"),
+                7,
+                cancel_tx,
+                lifecycle,
+            ))
+            .await;
+
+        assert!(registry.unregister_detached_worker(worker_id).await);
+        assert!(!registry.unregister_detached_worker(worker_id).await);
+    }
+
+    #[tokio::test]
+    async fn prune_dead_channels_removes_stale_entries() {
+        let registry = ProcessControlRegistry::new();
+        let channel_id: crate::ChannelId = Arc::from("channel-1");
+        registry
+            .register_channel(
+                channel_id.clone(),
+                crate::agent::channel::WeakChannelControlHandle::dangling(),
+            )
+            .await;
+
+        let pruned = registry.prune_dead_channels().await;
+
+        assert_eq!(pruned, 1);
+        assert!(!registry.unregister_channel(&channel_id).await);
+    }
+
+    #[tokio::test]
+    async fn cancel_missing_entries_is_idempotent_not_found() {
+        let registry = ProcessControlRegistry::new();
+        let channel_id: crate::ChannelId = Arc::from("missing-channel");
+        let worker_id = uuid::Uuid::new_v4();
+        let branch_id = uuid::Uuid::new_v4();
+
+        assert_eq!(
+            registry
+                .cancel_channel_worker(&channel_id, worker_id, "test")
+                .await,
+            ControlActionResult::NotFound
+        );
+        assert_eq!(
+            registry
+                .cancel_channel_branch(&channel_id, branch_id, "test")
+                .await,
+            ControlActionResult::NotFound
+        );
+        assert_eq!(
+            registry.cancel_detached_worker(worker_id, "test").await,
+            ControlActionResult::NotFound
+        );
+    }
+
+    #[tokio::test]
+    async fn cancel_detached_worker_is_single_winner_and_idempotent() {
+        let registry = ProcessControlRegistry::new();
+        let worker_id = uuid::Uuid::new_v4();
+        let lifecycle = Arc::new(AtomicU8::new(DETACHED_WORKER_LIFECYCLE_ACTIVE));
+        let (cancel_tx, mut cancel_rx) = tokio::sync::oneshot::channel();
+
+        registry
+            .register_detached_worker(DetachedWorkerControl::new(
+                worker_id,
+                Arc::from("agent"),
+                42,
+                cancel_tx,
+                lifecycle.clone(),
+            ))
+            .await;
+
+        let first = registry.cancel_detached_worker(worker_id, "timeout").await;
+        assert_eq!(first, ControlActionResult::Cancelled);
+        assert!(cancel_rx.try_recv().is_ok());
+
+        let second = registry.cancel_detached_worker(worker_id, "timeout").await;
+        assert_eq!(second, ControlActionResult::AlreadyTerminal);
+
+        assert_eq!(
+            lifecycle.load(Ordering::Acquire),
+            super::DETACHED_WORKER_LIFECYCLE_KILLING
+        );
+    }
+}
diff --git a/src/agent/status.rs b/src/agent/status.rs
index f410e6e18..ac25d707a 100644
--- a/src/agent/status.rs
+++ b/src/agent/status.rs
@@ -33,6 +33,8 @@ pub struct WorkerStatus {
     pub started_at: DateTime<Utc>,
     pub notify_on_complete: bool,
     pub tool_calls: usize,
+    /// Whether this worker accepts follow-up input via route.
+    pub interactive: bool,
 }
 
 /// Recently completed work item.
@@ -43,6 +45,10 @@ pub struct CompletedItem {
     pub description: String,
     pub completed_at: DateTime<Utc>,
     pub result_summary: String,
+    /// Whether this item's result has been relayed to the user via retrigger.
+    /// Once relayed, the result summary is excluded from the status block to
+    /// prevent the LLM from re-summarising stale results.
+    pub relayed: bool,
 }
 
 /// Status of an active link conversation.
@@ -77,6 +83,11 @@ impl StatusBlock {
                     worker.status.clone_from(status);
                 }
             }
+            ProcessEvent::WorkerIdle { worker_id, .. } => {
+                if let Some(worker) = self.active_workers.iter_mut().find(|w| w.id == *worker_id) {
+                    worker.status = "idle".to_string();
+                }
+            }
             ProcessEvent::WorkerComplete {
                 worker_id,
                 result,
@@ -94,6 +105,7 @@ impl StatusBlock {
                             description: worker.task,
                             completed_at: Utc::now(),
                             result_summary: result.clone(),
+                            relayed: false,
                         });
                     }
                 }
@@ -120,19 +132,42 @@ impl StatusBlock {
                         description: branch.description,
                         completed_at: Utc::now(),
                         result_summary: conclusion.clone(),
+                        relayed: false,
                     });
                 }
-
-                // Keep only last 10 completed items
-                if self.completed_items.len() > 10 {
-                    self.completed_items.remove(0);
-                }
             }
             ProcessEvent::AgentMessageSent { to_agent_id, .. } => {
                 self.track_link_conversation(to_agent_id.as_ref());
             }
             _ => {}
         }
+
+        // Prune completed items: drop relayed items older than 5 minutes,
+        // then cap at 10 to bound status block size.
+        self.prune_completed_items();
+    }
+
+    /// Mark completed items as relayed so the status block stops showing
+    /// their full result summaries. Called after a retrigger turn succeeds.
+    pub fn mark_relayed(&mut self, process_ids: &[String]) {
+        for item in &mut self.completed_items {
+            if process_ids.contains(&item.id) {
+                item.relayed = true;
+            }
+        }
+    }
+
+    /// Remove stale completed items: relayed items older than 5 minutes are
+    /// dropped entirely, then total count is capped at 10.
+    fn prune_completed_items(&mut self) {
+        let cutoff = Utc::now() - chrono::Duration::minutes(5);
+        self.completed_items
+            .retain(|item| !(item.relayed && item.completed_at < cutoff));
+
+        // Hard cap: keep the 10 most recent.
+        while self.completed_items.len() > 10 {
+            self.completed_items.remove(0);
+        }
     }
 
     /// Add a new active branch.
@@ -145,7 +180,13 @@ impl StatusBlock {
     }
 
     /// Add a new active worker.
-    pub fn add_worker(&mut self, id: WorkerId, task: impl Into<String>, notify_on_complete: bool) {
+    pub fn add_worker(
+        &mut self,
+        id: WorkerId,
+        task: impl Into<String>,
+        notify_on_complete: bool,
+        interactive: bool,
+    ) {
         self.active_workers.push(WorkerStatus {
             id,
             task: task.into(),
@@ -153,13 +194,51 @@ impl StatusBlock {
             started_at: Utc::now(),
             notify_on_complete,
             tool_calls: 0,
+            interactive,
         });
     }
 
+    /// Remove an active worker from the status block.
+    pub fn remove_worker(&mut self, worker_id: WorkerId) -> bool {
+        if let Some(position) = self
+            .active_workers
+            .iter()
+            .position(|worker| worker.id == worker_id)
+        {
+            self.active_workers.remove(position);
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Remove an active branch from the status block.
+    pub fn remove_branch(&mut self, branch_id: BranchId) -> bool {
+        if let Some(position) = self
+            .active_branches
+            .iter()
+            .position(|branch| branch.id == branch_id)
+        {
+            self.active_branches.remove(position);
+            true
+        } else {
+            false
+        }
+    }
+
     /// Render the status block as a string for context injection.
     pub fn render(&self) -> String {
+        self.render_with_time_context(None)
+    }
+
+    /// Render the status block with optional current time context.
+    pub fn render_with_time_context(&self, current_time_line: Option<&str>) -> String {
         let mut output = String::new();
 
+        if let Some(current_time_line) = current_time_line {
+            output.push_str(&format!("Current date/time: {current_time_line}\n\n"));
+        }
+
         // Active workers
         if !self.active_workers.is_empty() {
             output.push_str("## Active Workers\n");
@@ -209,10 +288,19 @@ impl StatusBlock {
             output.push('\n');
         }
 
-        // Recently completed
-        if !self.completed_items.is_empty() {
+        // Recently completed — only show items not yet relayed to the user.
+        // Relayed items already appeared in conversation via the retrigger flow;
+        // keeping their full summaries here causes the LLM to re-summarise them.
+        let unrelayed: Vec<_> = self
+            .completed_items
+            .iter()
+            .rev()
+            .filter(|item| !item.relayed)
+            .take(5)
+            .collect();
+        if !unrelayed.is_empty() {
             output.push_str("## Recently Completed\n");
-            for item in self.completed_items.iter().rev().take(5) {
+            for item in &unrelayed {
                 let type_str = match item.item_type {
                     CompletedItemType::Branch => "branch",
                     CompletedItemType::Worker => "worker",
@@ -269,3 +357,28 @@ impl StatusBlock {
             .retain(|l| l.peer_agent != peer_agent);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::StatusBlock;
+    use uuid::Uuid;
+
+    #[test]
+    fn render_with_time_context_renders_current_time_when_empty() {
+        let status = StatusBlock::new();
+        let rendered = status.render_with_time_context(Some("2026-02-26 12:00:00 UTC"));
+        assert!(rendered.contains("Current date/time: 2026-02-26 12:00:00 UTC"));
+    }
+
+    #[test]
+    fn remove_branch_removes_existing_branch() {
+        let mut status = StatusBlock::new();
+        let branch_id = Uuid::new_v4();
+        status.add_branch(branch_id, "work");
+
+        let removed = status.remove_branch(branch_id);
+
+        assert!(removed);
+        assert!(status.active_branches.is_empty());
+    }
+}
diff --git a/src/agent/worker.rs b/src/agent/worker.rs
index 6f941d7f9..5e1d67c9a 100644
--- a/src/agent/worker.rs
+++ b/src/agent/worker.rs
@@ -3,12 +3,12 @@
 use crate::agent::compactor::estimate_history_tokens;
 use crate::config::BrowserConfig;
 use crate::error::Result;
-use crate::hooks::SpacebotHook;
+use crate::hooks::{SpacebotHook, ToolNudgePolicy};
 use crate::llm::SpacebotModel;
 use crate::llm::routing::is_context_overflow_error;
 use crate::{AgentDeps, ChannelId, ProcessId, ProcessType, WorkerId};
 use rig::agent::AgentBuilder;
-use rig::completion::{CompletionModel, Prompt};
+use rig::completion::CompletionModel;
 use std::fmt::Write as _;
 use std::path::PathBuf;
 use tokio::sync::{mpsc, watch};
@@ -65,9 +65,8 @@ pub struct Worker {
 }
 
 impl Worker {
-    /// Create a new fire-and-forget worker.
     #[allow(clippy::too_many_arguments)]
-    pub fn new(
+    fn build(
         channel_id: Option<ChannelId>,
         task: impl Into<String>,
         system_prompt: impl Into<String>,
@@ -76,6 +75,7 @@ impl Worker {
         screenshot_dir: PathBuf,
         brave_search_key: Option<String>,
         logs_dir: PathBuf,
+        input_rx: Option<mpsc::Receiver<String>>,
     ) -> Self {
         let id = Uuid::new_v4();
         let process_id = ProcessId::Worker(id);
@@ -96,7 +96,7 @@ impl Worker {
             deps,
             hook,
             system_prompt: system_prompt.into(),
-            input_rx: None,
+            input_rx,
             browser_config,
             screenshot_dir,
             brave_search_key,
@@ -106,6 +106,31 @@ impl Worker {
         }
     }
 
+    /// Create a new fire-and-forget worker.
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        channel_id: Option<ChannelId>,
+        task: impl Into<String>,
+        system_prompt: impl Into<String>,
+        deps: AgentDeps,
+        browser_config: BrowserConfig,
+        screenshot_dir: PathBuf,
+        brave_search_key: Option<String>,
+        logs_dir: PathBuf,
+    ) -> Self {
+        Self::build(
+            channel_id,
+            task,
+            system_prompt,
+            deps,
+            browser_config,
+            screenshot_dir,
+            brave_search_key,
+            logs_dir,
+            None,
+        )
+    }
+
     /// Create a new interactive worker.
     #[allow(clippy::too_many_arguments)]
     pub fn new_interactive(
@@ -118,34 +143,18 @@ impl Worker {
         brave_search_key: Option<String>,
         logs_dir: PathBuf,
     ) -> (Self, mpsc::Sender<String>) {
-        let id = Uuid::new_v4();
-        let process_id = ProcessId::Worker(id);
-        let hook = SpacebotHook::new(
-            deps.agent_id.clone(),
-            process_id,
-            ProcessType::Worker,
-            channel_id.clone(),
-            deps.event_tx.clone(),
-        );
-        let (status_tx, status_rx) = watch::channel("starting".to_string());
         let (input_tx, input_rx) = mpsc::channel(32);
-
-        let worker = Self {
-            id,
+        let worker = Self::build(
             channel_id,
-            task: task.into(),
-            state: WorkerState::Running,
+            task,
+            system_prompt,
             deps,
-            hook,
-            system_prompt: system_prompt.into(),
-            input_rx: Some(input_rx),
             browser_config,
             screenshot_dir,
             brave_search_key,
             logs_dir,
-            status_tx,
-            status_rx,
-        };
+            Some(input_rx),
+        );
 
         (worker, input_tx)
     }
@@ -197,6 +206,7 @@ impl Worker {
             self.deps.agent_id.clone(),
             self.id,
             self.channel_id.clone(),
+            self.deps.task_store.clone(),
             self.deps.event_tx.clone(),
             self.browser_config.clone(),
             self.screenshot_dir.clone(),
@@ -221,6 +231,7 @@ impl Worker {
 
         // Fresh history for the worker (no channel context)
         let mut history = Vec::new();
+        let mut compacted_history = Vec::new();
 
         // Run the initial task in segments with compaction checkpoints
         let mut prompt = self.task.clone();
@@ -230,10 +241,9 @@ impl Worker {
         let result = loop {
             segments_run += 1;
 
-            match agent
-                .prompt(&prompt)
-                .with_history(&mut history)
-                .with_hook(self.hook.clone())
+            match self
+                .hook
+                .prompt_with_tool_nudge_retry(&agent, &mut history, &prompt)
                 .await
             {
                 Ok(response) => {
@@ -249,29 +259,16 @@ impl Worker {
                             "worker hit max segments, returning partial result"
                         );
                         self.hook.send_status("done (max segments)");
-                        break history
-                            .iter()
-                            .rev()
-                            .find_map(|message| {
-                                if let rig::message::Message::Assistant { content, .. } = message {
-                                    content.iter().find_map(|part| {
-                                        if let rig::message::AssistantContent::Text(text) = part {
-                                            Some(text.text.clone())
-                                        } else {
-                                            None
-                                        }
-                                    })
-                                } else {
-                                    None
-                                }
-                            })
-                            .unwrap_or_else(|| {
+                        break crate::agent::extract_last_assistant_text(&history).unwrap_or_else(
+                            || {
                                 "Worker reached maximum segments without a final response."
                                     .to_string()
-                            });
+                            },
+                        );
                     }
 
-                    self.maybe_compact_history(&mut history).await;
+                    self.maybe_compact_history(&mut compacted_history, &mut history)
+                        .await;
                     prompt = "Continue where you left off. Do not repeat completed work.".into();
                     self.hook
                         .send_status(format!("working (segment {segments_run})"));
@@ -287,8 +284,9 @@ impl Worker {
                     self.state = WorkerState::Failed;
                     self.hook.send_status("cancelled");
                     self.write_failure_log(&history, &format!("cancelled: {reason}"));
+                    self.persist_transcript(&compacted_history, &history);
                     tracing::info!(worker_id = %self.id, %reason, "worker cancelled");
-                    return Ok(format!("Worker cancelled: {reason}"));
+                    return Err(crate::error::AgentError::Cancelled { reason }.into());
                 }
                 Err(error) if is_context_overflow_error(&error.to_string()) => {
                     overflow_retries += 1;
@@ -296,6 +294,7 @@ impl Worker {
                         self.state = WorkerState::Failed;
                         self.hook.send_status("failed");
                         self.write_failure_log(&history, &format!("context overflow after {MAX_OVERFLOW_RETRIES} compaction attempts: {error}"));
+                        self.persist_transcript(&compacted_history, &history);
                         tracing::error!(worker_id = %self.id, %error, "worker context overflow unrecoverable");
                         return Err(crate::error::AgentError::Other(error.into()).into());
                     }
@@ -307,7 +306,8 @@ impl Worker {
                         "context overflow, compacting and retrying"
                     );
                     self.hook.send_status("compacting (overflow recovery)");
-                    self.force_compact_history(&mut history).await;
+                    self.force_compact_history(&mut compacted_history, &mut history)
+                        .await;
                     prompt = "Continue where you left off. Do not repeat completed work. \
                               Your previous attempt exceeded the context limit, so older history \
                               has been compacted."
@@ -317,6 +317,7 @@ impl Worker {
                     self.state = WorkerState::Failed;
                     self.hook.send_status("failed");
                     self.write_failure_log(&history, &error.to_string());
+                    self.persist_transcript(&compacted_history, &history);
                     tracing::error!(worker_id = %self.id, %error, "worker LLM call failed");
                     return Err(crate::error::AgentError::Other(error.into()).into());
                 }
@@ -324,34 +325,42 @@ impl Worker {
         };
 
         // For interactive workers, enter a follow-up loop
+        let mut follow_up_failure: Option<String> = None;
         if let Some(mut input_rx) = self.input_rx.take() {
             self.state = WorkerState::WaitingForInput;
             self.hook.send_status("waiting for input");
+            self.hook.send_worker_idle();
 
             while let Some(follow_up) = input_rx.recv().await {
                 self.state = WorkerState::Running;
                 self.hook.send_status("processing follow-up");
 
                 // Compact before follow-up if needed
-                self.maybe_compact_history(&mut history).await;
+                self.maybe_compact_history(&mut compacted_history, &mut history)
+                    .await;
 
                 let mut follow_up_prompt = follow_up.clone();
                 let mut follow_up_overflow_retries = 0;
-
-                let follow_up_ok = loop {
-                    match agent
-                        .prompt(&follow_up_prompt)
-                        .with_history(&mut history)
-                        .with_hook(self.hook.clone())
+                let follow_up_hook = self
+                    .hook
+                    .clone()
+                    .with_tool_nudge_policy(ToolNudgePolicy::Disabled);
+
+                let follow_up_result: std::result::Result<String, String> = loop {
+                    match follow_up_hook
+                        .prompt_once(&agent, &mut history, &follow_up_prompt)
                         .await
                     {
-                        Ok(_response) => break true,
+                        Ok(response) => break Ok(response),
                         Err(error) if is_context_overflow_error(&error.to_string()) => {
                             follow_up_overflow_retries += 1;
                             if follow_up_overflow_retries > MAX_OVERFLOW_RETRIES {
-                                self.write_failure_log(&history, &format!("follow-up context overflow after {MAX_OVERFLOW_RETRIES} compaction attempts: {error}"));
+                                let failure_reason = format!(
+                                    "follow-up context overflow after {MAX_OVERFLOW_RETRIES} compaction attempts: {error}"
+                                );
+                                self.write_failure_log(&history, &failure_reason);
                                 tracing::error!(worker_id = %self.id, %error, "follow-up context overflow unrecoverable");
-                                break false;
+                                break Err(failure_reason);
                             }
                             tracing::warn!(
                                 worker_id = %self.id,
@@ -360,30 +369,65 @@ impl Worker {
                                 "follow-up context overflow, compacting and retrying"
                             );
                             self.hook.send_status("compacting (overflow recovery)");
-                            self.force_compact_history(&mut history).await;
+                            self.force_compact_history(&mut compacted_history, &mut history)
+                                .await;
                             let prompt_engine = self.deps.runtime_config.prompts.load();
                             let overflow_msg = prompt_engine.render_system_worker_overflow()?;
                             follow_up_prompt = format!("{follow_up}\n\n{overflow_msg}");
                         }
                         Err(error) => {
-                            self.write_failure_log(&history, &format!("follow-up failed: {error}"));
+                            let failure_reason = format!("follow-up failed: {error}");
+                            self.write_failure_log(&history, &failure_reason);
                             tracing::error!(worker_id = %self.id, %error, "worker follow-up failed");
-                            break false;
+                            break Err(failure_reason);
                         }
                     }
                 };
 
-                if follow_up_ok {
-                    self.state = WorkerState::WaitingForInput;
-                    self.hook.send_status("waiting for input");
-                } else {
-                    self.state = WorkerState::Failed;
-                    self.hook.send_status("failed");
-                    break;
+                match follow_up_result {
+                    Ok(response) => {
+                        // Emit follow-up result so the channel can retrigger
+                        // and relay this to the user — same as initial result.
+                        if !response.is_empty() {
+                            let scrubbed = if let Some(store) =
+                                self.deps.runtime_config.secrets.load().as_ref().as_ref()
+                            {
+                                crate::secrets::scrub::scrub_with_store(&response, store)
+                            } else {
+                                response
+                            };
+                            let scrubbed = crate::secrets::scrub::scrub_leaks(&scrubbed);
+                            self.deps
+                                .event_tx
+                                .send(crate::ProcessEvent::WorkerInitialResult {
+                                    agent_id: self.deps.agent_id.clone(),
+                                    worker_id: self.id,
+                                    channel_id: self.channel_id.clone(),
+                                    result: scrubbed,
+                                })
+                                .ok();
+                        }
+                    }
+                    Err(failure_reason) => {
+                        self.state = WorkerState::Failed;
+                        self.hook.send_status("failed");
+                        follow_up_failure = Some(failure_reason);
+                        break;
+                    }
                 }
+
+                self.state = WorkerState::WaitingForInput;
+                self.hook.send_status("waiting for input");
+                self.hook.send_worker_idle();
             }
         }
 
+        if let Some(failure_reason) = follow_up_failure {
+            self.persist_transcript(&compacted_history, &history);
+            tracing::error!(worker_id = %self.id, reason = %failure_reason, "worker failed");
+            return Err(crate::error::AgentError::Other(anyhow::anyhow!(failure_reason)).into());
+        }
+
         self.state = WorkerState::Done;
         self.hook.send_status("completed");
 
@@ -393,6 +437,9 @@ impl Worker {
             self.write_success_log(&history);
         }
 
+        // Persist transcript blob (fire-and-forget)
+        self.persist_transcript(&compacted_history, &history);
+
         tracing::info!(worker_id = %self.id, "worker completed");
         Ok(result)
     }
@@ -402,7 +449,11 @@ impl Worker {
     /// Workers don't have a full Compactor instance — they do inline compaction
     /// by summarizing older tool calls and results into a condensed recap.
     /// No LLM call, just programmatic truncation with a summary marker.
-    async fn maybe_compact_history(&self, history: &mut Vec<rig::message::Message>) {
+    async fn maybe_compact_history(
+        &self,
+        compacted_history: &mut Vec<rig::message::Message>,
+        history: &mut Vec<rig::message::Message>,
+    ) {
         let context_window = **self.deps.runtime_config.context_window.load();
         let estimated = estimate_history_tokens(history);
         let usage = estimated as f32 / context_window as f32;
@@ -411,7 +462,7 @@ impl Worker {
             return;
         }
 
-        self.compact_history(history, 0.50, "worker history compacted")
+        self.compact_history(compacted_history, history, 0.50, "worker history compacted")
             .await;
     }
 
@@ -420,8 +471,13 @@ impl Worker {
     /// Unlike `maybe_compact_history`, this always fires regardless of current
     /// usage and removes 75% of messages. Used when the provider has already
     /// rejected the request for exceeding context limits.
-    async fn force_compact_history(&self, history: &mut Vec<rig::message::Message>) {
+    async fn force_compact_history(
+        &self,
+        compacted_history: &mut Vec<rig::message::Message>,
+        history: &mut Vec<rig::message::Message>,
+    ) {
         self.compact_history(
+            compacted_history,
             history,
             0.75,
             "worker history force-compacted (overflow recovery)",
@@ -432,6 +488,7 @@ impl Worker {
     /// Compact worker history by removing a fraction of the oldest messages.
     async fn compact_history(
         &self,
+        compacted_history: &mut Vec<rig::message::Message>,
         history: &mut Vec<rig::message::Message>,
         fraction: f32,
         log_message: &str,
@@ -449,6 +506,7 @@ impl Worker {
             .max(1)
             .min(total.saturating_sub(2));
         let removed: Vec<rig::message::Message> = history.drain(..remove_count).collect();
+        compacted_history.extend(removed.iter().cloned());
 
         let recap = build_worker_recap(&removed);
         let prompt_engine = self.deps.runtime_config.prompts.load();
@@ -470,6 +528,47 @@ impl Worker {
         );
     }
 
+    /// Persist the compressed transcript blob to worker_runs. Fire-and-forget.
+    fn persist_transcript(
+        &self,
+        compacted_history: &[rig::message::Message],
+        history: &[rig::message::Message],
+    ) {
+        let mut full_history = compacted_history.to_vec();
+        full_history.extend(history.iter().cloned());
+        let transcript_blob =
+            crate::conversation::worker_transcript::serialize_transcript(&full_history);
+        let pool = self.deps.sqlite_pool.clone();
+        let worker_id = self.id.to_string();
+
+        // Count tool calls from the Rig history (each ToolCall in an Assistant message)
+        let tool_calls: i64 = full_history
+            .iter()
+            .filter_map(|message| match message {
+                rig::message::Message::Assistant { content, .. } => Some(
+                    content
+                        .iter()
+                        .filter(|c| matches!(c, rig::message::AssistantContent::ToolCall(_)))
+                        .count() as i64,
+                ),
+                _ => None,
+            })
+            .sum();
+
+        tokio::spawn(async move {
+            if let Err(error) =
+                sqlx::query("UPDATE worker_runs SET transcript = ?, tool_calls = ? WHERE id = ?")
+                    .bind(&transcript_blob)
+                    .bind(tool_calls)
+                    .bind(&worker_id)
+                    .execute(&pool)
+                    .await
+            {
+                tracing::warn!(%error, worker_id, "failed to persist worker transcript");
+            }
+        });
+    }
+
     /// Check if worker is in a terminal state.
     pub fn is_done(&self) -> bool {
         matches!(self.state, WorkerState::Done | WorkerState::Failed)
@@ -672,7 +771,8 @@ fn build_worker_recap(messages: &[rig::message::Message]) -> String {
             rig::message::Message::Assistant { content, .. } => {
                 for item in content.iter() {
                     if let rig::message::AssistantContent::ToolCall(tc) = item {
-                        let args = tc.function.arguments.to_string();
+                        let args =
+                            crate::tools::truncate_output(&tc.function.arguments.to_string(), 200);
                         recap.push_str(&format!("- Called `{}` ({args})\n", tc.function.name));
                     }
                     if let rig::message::AssistantContent::Text(t) = item
@@ -687,7 +787,8 @@ fn build_worker_recap(messages: &[rig::message::Message]) -> String {
                     if let rig::message::UserContent::ToolResult(tr) = item {
                         for c in tr.content.iter() {
                             if let rig::message::ToolResultContent::Text(t) = c {
-                                recap.push_str(&format!("  Result: {}\n", t.text));
+                                let truncated = crate::tools::truncate_output(&t.text, 200);
+                                recap.push_str(&format!("  Result: {truncated}\n"));
                             }
                         }
                     }
@@ -702,26 +803,3 @@ fn build_worker_recap(messages: &[rig::message::Message]) -> String {
         recap
     }
 }
-
-/// Extract the last assistant text message from a history.
-#[allow(dead_code)]
-fn extract_last_assistant_text(history: &[rig::message::Message]) -> Option<String> {
-    for message in history.iter().rev() {
-        if let rig::message::Message::Assistant { content, .. } = message {
-            let texts: Vec<String> = content
-                .iter()
-                .filter_map(|c| {
-                    if let rig::message::AssistantContent::Text(t) = c {
-                        Some(t.text.clone())
-                    } else {
-                        None
-                    }
-                })
-                .collect();
-            if !texts.is_empty() {
-                return Some(texts.join("\n"));
-            }
-        }
-    }
-    None
-}
diff --git a/src/api.rs b/src/api.rs
index e8a13c91a..9e6121cff 100644
--- a/src/api.rs
+++ b/src/api.rs
@@ -16,13 +16,18 @@ mod mcp;
 mod memories;
 mod messaging;
 mod models;
+mod opencode_proxy;
 mod providers;
+mod secrets;
 mod server;
 mod settings;
 mod skills;
 mod state;
 mod system;
+mod tasks;
+mod tools;
 mod webchat;
+mod workers;
 
 pub use server::start_http_server;
 pub use state::{AgentInfo, ApiEvent, ApiState};
diff --git a/src/api/agents.rs b/src/api/agents.rs
index c139c4ffe..2fe72ddf0 100644
--- a/src/api/agents.rs
+++ b/src/api/agents.rs
@@ -361,6 +361,7 @@ pub(super) async fn trigger_warmup(
     let mcp_managers = state.mcp_managers.load();
     let pools = state.agent_pools.load();
     let sandboxes = state.sandboxes.load();
+    let task_stores = state.task_stores.load();
 
     let runtime_config_ids = runtime_configs.keys().cloned().collect::<HashSet<_>>();
     let memory_search_ids = memory_searches.keys().cloned().collect::<HashSet<_>>();
@@ -391,12 +392,18 @@ pub(super) async fn trigger_warmup(
         let Some(sandbox) = sandboxes.get(agent_id).cloned() else {
             continue;
         };
+        let task_store = task_stores
+            .get(agent_id)
+            .cloned()
+            .unwrap_or_else(|| Arc::new(crate::tasks::TaskStore::new(sqlite_pool.clone())));
 
         let llm_manager = llm_manager.clone();
         let force = request.force;
         let agent_id = agent_id.clone();
+        let task_store_registry = state.task_store_registry.clone();
+        let injection_tx = state.injection_tx.clone();
         tokio::spawn(async move {
-            let (event_tx, _event_rx) = tokio::sync::broadcast::channel(16);
+            let (event_tx, memory_event_tx) = crate::create_process_event_buses();
             let deps = crate::AgentDeps {
                 agent_id: Arc::from(agent_id.as_str()),
                 memory_search,
@@ -405,11 +412,18 @@ pub(super) async fn trigger_warmup(
                 cron_tool: None,
                 runtime_config,
                 event_tx,
+                memory_event_tx,
                 sqlite_pool: sqlite_pool.clone(),
                 messaging_manager: None,
                 sandbox,
+                task_store,
                 links: Arc::new(arc_swap::ArcSwap::from_pointee(Vec::new())),
                 agent_names: Arc::new(std::collections::HashMap::new()),
+                task_store_registry,
+                process_control_registry: Arc::new(
+                    crate::agent::process_control::ProcessControlRegistry::new(),
+                ),
+                injection_tx,
             };
             let logger = CortexLogger::new(sqlite_pool);
             crate::agent::cortex::run_warmup_once(&deps, &logger, "api_trigger", force).await;
@@ -502,11 +516,36 @@ pub(super) async fn create_agent(
             StatusCode::INTERNAL_SERVER_ERROR
         })?;
 
-    let defaults = state.defaults_config.read().await;
-    let defaults = defaults.as_ref().ok_or_else(|| {
-        tracing::error!("defaults config not available");
-        StatusCode::INTERNAL_SERVER_ERROR
-    })?;
+    // Read defaults directly from the config we just wrote to disk rather than
+    // relying on the cached `defaults_config` which may be stale (e.g. if a
+    // provider was configured but the in-memory cache wasn't refreshed yet).
+    let disk_defaults = match crate::config::Config::load_from_path(&config_path) {
+        Ok(fresh_config) => {
+            // Also update the in-memory cache so subsequent operations
+            // (e.g. creating another agent) don't hit stale defaults.
+            state
+                .set_defaults_config(fresh_config.defaults.clone())
+                .await;
+            Some(fresh_config.defaults)
+        }
+        Err(error) => {
+            tracing::warn!(
+                %error,
+                "failed to reload config.toml for defaults; falling back to cached defaults"
+            );
+            None
+        }
+    };
+    let cached_defaults;
+    let defaults = if let Some(ref d) = disk_defaults {
+        d
+    } else {
+        cached_defaults = state.defaults_config.read().await;
+        cached_defaults.as_ref().ok_or_else(|| {
+            tracing::error!("defaults config not available");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?
+    };
 
     let raw_config = crate::config::AgentConfig {
         id: agent_id.clone(),
@@ -527,14 +566,15 @@ pub(super) async fn create_agent(
         cortex: None,
         warmup: None,
         browser: None,
+        channel: None,
         mcp: None,
         brave_search_key: None,
         cron_timezone: None,
+        user_timezone: None,
         sandbox: None,
         cron: Vec::new(),
     };
     let agent_config = raw_config.resolve(&instance_dir, defaults);
-    let _ = defaults;
 
     for dir in [
         &agent_config.workspace,
@@ -592,8 +632,9 @@ pub(super) async fn create_agent(
         embedding_table,
         embedding_model,
     ));
+    let task_store = std::sync::Arc::new(crate::tasks::TaskStore::new(db.sqlite.clone()));
 
-    let (event_tx, _) = tokio::sync::broadcast::channel(256);
+    let (event_tx, memory_event_tx) = crate::create_process_event_buses();
     let arc_agent_id: crate::AgentId = std::sync::Arc::from(agent_id.as_str());
 
     crate::identity::scaffold_identity_files(&agent_config.workspace)
@@ -619,7 +660,9 @@ pub(super) async fn create_agent(
             .clone()
     };
 
-    let defaults_for_runtime = {
+    let defaults_for_runtime = if let Some(d) = disk_defaults {
+        d
+    } else {
         let guard = state.defaults_config.read().await;
         guard
             .as_ref()
@@ -638,7 +681,8 @@ pub(super) async fn create_agent(
         identity,
         skills,
     ));
-    runtime_config.set_settings(settings_store.clone());
+    let explicit_listen_only = raw_config.channel.map(|channel| channel.listen_only_mode);
+    runtime_config.set_settings(settings_store.clone(), explicit_listen_only);
 
     let llm_manager = {
         let guard = state.llm_manager.read().await;
@@ -656,7 +700,7 @@ pub(super) async fn create_agent(
 
     let sandbox = std::sync::Arc::new(
         crate::sandbox::Sandbox::new(
-            &agent_config.sandbox,
+            runtime_config.sandbox.clone(),
             agent_config.workspace.clone(),
             &instance_dir,
             agent_config.data_dir.clone(),
@@ -669,9 +713,11 @@ pub(super) async fn create_agent(
         memory_search: memory_search.clone(),
         llm_manager,
         mcp_manager: mcp_manager.clone(),
+        task_store: task_store.clone(),
         cron_tool: None,
         runtime_config: runtime_config.clone(),
         event_tx: event_tx.clone(),
+        memory_event_tx: memory_event_tx.clone(),
         sqlite_pool: db.sqlite.clone(),
         messaging_manager: {
             let guard = state.messaging_manager.read().await;
@@ -681,6 +727,11 @@ pub(super) async fn create_agent(
         links: Arc::new(arc_swap::ArcSwap::from_pointee(
             (**state.agent_links.load()).clone(),
         )),
+        task_store_registry: state.task_store_registry.clone(),
+        process_control_registry: Arc::new(
+            crate::agent::process_control::ProcessControlRegistry::new(),
+        ),
+        injection_tx: state.injection_tx.clone(),
         agent_names: {
             let configs = state.agent_configs.load();
             let mut names: std::collections::HashMap<String, String> = configs
@@ -730,16 +781,21 @@ pub(super) async fn create_agent(
     let conversation_logger =
         crate::conversation::history::ConversationLogger::new(db.sqlite.clone());
     let channel_store = crate::conversation::ChannelStore::new(db.sqlite.clone());
-
+    let run_logger = crate::conversation::ProcessRunLogger::new(db.sqlite.clone());
     let cortex_tool_server = crate::tools::create_cortex_chat_tool_server(
+        deps.agent_id.clone(),
+        deps.task_store.clone(),
         memory_search.clone(),
+        deps.memory_event_tx.clone(),
         conversation_logger,
         channel_store,
+        run_logger,
         browser_config,
         agent_config.screenshot_dir(),
         brave_search_key,
         runtime_config.workspace_dir.clone(),
         sandbox.clone(),
+        runtime_config.clone(),
     );
     let cortex_store = crate::agent::cortex_chat::CortexChatStore::new(db.sqlite.clone());
     let cortex_session = crate::agent::cortex_chat::CortexChatSession::new(
@@ -750,10 +806,13 @@ pub(super) async fn create_agent(
 
     let cortex_logger = crate::agent::cortex::CortexLogger::new(db.sqlite.clone());
     let _warmup_loop = crate::agent::cortex::spawn_warmup_loop(deps.clone(), cortex_logger.clone());
-    let _bulletin_loop =
-        crate::agent::cortex::spawn_bulletin_loop(deps.clone(), cortex_logger.clone());
+    let _cortex_loop = crate::agent::cortex::spawn_cortex_loop(deps.clone(), cortex_logger.clone());
     let _association_loop =
         crate::agent::cortex::spawn_association_loop(deps.clone(), cortex_logger);
+    crate::agent::cortex::spawn_ready_task_loop(
+        deps.clone(),
+        crate::agent::cortex::CortexLogger::new(db.sqlite.clone()),
+    );
 
     let ingestion_config = **runtime_config.ingestion.load();
     if ingestion_config.enabled {
@@ -782,6 +841,16 @@ pub(super) async fn create_agent(
         searches.insert(agent_id.clone(), memory_search);
         state.memory_searches.store(std::sync::Arc::new(searches));
 
+        let mut task_stores = (**state.task_stores.load()).clone();
+        task_stores.insert(agent_id.clone(), task_store.clone());
+        state.task_stores.store(std::sync::Arc::new(task_stores));
+
+        let mut registry = (**state.task_store_registry.load()).clone();
+        registry.insert(agent_id.clone(), task_store);
+        state
+            .task_store_registry
+            .store(std::sync::Arc::new(registry));
+
         let mut workspaces = (**state.agent_workspaces.load()).clone();
         workspaces.insert(agent_id.clone(), agent_config.workspace.clone());
         state
@@ -1432,10 +1501,16 @@ mod tests {
         let (agent_tx, _agent_rx) = tokio::sync::mpsc::channel(1);
         let (agent_remove_tx, _agent_remove_rx) = tokio::sync::mpsc::channel(1);
 
+        let (injection_tx, _injection_rx) = tokio::sync::mpsc::channel(1);
+        let task_store_registry = Arc::new(arc_swap::ArcSwap::from_pointee(
+            std::collections::HashMap::new(),
+        ));
         Arc::new(ApiState::new_with_provider_sender(
             provider_setup_tx,
             agent_tx,
             agent_remove_tx,
+            injection_tx,
+            task_store_registry,
         ))
     }
 
diff --git a/src/api/bindings.rs b/src/api/bindings.rs
index eeb118a24..42446bdaf 100644
--- a/src/api/bindings.rs
+++ b/src/api/bindings.rs
@@ -10,6 +10,7 @@ use std::sync::Arc;
 pub(super) struct BindingResponse {
     agent_id: String,
     channel: String,
+    adapter: Option<String>,
     guild_id: Option<String>,
     workspace_id: Option<String>,
     chat_id: Option<String>,
@@ -34,6 +35,8 @@ pub(super) struct CreateBindingRequest {
     agent_id: String,
     channel: String,
     #[serde(default)]
+    adapter: Option<String>,
+    #[serde(default)]
     guild_id: Option<String>,
     #[serde(default)]
     workspace_id: Option<String>,
@@ -61,6 +64,26 @@ pub(super) struct PlatformCredentials {
     #[serde(default)]
     telegram_token: Option<String>,
     #[serde(default)]
+    email_imap_host: Option<String>,
+    #[serde(default)]
+    email_imap_port: Option<u16>,
+    #[serde(default)]
+    email_imap_username: Option<String>,
+    #[serde(default)]
+    email_imap_password: Option<String>,
+    #[serde(default)]
+    email_smtp_host: Option<String>,
+    #[serde(default)]
+    email_smtp_port: Option<u16>,
+    #[serde(default)]
+    email_smtp_username: Option<String>,
+    #[serde(default)]
+    email_smtp_password: Option<String>,
+    #[serde(default)]
+    email_from_address: Option<String>,
+    #[serde(default)]
+    email_from_name: Option<String>,
+    #[serde(default)]
     twitch_username: Option<String>,
     #[serde(default)]
     twitch_oauth_token: Option<String>,
@@ -85,6 +108,8 @@ pub(super) struct DeleteBindingRequest {
     agent_id: String,
     channel: String,
     #[serde(default)]
+    adapter: Option<String>,
+    #[serde(default)]
     guild_id: Option<String>,
     #[serde(default)]
     workspace_id: Option<String>,
@@ -103,6 +128,8 @@ pub(super) struct UpdateBindingRequest {
     original_agent_id: String,
     original_channel: String,
     #[serde(default)]
+    original_adapter: Option<String>,
+    #[serde(default)]
     original_guild_id: Option<String>,
     #[serde(default)]
     original_workspace_id: Option<String>,
@@ -112,6 +139,8 @@ pub(super) struct UpdateBindingRequest {
     agent_id: String,
     channel: String,
     #[serde(default)]
+    adapter: Option<String>,
+    #[serde(default)]
     guild_id: Option<String>,
     #[serde(default)]
     workspace_id: Option<String>,
@@ -152,6 +181,7 @@ pub(super) async fn list_bindings(
         .map(|b| BindingResponse {
             agent_id: b.agent_id,
             channel: b.channel,
+            adapter: b.adapter,
             guild_id: b.guild_id,
             workspace_id: b.workspace_id,
             chat_id: b.chat_id,
@@ -193,6 +223,7 @@ pub(super) async fn create_binding(
     let mut new_discord_token: Option<String> = None;
     let mut new_slack_tokens: Option<(String, String)> = None;
     let mut new_telegram_token: Option<String> = None;
+    let mut new_email_configured = false;
     let mut new_twitch_creds: Option<(String, String)> = None;
 
     if let Some(credentials) = &request.platform_credentials {
@@ -255,6 +286,91 @@ pub(super) async fn create_binding(
             telegram["token"] = toml_edit::value(token.as_str());
             new_telegram_token = Some(token.clone());
         }
+
+        let email_imap_host = credentials
+            .email_imap_host
+            .as_deref()
+            .unwrap_or("")
+            .trim()
+            .to_string();
+        let email_imap_username = credentials
+            .email_imap_username
+            .as_deref()
+            .unwrap_or("")
+            .trim()
+            .to_string();
+        let email_imap_password = credentials
+            .email_imap_password
+            .as_deref()
+            .unwrap_or("")
+            .to_string();
+        let email_smtp_host = credentials
+            .email_smtp_host
+            .as_deref()
+            .unwrap_or("")
+            .trim()
+            .to_string();
+        let email_smtp_username = credentials
+            .email_smtp_username
+            .as_deref()
+            .unwrap_or("")
+            .trim()
+            .to_string();
+        let email_smtp_password = credentials
+            .email_smtp_password
+            .as_deref()
+            .unwrap_or("")
+            .to_string();
+        let email_from_address = credentials
+            .email_from_address
+            .as_deref()
+            .unwrap_or("")
+            .trim()
+            .to_string();
+
+        if !email_imap_host.is_empty()
+            && !email_imap_username.is_empty()
+            && !email_imap_password.is_empty()
+            && !email_smtp_host.is_empty()
+            && !email_smtp_username.is_empty()
+            && !email_smtp_password.is_empty()
+            && !email_from_address.is_empty()
+        {
+            if doc.get("messaging").is_none() {
+                doc["messaging"] = toml_edit::Item::Table(toml_edit::Table::new());
+            }
+            let messaging = doc["messaging"]
+                .as_table_mut()
+                .ok_or(StatusCode::INTERNAL_SERVER_ERROR)?;
+            if !messaging.contains_key("email") {
+                messaging["email"] = toml_edit::Item::Table(toml_edit::Table::new());
+            }
+            let email = messaging["email"]
+                .as_table_mut()
+                .ok_or(StatusCode::INTERNAL_SERVER_ERROR)?;
+            email["enabled"] = toml_edit::value(true);
+            email["imap_host"] = toml_edit::value(email_imap_host);
+            email["imap_port"] =
+                toml_edit::value(i64::from(credentials.email_imap_port.unwrap_or(993)));
+            email["imap_username"] = toml_edit::value(email_imap_username);
+            email["imap_password"] = toml_edit::value(email_imap_password);
+            email["smtp_host"] = toml_edit::value(email_smtp_host);
+            email["smtp_port"] =
+                toml_edit::value(i64::from(credentials.email_smtp_port.unwrap_or(587)));
+            email["smtp_username"] = toml_edit::value(email_smtp_username);
+            email["smtp_password"] = toml_edit::value(email_smtp_password);
+            email["from_address"] = toml_edit::value(email_from_address);
+
+            if let Some(from_name) = &credentials.email_from_name {
+                let from_name = from_name.trim();
+                if !from_name.is_empty() {
+                    email["from_name"] = toml_edit::value(from_name);
+                }
+            }
+
+            new_email_configured = true;
+        }
+
         if let Some(username) = &credentials.twitch_username {
             let oauth_token = credentials.twitch_oauth_token.as_deref().unwrap_or("");
             let client_id = credentials.twitch_client_id.as_deref().unwrap_or("");
@@ -300,6 +416,14 @@ pub(super) async fn create_binding(
     let mut binding_table = toml_edit::Table::new();
     binding_table["agent_id"] = toml_edit::value(&request.agent_id);
     binding_table["channel"] = toml_edit::value(&request.channel);
+    if let Some(adapter) = request
+        .adapter
+        .as_deref()
+        .map(str::trim)
+        .filter(|s| !s.is_empty())
+    {
+        binding_table["adapter"] = toml_edit::value(adapter);
+    }
     if let Some(guild_id) = &request.guild_id {
         binding_table["guild_id"] = toml_edit::value(guild_id.as_str());
     }
@@ -394,7 +518,11 @@ pub(super) async fn create_binding(
                         }
                     }
                 };
-                let adapter = crate::messaging::discord::DiscordAdapter::new(&token, discord_perms);
+                let adapter = crate::messaging::discord::DiscordAdapter::new(
+                    "discord",
+                    &token,
+                    discord_perms,
+                );
                 if let Err(error) = manager.register_and_start(adapter).await {
                     tracing::error!(%error, "failed to hot-start discord adapter");
                 }
@@ -431,6 +559,7 @@ pub(super) async fn create_binding(
                     .map(|s| s.commands.clone())
                     .unwrap_or_default();
                 match crate::messaging::slack::SlackAdapter::new(
+                    "slack",
                     &bot_token,
                     &app_token,
                     slack_perms,
@@ -459,13 +588,34 @@ pub(super) async fn create_binding(
                     );
                     std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(perms))
                 };
-                let adapter =
-                    crate::messaging::telegram::TelegramAdapter::new(&token, telegram_perms);
+                let adapter = crate::messaging::telegram::TelegramAdapter::new(
+                    "telegram",
+                    &token,
+                    telegram_perms,
+                );
                 if let Err(error) = manager.register_and_start(adapter).await {
                     tracing::error!(%error, "failed to hot-start telegram adapter");
                 }
             }
 
+            if new_email_configured {
+                let Some(email_config) = new_config.messaging.email.as_ref() else {
+                    tracing::error!("email config missing despite credentials being provided");
+                    return Err(StatusCode::INTERNAL_SERVER_ERROR);
+                };
+
+                match crate::messaging::email::EmailAdapter::from_config(email_config) {
+                    Ok(adapter) => {
+                        if let Err(error) = manager.register_and_start(adapter).await {
+                            tracing::error!(%error, "failed to hot-start email adapter");
+                        }
+                    }
+                    Err(error) => {
+                        tracing::error!(%error, "failed to build email adapter");
+                    }
+                }
+            }
+
             if let Some((username, oauth_token)) = new_twitch_creds {
                 let Some(twitch_config) = new_config.messaging.twitch.as_ref() else {
                     tracing::error!("twitch config missing despite credentials being provided");
@@ -481,6 +631,7 @@ pub(super) async fn create_binding(
                 let instance_dir = state.instance_dir.load();
                 let token_path = instance_dir.join("twitch_token.json");
                 let adapter = crate::messaging::twitch::TwitchAdapter::new(
+                    "twitch",
                     &username,
                     &oauth_token,
                     twitch_config.client_id.clone(),
@@ -541,6 +692,13 @@ pub(super) async fn update_binding(
             .get("channel")
             .and_then(|v| v.as_str())
             .is_some_and(|v| v == request.original_channel);
+        let matches_adapter = match &request.original_adapter {
+            Some(adapter) => table
+                .get("adapter")
+                .and_then(|v| v.as_str())
+                .is_some_and(|v| v == adapter),
+            None => table.get("adapter").is_none(),
+        };
         let matches_guild = match &request.original_guild_id {
             Some(gid) => table
                 .get("guild_id")
@@ -562,7 +720,13 @@ pub(super) async fn update_binding(
                 .is_some_and(|v| v == cid),
             None => table.get("chat_id").is_none(),
         };
-        if matches_agent && matches_channel && matches_guild && matches_workspace && matches_chat {
+        if matches_agent
+            && matches_channel
+            && matches_adapter
+            && matches_guild
+            && matches_workspace
+            && matches_chat
+        {
             match_idx = Some(i);
             break;
         }
@@ -582,10 +746,20 @@ pub(super) async fn update_binding(
     binding["agent_id"] = toml_edit::value(&request.agent_id);
     binding["channel"] = toml_edit::value(&request.channel);
 
+    binding.remove("adapter");
     binding.remove("guild_id");
     binding.remove("workspace_id");
     binding.remove("chat_id");
 
+    if let Some(adapter) = request
+        .adapter
+        .as_deref()
+        .map(str::trim)
+        .filter(|s| !s.is_empty())
+    {
+        binding["adapter"] = toml_edit::value(adapter);
+    }
+
     if let Some(ref guild_id) = request.guild_id
         && !guild_id.is_empty()
     {
@@ -712,6 +886,13 @@ pub(super) async fn delete_binding(
             .get("channel")
             .and_then(|v: &toml_edit::Item| v.as_str())
             .is_some_and(|v| v == request.channel);
+        let matches_adapter = match &request.adapter {
+            Some(adapter) => table
+                .get("adapter")
+                .and_then(|v: &toml_edit::Item| v.as_str())
+                .is_some_and(|v| v == adapter),
+            None => table.get("adapter").is_none(),
+        };
         let matches_guild = match &request.guild_id {
             Some(gid) => table
                 .get("guild_id")
@@ -733,7 +914,13 @@ pub(super) async fn delete_binding(
                 .is_some_and(|v| v == cid),
             None => table.get("chat_id").is_none(),
         };
-        if matches_agent && matches_channel && matches_guild && matches_workspace && matches_chat {
+        if matches_agent
+            && matches_channel
+            && matches_adapter
+            && matches_guild
+            && matches_workspace
+            && matches_chat
+        {
             match_idx = Some(i);
             break;
         }
diff --git a/src/api/channels.rs b/src/api/channels.rs
index 857c41674..1fa5c094c 100644
--- a/src/api/channels.rs
+++ b/src/api/channels.rs
@@ -26,6 +26,37 @@ pub(super) struct ChannelsResponse {
     channels: Vec<ChannelResponse>,
 }
 
+#[derive(Deserialize, Default)]
+pub(super) struct ListChannelsQuery {
+    #[serde(default)]
+    include_inactive: bool,
+    agent_id: Option<String>,
+    is_active: Option<bool>,
+}
+
+type AgentChannel = (String, crate::conversation::channels::ChannelInfo);
+
+fn resolve_is_active_filter(query: &ListChannelsQuery) -> Option<bool> {
+    query.is_active.or(if query.include_inactive {
+        None
+    } else {
+        Some(true)
+    })
+}
+
+fn sort_channels_newest_first(channels: &mut [AgentChannel]) {
+    channels.sort_by(
+        |(left_agent_id, left_channel), (right_agent_id, right_channel)| {
+            right_channel
+                .last_activity_at
+                .cmp(&left_channel.last_activity_at)
+                .then_with(|| right_channel.created_at.cmp(&left_channel.created_at))
+                .then_with(|| left_agent_id.cmp(right_agent_id))
+                .then_with(|| left_channel.id.cmp(&right_channel.id))
+        },
+    );
+}
+
 #[derive(Serialize)]
 pub(super) struct MessagesResponse {
     items: Vec<crate::conversation::history::TimelineItem>,
@@ -57,25 +88,24 @@ pub(super) struct CancelProcessResponse {
     message: String,
 }
 
-/// List active channels across all agents.
-pub(super) async fn list_channels(State(state): State<Arc<ApiState>>) -> Json<ChannelsResponse> {
+/// List channels across agents, with optional activity and agent filters.
+pub(super) async fn list_channels(
+    State(state): State<Arc<ApiState>>,
+    Query(query): Query<ListChannelsQuery>,
+) -> Json<ChannelsResponse> {
     let pools = state.agent_pools.load();
-    let mut all_channels = Vec::new();
+    let mut collected_channels: Vec<AgentChannel> = Vec::new();
+    let is_active_filter = resolve_is_active_filter(&query);
 
     for (agent_id, pool) in pools.iter() {
+        if query.agent_id.as_deref().is_some_and(|id| id != agent_id) {
+            continue;
+        }
         let store = ChannelStore::new(pool.clone());
-        match store.list_active().await {
+        match store.list(is_active_filter).await {
             Ok(channels) => {
                 for channel in channels {
-                    all_channels.push(ChannelResponse {
-                        agent_id: agent_id.clone(),
-                        id: channel.id,
-                        platform: channel.platform,
-                        display_name: channel.display_name,
-                        is_active: channel.is_active,
-                        last_activity_at: channel.last_activity_at.to_rfc3339(),
-                        created_at: channel.created_at.to_rfc3339(),
-                    });
+                    collected_channels.push((agent_id.clone(), channel));
                 }
             }
             Err(error) => {
@@ -84,6 +114,21 @@ pub(super) async fn list_channels(State(state): State<Arc<ApiState>>) -> Json<Ch
         }
     }
 
+    sort_channels_newest_first(&mut collected_channels);
+
+    let all_channels = collected_channels
+        .into_iter()
+        .map(|(agent_id, channel)| ChannelResponse {
+            agent_id,
+            id: channel.id,
+            platform: channel.platform,
+            display_name: channel.display_name,
+            is_active: channel.is_active,
+            last_activity_at: channel.last_activity_at.to_rfc3339(),
+            created_at: channel.created_at.to_rfc3339(),
+        })
+        .collect();
+
     Json(ChannelsResponse {
         channels: all_channels,
     })
@@ -154,6 +199,13 @@ pub(super) struct DeleteChannelQuery {
     channel_id: String,
 }
 
+#[derive(Deserialize)]
+pub(super) struct SetChannelArchiveRequest {
+    agent_id: String,
+    channel_id: String,
+    archived: bool,
+}
+
 /// Delete a channel and its message history.
 pub(super) async fn delete_channel(
     State(state): State<Arc<ApiState>>,
@@ -181,38 +233,139 @@ pub(super) async fn delete_channel(
     Ok(Json(serde_json::json!({ "success": true })))
 }
 
+/// Archive or unarchive a channel without deleting its history.
+pub(super) async fn set_channel_archive(
+    State(state): State<Arc<ApiState>>,
+    Json(request): Json<SetChannelArchiveRequest>,
+) -> Result<Json<serde_json::Value>, StatusCode> {
+    let pools = state.agent_pools.load();
+    let pool = pools.get(&request.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+    let store = ChannelStore::new(pool.clone());
+
+    let is_active = !request.archived;
+    let updated = store
+        .set_active(&request.channel_id, is_active)
+        .await
+        .map_err(|error| {
+            tracing::error!(%error, "failed to update channel active state");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    if !updated {
+        return Err(StatusCode::NOT_FOUND);
+    }
+
+    tracing::info!(
+        agent_id = %request.agent_id,
+        channel_id = %request.channel_id,
+        archived = request.archived,
+        "channel archive state updated via API"
+    );
+
+    Ok(Json(archive_update_response_payload(request.archived)))
+}
+
+fn archive_update_response_payload(archived: bool) -> serde_json::Value {
+    serde_json::json!({
+        "success": true,
+        "archived": archived,
+        "is_active": !archived,
+    })
+}
+
 /// Cancel a running worker or branch via the API.
 pub(super) async fn cancel_process(
     State(state): State<Arc<ApiState>>,
     Json(request): Json<CancelProcessRequest>,
 ) -> Result<Json<CancelProcessResponse>, StatusCode> {
-    let states = state.channel_states.read().await;
-    let channel_state = states
-        .get(&request.channel_id)
-        .ok_or(StatusCode::NOT_FOUND)?;
-
     match request.process_type.as_str() {
         "worker" => {
             let worker_id: crate::WorkerId = request
                 .process_id
                 .parse()
                 .map_err(|_| StatusCode::BAD_REQUEST)?;
-            channel_state
-                .cancel_worker(worker_id)
-                .await
-                .map_err(|_| StatusCode::NOT_FOUND)?;
-            Ok(Json(CancelProcessResponse {
-                success: true,
-                message: format!("Worker {} cancelled", request.process_id),
-            }))
+
+            let channel_state = {
+                let states = state.channel_states.read().await;
+                states.get(&request.channel_id).cloned()
+            };
+
+            if let Some(channel_state) = channel_state {
+                match channel_state
+                    .cancel_worker_with_reason(worker_id, "cancelled via API")
+                    .await
+                {
+                    Ok(()) => {
+                        return Ok(Json(CancelProcessResponse {
+                            success: true,
+                            message: format!("Worker {} cancelled", request.process_id),
+                        }));
+                    }
+                    Err(error) => {
+                        let not_found = error.to_ascii_lowercase().contains("not found");
+                        if not_found {
+                            tracing::debug!(
+                                channel_id = %request.channel_id,
+                                worker_id = %worker_id,
+                                %error,
+                                "worker not found in active channel state; attempting detached fallback"
+                            );
+                        } else {
+                            tracing::warn!(
+                                channel_id = %request.channel_id,
+                                worker_id = %worker_id,
+                                %error,
+                                "failed to cancel worker in channel state"
+                            );
+                            return Err(StatusCode::INTERNAL_SERVER_ERROR);
+                        }
+                    }
+                }
+            }
+
+            // Fallback for detached workers (for example after restart): no live
+            // channel state exists, but the DB row is still marked running.
+            let pools = state.agent_pools.load();
+            for (_agent_id, pool) in pools.iter() {
+                let logger = ProcessRunLogger::new(pool.clone());
+                match logger.cancel_running_detached_worker(worker_id).await {
+                    Ok(true) => {
+                        return Ok(Json(CancelProcessResponse {
+                            success: true,
+                            message: format!(
+                                "Worker {} cancelled (detached run reconciled)",
+                                request.process_id
+                            ),
+                        }));
+                    }
+                    Ok(false) => {}
+                    Err(error) => {
+                        tracing::warn!(
+                            %error,
+                            channel_id = %request.channel_id,
+                            process_id = %request.process_id,
+                            "failed to cancel detached worker run"
+                        );
+                        return Err(StatusCode::INTERNAL_SERVER_ERROR);
+                    }
+                }
+            }
+
+            Err(StatusCode::NOT_FOUND)
         }
         "branch" => {
+            let channel_state = {
+                let states = state.channel_states.read().await;
+                states.get(&request.channel_id).cloned()
+            }
+            .ok_or(StatusCode::NOT_FOUND)?;
+
             let branch_id: crate::BranchId = request
                 .process_id
                 .parse()
                 .map_err(|_| StatusCode::BAD_REQUEST)?;
             channel_state
-                .cancel_branch(branch_id)
+                .cancel_branch_with_reason(branch_id, "cancelled via API")
                 .await
                 .map_err(|_| StatusCode::NOT_FOUND)?;
             Ok(Json(CancelProcessResponse {
@@ -223,3 +376,100 @@ pub(super) async fn cancel_process(
         _ => Err(StatusCode::BAD_REQUEST),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn resolve_is_active_filter_defaults_to_active_only() {
+        let query = ListChannelsQuery {
+            include_inactive: false,
+            agent_id: None,
+            is_active: None,
+        };
+
+        assert_eq!(resolve_is_active_filter(&query), Some(true));
+    }
+
+    #[test]
+    fn resolve_is_active_filter_allows_explicit_include_inactive() {
+        let query = ListChannelsQuery {
+            include_inactive: true,
+            agent_id: None,
+            is_active: None,
+        };
+
+        assert_eq!(resolve_is_active_filter(&query), None);
+    }
+
+    #[test]
+    fn resolve_is_active_filter_prefers_explicit_state_filter() {
+        let query = ListChannelsQuery {
+            include_inactive: true,
+            agent_id: None,
+            is_active: Some(false),
+        };
+
+        assert_eq!(resolve_is_active_filter(&query), Some(false));
+    }
+
+    #[test]
+    fn archive_update_response_payload_contains_archived_and_is_active() {
+        let payload = archive_update_response_payload(true);
+
+        assert_eq!(payload["success"], serde_json::Value::Bool(true));
+        assert_eq!(payload["archived"], serde_json::Value::Bool(true));
+        assert_eq!(payload["is_active"], serde_json::Value::Bool(false));
+    }
+
+    #[test]
+    fn sort_channels_newest_first_by_last_activity_then_created_at() {
+        fn make_channel(
+            id: &str,
+            last_activity_at: &str,
+            created_at: &str,
+        ) -> crate::conversation::channels::ChannelInfo {
+            let last_activity_at = chrono::DateTime::parse_from_rfc3339(last_activity_at)
+                .expect("timestamp should parse")
+                .with_timezone(&chrono::Utc);
+            let created_at = chrono::DateTime::parse_from_rfc3339(created_at)
+                .expect("timestamp should parse")
+                .with_timezone(&chrono::Utc);
+
+            crate::conversation::channels::ChannelInfo {
+                id: id.to_string(),
+                platform: "portal".to_string(),
+                display_name: None,
+                platform_meta: None,
+                is_active: true,
+                created_at,
+                last_activity_at,
+            }
+        }
+
+        let mut channels = vec![
+            (
+                "agent-a".to_string(),
+                make_channel("a", "2026-03-02T10:00:00Z", "2026-03-02T08:00:00Z"),
+            ),
+            (
+                "agent-b".to_string(),
+                make_channel("b", "2026-03-02T12:00:00Z", "2026-03-02T07:00:00Z"),
+            ),
+            (
+                "agent-c".to_string(),
+                make_channel("c", "2026-03-02T10:00:00Z", "2026-03-02T09:00:00Z"),
+            ),
+        ];
+
+        sort_channels_newest_first(&mut channels);
+
+        let ids: Vec<_> = channels
+            .into_iter()
+            .map(|(agent_id, channel)| format!("{agent_id}:{}", channel.id))
+            .collect();
+
+        assert_eq!(ids, vec!["agent-b:b", "agent-c:c", "agent-a:a"]);
+    }
+}
diff --git a/src/api/config.rs b/src/api/config.rs
index f4546d605..a32ead344 100644
--- a/src/api/config.rs
+++ b/src/api/config.rs
@@ -1,4 +1,5 @@
 use super::state::ApiState;
+use crate::config::ClosePolicy;
 
 use axum::Json;
 use axum::extract::{Query, State};
@@ -39,6 +40,8 @@ pub(super) struct CortexSection {
     tick_interval_secs: u64,
     worker_timeout_secs: u64,
     branch_timeout_secs: u64,
+    detached_worker_timeout_retry_limit: u8,
+    supervisor_kill_budget_per_tick: usize,
     circuit_breaker_threshold: u8,
     bulletin_interval_secs: u64,
     bulletin_max_words: usize,
@@ -73,6 +76,20 @@ pub(super) struct BrowserSection {
     enabled: bool,
     headless: bool,
     evaluate_enabled: bool,
+    persist_session: bool,
+    close_policy: String,
+}
+
+#[derive(Serialize, Debug)]
+pub(super) struct ChannelSection {
+    listen_only_mode: bool,
+}
+
+#[derive(Serialize, Debug)]
+pub(super) struct SandboxSection {
+    mode: String,
+    writable_paths: Vec<String>,
+    passthrough_env: Vec<String>,
 }
 
 #[derive(Serialize, Debug)]
@@ -91,6 +108,8 @@ pub(super) struct AgentConfigResponse {
     coalesce: CoalesceSection,
     memory_persistence: MemoryPersistenceSection,
     browser: BrowserSection,
+    channel: ChannelSection,
+    sandbox: SandboxSection,
     discord: DiscordSection,
 }
 
@@ -119,6 +138,10 @@ pub(super) struct AgentConfigUpdateRequest {
     #[serde(default)]
     browser: Option<BrowserUpdate>,
     #[serde(default)]
+    channel: Option<ChannelUpdate>,
+    #[serde(default)]
+    sandbox: Option<SandboxUpdate>,
+    #[serde(default)]
     discord: Option<DiscordUpdate>,
 }
 
@@ -155,6 +178,8 @@ pub(super) struct CortexUpdate {
     tick_interval_secs: Option<u64>,
     worker_timeout_secs: Option<u64>,
     branch_timeout_secs: Option<u64>,
+    detached_worker_timeout_retry_limit: Option<u8>,
+    supervisor_kill_budget_per_tick: Option<usize>,
     circuit_breaker_threshold: Option<u8>,
     bulletin_interval_secs: Option<u64>,
     bulletin_max_words: Option<usize>,
@@ -189,6 +214,20 @@ pub(super) struct BrowserUpdate {
     enabled: Option<bool>,
     headless: Option<bool>,
     evaluate_enabled: Option<bool>,
+    persist_session: Option<bool>,
+    close_policy: Option<ClosePolicy>,
+}
+
+#[derive(Deserialize, Debug)]
+pub(super) struct ChannelUpdate {
+    listen_only_mode: Option<bool>,
+}
+
+#[derive(Deserialize, Debug)]
+pub(super) struct SandboxUpdate {
+    mode: Option<String>,
+    writable_paths: Option<Vec<String>>,
+    passthrough_env: Option<Vec<String>>,
 }
 
 #[derive(Deserialize, Debug)]
@@ -214,6 +253,8 @@ pub(super) async fn get_agent_config(
     let coalesce = rc.coalesce.load();
     let memory_persistence = rc.memory_persistence.load();
     let browser = rc.browser_config.load();
+    let channel = rc.channel_config.load();
+    let sandbox = rc.sandbox.load();
 
     let response = AgentConfigResponse {
         routing: RoutingSection {
@@ -242,6 +283,8 @@ pub(super) async fn get_agent_config(
             tick_interval_secs: cortex.tick_interval_secs,
             worker_timeout_secs: cortex.worker_timeout_secs,
             branch_timeout_secs: cortex.branch_timeout_secs,
+            detached_worker_timeout_retry_limit: cortex.detached_worker_timeout_retry_limit,
+            supervisor_kill_budget_per_tick: cortex.supervisor_kill_budget_per_tick,
             circuit_breaker_threshold: cortex.circuit_breaker_threshold,
             bulletin_interval_secs: cortex.bulletin_interval_secs,
             bulletin_max_words: cortex.bulletin_max_words,
@@ -268,6 +311,23 @@ pub(super) async fn get_agent_config(
             enabled: browser.enabled,
             headless: browser.headless,
             evaluate_enabled: browser.evaluate_enabled,
+            persist_session: browser.persist_session,
+            close_policy: browser.close_policy.as_str().to_string(),
+        },
+        channel: ChannelSection {
+            listen_only_mode: channel.listen_only_mode,
+        },
+        sandbox: SandboxSection {
+            mode: match sandbox.mode {
+                crate::sandbox::SandboxMode::Enabled => "enabled".to_string(),
+                crate::sandbox::SandboxMode::Disabled => "disabled".to_string(),
+            },
+            writable_paths: sandbox
+                .writable_paths
+                .iter()
+                .map(|p| p.display().to_string())
+                .collect(),
+            passthrough_env: sandbox.passthrough_env.clone(),
         },
         discord: {
             let perms = state.discord_permissions.read().await;
@@ -342,6 +402,12 @@ pub(super) async fn update_agent_config(
     if let Some(browser) = &request.browser {
         update_browser_table(&mut doc, agent_idx, browser)?;
     }
+    if let Some(channel) = &request.channel {
+        update_channel_table(&mut doc, agent_idx, channel)?;
+    }
+    if let Some(sandbox) = &request.sandbox {
+        update_sandbox_table(&mut doc, agent_idx, sandbox)?;
+    }
     if let Some(discord) = &request.discord {
         update_discord_table(&mut doc, discord)?;
     }
@@ -357,6 +423,10 @@ pub(super) async fn update_agent_config(
 
     match crate::config::Config::load_from_path(&config_path) {
         Ok(new_config) => {
+            // Keep in-memory defaults fresh so newly created agents inherit
+            // the latest routing values.
+            state.set_defaults_config(new_config.defaults.clone()).await;
+
             let runtime_configs = state.runtime_configs.load();
             let mcp_managers = state.mcp_managers.load();
             if let (Some(rc), Some(mcp_manager)) = (
@@ -539,6 +609,13 @@ fn update_cortex_table(
     if let Some(v) = cortex.branch_timeout_secs {
         table["branch_timeout_secs"] = toml_edit::value(v as i64);
     }
+    if let Some(v) = cortex.detached_worker_timeout_retry_limit {
+        table["detached_worker_timeout_retry_limit"] = toml_edit::value(v as i64);
+    }
+    if let Some(v) = cortex.supervisor_kill_budget_per_tick {
+        table["supervisor_kill_budget_per_tick"] =
+            toml_edit::value(i64::try_from(v).map_err(|_| StatusCode::BAD_REQUEST)?);
+    }
     if let Some(v) = cortex.circuit_breaker_threshold {
         table["circuit_breaker_threshold"] = toml_edit::value(v as i64);
     }
@@ -635,6 +712,52 @@ fn update_browser_table(
     if let Some(v) = browser.evaluate_enabled {
         table["evaluate_enabled"] = toml_edit::value(v);
     }
+    if let Some(v) = browser.persist_session {
+        table["persist_session"] = toml_edit::value(v);
+    }
+    if let Some(v) = browser.close_policy {
+        table["close_policy"] = toml_edit::value(v.as_str());
+    }
+    Ok(())
+}
+
+fn update_channel_table(
+    doc: &mut toml_edit::DocumentMut,
+    agent_idx: usize,
+    channel: &ChannelUpdate,
+) -> Result<(), StatusCode> {
+    let agent = get_agent_table_mut(doc, agent_idx)?;
+    let table = get_or_create_subtable(agent, "channel")?;
+    if let Some(v) = channel.listen_only_mode {
+        table["listen_only_mode"] = toml_edit::value(v);
+    }
+    Ok(())
+}
+
+fn update_sandbox_table(
+    doc: &mut toml_edit::DocumentMut,
+    agent_idx: usize,
+    sandbox: &SandboxUpdate,
+) -> Result<(), StatusCode> {
+    let agent = get_agent_table_mut(doc, agent_idx)?;
+    let table = get_or_create_subtable(agent, "sandbox")?;
+    if let Some(ref mode) = sandbox.mode {
+        table["mode"] = toml_edit::value(mode.as_str());
+    }
+    if let Some(ref paths) = sandbox.writable_paths {
+        let mut array = toml_edit::Array::new();
+        for path in paths {
+            array.push(path.as_str());
+        }
+        table["writable_paths"] = toml_edit::value(array);
+    }
+    if let Some(ref env_vars) = sandbox.passthrough_env {
+        let mut array = toml_edit::Array::new();
+        for var_name in env_vars {
+            array.push(var_name.as_str());
+        }
+        table["passthrough_env"] = toml_edit::value(array);
+    }
     Ok(())
 }
 
@@ -757,4 +880,82 @@ id = "main"
         let result = update_warmup_table(&mut doc, agent_idx, &update);
         assert_eq!(result, Err(StatusCode::BAD_REQUEST));
     }
+
+    #[test]
+    fn test_update_channel_table_writes_listen_only_mode() {
+        let mut doc: toml_edit::DocumentMut = r#"
+[[agents]]
+id = "main"
+"#
+        .parse()
+        .expect("failed to parse test TOML");
+
+        let agent_idx =
+            find_or_create_agent_table(&mut doc, "main").expect("failed to find/create agent");
+
+        let enable_update = ChannelUpdate {
+            listen_only_mode: Some(true),
+        };
+        update_channel_table(&mut doc, agent_idx, &enable_update)
+            .expect("failed to update channel table with true");
+
+        let agent = doc
+            .get("agents")
+            .and_then(|item| item.as_array_of_tables())
+            .and_then(|agents| agents.get(agent_idx))
+            .expect("missing agent table");
+        let channel = agent
+            .get("channel")
+            .and_then(|item| item.as_table())
+            .expect("missing channel table");
+        assert_eq!(channel["listen_only_mode"].as_bool(), Some(true));
+
+        let disable_update = ChannelUpdate {
+            listen_only_mode: Some(false),
+        };
+        update_channel_table(&mut doc, agent_idx, &disable_update)
+            .expect("failed to update channel table with false");
+
+        let agent = doc
+            .get("agents")
+            .and_then(|item| item.as_array_of_tables())
+            .and_then(|agents| agents.get(agent_idx))
+            .expect("missing agent table");
+        let channel = agent
+            .get("channel")
+            .and_then(|item| item.as_table())
+            .expect("missing channel table");
+        assert_eq!(channel["listen_only_mode"].as_bool(), Some(false));
+    }
+
+    #[test]
+    fn test_update_cortex_table_rejects_large_usize_value() {
+        let mut doc: toml_edit::DocumentMut = r#"
+[[agents]]
+id = "main"
+"#
+        .parse()
+        .expect("failed to parse test TOML");
+
+        let agent_idx =
+            find_or_create_agent_table(&mut doc, "main").expect("failed to find/create agent");
+        let update = CortexUpdate {
+            tick_interval_secs: None,
+            worker_timeout_secs: None,
+            branch_timeout_secs: None,
+            detached_worker_timeout_retry_limit: None,
+            supervisor_kill_budget_per_tick: Some(usize::MAX),
+            circuit_breaker_threshold: None,
+            bulletin_interval_secs: None,
+            bulletin_max_words: None,
+            bulletin_max_turns: None,
+        };
+
+        let result = update_cortex_table(&mut doc, agent_idx, &update);
+        if (usize::MAX as u128) > (i64::MAX as u128) {
+            assert_eq!(result, Err(StatusCode::BAD_REQUEST));
+        } else {
+            assert!(result.is_ok());
+        }
+    }
 }
diff --git a/src/api/cortex.rs b/src/api/cortex.rs
index 16de7c4b1..1ae192a37 100644
--- a/src/api/cortex.rs
+++ b/src/api/cortex.rs
@@ -1,7 +1,9 @@
 use super::state::ApiState;
 
 use crate::agent::cortex::{CortexEvent, CortexLogger};
-use crate::agent::cortex_chat::{CortexChatEvent, CortexChatMessage, CortexChatStore};
+use crate::agent::cortex_chat::{
+    CortexChatEvent, CortexChatMessage, CortexChatSendError, CortexChatStore,
+};
 
 use axum::Json;
 use axum::extract::{Query, State};
@@ -60,6 +62,13 @@ fn default_cortex_events_limit() -> i64 {
     50
 }
 
+fn map_cortex_chat_send_error(error: &CortexChatSendError) -> StatusCode {
+    match error {
+        CortexChatSendError::Busy => StatusCode::CONFLICT,
+        _ => StatusCode::INTERNAL_SERVER_ERROR,
+    }
+}
+
 /// Load persisted cortex chat history for a thread.
 /// If no thread_id is provided, loads the latest thread.
 /// If no threads exist, returns an empty list with a fresh thread_id.
@@ -122,8 +131,11 @@ pub(super) async fn cortex_chat_send(
         .send_message_with_events(&thread_id, &message, channel_ref)
         .await
         .map_err(|error| {
-            tracing::warn!(%error, "failed to start cortex chat send");
-            StatusCode::INTERNAL_SERVER_ERROR
+            let status = map_cortex_chat_send_error(&error);
+            if status == StatusCode::INTERNAL_SERVER_ERROR {
+                tracing::warn!(%error, "failed to start cortex chat send");
+            }
+            status
         })?;
 
     let stream = async_stream::stream! {
@@ -177,3 +189,26 @@ pub(super) async fn cortex_events(
 
     Ok(Json(CortexEventsResponse { events, total }))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::map_cortex_chat_send_error;
+    use crate::agent::cortex_chat::CortexChatSendError;
+    use axum::http::StatusCode;
+
+    #[test]
+    fn maps_busy_send_error_to_conflict() {
+        assert_eq!(
+            map_cortex_chat_send_error(&CortexChatSendError::Busy),
+            StatusCode::CONFLICT
+        );
+    }
+
+    #[test]
+    fn maps_database_send_error_to_internal_server_error() {
+        assert_eq!(
+            map_cortex_chat_send_error(&CortexChatSendError::Database(sqlx::Error::RowNotFound)),
+            StatusCode::INTERNAL_SERVER_ERROR
+        );
+    }
+}
diff --git a/src/api/cron.rs b/src/api/cron.rs
index 8a10890ec..a0b3c3309 100644
--- a/src/api/cron.rs
+++ b/src/api/cron.rs
@@ -4,6 +4,7 @@ use axum::Json;
 use axum::extract::{Query, State};
 use axum::http::StatusCode;
 use serde::{Deserialize, Serialize};
+use std::str::FromStr;
 use std::sync::Arc;
 
 #[derive(Deserialize)]
@@ -29,6 +30,8 @@ pub(super) struct CreateCronRequest {
     agent_id: String,
     id: String,
     prompt: String,
+    #[serde(default)]
+    cron_expr: Option<String>,
     #[serde(default = "default_interval")]
     interval_secs: u64,
     delivery_target: String,
@@ -75,6 +78,7 @@ pub(super) struct ToggleCronRequest {
 struct CronJobWithStats {
     id: String,
     prompt: String,
+    cron_expr: Option<String>,
     interval_secs: u64,
     delivery_target: String,
     enabled: bool,
@@ -130,6 +134,7 @@ pub(super) async fn list_cron_jobs(
         jobs.push(CronJobWithStats {
             id: config.id,
             prompt: config.prompt,
+            cron_expr: config.cron_expr,
             interval_secs: config.interval_secs,
             delivery_target: config.delivery_target,
             enabled: config.enabled,
@@ -177,18 +182,133 @@ pub(super) async fn cron_executions(
     Ok(Json(CronExecutionsResponse { executions }))
 }
 
+const MIN_CRON_INTERVAL_SECS: u64 = 60;
+const MAX_CRON_PROMPT_LENGTH: usize = 10_000;
+
+fn validate_cron_request(request: &CreateCronRequest) -> Result<(), (StatusCode, String)> {
+    if request.id.is_empty()
+        || request.id.len() > 50
+        || !request
+            .id
+            .chars()
+            .all(|c| c.is_alphanumeric() || c == '-' || c == '_')
+    {
+        return Err((
+            StatusCode::BAD_REQUEST,
+            "id must be 1-50 alphanumeric/hyphen/underscore characters".into(),
+        ));
+    }
+
+    let cron_expr = request
+        .cron_expr
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty());
+
+    if cron_expr.is_none() && request.interval_secs < MIN_CRON_INTERVAL_SECS {
+        return Err((
+            StatusCode::BAD_REQUEST,
+            format!(
+                "interval_secs must be at least {MIN_CRON_INTERVAL_SECS} (got {})",
+                request.interval_secs
+            ),
+        ));
+    }
+
+    if let Some(expr) = cron_expr {
+        let field_count = expr.split_whitespace().count();
+        if field_count != 5 {
+            return Err((
+                StatusCode::BAD_REQUEST,
+                format!("cron_expr must have exactly 5 fields (got {field_count}): '{expr}'"),
+            ));
+        }
+        cron::Schedule::from_str(expr).map_err(|error| {
+            (
+                StatusCode::BAD_REQUEST,
+                format!("invalid cron_expr '{expr}': {error}"),
+            )
+        })?;
+    }
+
+    if request.prompt.len() > MAX_CRON_PROMPT_LENGTH {
+        return Err((
+            StatusCode::BAD_REQUEST,
+            format!(
+                "prompt exceeds maximum length of {MAX_CRON_PROMPT_LENGTH} characters (got {})",
+                request.prompt.len()
+            ),
+        ));
+    }
+
+    if !request.delivery_target.contains(':') {
+        return Err((
+            StatusCode::BAD_REQUEST,
+            "delivery_target must be in 'adapter:target' format".into(),
+        ));
+    }
+
+    if let Some(start) = request.active_start_hour
+        && start > 23
+    {
+        return Err((
+            StatusCode::BAD_REQUEST,
+            "active_start_hour must be 0-23".into(),
+        ));
+    }
+    if let Some(end) = request.active_end_hour
+        && end > 23
+    {
+        return Err((
+            StatusCode::BAD_REQUEST,
+            "active_end_hour must be 0-23".into(),
+        ));
+    }
+
+    Ok(())
+}
+
 /// Create or update a cron job.
 pub(super) async fn create_or_update_cron(
     State(state): State<Arc<ApiState>>,
     Json(request): Json<CreateCronRequest>,
-) -> Result<Json<CronActionResponse>, StatusCode> {
+) -> Result<Json<CronActionResponse>, (StatusCode, Json<CronActionResponse>)> {
+    if let Err((status, message)) = validate_cron_request(&request) {
+        tracing::warn!(agent_id = %request.agent_id, cron_id = %request.id, %message, "cron validation failed");
+        return Err((
+            status,
+            Json(CronActionResponse {
+                success: false,
+                message,
+            }),
+        ));
+    }
+
     let stores = state.cron_stores.load();
     let schedulers = state.cron_schedulers.load();
 
-    let store = stores.get(&request.agent_id).ok_or(StatusCode::NOT_FOUND)?;
-    let scheduler = schedulers
-        .get(&request.agent_id)
-        .ok_or(StatusCode::NOT_FOUND)?;
+    let cron_err = |status: StatusCode, message: String| {
+        (
+            status,
+            Json(CronActionResponse {
+                success: false,
+                message,
+            }),
+        )
+    };
+
+    let store = stores.get(&request.agent_id).ok_or_else(|| {
+        cron_err(
+            StatusCode::NOT_FOUND,
+            format!("agent '{}' not found", request.agent_id),
+        )
+    })?;
+    let scheduler = schedulers.get(&request.agent_id).ok_or_else(|| {
+        cron_err(
+            StatusCode::NOT_FOUND,
+            format!("agent '{}' not found", request.agent_id),
+        )
+    })?;
 
     let active_hours = match (request.active_start_hour, request.active_end_hour) {
         (Some(start), Some(end)) => Some((start, end)),
@@ -198,6 +318,12 @@ pub(super) async fn create_or_update_cron(
     let config = crate::cron::CronConfig {
         id: request.id.clone(),
         prompt: request.prompt,
+        cron_expr: request
+            .cron_expr
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .map(ToString::to_string),
         interval_secs: request.interval_secs,
         delivery_target: request.delivery_target,
         active_hours,
@@ -208,12 +334,12 @@ pub(super) async fn create_or_update_cron(
 
     store.save(&config).await.map_err(|error| {
         tracing::warn!(%error, agent_id = %request.agent_id, cron_id = %request.id, "failed to save cron job");
-        StatusCode::INTERNAL_SERVER_ERROR
+        cron_err(StatusCode::INTERNAL_SERVER_ERROR, format!("failed to save: {error}"))
     })?;
 
     scheduler.register(config).await.map_err(|error| {
         tracing::warn!(%error, agent_id = %request.agent_id, cron_id = %request.id, "failed to register cron job");
-        StatusCode::INTERNAL_SERVER_ERROR
+        cron_err(StatusCode::INTERNAL_SERVER_ERROR, format!("failed to register: {error}"))
     })?;
 
     Ok(Json(CronActionResponse {
diff --git a/src/api/mcp.rs b/src/api/mcp.rs
index 1166182ae..f3291b0b4 100644
--- a/src/api/mcp.rs
+++ b/src/api/mcp.rs
@@ -12,8 +12,6 @@ use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::Arc;
 
-// ── Request / Response types ────────────────────────────────────────────
-
 #[derive(Deserialize)]
 pub(super) struct CreateMcpServerRequest {
     pub name: String,
@@ -54,8 +52,6 @@ pub(super) struct MutationResponse {
     pub message: String,
 }
 
-// ── Handlers ────────────────────────────────────────────────────────────
-
 /// GET /api/mcp/servers — list all configured MCP servers from config.toml.
 pub(super) async fn list_mcp_servers(
     State(state): State<Arc<ApiState>>,
@@ -407,8 +403,6 @@ pub(super) async fn reconnect_mcp_server(
     }))
 }
 
-// ── Helpers ─────────────────────────────────────────────────────────────
-
 /// Look up live connection state for a server name across all agents.
 async fn get_server_state(state: &ApiState, server_name: &str) -> String {
     let managers = state.mcp_managers.load();
diff --git a/src/api/messaging.rs b/src/api/messaging.rs
index d0dd973aa..692dea009 100644
--- a/src/api/messaging.rs
+++ b/src/api/messaging.rs
@@ -12,33 +12,181 @@ pub(super) struct PlatformStatus {
     enabled: bool,
 }
 
+#[derive(Serialize, Clone)]
+pub(super) struct AdapterInstanceStatus {
+    platform: String,
+    /// `None` means the default instance for the platform.
+    name: Option<String>,
+    runtime_key: String,
+    configured: bool,
+    enabled: bool,
+    binding_count: usize,
+}
+
 #[derive(Serialize)]
 pub(super) struct MessagingStatusResponse {
     discord: PlatformStatus,
     slack: PlatformStatus,
     telegram: PlatformStatus,
+    email: PlatformStatus,
     webhook: PlatformStatus,
     twitch: PlatformStatus,
+    instances: Vec<AdapterInstanceStatus>,
 }
 
 #[derive(Deserialize)]
 pub(super) struct DisconnectPlatformRequest {
     platform: String,
+    #[serde(default)]
+    adapter: Option<String>,
 }
 
 #[derive(Deserialize)]
 pub(super) struct TogglePlatformRequest {
     platform: String,
+    #[serde(default)]
+    adapter: Option<String>,
     enabled: bool,
 }
 
+#[derive(Deserialize, Default)]
+pub(super) struct InstanceCredentials {
+    #[serde(default)]
+    discord_token: Option<String>,
+    #[serde(default)]
+    slack_bot_token: Option<String>,
+    #[serde(default)]
+    slack_app_token: Option<String>,
+    #[serde(default)]
+    telegram_token: Option<String>,
+    #[serde(default)]
+    twitch_username: Option<String>,
+    #[serde(default)]
+    twitch_oauth_token: Option<String>,
+    #[serde(default)]
+    twitch_client_id: Option<String>,
+    #[serde(default)]
+    twitch_client_secret: Option<String>,
+    #[serde(default)]
+    twitch_refresh_token: Option<String>,
+    // Email credentials
+    #[serde(default)]
+    email_imap_host: Option<String>,
+    #[serde(default)]
+    email_imap_port: Option<u16>,
+    #[serde(default)]
+    email_imap_username: Option<String>,
+    #[serde(default)]
+    email_imap_password: Option<String>,
+    #[serde(default)]
+    email_smtp_host: Option<String>,
+    #[serde(default)]
+    email_smtp_port: Option<u16>,
+    #[serde(default)]
+    email_smtp_username: Option<String>,
+    #[serde(default)]
+    email_smtp_password: Option<String>,
+    #[serde(default)]
+    email_from_address: Option<String>,
+    // Webhook credentials
+    #[serde(default)]
+    webhook_port: Option<u16>,
+    #[serde(default)]
+    webhook_bind: Option<String>,
+    #[serde(default)]
+    webhook_auth_token: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct CreateMessagingInstanceRequest {
+    platform: String,
+    #[serde(default)]
+    name: Option<String>,
+    #[serde(default)]
+    enabled: Option<bool>,
+    #[serde(default)]
+    credentials: InstanceCredentials,
+}
+
+#[derive(Deserialize)]
+pub(super) struct DeleteMessagingInstanceRequest {
+    platform: String,
+    #[serde(default)]
+    name: Option<String>,
+}
+
+#[derive(Serialize)]
+pub(super) struct MessagingInstanceActionResponse {
+    success: bool,
+    message: String,
+}
+
+fn normalize_adapter_selector(value: Option<&str>) -> Option<String> {
+    value
+        .map(str::trim)
+        .filter(|candidate| !candidate.is_empty())
+        .map(str::to_string)
+}
+
+fn binding_count_for(
+    bindings: Option<&toml_edit::ArrayOfTables>,
+    platform: &str,
+    adapter: Option<&str>,
+) -> usize {
+    let Some(bindings) = bindings else {
+        return 0;
+    };
+
+    bindings
+        .iter()
+        .filter(|table| {
+            let Some(channel) = table.get("channel").and_then(|value| value.as_str()) else {
+                return false;
+            };
+            if channel != platform {
+                return false;
+            }
+
+            let binding_adapter =
+                normalize_adapter_selector(table.get("adapter").and_then(|value| value.as_str()));
+
+            match (binding_adapter.as_deref(), adapter) {
+                (None, None) => true,
+                (Some(binding_adapter), Some(adapter)) => binding_adapter == adapter,
+                _ => false,
+            }
+        })
+        .count()
+}
+
+fn push_instance_status(
+    instances: &mut Vec<AdapterInstanceStatus>,
+    bindings: Option<&toml_edit::ArrayOfTables>,
+    platform: &str,
+    name: Option<String>,
+    configured: bool,
+    enabled: bool,
+) {
+    let runtime_key = crate::config::binding_runtime_adapter_key(platform, name.as_deref());
+    let binding_count = binding_count_for(bindings, platform, name.as_deref());
+
+    instances.push(AdapterInstanceStatus {
+        platform: platform.to_string(),
+        name,
+        runtime_key,
+        configured,
+        enabled,
+        binding_count,
+    });
+}
+
 /// Get which messaging platforms are configured and enabled.
 pub(super) async fn messaging_status(
     State(state): State<Arc<ApiState>>,
 ) -> Result<Json<MessagingStatusResponse>, StatusCode> {
     let config_path = state.config_path.read().await.clone();
 
-    let (discord, slack, telegram, webhook, twitch) = if config_path.exists() {
+    let (discord, slack, telegram, email, webhook, twitch, instances) = if config_path.exists() {
         let content = tokio::fs::read_to_string(&config_path)
             .await
             .map_err(|error| {
@@ -50,6 +198,11 @@ pub(super) async fn messaging_status(
             StatusCode::INTERNAL_SERVER_ERROR
         })?;
 
+        let mut instances: Vec<AdapterInstanceStatus> = Vec::new();
+        let bindings = doc
+            .get("bindings")
+            .and_then(|value| value.as_array_of_tables());
+
         let discord_status = doc
             .get("messaging")
             .and_then(|m| m.get("discord"))
@@ -59,6 +212,44 @@ pub(super) async fn messaging_status(
                     .and_then(|v| v.as_str())
                     .is_some_and(|s| !s.is_empty());
                 let enabled = d.get("enabled").and_then(|v| v.as_bool()).unwrap_or(false);
+
+                if has_token {
+                    push_instance_status(&mut instances, bindings, "discord", None, true, enabled);
+                }
+
+                if let Some(named_instances) = d
+                    .get("instances")
+                    .and_then(|value| value.as_array_of_tables())
+                {
+                    for instance in named_instances {
+                        let instance_name = normalize_adapter_selector(
+                            instance.get("name").and_then(|value| value.as_str()),
+                        );
+                        let instance_enabled = instance
+                            .get("enabled")
+                            .and_then(|value| value.as_bool())
+                            .unwrap_or(true)
+                            && enabled;
+                        let instance_configured = instance
+                            .get("token")
+                            .and_then(|value| value.as_str())
+                            .is_some_and(|token| !token.is_empty());
+
+                        if let Some(instance_name) = instance_name
+                            && instance_configured
+                        {
+                            push_instance_status(
+                                &mut instances,
+                                bindings,
+                                "discord",
+                                Some(instance_name),
+                                true,
+                                instance_enabled,
+                            );
+                        }
+                    }
+                }
+
                 PlatformStatus {
                     configured: has_token,
                     enabled: has_token && enabled,
@@ -82,6 +273,49 @@ pub(super) async fn messaging_status(
                     .and_then(|v| v.as_str())
                     .is_some_and(|t| !t.is_empty());
                 let enabled = s.get("enabled").and_then(|v| v.as_bool()).unwrap_or(false);
+
+                if has_bot_token && has_app_token {
+                    push_instance_status(&mut instances, bindings, "slack", None, true, enabled);
+                }
+
+                if let Some(named_instances) = s
+                    .get("instances")
+                    .and_then(|value| value.as_array_of_tables())
+                {
+                    for instance in named_instances {
+                        let instance_name = normalize_adapter_selector(
+                            instance.get("name").and_then(|value| value.as_str()),
+                        );
+                        let has_instance_bot = instance
+                            .get("bot_token")
+                            .and_then(|value| value.as_str())
+                            .is_some_and(|value| !value.is_empty());
+                        let has_instance_app = instance
+                            .get("app_token")
+                            .and_then(|value| value.as_str())
+                            .is_some_and(|value| !value.is_empty());
+                        let instance_enabled = instance
+                            .get("enabled")
+                            .and_then(|value| value.as_bool())
+                            .unwrap_or(true)
+                            && enabled;
+
+                        if let Some(instance_name) = instance_name
+                            && has_instance_bot
+                            && has_instance_app
+                        {
+                            push_instance_status(
+                                &mut instances,
+                                bindings,
+                                "slack",
+                                Some(instance_name),
+                                true,
+                                instance_enabled,
+                            );
+                        }
+                    }
+                }
+
                 PlatformStatus {
                     configured: has_bot_token && has_app_token,
                     enabled: has_bot_token && has_app_token && enabled,
@@ -97,6 +331,9 @@ pub(super) async fn messaging_status(
             .and_then(|m| m.get("webhook"))
             .map(|w| {
                 let enabled = w.get("enabled").and_then(|v| v.as_bool()).unwrap_or(false);
+
+                push_instance_status(&mut instances, bindings, "webhook", None, true, enabled);
+
                 PlatformStatus {
                     configured: true,
                     enabled,
@@ -107,6 +344,49 @@ pub(super) async fn messaging_status(
                 enabled: false,
             });
 
+        let email_status = doc
+            .get("messaging")
+            .and_then(|m| m.get("email"))
+            .map(|email| {
+                let has_imap_host = email
+                    .get("imap_host")
+                    .and_then(|v| v.as_str())
+                    .is_some_and(|s| !s.is_empty());
+                let has_imap_username = email
+                    .get("imap_username")
+                    .and_then(|v| v.as_str())
+                    .is_some_and(|s| !s.is_empty());
+                let has_imap_password = email
+                    .get("imap_password")
+                    .and_then(|v| v.as_str())
+                    .is_some_and(|s| !s.is_empty());
+                let has_smtp_host = email
+                    .get("smtp_host")
+                    .and_then(|v| v.as_str())
+                    .is_some_and(|s| !s.is_empty());
+
+                let configured =
+                    has_imap_host && has_imap_username && has_imap_password && has_smtp_host;
+
+                let enabled = email
+                    .get("enabled")
+                    .and_then(|v| v.as_bool())
+                    .unwrap_or(false);
+
+                if configured {
+                    push_instance_status(&mut instances, bindings, "email", None, true, enabled);
+                }
+
+                PlatformStatus {
+                    configured,
+                    enabled: configured && enabled,
+                }
+            })
+            .unwrap_or(PlatformStatus {
+                configured: false,
+                enabled: false,
+            });
+
         let telegram_status = doc
             .get("messaging")
             .and_then(|m| m.get("telegram"))
@@ -116,6 +396,44 @@ pub(super) async fn messaging_status(
                     .and_then(|v| v.as_str())
                     .is_some_and(|s| !s.is_empty());
                 let enabled = t.get("enabled").and_then(|v| v.as_bool()).unwrap_or(false);
+
+                if has_token {
+                    push_instance_status(&mut instances, bindings, "telegram", None, true, enabled);
+                }
+
+                if let Some(named_instances) = t
+                    .get("instances")
+                    .and_then(|value| value.as_array_of_tables())
+                {
+                    for instance in named_instances {
+                        let instance_name = normalize_adapter_selector(
+                            instance.get("name").and_then(|value| value.as_str()),
+                        );
+                        let instance_enabled = instance
+                            .get("enabled")
+                            .and_then(|value| value.as_bool())
+                            .unwrap_or(true)
+                            && enabled;
+                        let instance_configured = instance
+                            .get("token")
+                            .and_then(|value| value.as_str())
+                            .is_some_and(|value| !value.is_empty());
+
+                        if let Some(instance_name) = instance_name
+                            && instance_configured
+                        {
+                            push_instance_status(
+                                &mut instances,
+                                bindings,
+                                "telegram",
+                                Some(instance_name),
+                                true,
+                                instance_enabled,
+                            );
+                        }
+                    }
+                }
+
                 PlatformStatus {
                     configured: has_token,
                     enabled: has_token && enabled,
@@ -139,6 +457,49 @@ pub(super) async fn messaging_status(
                     .and_then(|v| v.as_str())
                     .is_some_and(|s| !s.is_empty());
                 let enabled = t.get("enabled").and_then(|v| v.as_bool()).unwrap_or(false);
+
+                if has_username && has_token {
+                    push_instance_status(&mut instances, bindings, "twitch", None, true, enabled);
+                }
+
+                if let Some(named_instances) = t
+                    .get("instances")
+                    .and_then(|value| value.as_array_of_tables())
+                {
+                    for instance in named_instances {
+                        let instance_name = normalize_adapter_selector(
+                            instance.get("name").and_then(|value| value.as_str()),
+                        );
+                        let instance_enabled = instance
+                            .get("enabled")
+                            .and_then(|value| value.as_bool())
+                            .unwrap_or(true)
+                            && enabled;
+                        let has_instance_username = instance
+                            .get("username")
+                            .and_then(|value| value.as_str())
+                            .is_some_and(|value| !value.is_empty());
+                        let has_instance_token = instance
+                            .get("oauth_token")
+                            .and_then(|value| value.as_str())
+                            .is_some_and(|value| !value.is_empty());
+
+                        if let Some(instance_name) = instance_name
+                            && has_instance_username
+                            && has_instance_token
+                        {
+                            push_instance_status(
+                                &mut instances,
+                                bindings,
+                                "twitch",
+                                Some(instance_name),
+                                true,
+                                instance_enabled,
+                            );
+                        }
+                    }
+                }
+
                 PlatformStatus {
                     configured: has_username && has_token,
                     enabled: has_username && has_token && enabled,
@@ -153,8 +514,10 @@ pub(super) async fn messaging_status(
             discord_status,
             slack_status,
             telegram_status,
+            email_status,
             webhook_status,
             twitch_status,
+            instances,
         )
     } else {
         let default = PlatformStatus {
@@ -166,7 +529,9 @@ pub(super) async fn messaging_status(
             default.clone(),
             default.clone(),
             default.clone(),
+            default.clone(),
             default,
+            Vec::new(),
         )
     };
 
@@ -174,18 +539,29 @@ pub(super) async fn messaging_status(
         discord,
         slack,
         telegram,
+        email,
         webhook,
         twitch,
+        instances,
     }))
 }
 
 /// Disconnect a messaging platform: remove credentials from config, remove all
 /// bindings for that platform, and shut down the adapter.
+///
+/// When `adapter` is set, only the specified named instance is disconnected.
+/// When `adapter` is absent, the entire platform section (default + all named
+/// instances) is removed.
 pub(super) async fn disconnect_platform(
     State(state): State<Arc<ApiState>>,
     Json(request): Json<DisconnectPlatformRequest>,
 ) -> Result<Json<serde_json::Value>, StatusCode> {
     let platform = &request.platform;
+    let adapter_name = request
+        .adapter
+        .as_deref()
+        .map(str::trim)
+        .filter(|s| !s.is_empty());
     let config_path = state.config_path.read().await.clone();
 
     let content = tokio::fs::read_to_string(&config_path)
@@ -199,25 +575,76 @@ pub(super) async fn disconnect_platform(
         StatusCode::INTERNAL_SERVER_ERROR
     })?;
 
-    if let Some(messaging) = doc.get_mut("messaging").and_then(|m| m.as_table_mut()) {
-        messaging.remove(platform);
-    }
+    if let Some(adapter_name) = adapter_name {
+        // Disconnect a specific named instance only
+        if let Some(instances) = doc
+            .get_mut("messaging")
+            .and_then(|m| m.get_mut(platform.as_str()))
+            .and_then(|p| p.get_mut("instances"))
+            .and_then(|item| item.as_array_of_tables_mut())
+        {
+            let mut index = 0;
+            while index < instances.len() {
+                let matches = instances
+                    .get(index)
+                    .and_then(|t| t.get("name"))
+                    .and_then(|v| v.as_str())
+                    .is_some_and(|name| name == adapter_name);
+                if matches {
+                    instances.remove(index);
+                    break;
+                }
+                index += 1;
+            }
+        }
 
-    if let Some(bindings) = doc
-        .get_mut("bindings")
-        .and_then(|b| b.as_array_of_tables_mut())
-    {
-        let mut i = 0;
-        while i < bindings.len() {
-            let matches = bindings
-                .get(i)
-                .and_then(|t| t.get("channel"))
-                .and_then(|v| v.as_str())
-                .is_some_and(|ch| ch == platform);
-            if matches {
-                bindings.remove(i);
-            } else {
-                i += 1;
+        // Remove bindings targeting this specific adapter
+        if let Some(bindings) = doc
+            .get_mut("bindings")
+            .and_then(|b| b.as_array_of_tables_mut())
+        {
+            let mut index = 0;
+            while index < bindings.len() {
+                let binding_channel = bindings
+                    .get(index)
+                    .and_then(|t| t.get("channel"))
+                    .and_then(|v| v.as_str());
+                let binding_adapter = bindings
+                    .get(index)
+                    .and_then(|t| t.get("adapter"))
+                    .and_then(|v| v.as_str());
+
+                if binding_channel.is_some_and(|ch| ch == platform)
+                    && binding_adapter.is_some_and(|ba| ba == adapter_name)
+                {
+                    bindings.remove(index);
+                } else {
+                    index += 1;
+                }
+            }
+        }
+    } else {
+        // Disconnect entire platform — remove the whole section and all bindings
+        if let Some(messaging) = doc.get_mut("messaging").and_then(|m| m.as_table_mut()) {
+            messaging.remove(platform);
+        }
+
+        if let Some(bindings) = doc
+            .get_mut("bindings")
+            .and_then(|b| b.as_array_of_tables_mut())
+        {
+            let mut i = 0;
+            while i < bindings.len() {
+                let matches = bindings
+                    .get(i)
+                    .and_then(|t| t.get("channel"))
+                    .and_then(|v| v.as_str())
+                    .is_some_and(|ch| ch == platform);
+                if matches {
+                    bindings.remove(i);
+                } else {
+                    i += 1;
+                }
             }
         }
     }
@@ -237,17 +664,71 @@ pub(super) async fn disconnect_platform(
     }
 
     let manager_guard = state.messaging_manager.read().await;
-    if let Some(manager) = manager_guard.as_ref()
-        && let Err(error) = manager.remove_adapter(platform).await
-    {
-        tracing::warn!(%error, platform = %platform, "failed to shut down adapter during disconnect");
+    if let Some(manager) = manager_guard.as_ref() {
+        if let Some(adapter_name) = adapter_name {
+            // Disconnect only the specific named adapter
+            let runtime_key =
+                crate::config::binding_runtime_adapter_key(platform, Some(adapter_name));
+            if let Err(error) = manager.remove_adapter(&runtime_key).await {
+                tracing::warn!(%error, adapter = %runtime_key, "failed to shut down adapter during disconnect");
+            }
+        } else {
+            // Disconnect all adapters for this platform
+            if let Err(error) = manager.remove_platform_adapters(platform).await {
+                tracing::warn!(%error, platform = %platform, "failed to shut down adapters during disconnect");
+            }
+        }
+    }
+
+    if platform == "twitch" {
+        let instance_dir = state.instance_dir.load();
+        if let Some(name) = adapter_name {
+            let safe_name: String = name
+                .chars()
+                .map(|ch| if ch.is_ascii_alphanumeric() { ch } else { '_' })
+                .collect();
+            let token_path = instance_dir.join(format!("twitch_token_{safe_name}.json"));
+            match tokio::fs::remove_file(&token_path).await {
+                Ok(()) => {
+                    tracing::info!(path = %token_path.display(), "twitch token file deleted");
+                }
+                Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+                Err(error) => {
+                    tracing::warn!(
+                        %error,
+                        path = %token_path.display(),
+                        "failed to delete twitch token file"
+                    );
+                }
+            }
+        } else {
+            let token_path = instance_dir.join("twitch_token.json");
+            match tokio::fs::remove_file(&token_path).await {
+                Ok(()) => {
+                    tracing::info!(path = %token_path.display(), "twitch token file deleted");
+                }
+                Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+                Err(error) => {
+                    tracing::warn!(
+                        %error,
+                        path = %token_path.display(),
+                        "failed to delete twitch token file"
+                    );
+                }
+            }
+        }
     }
 
-    tracing::info!(platform = %platform, "platform disconnected via API");
+    let label = if let Some(name) = adapter_name {
+        format!("{platform}:{name}")
+    } else {
+        platform.to_string()
+    };
+    tracing::info!(platform = %platform, adapter = %label, "platform disconnected via API");
 
     Ok(Json(serde_json::json!({
         "success": true,
-        "message": format!("{platform} disconnected")
+        "message": format!("{label} disconnected")
     })))
 }
 
@@ -284,7 +765,36 @@ pub(super) async fn toggle_platform(
         })));
     };
 
-    table["enabled"] = toml_edit::value(request.enabled);
+    if let Some(adapter_name) = &request.adapter {
+        // Toggle a specific named instance
+        let adapter_name = adapter_name.trim();
+        let mut found = false;
+        if let Some(instances) = table
+            .get_mut("instances")
+            .and_then(|item| item.as_array_of_tables_mut())
+        {
+            for instance in instances.iter_mut() {
+                if instance
+                    .get("name")
+                    .and_then(|v| v.as_str())
+                    .is_some_and(|n| n == adapter_name)
+                {
+                    instance["enabled"] = toml_edit::value(request.enabled);
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if !found {
+            return Ok(Json(serde_json::json!({
+                "success": false,
+                "message": format!("instance '{adapter_name}' not found for {platform}")
+            })));
+        }
+    } else {
+        // Toggle the default (root-level) instance
+        table["enabled"] = toml_edit::value(request.enabled);
+    }
 
     tokio::fs::write(&config_path, doc.to_string())
         .await
@@ -303,81 +813,191 @@ pub(super) async fn toggle_platform(
             match platform.as_str() {
                 "discord" => {
                     if let Some(discord_config) = &new_config.messaging.discord {
-                        let perms = {
-                            let perms_guard = state.discord_permissions.read().await;
-                            match perms_guard.as_ref() {
-                                Some(existing) => existing.clone(),
-                                None => {
-                                    drop(perms_guard);
-                                    let perms = crate::config::DiscordPermissions::from_config(
-                                        discord_config,
-                                        &new_config.bindings,
-                                    );
-                                    let arc_swap =
-                                        std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(perms));
-                                    state.set_discord_permissions(arc_swap.clone()).await;
-                                    arc_swap
+                        if !discord_config.token.is_empty() {
+                            let perms = {
+                                let perms_guard = state.discord_permissions.read().await;
+                                match perms_guard.as_ref() {
+                                    Some(existing) => existing.clone(),
+                                    None => {
+                                        drop(perms_guard);
+                                        let perms = crate::config::DiscordPermissions::from_config(
+                                            discord_config,
+                                            &new_config.bindings,
+                                        );
+                                        let arc_swap = std::sync::Arc::new(
+                                            arc_swap::ArcSwap::from_pointee(perms),
+                                        );
+                                        state.set_discord_permissions(arc_swap.clone()).await;
+                                        arc_swap
+                                    }
                                 }
+                            };
+                            let adapter = crate::messaging::discord::DiscordAdapter::new(
+                                "discord",
+                                &discord_config.token,
+                                perms,
+                            );
+                            if let Err(error) = manager.register_and_start(adapter).await {
+                                tracing::error!(%error, "failed to start discord adapter on toggle");
+                            }
+                        }
+
+                        for instance in discord_config
+                            .instances
+                            .iter()
+                            .filter(|instance| instance.enabled)
+                        {
+                            let runtime_key = crate::config::binding_runtime_adapter_key(
+                                "discord",
+                                Some(instance.name.as_str()),
+                            );
+                            let perms = std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(
+                                crate::config::DiscordPermissions::from_instance_config(
+                                    instance,
+                                    &new_config.bindings,
+                                ),
+                            ));
+                            let adapter = crate::messaging::discord::DiscordAdapter::new(
+                                runtime_key,
+                                &instance.token,
+                                perms,
+                            );
+                            if let Err(error) = manager.register_and_start(adapter).await {
+                                tracing::error!(%error, adapter = %instance.name, "failed to start named discord adapter on toggle");
                             }
-                        };
-                        let adapter = crate::messaging::discord::DiscordAdapter::new(
-                            &discord_config.token,
-                            perms,
-                        );
-                        if let Err(error) = manager.register_and_start(adapter).await {
-                            tracing::error!(%error, "failed to start discord adapter on toggle");
                         }
                     }
                 }
                 "slack" => {
                     if let Some(slack_config) = &new_config.messaging.slack {
-                        let perms = {
-                            let perms_guard = state.slack_permissions.read().await;
-                            match perms_guard.as_ref() {
-                                Some(existing) => existing.clone(),
-                                None => {
-                                    drop(perms_guard);
-                                    let perms = crate::config::SlackPermissions::from_config(
-                                        slack_config,
-                                        &new_config.bindings,
-                                    );
-                                    let arc_swap =
-                                        std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(perms));
-                                    state.set_slack_permissions(arc_swap.clone()).await;
-                                    arc_swap
+                        if !slack_config.bot_token.is_empty() && !slack_config.app_token.is_empty()
+                        {
+                            let perms = {
+                                let perms_guard = state.slack_permissions.read().await;
+                                match perms_guard.as_ref() {
+                                    Some(existing) => existing.clone(),
+                                    None => {
+                                        drop(perms_guard);
+                                        let perms = crate::config::SlackPermissions::from_config(
+                                            slack_config,
+                                            &new_config.bindings,
+                                        );
+                                        let arc_swap = std::sync::Arc::new(
+                                            arc_swap::ArcSwap::from_pointee(perms),
+                                        );
+                                        state.set_slack_permissions(arc_swap.clone()).await;
+                                        arc_swap
+                                    }
                                 }
-                            }
-                        };
-                        match crate::messaging::slack::SlackAdapter::new(
-                            &slack_config.bot_token,
-                            &slack_config.app_token,
-                            perms,
-                            slack_config.commands.clone(),
-                        ) {
-                            Ok(adapter) => {
-                                if let Err(error) = manager.register_and_start(adapter).await {
-                                    tracing::error!(%error, "failed to start slack adapter on toggle");
+                            };
+                            match crate::messaging::slack::SlackAdapter::new(
+                                "slack",
+                                &slack_config.bot_token,
+                                &slack_config.app_token,
+                                perms,
+                                slack_config.commands.clone(),
+                            ) {
+                                Ok(adapter) => {
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, "failed to start slack adapter on toggle");
+                                    }
+                                }
+                                Err(error) => {
+                                    tracing::error!(%error, "failed to build slack adapter on toggle");
                                 }
                             }
-                            Err(error) => {
-                                tracing::error!(%error, "failed to build slack adapter on toggle");
+                        }
+
+                        for instance in slack_config
+                            .instances
+                            .iter()
+                            .filter(|instance| instance.enabled)
+                        {
+                            let runtime_key = crate::config::binding_runtime_adapter_key(
+                                "slack",
+                                Some(instance.name.as_str()),
+                            );
+                            let perms = std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(
+                                crate::config::SlackPermissions::from_instance_config(
+                                    instance,
+                                    &new_config.bindings,
+                                ),
+                            ));
+                            match crate::messaging::slack::SlackAdapter::new(
+                                runtime_key,
+                                &instance.bot_token,
+                                &instance.app_token,
+                                perms,
+                                instance.commands.clone(),
+                            ) {
+                                Ok(adapter) => {
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, adapter = %instance.name, "failed to start named slack adapter on toggle");
+                                    }
+                                }
+                                Err(error) => {
+                                    tracing::error!(%error, adapter = %instance.name, "failed to build named slack adapter on toggle");
+                                }
                             }
                         }
                     }
                 }
                 "telegram" => {
                     if let Some(telegram_config) = &new_config.messaging.telegram {
-                        let perms = crate::config::TelegramPermissions::from_config(
-                            telegram_config,
-                            &new_config.bindings,
-                        );
-                        let arc_swap = std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(perms));
-                        let adapter = crate::messaging::telegram::TelegramAdapter::new(
-                            &telegram_config.token,
-                            arc_swap,
-                        );
-                        if let Err(error) = manager.register_and_start(adapter).await {
-                            tracing::error!(%error, "failed to start telegram adapter on toggle");
+                        if !telegram_config.token.is_empty() {
+                            let perms = crate::config::TelegramPermissions::from_config(
+                                telegram_config,
+                                &new_config.bindings,
+                            );
+                            let arc_swap =
+                                std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(perms));
+                            let adapter = crate::messaging::telegram::TelegramAdapter::new(
+                                "telegram",
+                                &telegram_config.token,
+                                arc_swap,
+                            );
+                            if let Err(error) = manager.register_and_start(adapter).await {
+                                tracing::error!(%error, "failed to start telegram adapter on toggle");
+                            }
+                        }
+
+                        for instance in telegram_config
+                            .instances
+                            .iter()
+                            .filter(|instance| instance.enabled)
+                        {
+                            let runtime_key = crate::config::binding_runtime_adapter_key(
+                                "telegram",
+                                Some(instance.name.as_str()),
+                            );
+                            let perms = std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(
+                                crate::config::TelegramPermissions::from_instance_config(
+                                    instance,
+                                    &new_config.bindings,
+                                ),
+                            ));
+                            let adapter = crate::messaging::telegram::TelegramAdapter::new(
+                                runtime_key,
+                                &instance.token,
+                                perms,
+                            );
+                            if let Err(error) = manager.register_and_start(adapter).await {
+                                tracing::error!(%error, adapter = %instance.name, "failed to start named telegram adapter on toggle");
+                            }
+                        }
+                    }
+                }
+                "email" => {
+                    if let Some(email_config) = &new_config.messaging.email {
+                        match crate::messaging::email::EmailAdapter::from_config(email_config) {
+                            Ok(adapter) => {
+                                if let Err(error) = manager.register_and_start(adapter).await {
+                                    tracing::error!(%error, "failed to start email adapter on toggle");
+                                }
+                            }
+                            Err(error) => {
+                                tracing::error!(%error, "failed to build email adapter on toggle");
+                            }
                         }
                     }
                 }
@@ -395,36 +1015,91 @@ pub(super) async fn toggle_platform(
                 }
                 "twitch" => {
                     if let Some(twitch_config) = &new_config.messaging.twitch {
-                        let perms = crate::config::TwitchPermissions::from_config(
-                            twitch_config,
-                            &new_config.bindings,
-                        );
-                        let arc_swap = std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(perms));
-                        let instance_dir = state.instance_dir.load();
-                        let token_path = instance_dir.join("twitch_token.json");
-                        let adapter = crate::messaging::twitch::TwitchAdapter::new(
-                            &twitch_config.username,
-                            &twitch_config.oauth_token,
-                            twitch_config.client_id.clone(),
-                            twitch_config.client_secret.clone(),
-                            twitch_config.refresh_token.clone(),
-                            Some(token_path),
-                            twitch_config.channels.clone(),
-                            twitch_config.trigger_prefix.clone(),
-                            arc_swap,
-                        );
-                        if let Err(error) = manager.register_and_start(adapter).await {
-                            tracing::error!(%error, "failed to start twitch adapter on toggle");
+                        if !twitch_config.username.is_empty()
+                            && !twitch_config.oauth_token.is_empty()
+                        {
+                            let perms = crate::config::TwitchPermissions::from_config(
+                                twitch_config,
+                                &new_config.bindings,
+                            );
+                            let arc_swap =
+                                std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(perms));
+                            let instance_dir = state.instance_dir.load();
+                            let token_path = instance_dir.join("twitch_token.json");
+                            let adapter = crate::messaging::twitch::TwitchAdapter::new(
+                                "twitch",
+                                &twitch_config.username,
+                                &twitch_config.oauth_token,
+                                twitch_config.client_id.clone(),
+                                twitch_config.client_secret.clone(),
+                                twitch_config.refresh_token.clone(),
+                                Some(token_path),
+                                twitch_config.channels.clone(),
+                                twitch_config.trigger_prefix.clone(),
+                                arc_swap,
+                            );
+                            if let Err(error) = manager.register_and_start(adapter).await {
+                                tracing::error!(%error, "failed to start twitch adapter on toggle");
+                            }
+                        }
+
+                        for instance in twitch_config
+                            .instances
+                            .iter()
+                            .filter(|instance| instance.enabled)
+                        {
+                            let runtime_key = crate::config::binding_runtime_adapter_key(
+                                "twitch",
+                                Some(instance.name.as_str()),
+                            );
+                            let token_file_name = format!(
+                                "twitch_token_{}.json",
+                                instance
+                                    .name
+                                    .chars()
+                                    .map(|ch| if ch.is_ascii_alphanumeric() { ch } else { '_' })
+                                    .collect::<String>()
+                            );
+                            let instance_dir = state.instance_dir.load();
+                            let token_path = instance_dir.join(token_file_name);
+                            let perms = std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(
+                                crate::config::TwitchPermissions::from_instance_config(
+                                    instance,
+                                    &new_config.bindings,
+                                ),
+                            ));
+                            let adapter = crate::messaging::twitch::TwitchAdapter::new(
+                                runtime_key,
+                                &instance.username,
+                                &instance.oauth_token,
+                                instance.client_id.clone(),
+                                instance.client_secret.clone(),
+                                instance.refresh_token.clone(),
+                                Some(token_path),
+                                instance.channels.clone(),
+                                instance.trigger_prefix.clone(),
+                                perms,
+                            );
+                            if let Err(error) = manager.register_and_start(adapter).await {
+                                tracing::error!(%error, adapter = %instance.name, "failed to start named twitch adapter on toggle");
+                            }
                         }
                     }
                 }
                 _ => {}
             }
         }
-    } else if let Some(manager) = manager
-        && let Err(error) = manager.remove_adapter(platform).await
-    {
-        tracing::warn!(%error, platform = %platform, "failed to shut down adapter on toggle");
+    } else if let Some(manager) = manager {
+        if let Some(ref adapter_name) = request.adapter {
+            // Shut down only the specific named instance.
+            let runtime_key =
+                crate::config::binding_runtime_adapter_key(platform, Some(adapter_name.trim()));
+            if let Err(error) = manager.remove_adapter(&runtime_key).await {
+                tracing::warn!(%error, adapter = %runtime_key, "failed to shut down named adapter on toggle");
+            }
+        } else if let Err(error) = manager.remove_platform_adapters(platform).await {
+            tracing::warn!(%error, platform = %platform, "failed to shut down adapters on toggle");
+        }
     }
 
     let action = if request.enabled {
@@ -439,3 +1114,522 @@ pub(super) async fn toggle_platform(
         "message": format!("{platform} {action}")
     })))
 }
+
+/// Create a new adapter instance for a platform.
+///
+/// If `name` is `None`, creates/updates the default instance (root-level credentials).
+/// If `name` is `Some`, adds a `[[messaging.<platform>.instances]]` entry.
+/// Starts the adapter at runtime and reloads bindings.
+pub(super) async fn create_messaging_instance(
+    State(state): State<Arc<ApiState>>,
+    Json(request): Json<CreateMessagingInstanceRequest>,
+) -> Result<Json<MessagingInstanceActionResponse>, StatusCode> {
+    let platform = &request.platform;
+
+    if !matches!(
+        platform.as_str(),
+        "discord" | "slack" | "telegram" | "twitch" | "email" | "webhook"
+    ) {
+        return Ok(Json(MessagingInstanceActionResponse {
+            success: false,
+            message: format!("instances are not supported for '{platform}'"),
+        }));
+    }
+
+    // Validate instance name
+    if let Some(name) = &request.name {
+        let trimmed = name.trim();
+        if trimmed.is_empty() || trimmed.eq_ignore_ascii_case("default") {
+            return Ok(Json(MessagingInstanceActionResponse {
+                success: false,
+                message: "instance name cannot be empty or 'default'".to_string(),
+            }));
+        }
+        if trimmed.contains(':') || trimmed.contains(' ') {
+            return Ok(Json(MessagingInstanceActionResponse {
+                success: false,
+                message: "instance name cannot contain ':' or spaces".to_string(),
+            }));
+        }
+    }
+
+    let config_path = state.config_path.read().await.clone();
+    let content = tokio::fs::read_to_string(&config_path)
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, "failed to read config.toml");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+    let mut doc: toml_edit::DocumentMut = content.parse().map_err(|error| {
+        tracing::warn!(%error, "failed to parse config.toml");
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
+
+    // Ensure [messaging] and [messaging.<platform>] tables exist
+    if doc.get("messaging").is_none() {
+        doc["messaging"] = toml_edit::Item::Table(toml_edit::Table::new());
+    }
+    let messaging = doc["messaging"].as_table_mut().ok_or_else(|| {
+        tracing::warn!("messaging is not a table");
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
+
+    if messaging.get(platform.as_str()).is_none() {
+        let mut platform_table = toml_edit::Table::new();
+        platform_table["enabled"] = toml_edit::value(true);
+        messaging[platform.as_str()] = toml_edit::Item::Table(platform_table);
+    }
+    let platform_table = messaging
+        .get_mut(platform.as_str())
+        .and_then(|item| item.as_table_mut())
+        .ok_or_else(|| {
+            tracing::warn!(platform = %platform, "platform config is not a table");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    let credentials = &request.credentials;
+    let enabled = request.enabled.unwrap_or(true);
+
+    match request.name {
+        None => {
+            // Default instance — set root-level credential fields
+            match platform.as_str() {
+                "discord" => {
+                    if let Some(token) = &credentials.discord_token {
+                        platform_table["token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                "slack" => {
+                    if let Some(token) = &credentials.slack_bot_token {
+                        platform_table["bot_token"] = toml_edit::value(token.as_str());
+                    }
+                    if let Some(token) = &credentials.slack_app_token {
+                        platform_table["app_token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                "telegram" => {
+                    if let Some(token) = &credentials.telegram_token {
+                        platform_table["token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                "twitch" => {
+                    if let Some(username) = &credentials.twitch_username {
+                        platform_table["username"] = toml_edit::value(username.as_str());
+                    }
+                    if let Some(token) = &credentials.twitch_oauth_token {
+                        platform_table["oauth_token"] = toml_edit::value(token.as_str());
+                    }
+                    if let Some(client_id) = &credentials.twitch_client_id {
+                        platform_table["client_id"] = toml_edit::value(client_id.as_str());
+                    }
+                    if let Some(client_secret) = &credentials.twitch_client_secret {
+                        platform_table["client_secret"] = toml_edit::value(client_secret.as_str());
+                    }
+                    if let Some(refresh) = &credentials.twitch_refresh_token {
+                        platform_table["refresh_token"] = toml_edit::value(refresh.as_str());
+                    }
+                }
+                "email" => {
+                    if let Some(host) = &credentials.email_imap_host {
+                        platform_table["imap_host"] = toml_edit::value(host.as_str());
+                    }
+                    if let Some(port) = credentials.email_imap_port {
+                        platform_table["imap_port"] = toml_edit::value(i64::from(port));
+                    }
+                    if let Some(username) = &credentials.email_imap_username {
+                        platform_table["imap_username"] = toml_edit::value(username.as_str());
+                    }
+                    if let Some(password) = &credentials.email_imap_password {
+                        platform_table["imap_password"] = toml_edit::value(password.as_str());
+                    }
+                    if let Some(host) = &credentials.email_smtp_host {
+                        platform_table["smtp_host"] = toml_edit::value(host.as_str());
+                    }
+                    if let Some(port) = credentials.email_smtp_port {
+                        platform_table["smtp_port"] = toml_edit::value(i64::from(port));
+                    }
+                    if let Some(username) = &credentials.email_smtp_username {
+                        platform_table["smtp_username"] = toml_edit::value(username.as_str());
+                    }
+                    if let Some(password) = &credentials.email_smtp_password {
+                        platform_table["smtp_password"] = toml_edit::value(password.as_str());
+                    }
+                    if let Some(from) = &credentials.email_from_address {
+                        platform_table["from_address"] = toml_edit::value(from.as_str());
+                    }
+                }
+                "webhook" => {
+                    if let Some(port) = credentials.webhook_port {
+                        platform_table["port"] = toml_edit::value(i64::from(port));
+                    }
+                    if let Some(bind) = &credentials.webhook_bind {
+                        platform_table["bind"] = toml_edit::value(bind.as_str());
+                    }
+                    if let Some(token) = &credentials.webhook_auth_token {
+                        platform_table["auth_token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                _ => {}
+            }
+            platform_table["enabled"] = toml_edit::value(enabled);
+        }
+        Some(ref name) => {
+            // Named instance — add to [[messaging.<platform>.instances]]
+            let instance_name = name.trim().to_string();
+
+            // Check for duplicates
+            if let Some(existing_instances) = platform_table
+                .get("instances")
+                .and_then(|item| item.as_array_of_tables())
+            {
+                for existing in existing_instances {
+                    if existing
+                        .get("name")
+                        .and_then(|value| value.as_str())
+                        .is_some_and(|name| name == instance_name)
+                    {
+                        return Ok(Json(MessagingInstanceActionResponse {
+                            success: false,
+                            message: format!(
+                                "instance '{instance_name}' already exists for {platform}"
+                            ),
+                        }));
+                    }
+                }
+            }
+
+            let mut instance_table = toml_edit::Table::new();
+            instance_table["name"] = toml_edit::value(&instance_name);
+            instance_table["enabled"] = toml_edit::value(enabled);
+
+            match platform.as_str() {
+                "discord" => {
+                    if let Some(token) = &credentials.discord_token {
+                        instance_table["token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                "slack" => {
+                    if let Some(token) = &credentials.slack_bot_token {
+                        instance_table["bot_token"] = toml_edit::value(token.as_str());
+                    }
+                    if let Some(token) = &credentials.slack_app_token {
+                        instance_table["app_token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                "telegram" => {
+                    if let Some(token) = &credentials.telegram_token {
+                        instance_table["token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                "twitch" => {
+                    if let Some(username) = &credentials.twitch_username {
+                        instance_table["username"] = toml_edit::value(username.as_str());
+                    }
+                    if let Some(token) = &credentials.twitch_oauth_token {
+                        instance_table["oauth_token"] = toml_edit::value(token.as_str());
+                    }
+                    if let Some(client_id) = &credentials.twitch_client_id {
+                        instance_table["client_id"] = toml_edit::value(client_id.as_str());
+                    }
+                    if let Some(client_secret) = &credentials.twitch_client_secret {
+                        instance_table["client_secret"] = toml_edit::value(client_secret.as_str());
+                    }
+                    if let Some(refresh) = &credentials.twitch_refresh_token {
+                        instance_table["refresh_token"] = toml_edit::value(refresh.as_str());
+                    }
+                }
+                "email" => {
+                    if let Some(host) = &credentials.email_imap_host {
+                        instance_table["imap_host"] = toml_edit::value(host.as_str());
+                    }
+                    if let Some(port) = credentials.email_imap_port {
+                        instance_table["imap_port"] = toml_edit::value(i64::from(port));
+                    }
+                    if let Some(username) = &credentials.email_imap_username {
+                        instance_table["imap_username"] = toml_edit::value(username.as_str());
+                    }
+                    if let Some(password) = &credentials.email_imap_password {
+                        instance_table["imap_password"] = toml_edit::value(password.as_str());
+                    }
+                    if let Some(host) = &credentials.email_smtp_host {
+                        instance_table["smtp_host"] = toml_edit::value(host.as_str());
+                    }
+                    if let Some(port) = credentials.email_smtp_port {
+                        instance_table["smtp_port"] = toml_edit::value(i64::from(port));
+                    }
+                    if let Some(username) = &credentials.email_smtp_username {
+                        instance_table["smtp_username"] = toml_edit::value(username.as_str());
+                    }
+                    if let Some(password) = &credentials.email_smtp_password {
+                        instance_table["smtp_password"] = toml_edit::value(password.as_str());
+                    }
+                    if let Some(from) = &credentials.email_from_address {
+                        instance_table["from_address"] = toml_edit::value(from.as_str());
+                    }
+                }
+                "webhook" => {
+                    if let Some(port) = credentials.webhook_port {
+                        instance_table["port"] = toml_edit::value(i64::from(port));
+                    }
+                    if let Some(bind) = &credentials.webhook_bind {
+                        instance_table["bind"] = toml_edit::value(bind.as_str());
+                    }
+                    if let Some(token) = &credentials.webhook_auth_token {
+                        instance_table["auth_token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                _ => {}
+            }
+
+            // Append the new instance table
+            if platform_table.get("instances").is_none() {
+                platform_table.insert(
+                    "instances",
+                    toml_edit::Item::ArrayOfTables(toml_edit::ArrayOfTables::new()),
+                );
+            }
+            if let Some(instances) = platform_table
+                .get_mut("instances")
+                .and_then(|item| item.as_array_of_tables_mut())
+            {
+                instances.push(instance_table);
+            }
+        }
+    }
+
+    // Write updated config
+    tokio::fs::write(&config_path, doc.to_string())
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, "failed to write config.toml");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    // Reload config and hot-start the new adapter
+    if let Ok(new_config) = crate::config::Config::load_from_path(&config_path) {
+        let bindings_guard = state.bindings.read().await;
+        if let Some(bindings_swap) = bindings_guard.as_ref() {
+            bindings_swap.store(std::sync::Arc::new(new_config.bindings.clone()));
+        }
+    }
+
+    // The file watcher will pick up the change and start the adapter.
+    // We don't duplicate the adapter-start logic here — the hot-reload
+    // path in config.rs handles creating and registering all adapters.
+
+    let label = if let Some(name) = &request.name {
+        format!("{platform}:{}", name.trim())
+    } else {
+        format!("{platform} (default)")
+    };
+    tracing::info!(platform = %platform, instance = %label, "messaging instance created via API");
+
+    Ok(Json(MessagingInstanceActionResponse {
+        success: true,
+        message: format!("{label} instance created"),
+    }))
+}
+
+/// Delete a named adapter instance (or the default instance) for a platform.
+///
+/// Removes the instance entry from config.toml, removes bindings targeting
+/// that adapter, and shuts down the runtime adapter.
+pub(super) async fn delete_messaging_instance(
+    State(state): State<Arc<ApiState>>,
+    Json(request): Json<DeleteMessagingInstanceRequest>,
+) -> Result<Json<MessagingInstanceActionResponse>, StatusCode> {
+    let platform = &request.platform;
+    let adapter_name = request.name.as_deref().map(str::trim);
+
+    if !matches!(
+        platform.as_str(),
+        "discord" | "slack" | "telegram" | "twitch" | "email" | "webhook"
+    ) {
+        return Ok(Json(MessagingInstanceActionResponse {
+            success: false,
+            message: format!("instances are not supported for '{platform}'"),
+        }));
+    }
+
+    let config_path = state.config_path.read().await.clone();
+    let content = tokio::fs::read_to_string(&config_path)
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, "failed to read config.toml");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+    let mut doc: toml_edit::DocumentMut = content.parse().map_err(|error| {
+        tracing::warn!(%error, "failed to parse config.toml");
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
+
+    let runtime_key = crate::config::binding_runtime_adapter_key(platform, adapter_name);
+
+    if let Some(adapter_name) = adapter_name {
+        // Remove a named instance from [[messaging.<platform>.instances]]
+        let removed = if let Some(instances) = doc
+            .get_mut("messaging")
+            .and_then(|m| m.get_mut(platform.as_str()))
+            .and_then(|p| p.get_mut("instances"))
+            .and_then(|item| item.as_array_of_tables_mut())
+        {
+            let mut found = false;
+            let mut index = 0;
+            while index < instances.len() {
+                let matches = instances
+                    .get(index)
+                    .and_then(|t| t.get("name"))
+                    .and_then(|v| v.as_str())
+                    .is_some_and(|name| name == adapter_name);
+                if matches {
+                    instances.remove(index);
+                    found = true;
+                    break;
+                }
+                index += 1;
+            }
+            found
+        } else {
+            false
+        };
+
+        if !removed {
+            return Ok(Json(MessagingInstanceActionResponse {
+                success: false,
+                message: format!("instance '{adapter_name}' not found for {platform}"),
+            }));
+        }
+    } else {
+        // Remove default instance — clear root-level credentials
+        if let Some(table) = doc
+            .get_mut("messaging")
+            .and_then(|m| m.get_mut(platform.as_str()))
+            .and_then(|p| p.as_table_mut())
+        {
+            match platform.as_str() {
+                "discord" => {
+                    table.remove("token");
+                }
+                "slack" => {
+                    table.remove("bot_token");
+                    table.remove("app_token");
+                }
+                "telegram" => {
+                    table.remove("token");
+                }
+                "twitch" => {
+                    table.remove("username");
+                    table.remove("oauth_token");
+                    table.remove("client_id");
+                    table.remove("client_secret");
+                    table.remove("refresh_token");
+                }
+                "email" => {
+                    table.remove("imap_host");
+                    table.remove("imap_port");
+                    table.remove("imap_username");
+                    table.remove("imap_password");
+                    table.remove("smtp_host");
+                    table.remove("smtp_port");
+                    table.remove("smtp_username");
+                    table.remove("smtp_password");
+                    table.remove("from_address");
+                }
+                "webhook" => {
+                    table.remove("port");
+                    table.remove("bind");
+                    table.remove("auth_token");
+                }
+                _ => {}
+            }
+        }
+    }
+
+    // Remove bindings targeting this adapter
+    if let Some(bindings) = doc
+        .get_mut("bindings")
+        .and_then(|b| b.as_array_of_tables_mut())
+    {
+        let mut index = 0;
+        while index < bindings.len() {
+            let binding_channel = bindings
+                .get(index)
+                .and_then(|t| t.get("channel"))
+                .and_then(|v| v.as_str());
+            let binding_adapter = bindings
+                .get(index)
+                .and_then(|t| t.get("adapter"))
+                .and_then(|v| v.as_str());
+
+            let matches_platform = binding_channel.is_some_and(|ch| ch == platform);
+            let matches_adapter = match (binding_adapter, adapter_name) {
+                (None, None) => true,
+                (Some(ba), Some(an)) => ba == an,
+                _ => false,
+            };
+
+            if matches_platform && matches_adapter {
+                bindings.remove(index);
+            } else {
+                index += 1;
+            }
+        }
+    }
+
+    tokio::fs::write(&config_path, doc.to_string())
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, "failed to write config.toml");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    // Reload bindings
+    if let Ok(new_config) = crate::config::Config::load_from_path(&config_path) {
+        let bindings_guard = state.bindings.read().await;
+        if let Some(bindings_swap) = bindings_guard.as_ref() {
+            bindings_swap.store(std::sync::Arc::new(new_config.bindings.clone()));
+        }
+    }
+
+    // Shut down the runtime adapter
+    let manager_guard = state.messaging_manager.read().await;
+    if let Some(manager) = manager_guard.as_ref()
+        && let Err(error) = manager.remove_adapter(&runtime_key).await
+    {
+        tracing::warn!(%error, adapter = %runtime_key, "failed to shut down adapter during instance delete");
+    }
+
+    // Clean up twitch token file if applicable
+    if platform == "twitch" {
+        let instance_dir = state.instance_dir.load();
+        let token_path = if let Some(name) = adapter_name {
+            let safe_name: String = name
+                .chars()
+                .map(|ch| if ch.is_ascii_alphanumeric() { ch } else { '_' })
+                .collect();
+            instance_dir.join(format!("twitch_token_{safe_name}.json"))
+        } else {
+            instance_dir.join("twitch_token.json")
+        };
+        match tokio::fs::remove_file(&token_path).await {
+            Ok(()) => {
+                tracing::info!(path = %token_path.display(), "twitch token file deleted");
+            }
+            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+            Err(error) => {
+                tracing::warn!(
+                    %error,
+                    path = %token_path.display(),
+                    "failed to delete twitch token file"
+                );
+            }
+        }
+    }
+
+    tracing::info!(platform = %platform, adapter = %runtime_key, "messaging instance deleted via API");
+
+    Ok(Json(MessagingInstanceActionResponse {
+        success: true,
+        message: format!("{runtime_key} instance deleted"),
+    }))
+}
diff --git a/src/api/models.rs b/src/api/models.rs
index aa26da052..f988bf6b6 100644
--- a/src/api/models.rs
+++ b/src/api/models.rs
@@ -105,6 +105,7 @@ fn direct_provider_mapping(models_dev_id: &str) -> Option<&'static str> {
     match models_dev_id {
         "anthropic" => Some("anthropic"),
         "openai" => Some("openai"),
+        "kilo" => Some("kilo"),
         "deepseek" => Some("deepseek"),
         "xai" => Some("xai"),
         "mistral" => Some("mistral"),
@@ -113,6 +114,11 @@ fn direct_provider_mapping(models_dev_id: &str) -> Option<&'static str> {
         "togetherai" => Some("together"),
         "fireworks-ai" => Some("fireworks"),
         "zhipuai" => Some("zhipu"),
+        "opencode" => Some("opencode-zen"),
+        "opencode-go" => Some("opencode-go"),
+        "zai-coding-plan" => Some("zai-coding-plan"),
+        "minimax" => Some("minimax"),
+        "moonshotai" => Some("moonshot"),
         _ => None,
     }
 }
@@ -141,108 +147,7 @@ fn as_openai_chatgpt_model(model: &ModelInfo) -> Option<ModelInfo> {
 /// Models from providers not in models.dev (private/custom endpoints).
 fn extra_models() -> Vec<ModelInfo> {
     vec![
-        ModelInfo {
-            id: "opencode-zen/kimi-k2.5".into(),
-            name: "Kimi K2.5".into(),
-            provider: "opencode-zen".into(),
-            context_window: None,
-            tool_call: true,
-            reasoning: true,
-            input_audio: false,
-        },
-        ModelInfo {
-            id: "opencode-zen/kimi-k2".into(),
-            name: "Kimi K2".into(),
-            provider: "opencode-zen".into(),
-            context_window: None,
-            tool_call: true,
-            reasoning: false,
-            input_audio: false,
-        },
-        ModelInfo {
-            id: "opencode-zen/kimi-k2-thinking".into(),
-            name: "Kimi K2 Thinking".into(),
-            provider: "opencode-zen".into(),
-            context_window: None,
-            tool_call: true,
-            reasoning: true,
-            input_audio: false,
-        },
-        ModelInfo {
-            id: "opencode-zen/glm-5".into(),
-            name: "GLM 5".into(),
-            provider: "opencode-zen".into(),
-            context_window: None,
-            tool_call: true,
-            reasoning: false,
-            input_audio: false,
-        },
-        ModelInfo {
-            id: "opencode-zen/minimax-m2.5".into(),
-            name: "MiniMax M2.5".into(),
-            provider: "opencode-zen".into(),
-            context_window: None,
-            tool_call: true,
-            reasoning: false,
-            input_audio: false,
-        },
-        ModelInfo {
-            id: "opencode-zen/qwen3-coder".into(),
-            name: "Qwen3 Coder 480B".into(),
-            provider: "opencode-zen".into(),
-            context_window: None,
-            tool_call: true,
-            reasoning: false,
-            input_audio: false,
-        },
-        ModelInfo {
-            id: "opencode-zen/big-pickle".into(),
-            name: "Big Pickle".into(),
-            provider: "opencode-zen".into(),
-            context_window: None,
-            tool_call: true,
-            reasoning: false,
-            input_audio: false,
-        },
-        // Z.AI Coding Plan
-        ModelInfo {
-            id: "zai-coding-plan/glm-4.7".into(),
-            name: "GLM 4.7 (Coding)".into(),
-            provider: "zai-coding-plan".into(),
-            context_window: None,
-            tool_call: true,
-            reasoning: false,
-            input_audio: false,
-        },
-        ModelInfo {
-            id: "zai-coding-plan/glm-5".into(),
-            name: "GLM 5 (Coding)".into(),
-            provider: "zai-coding-plan".into(),
-            context_window: None,
-            tool_call: true,
-            reasoning: false,
-            input_audio: false,
-        },
-        ModelInfo {
-            id: "zai-coding-plan/glm-4.5-air".into(),
-            name: "GLM 4.5 Air (Coding)".into(),
-            provider: "zai-coding-plan".into(),
-            context_window: None,
-            tool_call: true,
-            reasoning: false,
-            input_audio: false,
-        },
-        // MiniMax
-        ModelInfo {
-            id: "minimax/MiniMax-M2.5".into(),
-            name: "MiniMax M2.5".into(),
-            provider: "minimax".into(),
-            context_window: Some(200000),
-            tool_call: true,
-            reasoning: true,
-            input_audio: false,
-        },
-        // MiniMax CN
+        // MiniMax CN - China-specific endpoint, not on models.dev
         ModelInfo {
             id: "minimax-cn/MiniMax-M2.5".into(),
             name: "MiniMax M2.5".into(),
@@ -252,16 +157,7 @@ fn extra_models() -> Vec<ModelInfo> {
             reasoning: true,
             input_audio: false,
         },
-        // Moonshot AI (Kimi)
-        ModelInfo {
-            id: "moonshot/kimi-k2.5".into(),
-            name: "Kimi K2.5".into(),
-            provider: "moonshot".into(),
-            context_window: None,
-            tool_call: true,
-            reasoning: true,
-            input_audio: false,
-        },
+        // Moonshot AI (Kimi) - moonshot-v1-8k not on models.dev
         ModelInfo {
             id: "moonshot/moonshot-v1-8k".into(),
             name: "Moonshot V1 8K".into(),
@@ -406,6 +302,9 @@ pub(super) async fn configured_providers(config_path: &std::path::Path) -> Vec<&
     if has_key("openrouter_key", "OPENROUTER_API_KEY") {
         providers.push("openrouter");
     }
+    if has_key("kilo_key", "KILO_API_KEY") {
+        providers.push("kilo");
+    }
     if has_key("zhipu_key", "ZHIPU_API_KEY") {
         providers.push("zhipu");
     }
@@ -433,6 +332,9 @@ pub(super) async fn configured_providers(config_path: &std::path::Path) -> Vec<&
     if has_key("opencode_zen_key", "OPENCODE_ZEN_API_KEY") {
         providers.push("opencode-zen");
     }
+    if has_key("opencode_go_key", "OPENCODE_GO_API_KEY") {
+        providers.push("opencode-go");
+    }
     if has_key("minimax_key", "MINIMAX_API_KEY") {
         providers.push("minimax");
     }
diff --git a/src/api/opencode_proxy.rs b/src/api/opencode_proxy.rs
new file mode 100644
index 000000000..1daa4f256
--- /dev/null
+++ b/src/api/opencode_proxy.rs
@@ -0,0 +1,205 @@
+//! Reverse proxy for OpenCode web UI.
+//!
+//! Forwards requests from `/api/opencode/{port}/{path}` to the OpenCode
+//! server running on `127.0.0.1:{port}`. This keeps the iframe same-origin
+//! with the Spacebot interface, avoiding CSP/CORS issues and working on
+//! hosted Fly instances where the OpenCode server is on localhost inside
+//! the VM.
+//!
+//! For HTML responses (the SPA shell), we inject a `<base>` tag so asset
+//! URLs resolve through the proxy path, and a script that sets the OpenCode
+//! SDK's `defaultServerUrl` in localStorage so API calls also route through
+//! the proxy rather than hitting `location.origin` directly.
+
+use axum::body::Body;
+use axum::extract::Request;
+use axum::http::{HeaderName, StatusCode, header};
+use axum::response::{IntoResponse, Response};
+use futures::TryStreamExt;
+
+/// Check if a header is a hop-by-hop header that must not be forwarded.
+fn is_hop_by_hop(name: &HeaderName) -> bool {
+    matches!(
+        *name,
+        header::CONNECTION
+            | header::TRANSFER_ENCODING
+            | header::UPGRADE
+            | header::TE
+            | header::TRAILER
+    ) || name.as_str() == "keep-alive"
+        || name.as_str() == "proxy-authenticate"
+        || name.as_str() == "proxy-authorization"
+}
+
+/// Port range used by `OpenCodeServerPool` (deterministic hash of directory path).
+const PORT_MIN: u16 = 10000;
+const PORT_MAX: u16 = 60000;
+
+/// Reverse proxy handler. Matches `/api/opencode/{port}/{*path}`.
+///
+/// Validates the port is in the OpenCode deterministic range, then forwards
+/// the full request (method, headers, body, query string) to the local
+/// OpenCode server. Streams the response back, supporting SSE connections.
+///
+/// HTML responses are intercepted and rewritten to inject:
+/// - A `<base href>` tag so relative asset URLs resolve through the proxy
+/// - A script that sets `localStorage` so the OpenCode SDK routes API calls
+///   through the proxy path instead of `location.origin`
+pub(super) async fn opencode_proxy(request: Request) -> Response {
+    let uri = request.uri().clone();
+    let path = uri.path();
+
+    // Parse port and remainder from the path.
+    // Path format: /api/opencode/{port}/{rest...}
+    let after_prefix = match path.strip_prefix("/api/opencode/") {
+        Some(rest) => rest,
+        None => return (StatusCode::BAD_REQUEST, "invalid proxy path").into_response(),
+    };
+
+    let (port_str, remainder) = match after_prefix.split_once('/') {
+        Some((p, r)) => (p, r),
+        None => (after_prefix, ""),
+    };
+
+    let port: u16 = match port_str.parse() {
+        Ok(p) if (PORT_MIN..=PORT_MAX).contains(&p) => p,
+        Ok(_) => return (StatusCode::BAD_REQUEST, "port out of allowed range").into_response(),
+        Err(_) => return (StatusCode::BAD_REQUEST, "invalid port").into_response(),
+    };
+
+    // Build target URL preserving query string
+    let target_url = match uri.query() {
+        Some(query) => format!("http://127.0.0.1:{port}/{remainder}?{query}"),
+        None => format!("http://127.0.0.1:{port}/{remainder}"),
+    };
+
+    // Build the proxied request
+    let method = request.method().clone();
+    let client = reqwest::Client::builder()
+        .no_proxy()
+        // No read timeout — SSE connections are long-lived
+        .connect_timeout(std::time::Duration::from_secs(5))
+        .build()
+        .unwrap_or_default();
+
+    let mut proxy_request = client.request(method, &target_url);
+
+    // Forward headers, skipping hop-by-hop and host
+    for (name, value) in request.headers() {
+        if name == header::HOST || is_hop_by_hop(name) {
+            continue;
+        }
+        proxy_request = proxy_request.header(name.clone(), value.clone());
+    }
+
+    // Forward request body
+    let body_bytes = match axum::body::to_bytes(request.into_body(), 10 * 1024 * 1024).await {
+        Ok(bytes) => bytes,
+        Err(error) => {
+            tracing::warn!(%error, "failed to read proxy request body");
+            return (StatusCode::BAD_REQUEST, "failed to read request body").into_response();
+        }
+    };
+
+    if !body_bytes.is_empty() {
+        proxy_request = proxy_request.body(body_bytes);
+    }
+
+    // Send the request
+    let upstream_response = match proxy_request.send().await {
+        Ok(response) => response,
+        Err(error) => {
+            tracing::debug!(%error, port, "OpenCode proxy: upstream unreachable");
+            return (StatusCode::BAD_GATEWAY, "OpenCode server unreachable").into_response();
+        }
+    };
+
+    // Check if this is an HTML response that needs rewriting
+    let is_html = upstream_response
+        .headers()
+        .get(header::CONTENT_TYPE)
+        .and_then(|value| value.to_str().ok())
+        .is_some_and(|content_type| content_type.contains("text/html"));
+
+    // Build the response, streaming the body
+    let status = upstream_response.status();
+    let mut response_builder = Response::builder().status(status.as_u16());
+
+    // Forward response headers, skipping hop-by-hop (and content-length for HTML
+    // since we'll modify the body)
+    for (name, value) in upstream_response.headers() {
+        if is_hop_by_hop(name) {
+            continue;
+        }
+        if is_html && name == header::CONTENT_LENGTH {
+            continue;
+        }
+        response_builder = response_builder.header(name.clone(), value.clone());
+    }
+
+    if is_html {
+        // Buffer the HTML body and inject base href + SDK URL override
+        let html_bytes = match upstream_response.bytes().await {
+            Ok(bytes) => bytes,
+            Err(error) => {
+                tracing::warn!(%error, "failed to read HTML response body");
+                return (StatusCode::BAD_GATEWAY, "failed to read upstream HTML").into_response();
+            }
+        };
+
+        let html = String::from_utf8_lossy(&html_bytes);
+        let proxy_base = format!("/api/opencode/{port}/");
+
+        // Inject <base href> for asset resolution and a script to set the SDK
+        // base URL in localStorage. The OpenCode SPA checks localStorage key
+        // "opencode.settings.dat:defaultServerUrl" before falling back to
+        // location.origin. By setting it to our proxy path, all SDK fetch
+        // calls route through /api/opencode/{port}/... which we proxy to
+        // the real OpenCode server.
+        let injection = format!(
+            "<base href=\"{proxy_base}\">\
+             <script>\
+             (function(){{\
+               try{{\
+                 var key='opencode.settings.dat:defaultServerUrl';\
+                 var url=location.origin+'{proxy_base}';\
+                 if(url.endsWith('/'))url=url.slice(0,-1);\
+                 localStorage.setItem(key,url);\
+               }}catch(e){{}}\
+             }})();\
+             </script>"
+        );
+
+        let rewritten = if let Some(head_pos) = html.find("<head>") {
+            let insert_at = head_pos + "<head>".len();
+            format!("{}{injection}{}", &html[..insert_at], &html[insert_at..])
+        } else if let Some(head_pos) = html.find("<HEAD>") {
+            let insert_at = head_pos + "<HEAD>".len();
+            format!("{}{injection}{}", &html[..insert_at], &html[insert_at..])
+        } else {
+            // No <head> tag found — prepend the injection
+            format!("{injection}{html}")
+        };
+
+        match response_builder.body(Body::from(rewritten)) {
+            Ok(response) => response,
+            Err(error) => {
+                tracing::warn!(%error, "failed to build rewritten HTML response");
+                (StatusCode::INTERNAL_SERVER_ERROR, "proxy response error").into_response()
+            }
+        }
+    } else {
+        // Non-HTML: stream the response body as-is (supports SSE)
+        let body_stream = upstream_response
+            .bytes_stream()
+            .map_err(std::io::Error::other);
+
+        match response_builder.body(Body::from_stream(body_stream)) {
+            Ok(response) => response,
+            Err(error) => {
+                tracing::warn!(%error, "failed to build proxy response");
+                (StatusCode::INTERNAL_SERVER_ERROR, "proxy response error").into_response()
+            }
+        }
+    }
+}
diff --git a/src/api/providers.rs b/src/api/providers.rs
index 954409992..39c9d6558 100644
--- a/src/api/providers.rs
+++ b/src/api/providers.rs
@@ -43,6 +43,7 @@ pub(super) struct ProviderStatus {
     openai: bool,
     openai_chatgpt: bool,
     openrouter: bool,
+    kilo: bool,
     zhipu: bool,
     groq: bool,
     together: bool,
@@ -53,6 +54,7 @@ pub(super) struct ProviderStatus {
     gemini: bool,
     ollama: bool,
     opencode_zen: bool,
+    opencode_go: bool,
     nvidia: bool,
     minimax: bool,
     minimax_cn: bool,
@@ -127,6 +129,7 @@ fn provider_toml_key(provider: &str) -> Option<&'static str> {
         "anthropic" => Some("anthropic_key"),
         "openai" => Some("openai_key"),
         "openrouter" => Some("openrouter_key"),
+        "kilo" => Some("kilo_key"),
         "zhipu" => Some("zhipu_key"),
         "groq" => Some("groq_key"),
         "together" => Some("together_key"),
@@ -137,6 +140,7 @@ fn provider_toml_key(provider: &str) -> Option<&'static str> {
         "gemini" => Some("gemini_key"),
         "ollama" => Some("ollama_base_url"),
         "opencode-zen" => Some("opencode_zen_key"),
+        "opencode-go" => Some("opencode_go_key"),
         "nvidia" => Some("nvidia_key"),
         "minimax" => Some("minimax_key"),
         "minimax-cn" => Some("minimax_cn_key"),
@@ -150,6 +154,24 @@ fn model_matches_provider(provider: &str, model: &str) -> bool {
     crate::llm::routing::provider_from_model(model) == provider
 }
 
+/// Reload the in-memory defaults config from disk so that newly created agents
+/// inherit the latest routing values rather than stale startup defaults.
+async fn refresh_defaults_config(state: &Arc<ApiState>) {
+    let config_path = state.config_path.read().await.clone();
+    if config_path.as_os_str().is_empty() || !config_path.exists() {
+        return;
+    }
+    match crate::config::Config::load_from_path(&config_path) {
+        Ok(new_config) => {
+            state.set_defaults_config(new_config.defaults).await;
+            tracing::debug!("defaults_config refreshed from config.toml");
+        }
+        Err(error) => {
+            tracing::warn!(%error, "failed to refresh defaults_config from config.toml");
+        }
+    }
+}
+
 fn normalize_openai_chatgpt_model(model: &str) -> Option<String> {
     let trimmed = model.trim();
     let (provider, model_name) = trimmed.split_once('/')?;
@@ -165,116 +187,8 @@ fn normalize_openai_chatgpt_model(model: &str) -> Option<String> {
 }
 
 fn build_test_llm_config(provider: &str, credential: &str) -> crate::config::LlmConfig {
-    use crate::config::{ApiType, ProviderConfig};
-
     let mut providers = HashMap::new();
-    let provider_config = match provider {
-        "anthropic" => Some(ProviderConfig {
-            api_type: ApiType::Anthropic,
-            base_url: "https://api.anthropic.com".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "openai" => Some(ProviderConfig {
-            api_type: ApiType::OpenAiCompletions,
-            base_url: "https://api.openai.com".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "openrouter" => Some(ProviderConfig {
-            api_type: ApiType::OpenAiCompletions,
-            base_url: "https://openrouter.ai/api".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "zhipu" => Some(ProviderConfig {
-            api_type: ApiType::OpenAiCompletions,
-            base_url: "https://api.z.ai/api/paas/v4".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "groq" => Some(ProviderConfig {
-            api_type: ApiType::OpenAiCompletions,
-            base_url: "https://api.groq.com/openai".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "together" => Some(ProviderConfig {
-            api_type: ApiType::OpenAiCompletions,
-            base_url: "https://api.together.xyz".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "fireworks" => Some(ProviderConfig {
-            api_type: ApiType::OpenAiCompletions,
-            base_url: "https://api.fireworks.ai/inference".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "deepseek" => Some(ProviderConfig {
-            api_type: ApiType::OpenAiCompletions,
-            base_url: "https://api.deepseek.com".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "xai" => Some(ProviderConfig {
-            api_type: ApiType::OpenAiCompletions,
-            base_url: "https://api.x.ai".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "mistral" => Some(ProviderConfig {
-            api_type: ApiType::OpenAiCompletions,
-            base_url: "https://api.mistral.ai".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "gemini" => Some(ProviderConfig {
-            api_type: ApiType::Gemini,
-            base_url: crate::config::GEMINI_PROVIDER_BASE_URL.to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "opencode-zen" => Some(ProviderConfig {
-            api_type: ApiType::OpenAiCompletions,
-            base_url: "https://opencode.ai/zen".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "nvidia" => Some(ProviderConfig {
-            api_type: ApiType::OpenAiCompletions,
-            base_url: "https://integrate.api.nvidia.com".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "minimax" => Some(ProviderConfig {
-            api_type: ApiType::Anthropic,
-            base_url: "https://api.minimax.io/anthropic".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "minimax-cn" => Some(ProviderConfig {
-            api_type: ApiType::Anthropic,
-            base_url: "https://api.minimaxi.com/anthropic".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "moonshot" => Some(ProviderConfig {
-            api_type: ApiType::OpenAiCompletions,
-            base_url: "https://api.moonshot.ai".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        "zai-coding-plan" => Some(ProviderConfig {
-            api_type: ApiType::OpenAiCompletions,
-            base_url: "https://api.z.ai/api/coding/paas/v4".to_string(),
-            api_key: credential.to_string(),
-            name: None,
-        }),
-        _ => None,
-    };
-
-    if let Some(provider_config) = provider_config {
+    if let Some(provider_config) = crate::config::default_provider_config(provider, credential) {
         providers.insert(provider.to_string(), provider_config);
     }
 
@@ -282,6 +196,7 @@ fn build_test_llm_config(provider: &str, credential: &str) -> crate::config::Llm
         anthropic_key: (provider == "anthropic").then(|| credential.to_string()),
         openai_key: (provider == "openai").then(|| credential.to_string()),
         openrouter_key: (provider == "openrouter").then(|| credential.to_string()),
+        kilo_key: (provider == "kilo").then(|| credential.to_string()),
         zhipu_key: (provider == "zhipu").then(|| credential.to_string()),
         groq_key: (provider == "groq").then(|| credential.to_string()),
         together_key: (provider == "together").then(|| credential.to_string()),
@@ -293,6 +208,7 @@ fn build_test_llm_config(provider: &str, credential: &str) -> crate::config::Llm
         ollama_key: None,
         ollama_base_url: (provider == "ollama").then(|| credential.to_string()),
         opencode_zen_key: (provider == "opencode-zen").then(|| credential.to_string()),
+        opencode_go_key: (provider == "opencode-go").then(|| credential.to_string()),
         nvidia_key: (provider == "nvidia").then(|| credential.to_string()),
         minimax_key: (provider == "minimax").then(|| credential.to_string()),
         minimax_cn_key: (provider == "minimax-cn").then(|| credential.to_string()),
@@ -413,6 +329,9 @@ async fn finalize_openai_oauth(
         .await
         .context("failed to write config.toml")?;
 
+    // Refresh in-memory defaults so newly created agents inherit the updated routing.
+    refresh_defaults_config(state).await;
+
     state
         .provider_setup_tx
         .try_send(crate::ProviderSetupEvent::ProvidersConfigured)
@@ -433,6 +352,7 @@ pub(super) async fn get_providers(
         openai,
         openai_chatgpt,
         openrouter,
+        kilo,
         zhipu,
         groq,
         together,
@@ -443,6 +363,7 @@ pub(super) async fn get_providers(
         gemini,
         ollama,
         opencode_zen,
+        opencode_go,
         nvidia,
         minimax,
         minimax_cn,
@@ -474,6 +395,7 @@ pub(super) async fn get_providers(
             has_value("openai_key", "OPENAI_API_KEY"),
             openai_oauth_configured,
             has_value("openrouter_key", "OPENROUTER_API_KEY"),
+            has_value("kilo_key", "KILO_API_KEY"),
             has_value("zhipu_key", "ZHIPU_API_KEY"),
             has_value("groq_key", "GROQ_API_KEY"),
             has_value("together_key", "TOGETHER_API_KEY"),
@@ -485,6 +407,7 @@ pub(super) async fn get_providers(
             has_value("ollama_base_url", "OLLAMA_BASE_URL")
                 || has_value("ollama_key", "OLLAMA_API_KEY"),
             has_value("opencode_zen_key", "OPENCODE_ZEN_API_KEY"),
+            has_value("opencode_go_key", "OPENCODE_GO_API_KEY"),
             has_value("nvidia_key", "NVIDIA_API_KEY"),
             has_value("minimax_key", "MINIMAX_API_KEY"),
             has_value("minimax_cn_key", "MINIMAX_CN_API_KEY"),
@@ -497,6 +420,7 @@ pub(super) async fn get_providers(
             std::env::var("OPENAI_API_KEY").is_ok(),
             openai_oauth_configured,
             std::env::var("OPENROUTER_API_KEY").is_ok(),
+            std::env::var("KILO_API_KEY").is_ok(),
             std::env::var("ZHIPU_API_KEY").is_ok(),
             std::env::var("GROQ_API_KEY").is_ok(),
             std::env::var("TOGETHER_API_KEY").is_ok(),
@@ -507,6 +431,7 @@ pub(super) async fn get_providers(
             std::env::var("GEMINI_API_KEY").is_ok(),
             std::env::var("OLLAMA_BASE_URL").is_ok() || std::env::var("OLLAMA_API_KEY").is_ok(),
             std::env::var("OPENCODE_ZEN_API_KEY").is_ok(),
+            std::env::var("OPENCODE_GO_API_KEY").is_ok(),
             std::env::var("NVIDIA_API_KEY").is_ok(),
             std::env::var("MINIMAX_API_KEY").is_ok(),
             std::env::var("MINIMAX_CN_API_KEY").is_ok(),
@@ -520,6 +445,7 @@ pub(super) async fn get_providers(
         openai,
         openai_chatgpt,
         openrouter,
+        kilo,
         zhipu,
         groq,
         together,
@@ -530,6 +456,7 @@ pub(super) async fn get_providers(
         gemini,
         ollama,
         opencode_zen,
+        opencode_go,
         nvidia,
         minimax,
         minimax_cn,
@@ -540,6 +467,7 @@ pub(super) async fn get_providers(
         || providers.openai
         || providers.openai_chatgpt
         || providers.openrouter
+        || providers.kilo
         || providers.zhipu
         || providers.groq
         || providers.together
@@ -550,6 +478,7 @@ pub(super) async fn get_providers(
         || providers.gemini
         || providers.ollama
         || providers.opencode_zen
+        || providers.opencode_go
         || providers.nvidia
         || providers.minimax
         || providers.minimax_cn
@@ -801,7 +730,9 @@ pub(super) async fn update_provider(
     State(state): State<Arc<ApiState>>,
     Json(request): Json<ProviderUpdateRequest>,
 ) -> Result<Json<ProviderUpdateResponse>, StatusCode> {
-    let Some(key_name) = provider_toml_key(&request.provider) else {
+    let normalized_provider = request.provider.trim().to_lowercase();
+    let normalized_model = request.model.trim();
+    let Some(key_name) = provider_toml_key(&normalized_provider) else {
         return Ok(Json(ProviderUpdateResponse {
             success: false,
             message: format!("Unknown provider: {}", request.provider),
@@ -822,7 +753,7 @@ pub(super) async fn update_provider(
         }));
     }
 
-    if !model_matches_provider(&request.provider, &request.model) {
+    if !model_matches_provider(&normalized_provider, normalized_model) {
         return Ok(Json(ProviderUpdateResponse {
             success: false,
             message: format!(
@@ -851,12 +782,15 @@ pub(super) async fn update_provider(
     }
 
     doc["llm"][key_name] = toml_edit::value(request.api_key);
-    apply_model_routing(&mut doc, request.model.as_str());
+    apply_model_routing(&mut doc, normalized_model);
 
     tokio::fs::write(&config_path, doc.to_string())
         .await
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
+    // Refresh in-memory defaults so newly created agents inherit the updated routing.
+    refresh_defaults_config(&state).await;
+
     state
         .provider_setup_tx
         .try_send(crate::ProviderSetupEvent::ProvidersConfigured)
@@ -874,7 +808,9 @@ pub(super) async fn update_provider(
 pub(super) async fn test_provider_model(
     Json(request): Json<ProviderModelTestRequest>,
 ) -> Result<Json<ProviderModelTestResponse>, StatusCode> {
-    if provider_toml_key(&request.provider).is_none() {
+    let normalized_provider = request.provider.trim().to_lowercase();
+    let normalized_model = request.model.trim().to_string();
+    if provider_toml_key(&normalized_provider).is_none() {
         return Ok(Json(ProviderModelTestResponse {
             success: false,
             message: format!("Unknown provider: {}", request.provider),
@@ -894,7 +830,7 @@ pub(super) async fn test_provider_model(
         }));
     }
 
-    if request.model.trim().is_empty() {
+    if normalized_model.is_empty() {
         return Ok(Json(ProviderModelTestResponse {
             success: false,
             message: "Model cannot be empty".to_string(),
@@ -904,12 +840,12 @@ pub(super) async fn test_provider_model(
         }));
     }
 
-    if !model_matches_provider(&request.provider, &request.model) {
+    if !model_matches_provider(&normalized_provider, &normalized_model) {
         return Ok(Json(ProviderModelTestResponse {
             success: false,
             message: format!(
                 "Model '{}' does not match provider '{}'.",
-                request.model, request.provider
+                normalized_model, request.provider
             ),
             provider: request.provider,
             model: request.model,
@@ -917,7 +853,7 @@ pub(super) async fn test_provider_model(
         }));
     }
 
-    let llm_config = build_test_llm_config(&request.provider, request.api_key.trim());
+    let llm_config = build_test_llm_config(&normalized_provider, request.api_key.trim());
     let llm_manager = match crate::llm::LlmManager::new(llm_config).await {
         Ok(manager) => Arc::new(manager),
         Err(error) => {
@@ -931,7 +867,7 @@ pub(super) async fn test_provider_model(
         }
     };
 
-    let model = crate::llm::SpacebotModel::make(&llm_manager, request.model.clone());
+    let model = crate::llm::SpacebotModel::make(&llm_manager, normalized_model);
     let agent = AgentBuilder::new(model)
         .preamble("You are running a provider connectivity check. Reply with exactly: OK")
         .build();
@@ -958,6 +894,7 @@ pub(super) async fn delete_provider(
     State(state): State<Arc<ApiState>>,
     axum::extract::Path(provider): axum::extract::Path<String>,
 ) -> Result<Json<ProviderUpdateResponse>, StatusCode> {
+    let provider = provider.trim().to_lowercase();
     // OpenAI ChatGPT OAuth credentials are stored as a separate JSON file,
     // not in the TOML config, so handle removal separately.
     if provider == "openai-chatgpt" {
@@ -1015,3 +952,20 @@ pub(super) async fn delete_provider(
         message: format!("Provider '{}' removed", provider),
     }))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::build_test_llm_config;
+
+    #[test]
+    fn build_test_llm_config_registers_ollama_provider_from_base_url() {
+        let config = build_test_llm_config("ollama", "http://remote-ollama.local:11434");
+        let provider = config
+            .providers
+            .get("ollama")
+            .expect("ollama provider should be registered");
+
+        assert_eq!(provider.base_url, "http://remote-ollama.local:11434");
+        assert_eq!(provider.api_key, "");
+    }
+}
diff --git a/src/api/secrets.rs b/src/api/secrets.rs
new file mode 100644
index 000000000..bc97fccd5
--- /dev/null
+++ b/src/api/secrets.rs
@@ -0,0 +1,760 @@
+//! Secret management API endpoints.
+//!
+//! Provides CRUD operations, encryption lifecycle management, and auto-migration
+//! for the instance-level secret store. Secrets are global — shared across all
+//! agents in the instance.
+
+use super::state::ApiState;
+use crate::config::{
+    DefaultsConfig, DiscordConfig, EmailConfig, LlmConfig, SlackConfig, TelegramConfig,
+    TwitchConfig,
+};
+use crate::secrets::store::{
+    ExportData, SecretCategory, SecretsStore, StoreState, SystemSecrets, auto_categorize,
+};
+
+use axum::Json;
+use axum::extract::{Path, State};
+use axum::http::StatusCode;
+use axum::response::IntoResponse;
+use serde::{Deserialize, Serialize};
+
+use std::sync::Arc;
+
+/// Keystore identifier for the instance-level master key.
+const KEYSTORE_INSTANCE_ID: &str = "instance";
+
+fn get_secrets_store(
+    state: &ApiState,
+) -> Result<Arc<SecretsStore>, (StatusCode, Json<serde_json::Value>)> {
+    let guard = state.secrets_store.load();
+    match (*guard).as_ref() {
+        Some(store) => Ok(store.clone()),
+        None => Err((
+            StatusCode::SERVICE_UNAVAILABLE,
+            Json(serde_json::json!({"error": "secrets store not initialized"})),
+        )),
+    }
+}
+
+/// `GET /api/secrets/status` — Store state, counts, encryption status.
+pub async fn secrets_status(State(state): State<Arc<ApiState>>) -> impl IntoResponse {
+    let store = match get_secrets_store(&state) {
+        Ok(s) => s,
+        Err(e) => return e.into_response(),
+    };
+
+    // TODO: detect platform_managed from deployment mode.
+    match store.status(false) {
+        Ok(status) => Json(status).into_response(),
+        Err(error) => (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(serde_json::json!({"error": error.to_string()})),
+        )
+            .into_response(),
+    }
+}
+
+#[derive(Serialize)]
+struct SecretListItem {
+    name: String,
+    category: SecretCategory,
+    created_at: chrono::DateTime<chrono::Utc>,
+    updated_at: chrono::DateTime<chrono::Utc>,
+}
+
+#[derive(Serialize)]
+struct SecretListResponse {
+    secrets: Vec<SecretListItem>,
+}
+
+/// `GET /api/secrets` — List all secrets (name + category, no values).
+pub async fn list_secrets(State(state): State<Arc<ApiState>>) -> impl IntoResponse {
+    let store = match get_secrets_store(&state) {
+        Ok(s) => s,
+        Err(e) => return e.into_response(),
+    };
+
+    match store.list_metadata() {
+        Ok(metadata) => {
+            let mut secrets: Vec<SecretListItem> = metadata
+                .into_iter()
+                .map(|(name, meta)| SecretListItem {
+                    name,
+                    category: meta.category,
+                    created_at: meta.created_at,
+                    updated_at: meta.updated_at,
+                })
+                .collect();
+            secrets.sort_by(|a, b| a.name.cmp(&b.name));
+            Json(SecretListResponse { secrets }).into_response()
+        }
+        Err(error) => (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(serde_json::json!({"error": error.to_string()})),
+        )
+            .into_response(),
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct PutSecretBody {
+    pub value: String,
+    /// If not provided, auto-categorized based on the secret name.
+    pub category: Option<SecretCategory>,
+}
+
+#[derive(Serialize)]
+struct PutSecretResponse {
+    name: String,
+    category: SecretCategory,
+    reload_required: bool,
+    message: String,
+}
+
+/// `PUT /api/secrets/:name` — Add or update a secret.
+pub async fn put_secret(
+    State(state): State<Arc<ApiState>>,
+    Path(name): Path<String>,
+    Json(body): Json<PutSecretBody>,
+) -> impl IntoResponse {
+    let store = match get_secrets_store(&state) {
+        Ok(s) => s,
+        Err(e) => return e.into_response(),
+    };
+
+    if store.state() == StoreState::Locked {
+        return (
+            StatusCode::LOCKED,
+            Json(serde_json::json!({"error": "secret store is locked — unlock with master key first"})),
+        )
+            .into_response();
+    }
+
+    let category = body.category.unwrap_or_else(|| auto_categorize(&name));
+
+    match store.set(&name, &body.value, category) {
+        Ok(()) => {
+            let reload_required = category == SecretCategory::System;
+            let message = if reload_required {
+                "Secret updated. Reload config or restart for the new value to take effect."
+                    .to_string()
+            } else {
+                "Secret updated. Available to workers immediately.".to_string()
+            };
+            Json(PutSecretResponse {
+                name,
+                category,
+                reload_required,
+                message,
+            })
+            .into_response()
+        }
+        Err(error) => (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(serde_json::json!({"error": error.to_string()})),
+        )
+            .into_response(),
+    }
+}
+
+#[derive(Serialize)]
+struct DeleteSecretResponse {
+    deleted: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    warning: Option<String>,
+}
+
+/// `DELETE /api/secrets/:name` — Delete a secret.
+pub async fn delete_secret(
+    State(state): State<Arc<ApiState>>,
+    Path(name): Path<String>,
+) -> impl IntoResponse {
+    let store = match get_secrets_store(&state) {
+        Ok(s) => s,
+        Err(e) => return e.into_response(),
+    };
+
+    if store.state() == StoreState::Locked {
+        return (
+            StatusCode::LOCKED,
+            Json(serde_json::json!({"error": "secret store is locked — unlock with master key first"})),
+        )
+            .into_response();
+    }
+
+    match store.delete(&name) {
+        Ok(()) => Json(DeleteSecretResponse {
+            deleted: name,
+            warning: None,
+        })
+        .into_response(),
+        Err(error) => (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(serde_json::json!({"error": error.to_string()})),
+        )
+            .into_response(),
+    }
+}
+
+#[derive(Serialize)]
+struct SecretInfoResponse {
+    name: String,
+    category: SecretCategory,
+    created_at: chrono::DateTime<chrono::Utc>,
+    updated_at: chrono::DateTime<chrono::Utc>,
+}
+
+/// `GET /api/secrets/:name/info` — Secret metadata (no value).
+pub async fn secret_info(
+    State(state): State<Arc<ApiState>>,
+    Path(name): Path<String>,
+) -> impl IntoResponse {
+    let store = match get_secrets_store(&state) {
+        Ok(s) => s,
+        Err(e) => return e.into_response(),
+    };
+
+    match store.get_metadata(&name) {
+        Ok(meta) => Json(SecretInfoResponse {
+            name,
+            category: meta.category,
+            created_at: meta.created_at,
+            updated_at: meta.updated_at,
+        })
+        .into_response(),
+        Err(_) => (
+            StatusCode::NOT_FOUND,
+            Json(serde_json::json!({"error": format!("secret '{name}' not found")})),
+        )
+            .into_response(),
+    }
+}
+
+#[derive(Serialize)]
+struct EncryptResponse {
+    master_key: String,
+    message: String,
+}
+
+/// `POST /api/secrets/encrypt` — Enable encryption. Returns the master key (hex).
+pub async fn enable_encryption(State(state): State<Arc<ApiState>>) -> impl IntoResponse {
+    let store = match get_secrets_store(&state) {
+        Ok(s) => s,
+        Err(e) => return e.into_response(),
+    };
+
+    match store.enable_encryption() {
+        Ok(key_bytes) => {
+            // Store master key in OS credential store.
+            let keystore = crate::secrets::keystore::platform_keystore();
+            if let Err(error) = keystore.store_key(KEYSTORE_INSTANCE_ID, &key_bytes) {
+                tracing::warn!(%error, "failed to store master key in OS credential store — user must save the displayed key");
+            }
+
+            Json(EncryptResponse {
+                master_key: hex::encode(&key_bytes),
+                message: "Encryption enabled. Save this master key — you will need it to unlock \
+                          the secret manager after a reboot (Linux) or if the Keychain is reset \
+                          (macOS). This is the only time the key will be shown."
+                    .to_string(),
+            })
+            .into_response()
+        }
+        Err(error) => (
+            StatusCode::BAD_REQUEST,
+            Json(serde_json::json!({"error": error.to_string()})),
+        )
+            .into_response(),
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct UnlockBody {
+    pub master_key: String,
+}
+
+/// `POST /api/secrets/unlock` — Unlock encrypted store with master key (hex).
+pub async fn unlock_secrets(
+    State(state): State<Arc<ApiState>>,
+    Json(body): Json<UnlockBody>,
+) -> impl IntoResponse {
+    let store = match get_secrets_store(&state) {
+        Ok(s) => s,
+        Err(e) => return e.into_response(),
+    };
+
+    let key_bytes = match hex::decode(&body.master_key) {
+        Ok(bytes) => bytes,
+        Err(_) => {
+            return (
+                StatusCode::BAD_REQUEST,
+                Json(serde_json::json!({"error": "invalid master key format (expected hex)"})),
+            )
+                .into_response();
+        }
+    };
+
+    match store.unlock(&key_bytes) {
+        Ok(()) => {
+            // Also store in OS credential store for automatic unlock on next restart.
+            let keystore = crate::secrets::keystore::platform_keystore();
+            if let Err(error) = keystore.store_key(KEYSTORE_INSTANCE_ID, &key_bytes) {
+                tracing::warn!(%error, "failed to persist master key in OS credential store");
+            }
+
+            let status = store.status(false).ok();
+            Json(serde_json::json!({
+                "state": "unlocked",
+                "secret_count": status.map(|s| s.secret_count).unwrap_or(0),
+                "message": "Secret manager unlocked."
+            }))
+            .into_response()
+        }
+        Err(error) => {
+            let status = if error.to_string().contains("invalid")
+                || error.to_string().contains("InvalidKey")
+            {
+                StatusCode::UNAUTHORIZED
+            } else {
+                StatusCode::INTERNAL_SERVER_ERROR
+            };
+            (
+                status,
+                Json(serde_json::json!({"error": error.to_string()})),
+            )
+                .into_response()
+        }
+    }
+}
+
+/// `POST /api/secrets/lock` — Lock encrypted store (clear key from memory).
+pub async fn lock_secrets(State(state): State<Arc<ApiState>>) -> impl IntoResponse {
+    let store = match get_secrets_store(&state) {
+        Ok(s) => s,
+        Err(e) => return e.into_response(),
+    };
+
+    // Clear key from OS credential store too.
+    let keystore = crate::secrets::keystore::platform_keystore();
+    if let Err(error) = keystore.delete_key(KEYSTORE_INSTANCE_ID) {
+        tracing::warn!(%error, "failed to delete master key from OS credential store");
+    }
+
+    match store.lock() {
+        Ok(()) => Json(serde_json::json!({
+            "state": "locked",
+            "message": "Secret manager locked. Secrets remain encrypted on disk."
+        }))
+        .into_response(),
+        Err(error) => (
+            StatusCode::BAD_REQUEST,
+            Json(serde_json::json!({"error": error.to_string()})),
+        )
+            .into_response(),
+    }
+}
+
+/// `POST /api/secrets/rotate` — Rotate master key.
+pub async fn rotate_key(State(state): State<Arc<ApiState>>) -> impl IntoResponse {
+    let store = match get_secrets_store(&state) {
+        Ok(s) => s,
+        Err(e) => return e.into_response(),
+    };
+
+    match store.rotate_key() {
+        Ok(new_key) => {
+            // Update OS credential store with new key.
+            let keystore = crate::secrets::keystore::platform_keystore();
+            if let Err(error) = keystore.store_key(KEYSTORE_INSTANCE_ID, &new_key) {
+                tracing::warn!(%error, "failed to store rotated key in OS credential store");
+            }
+
+            Json(serde_json::json!({
+                "master_key": hex::encode(&new_key),
+                "message": "Master key rotated. Save the new key — the old key no longer works."
+            }))
+            .into_response()
+        }
+        Err(error) => (
+            StatusCode::BAD_REQUEST,
+            Json(serde_json::json!({"error": error.to_string()})),
+        )
+            .into_response(),
+    }
+}
+
+#[derive(Serialize)]
+struct MigrationItem {
+    config_key: String,
+    secret_name: String,
+    category: SecretCategory,
+}
+
+#[derive(Serialize)]
+struct MigrateResponse {
+    migrated: Vec<MigrationItem>,
+    skipped: Vec<String>,
+    message: String,
+}
+
+/// `POST /api/secrets/migrate` — Auto-migrate literal keys from config.toml
+/// to the secret store.
+///
+/// Scans the resolved config for plaintext credential values (not `env:` or
+/// `secret:` prefixed) and moves them to the secret store, replacing the
+/// config.toml entries with `secret:NAME` references.
+pub async fn migrate_secrets(State(state): State<Arc<ApiState>>) -> impl IntoResponse {
+    let store = match get_secrets_store(&state) {
+        Ok(s) => s,
+        Err(e) => return e.into_response(),
+    };
+
+    if store.state() == StoreState::Locked {
+        return (
+            StatusCode::LOCKED,
+            Json(serde_json::json!({"error": "secret store is locked — unlock first"})),
+        )
+            .into_response();
+    }
+
+    // Read the raw config.toml to find literal key values.
+    let config_path = state.config_path.read().await.clone();
+    let config_content = match std::fs::read_to_string(&config_path) {
+        Ok(content) => content,
+        Err(error) => {
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(serde_json::json!({"error": format!("failed to read config.toml: {error}")})),
+            )
+                .into_response();
+        }
+    };
+
+    let mut doc = match config_content.parse::<toml_edit::DocumentMut>() {
+        Ok(doc) => doc,
+        Err(error) => {
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(serde_json::json!({"error": format!("failed to parse config.toml: {error}")})),
+            )
+                .into_response();
+        }
+    };
+
+    let mut migrated = Vec::new();
+    let skipped = Vec::new();
+
+    // All secret migration is driven by SystemSecrets trait impls.
+    // Each config section declares its own credential fields — no hard-coded
+    // TOML paths needed.
+    //
+    // Non-adapter sections (LLM keys, search keys):
+    migrate_section_secrets::<LlmConfig>(&store, &mut doc, &mut migrated);
+    migrate_section_secrets::<DefaultsConfig>(&store, &mut doc, &mut migrated);
+    // Messaging adapters (default + named instances):
+    migrate_section_secrets::<DiscordConfig>(&store, &mut doc, &mut migrated);
+    migrate_section_secrets::<SlackConfig>(&store, &mut doc, &mut migrated);
+    migrate_section_secrets::<TelegramConfig>(&store, &mut doc, &mut migrated);
+    migrate_section_secrets::<TwitchConfig>(&store, &mut doc, &mut migrated);
+    migrate_section_secrets::<EmailConfig>(&store, &mut doc, &mut migrated);
+
+    // Write updated config.toml if any migrations were made.
+    if !migrated.is_empty()
+        && let Err(error) = std::fs::write(&config_path, doc.to_string())
+    {
+        tracing::error!(%error, "failed to write updated config.toml after migration");
+        return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(serde_json::json!({
+                    "error": format!("migrated {count} secrets to the store but failed to update config.toml: {error}", count = migrated.len())
+                })),
+            )
+                .into_response();
+    }
+
+    let count = migrated.len();
+    Json(MigrateResponse {
+        migrated,
+        skipped,
+        message: if count > 0 {
+            format!("Migrated {count} secrets. config.toml updated with secret: references.")
+        } else {
+            "No plaintext secrets found to migrate.".to_string()
+        },
+    })
+    .into_response()
+}
+
+/// `POST /api/secrets/export` — Export all secrets as a JSON backup.
+pub async fn export_secrets(State(state): State<Arc<ApiState>>) -> impl IntoResponse {
+    let store = match get_secrets_store(&state) {
+        Ok(s) => s,
+        Err(e) => return e.into_response(),
+    };
+
+    match store.export_all() {
+        Ok(export) => {
+            let mut response = serde_json::json!({
+                "version": export.version,
+                "encrypted": export.encrypted,
+                "entries": export.entries,
+                "count": export.entries.len(),
+            });
+            if !export.encrypted {
+                response["warning"] = serde_json::json!(
+                    "Encryption is not enabled. This export contains plaintext secrets. \
+                     Store it securely or enable encryption first with: spacebot secrets encrypt"
+                );
+            }
+            Json(response).into_response()
+        }
+        Err(error) => {
+            let status = if error.to_string().contains("locked") {
+                StatusCode::LOCKED
+            } else {
+                StatusCode::INTERNAL_SERVER_ERROR
+            };
+            (
+                status,
+                Json(serde_json::json!({"error": error.to_string()})),
+            )
+                .into_response()
+        }
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ImportBody {
+    /// The export data to import (JSON object matching ExportData format).
+    #[serde(flatten)]
+    pub data: ExportData,
+    /// Whether to overwrite existing secrets with the same name.
+    #[serde(default)]
+    pub overwrite: bool,
+}
+
+/// `POST /api/secrets/import` — Import secrets from a backup.
+pub async fn import_secrets(
+    State(state): State<Arc<ApiState>>,
+    Json(body): Json<ImportBody>,
+) -> impl IntoResponse {
+    let store = match get_secrets_store(&state) {
+        Ok(s) => s,
+        Err(e) => return e.into_response(),
+    };
+
+    match store.import_all(&body.data, body.overwrite) {
+        Ok(result) => {
+            let message = if result.skipped.is_empty() {
+                format!("Imported {} secrets.", result.imported)
+            } else {
+                format!(
+                    "Imported {} secrets. {} conflicts (existing secrets with same name): {}",
+                    result.imported,
+                    result.skipped.len(),
+                    result.skipped.join(", ")
+                )
+            };
+            Json(serde_json::json!({
+                "imported": result.imported,
+                "skipped": result.skipped,
+                "message": message,
+            }))
+            .into_response()
+        }
+        Err(error) => {
+            let status = if error.to_string().contains("locked") {
+                StatusCode::LOCKED
+            } else {
+                StatusCode::INTERNAL_SERVER_ERROR
+            };
+            (
+                status,
+                Json(serde_json::json!({"error": error.to_string()})),
+            )
+                .into_response()
+        }
+    }
+}
+
+/// Try to migrate a single TOML field to the secret store.
+///
+/// Reads the value at `path` in the TOML document. If it's a plaintext literal
+/// (not `env:` or `secret:` prefixed and not empty), stores it in the secret
+/// store and replaces the TOML value with a `secret:NAME` reference.
+fn try_migrate_field(
+    store: &SecretsStore,
+    doc: &mut toml_edit::DocumentMut,
+    path: &[&str],
+    secret_name: &str,
+    migrated: &mut Vec<MigrationItem>,
+) {
+    let value_str = match get_toml_value(doc, path) {
+        Some(item) => match item.as_str() {
+            Some(s) => s.to_string(),
+            None => return,
+        },
+        None => return,
+    };
+
+    if value_str.starts_with("env:") || value_str.starts_with("secret:") || value_str.is_empty() {
+        return;
+    }
+
+    let category = auto_categorize(secret_name);
+    if let Err(error) = store.set(secret_name, &value_str, category) {
+        tracing::warn!(%error, secret_name, "failed to migrate secret");
+        return;
+    }
+
+    set_toml_value(doc, path, &format!("secret:{secret_name}"));
+
+    migrated.push(MigrationItem {
+        config_key: path.join("."),
+        secret_name: secret_name.to_string(),
+        category,
+    });
+}
+
+/// Migrate all credential fields for a config section that implements [`SystemSecrets`].
+///
+/// For non-adapter sections (e.g. `LlmConfig`, `DefaultsConfig`), migrates
+/// fields at `{section}.{toml_key}`.
+///
+/// For messaging adapter sections (`is_messaging_adapter() == true`), additionally
+/// scans `messaging.{section}.instances` for named instances and migrates each
+/// instance's credential fields using the `{PREFIX}_{INSTANCE}_{SUFFIX}` naming
+/// pattern (e.g. `DISCORD_ALERTS_BOT_TOKEN`).
+fn migrate_section_secrets<T: SystemSecrets>(
+    store: &SecretsStore,
+    doc: &mut toml_edit::DocumentMut,
+    migrated: &mut Vec<MigrationItem>,
+) {
+    let section = T::section();
+    let fields = T::secret_fields();
+
+    // Build the TOML path prefix for this section.
+    // Messaging adapters live under `messaging.{section}`, others under `{section}`.
+    let is_adapter = T::is_messaging_adapter();
+
+    // Migrate default (top-level) fields.
+    for field in fields {
+        let path: Vec<&str> = if is_adapter {
+            vec!["messaging", section, field.toml_key]
+        } else {
+            vec![section, field.toml_key]
+        };
+        try_migrate_field(store, doc, &path, field.secret_name, migrated);
+    }
+
+    // Named instances are only relevant for messaging adapters.
+    if !is_adapter {
+        return;
+    }
+
+    // Walk the TOML array at `messaging.{section}.instances` and migrate
+    // each named instance's credential fields.
+    let instances_array = doc
+        .get("messaging")
+        .and_then(|m| m.get(section))
+        .and_then(|p| p.get("instances"))
+        .and_then(|i| i.as_array_of_tables())
+        .cloned();
+
+    let Some(instances) = instances_array else {
+        return;
+    };
+
+    for (index, instance) in instances.iter().enumerate() {
+        let instance_name = match instance.get("name").and_then(|n| n.as_str()) {
+            Some(name) if !name.is_empty() => name.to_string(),
+            _ => continue,
+        };
+
+        for field in fields {
+            let Some(secret_name) = field.instance_name(&instance_name) else {
+                continue;
+            };
+
+            // Read the value from the instance entry.
+            let value_str = match instance.get(field.toml_key).and_then(|v| v.as_str()) {
+                Some(s) if !s.is_empty() && !s.starts_with("env:") && !s.starts_with("secret:") => {
+                    s.to_string()
+                }
+                _ => continue,
+            };
+
+            let category = auto_categorize(&secret_name);
+            if let Err(error) = store.set(&secret_name, &value_str, category) {
+                tracing::warn!(%error, %secret_name, "failed to migrate instance secret");
+                continue;
+            }
+
+            // Update the TOML value in-place within the instances array.
+            set_instance_toml_value(
+                doc,
+                section,
+                index,
+                field.toml_key,
+                &format!("secret:{secret_name}"),
+            );
+
+            migrated.push(MigrationItem {
+                config_key: format!("messaging.{section}.instances[{index}].{}", field.toml_key),
+                secret_name,
+                category,
+            });
+        }
+    }
+}
+
+fn get_toml_value<'a>(
+    doc: &'a toml_edit::DocumentMut,
+    path: &[&str],
+) -> Option<&'a toml_edit::Item> {
+    let mut current: &toml_edit::Item = doc.as_item();
+    for key in path {
+        current = current.get(key)?;
+    }
+    if current.is_none() {
+        return None;
+    }
+    Some(current)
+}
+
+fn set_toml_value(doc: &mut toml_edit::DocumentMut, path: &[&str], value: &str) {
+    if path.is_empty() {
+        return;
+    }
+    let (parents, key) = path.split_at(path.len() - 1);
+    let mut current: &mut toml_edit::Item = doc.as_item_mut();
+    for parent in parents {
+        if !current.is_table_like() {
+            return;
+        }
+        current = &mut current[parent];
+    }
+    current[key[0]] = toml_edit::value(value);
+}
+
+/// Set a value inside `messaging.{platform}.instances[{index}].{key}`.
+fn set_instance_toml_value(
+    doc: &mut toml_edit::DocumentMut,
+    platform: &str,
+    index: usize,
+    key: &str,
+    value: &str,
+) {
+    let Some(instances) = doc
+        .get_mut("messaging")
+        .and_then(|m| m.get_mut(platform))
+        .and_then(|p| p.get_mut("instances"))
+        .and_then(|i| i.as_array_of_tables_mut())
+    else {
+        return;
+    };
+    if let Some(instance) = instances.get_mut(index) {
+        instance[key] = toml_edit::value(value);
+    }
+}
diff --git a/src/api/server.rs b/src/api/server.rs
index 9cf29495f..1fe29dc87 100644
--- a/src/api/server.rs
+++ b/src/api/server.rs
@@ -3,7 +3,8 @@
 use super::state::ApiState;
 use super::{
     agents, bindings, channels, config, cortex, cron, ingest, links, mcp, memories, messaging,
-    models, providers, settings, skills, system, webchat,
+    models, opencode_proxy, providers, secrets, settings, skills, system, tasks, tools, webchat,
+    workers,
 };
 
 use axum::Json;
@@ -13,7 +14,7 @@ use axum::extract::{DefaultBodyLimit, Request, State};
 use axum::http::{StatusCode, Uri, header};
 use axum::middleware::{self, Next};
 use axum::response::{Html, IntoResponse, Response};
-use axum::routing::{delete, get, post, put};
+use axum::routing::{any, delete, get, post, put};
 use rust_embed::Embed;
 use serde_json::json;
 use tower_http::cors::CorsLayer;
@@ -86,8 +87,15 @@ pub async fn start_http_server(
             "/channels",
             get(channels::list_channels).delete(channels::delete_channel),
         )
+        .route("/channels/archive", put(channels::set_channel_archive))
         .route("/channels/messages", get(channels::channel_messages))
         .route("/channels/status", get(channels::channel_status))
+        .route("/agents/workers", get(workers::list_workers))
+        .route("/agents/workers/detail", get(workers::worker_detail))
+        .route(
+            "/opencode/{port}/{*path}",
+            any(opencode_proxy::opencode_proxy),
+        )
         .route("/agents/memories", get(memories::list_memories))
         .route("/agents/memories/search", get(memories::search_memories))
         .route("/agents/memories/graph", get(memories::memory_graph))
@@ -116,6 +124,18 @@ pub async fn start_http_server(
         .route("/agents/cron/executions", get(cron::cron_executions))
         .route("/agents/cron/trigger", post(cron::trigger_cron))
         .route("/agents/cron/toggle", put(cron::toggle_cron))
+        .route(
+            "/agents/tasks",
+            get(tasks::list_tasks).post(tasks::create_task),
+        )
+        .route(
+            "/agents/tasks/{number}",
+            get(tasks::get_task)
+                .put(tasks::update_task)
+                .delete(tasks::delete_task),
+        )
+        .route("/agents/tasks/{number}/approve", post(tasks::approve_task))
+        .route("/agents/tasks/{number}/execute", post(tasks::execute_task))
         .route("/channels/cancel", post(channels::cancel_process))
         .route(
             "/agents/ingest/files",
@@ -125,6 +145,22 @@ pub async fn start_http_server(
         .route("/agents/skills", get(skills::list_skills))
         .route("/agents/skills/install", post(skills::install_skill))
         .route("/agents/skills/remove", delete(skills::remove_skill))
+        .route("/agents/tools", get(tools::list_tools))
+        // Secret store management
+        .route("/secrets/status", get(secrets::secrets_status))
+        .route("/secrets", get(secrets::list_secrets))
+        .route(
+            "/secrets/{name}",
+            put(secrets::put_secret).delete(secrets::delete_secret),
+        )
+        .route("/secrets/{name}/info", get(secrets::secret_info))
+        .route("/secrets/migrate", post(secrets::migrate_secrets))
+        .route("/secrets/encrypt", post(secrets::enable_encryption))
+        .route("/secrets/unlock", post(secrets::unlock_secrets))
+        .route("/secrets/lock", post(secrets::lock_secrets))
+        .route("/secrets/rotate", post(secrets::rotate_key))
+        .route("/secrets/export", post(secrets::export_secrets))
+        .route("/secrets/import", post(secrets::import_secrets))
         .route("/skills/registry/browse", get(skills::registry_browse))
         .route("/skills/registry/search", get(skills::registry_search))
         .route(
@@ -149,6 +185,10 @@ pub async fn start_http_server(
             post(messaging::disconnect_platform),
         )
         .route("/messaging/toggle", post(messaging::toggle_platform))
+        .route(
+            "/messaging/instances",
+            post(messaging::create_messaging_instance).delete(messaging::delete_messaging_instance),
+        )
         .route(
             "/bindings",
             get(bindings::list_bindings)
diff --git a/src/api/settings.rs b/src/api/settings.rs
index 754c12f25..098d0034b 100644
--- a/src/api/settings.rs
+++ b/src/api/settings.rs
@@ -333,6 +333,42 @@ pub(super) async fn update_global_settings(
         .await
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
+    let reload_path = config_path.clone();
+    match tokio::task::spawn_blocking(move || crate::config::Config::load_from_path(&reload_path))
+        .await
+    {
+        Ok(Ok(new_config)) => {
+            let runtime_configs = state.runtime_configs.load();
+            let mcp_managers = state.mcp_managers.load();
+            let reload_targets = runtime_configs
+                .iter()
+                .filter_map(|(agent_id, runtime_config)| {
+                    mcp_managers.get(agent_id).map(|mcp_manager| {
+                        (
+                            agent_id.clone(),
+                            runtime_config.clone(),
+                            mcp_manager.clone(),
+                        )
+                    })
+                })
+                .collect::<Vec<_>>();
+            drop(runtime_configs);
+            drop(mcp_managers);
+
+            for (agent_id, runtime_config, mcp_manager) in reload_targets {
+                runtime_config
+                    .reload_config(&new_config, &agent_id, &mcp_manager)
+                    .await;
+            }
+        }
+        Ok(Err(error)) => {
+            tracing::warn!(%error, "settings written but failed to reload config immediately");
+        }
+        Err(error) => {
+            tracing::warn!(%error, "settings written but config reload task failed");
+        }
+    }
+
     let message = if requires_restart {
         "Settings updated. API server changes require a restart to take effect.".to_string()
     } else {
diff --git a/src/api/skills.rs b/src/api/skills.rs
index ccad77f22..8af60d97c 100644
--- a/src/api/skills.rs
+++ b/src/api/skills.rs
@@ -3,8 +3,22 @@ use super::state::{ApiEvent, ApiState};
 use axum::Json;
 use axum::extract::{Query, State};
 use axum::http::StatusCode;
+use moka::sync::Cache;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
+use std::sync::LazyLock;
+use std::time::Duration;
+
+const REGISTRY_SKILL_DESCRIPTION_CACHE_CAPACITY: u64 = 10_000;
+const REGISTRY_SKILL_DESCRIPTION_CACHE_TTL: Duration = Duration::from_secs(60 * 60 * 6);
+
+static REGISTRY_SKILL_DESCRIPTION_CACHE: LazyLock<Cache<String, Option<String>>> =
+    LazyLock::new(|| {
+        Cache::builder()
+            .max_capacity(REGISTRY_SKILL_DESCRIPTION_CACHE_CAPACITY)
+            .time_to_live(REGISTRY_SKILL_DESCRIPTION_CACHE_TTL)
+            .build()
+    });
 
 #[derive(Serialize)]
 pub(super) struct SkillInfo {
@@ -13,6 +27,8 @@ pub(super) struct SkillInfo {
     file_path: String,
     base_dir: String,
     source: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    source_repo: Option<String>,
 }
 
 #[derive(Serialize)]
@@ -52,6 +68,9 @@ pub(super) struct RegistrySkill {
     skill_id: String,
     name: String,
     installs: u64,
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    description: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     id: Option<String>,
 }
@@ -60,6 +79,8 @@ pub(super) struct RegistrySkill {
 pub(super) struct RegistryBrowseResponse {
     skills: Vec<RegistrySkill>,
     has_more: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    total: Option<u64>,
 }
 
 #[derive(Serialize)]
@@ -126,6 +147,7 @@ pub(super) async fn list_skills(
                 crate::skills::SkillSource::Instance => "instance".to_string(),
                 crate::skills::SkillSource::Workspace => "workspace".to_string(),
             },
+            source_repo: s.source_repo,
         })
         .collect();
 
@@ -214,7 +236,7 @@ pub(super) async fn registry_browse(
     let client = reqwest::Client::new();
     let response = client
         .get(&url)
-        .timeout(std::time::Duration::from_secs(10))
+        .timeout(Duration::from_secs(10))
         .send()
         .await
         .map_err(|error| {
@@ -233,6 +255,8 @@ pub(super) async fn registry_browse(
         #[serde(default)]
         #[serde(rename = "hasMore")]
         has_more: bool,
+        #[serde(default)]
+        total: Option<u64>,
     }
 
     let body: UpstreamResponse = response.json().await.map_err(|error| {
@@ -240,9 +264,14 @@ pub(super) async fn registry_browse(
         StatusCode::BAD_GATEWAY
     })?;
 
+    let mut skills = body.skills;
+    apply_cached_registry_descriptions(&mut skills);
+    spawn_registry_description_enrichment(client, skills.clone());
+
     Ok(Json(RegistryBrowseResponse {
-        skills: body.skills,
+        skills,
         has_more: body.has_more,
+        total: body.total,
     }))
 }
 
@@ -261,7 +290,7 @@ pub(super) async fn registry_search(
             ("q", &query.q),
             ("limit", &query.limit.min(100).to_string()),
         ])
-        .timeout(std::time::Duration::from_secs(10))
+        .timeout(Duration::from_secs(10))
         .send()
         .await
         .map_err(|error| {
@@ -286,9 +315,253 @@ pub(super) async fn registry_search(
         StatusCode::BAD_GATEWAY
     })?;
 
+    let mut skills = body.skills;
+    apply_cached_registry_descriptions(&mut skills);
+    spawn_registry_description_enrichment(client, skills.clone());
+
     Ok(Json(RegistrySearchResponse {
-        skills: body.skills,
+        skills,
         query: body.query,
         count: body.count,
     }))
 }
+
+fn apply_cached_registry_descriptions(skills: &mut [RegistrySkill]) {
+    for skill in skills {
+        if skill
+            .description
+            .as_ref()
+            .is_some_and(|description| !description.trim().is_empty())
+        {
+            continue;
+        }
+
+        let cache_key = registry_skill_key(&skill.source, &skill.skill_id);
+        if let Some(cached_description) = REGISTRY_SKILL_DESCRIPTION_CACHE.get(&cache_key) {
+            skill.description = cached_description;
+        }
+    }
+}
+
+fn spawn_registry_description_enrichment(client: reqwest::Client, skills: Vec<RegistrySkill>) {
+    let should_enrich = skills.iter().any(|skill| {
+        if skill
+            .description
+            .as_ref()
+            .is_some_and(|description| !description.trim().is_empty())
+        {
+            return false;
+        }
+
+        let cache_key = registry_skill_key(&skill.source, &skill.skill_id);
+        REGISTRY_SKILL_DESCRIPTION_CACHE.get(&cache_key).is_none()
+    });
+    if !should_enrich {
+        return;
+    }
+
+    tokio::spawn(async move {
+        let mut enrichment_skills = skills;
+        enrich_registry_descriptions(&client, &mut enrichment_skills).await;
+    });
+}
+
+async fn enrich_registry_descriptions(client: &reqwest::Client, skills: &mut [RegistrySkill]) {
+    let mut join_set = tokio::task::JoinSet::new();
+
+    for (index, skill) in skills.iter_mut().enumerate() {
+        if skill
+            .description
+            .as_ref()
+            .is_some_and(|description| !description.trim().is_empty())
+        {
+            continue;
+        }
+
+        let source = skill.source.clone();
+        let skill_id = skill.skill_id.clone();
+        let cache_key = registry_skill_key(&source, &skill_id);
+
+        if let Some(cached_description) = REGISTRY_SKILL_DESCRIPTION_CACHE.get(&cache_key) {
+            skill.description = cached_description;
+            continue;
+        }
+
+        let client = client.clone();
+        join_set.spawn(async move {
+            let description = fetch_registry_skill_description(&client, &source, &skill_id).await;
+            (index, cache_key, description)
+        });
+    }
+
+    while let Some(result) = join_set.join_next().await {
+        let Ok((index, cache_key, description)) = result else {
+            continue;
+        };
+        let description = description.filter(|candidate| !candidate.trim().is_empty());
+
+        if let Some(skill) = skills.get_mut(index) {
+            skill.description = description.clone();
+        }
+
+        REGISTRY_SKILL_DESCRIPTION_CACHE.insert(cache_key, description);
+    }
+}
+
+fn registry_skill_key(source: &str, skill_id: &str) -> String {
+    format!("{source}/{skill_id}")
+}
+
+async fn fetch_registry_skill_description(
+    client: &reqwest::Client,
+    source: &str,
+    skill_id: &str,
+) -> Option<String> {
+    let repo_name = source.split('/').next_back().unwrap_or_default();
+
+    let mut candidate_paths = if repo_name == skill_id {
+        vec![
+            "SKILL.md".to_string(),
+            format!("{skill_id}/SKILL.md"),
+            format!("skills/{skill_id}/SKILL.md"),
+            format!(".claude/skills/{skill_id}/SKILL.md"),
+        ]
+    } else {
+        vec![
+            format!("{skill_id}/SKILL.md"),
+            format!("skills/{skill_id}/SKILL.md"),
+            format!(".claude/skills/{skill_id}/SKILL.md"),
+            "SKILL.md".to_string(),
+        ]
+    };
+
+    for path in candidate_paths.drain(..) {
+        for branch in ["HEAD", "main", "master"] {
+            let url = format!("https://raw.githubusercontent.com/{source}/{branch}/{path}");
+            let response = match client
+                .get(&url)
+                .header(reqwest::header::USER_AGENT, "spacebot-registry-client")
+                .timeout(Duration::from_secs(3))
+                .send()
+                .await
+            {
+                Ok(response) => response,
+                Err(_) => continue,
+            };
+
+            if !response.status().is_success() {
+                continue;
+            }
+
+            let markdown = match response.text().await {
+                Ok(markdown) => markdown,
+                Err(_) => continue,
+            };
+
+            if let Some(description) = extract_skill_description(&markdown) {
+                return Some(description);
+            }
+        }
+    }
+
+    None
+}
+
+fn extract_skill_description(markdown: &str) -> Option<String> {
+    let lines = strip_frontmatter(markdown)
+        .lines()
+        .map(str::to_string)
+        .collect::<Vec<_>>();
+
+    for (index, line) in lines.iter().enumerate() {
+        let heading = line.trim().to_ascii_lowercase();
+        if heading.starts_with('#')
+            && heading.contains("description")
+            && let Some(description) = extract_paragraph(&lines[(index + 1)..])
+        {
+            return Some(description);
+        }
+    }
+
+    extract_paragraph(&lines)
+}
+
+fn strip_frontmatter(markdown: &str) -> String {
+    let mut lines = markdown.lines();
+    let Some(first_line) = lines.next() else {
+        return String::new();
+    };
+
+    if first_line.trim() != "---" {
+        return markdown.to_string();
+    }
+
+    for line in lines.by_ref() {
+        if line.trim() == "---" {
+            break;
+        }
+    }
+
+    lines.collect::<Vec<_>>().join("\n")
+}
+
+fn extract_paragraph(lines: &[String]) -> Option<String> {
+    let mut in_code_block = false;
+    let mut paragraph_lines = Vec::new();
+
+    for line in lines {
+        let trimmed = line.trim();
+
+        if trimmed.starts_with("```") {
+            in_code_block = !in_code_block;
+            continue;
+        }
+        if in_code_block {
+            continue;
+        }
+
+        if trimmed.is_empty() {
+            if paragraph_lines.is_empty() {
+                continue;
+            }
+            break;
+        }
+
+        if trimmed.starts_with('#') || trimmed.starts_with("| ---") {
+            if paragraph_lines.is_empty() {
+                continue;
+            }
+            break;
+        }
+
+        let cleaned = cleaned_description_line(trimmed);
+        if cleaned.is_empty() {
+            continue;
+        }
+        paragraph_lines.push(cleaned);
+    }
+
+    if paragraph_lines.is_empty() {
+        return None;
+    }
+
+    let mut description = paragraph_lines.join(" ");
+    description = description.split_whitespace().collect::<Vec<_>>().join(" ");
+
+    if description.is_empty() {
+        return None;
+    }
+
+    if description.chars().count() > 220 {
+        description = format!("{}...", description.chars().take(217).collect::<String>());
+    }
+
+    Some(description)
+}
+
+fn cleaned_description_line(line: &str) -> String {
+    line.trim_start_matches("- ")
+        .trim_start_matches("* ")
+        .trim_start_matches("+ ")
+        .replace('`', "")
+}
diff --git a/src/api/state.rs b/src/api/state.rs
index 03914f079..0f97f5d6e 100644
--- a/src/api/state.rs
+++ b/src/api/state.rs
@@ -11,6 +11,7 @@ use crate::memory::{EmbeddingModel, MemorySearch};
 use crate::messaging::MessagingManager;
 use crate::messaging::webchat::WebChatAdapter;
 use crate::prompts::PromptEngine;
+use crate::tasks::TaskStore;
 use crate::update::SharedUpdateStatus;
 use crate::{ProcessEvent, ProcessId};
 
@@ -65,12 +66,16 @@ pub struct ApiState {
     pub cron_stores: arc_swap::ArcSwap<HashMap<String, Arc<CronStore>>>,
     /// Per-agent cron schedulers for job timer management.
     pub cron_schedulers: arc_swap::ArcSwap<HashMap<String, Arc<Scheduler>>>,
+    /// Per-agent task stores for task CRUD operations.
+    pub task_stores: arc_swap::ArcSwap<HashMap<String, Arc<TaskStore>>>,
     /// Per-agent RuntimeConfig for reading live hot-reloaded configuration.
     pub runtime_configs: ArcSwap<HashMap<String, Arc<RuntimeConfig>>>,
     /// Per-agent MCP managers for status and reconnect APIs.
     pub mcp_managers: ArcSwap<HashMap<String, Arc<McpManager>>>,
     /// Per-agent sandbox instances for process containment.
     pub sandboxes: ArcSwap<HashMap<String, Arc<crate::sandbox::Sandbox>>>,
+    /// Instance-level secrets store (shared across all agents).
+    pub secrets_store: ArcSwap<Option<Arc<crate::secrets::store::SecretsStore>>>,
     /// Shared reference to the Discord permissions ArcSwap (same instance used by the adapter and file watcher).
     pub discord_permissions: RwLock<Option<Arc<ArcSwap<DiscordPermissions>>>>,
     /// Shared reference to the Slack permissions ArcSwap (same instance used by the adapter and file watcher).
@@ -99,6 +104,11 @@ pub struct ApiState {
     pub agent_remove_tx: mpsc::Sender<String>,
     /// Shared webchat adapter for session management from API handlers.
     pub webchat_adapter: ArcSwap<Option<Arc<WebChatAdapter>>>,
+    /// Cross-agent task store registry for delegation.
+    pub task_store_registry:
+        Arc<ArcSwap<std::collections::HashMap<String, Arc<crate::tasks::TaskStore>>>>,
+    /// Sender for cross-agent message injection.
+    pub injection_tx: mpsc::Sender<crate::ChannelInjection>,
     /// Instance-level agent links for the communication graph.
     pub agent_links: ArcSwap<Vec<crate::links::AgentLink>>,
     /// Visual agent groups for the topology UI.
@@ -131,12 +141,21 @@ pub enum ApiEvent {
         channel_id: String,
         is_typing: bool,
     },
+    /// Streaming text delta for an outbound assistant message.
+    OutboundMessageDelta {
+        agent_id: String,
+        channel_id: String,
+        text_delta: String,
+        aggregated_text: String,
+    },
     /// A worker was started.
     WorkerStarted {
         agent_id: String,
         channel_id: Option<String>,
         worker_id: String,
         task: String,
+        worker_type: String,
+        interactive: bool,
     },
     /// A worker's status changed.
     WorkerStatusUpdate {
@@ -145,12 +164,19 @@ pub enum ApiEvent {
         worker_id: String,
         status: String,
     },
+    /// A worker entered the idle state (waiting for follow-up input).
+    WorkerIdle {
+        agent_id: String,
+        channel_id: Option<String>,
+        worker_id: String,
+    },
     /// A worker completed.
     WorkerCompleted {
         agent_id: String,
         channel_id: Option<String>,
         worker_id: String,
         result: String,
+        success: bool,
     },
     /// A branch was started.
     BranchStarted {
@@ -173,6 +199,7 @@ pub enum ApiEvent {
         process_type: String,
         process_id: String,
         tool_name: String,
+        args: String,
     },
     /// A tool call completed on a process.
     ToolCompleted {
@@ -181,6 +208,7 @@ pub enum ApiEvent {
         process_type: String,
         process_id: String,
         tool_name: String,
+        result: String,
     },
     /// Configuration was reloaded (skills, identity, etc.).
     ConfigReloaded,
@@ -198,6 +226,20 @@ pub enum ApiEvent {
         link_id: String,
         channel_id: String,
     },
+    /// A task was created, updated, or deleted.
+    TaskUpdated {
+        agent_id: String,
+        task_number: i64,
+        status: String,
+        /// "created", "updated", or "deleted".
+        action: String,
+    },
+    /// A finalized content part from an OpenCode worker session.
+    OpenCodePartUpdated {
+        agent_id: String,
+        worker_id: String,
+        part: crate::opencode::types::OpenCodePart,
+    },
 }
 
 impl ApiState {
@@ -205,6 +247,10 @@ impl ApiState {
         provider_setup_tx: mpsc::Sender<crate::ProviderSetupEvent>,
         agent_tx: mpsc::Sender<crate::Agent>,
         agent_remove_tx: mpsc::Sender<String>,
+        injection_tx: mpsc::Sender<crate::ChannelInjection>,
+        task_store_registry: Arc<
+            ArcSwap<std::collections::HashMap<String, Arc<crate::tasks::TaskStore>>>,
+        >,
     ) -> Self {
         let (event_tx, _) = broadcast::channel(512);
         Self {
@@ -221,9 +267,11 @@ impl ApiState {
             config_path: RwLock::new(PathBuf::new()),
             cron_stores: arc_swap::ArcSwap::from_pointee(HashMap::new()),
             cron_schedulers: arc_swap::ArcSwap::from_pointee(HashMap::new()),
+            task_stores: arc_swap::ArcSwap::from_pointee(HashMap::new()),
             runtime_configs: ArcSwap::from_pointee(HashMap::new()),
             mcp_managers: ArcSwap::from_pointee(HashMap::new()),
             sandboxes: ArcSwap::from_pointee(HashMap::new()),
+            secrets_store: ArcSwap::from_pointee(None),
             discord_permissions: RwLock::new(None),
             slack_permissions: RwLock::new(None),
             bindings: RwLock::new(None),
@@ -237,6 +285,8 @@ impl ApiState {
             defaults_config: RwLock::new(None),
             agent_tx,
             agent_remove_tx,
+            task_store_registry,
+            injection_tx,
             webchat_adapter: ArcSwap::from_pointee(None),
             agent_links: ArcSwap::from_pointee(Vec::new()),
             agent_groups: ArcSwap::from_pointee(Vec::new()),
@@ -289,6 +339,8 @@ impl ApiState {
                                 worker_id,
                                 channel_id,
                                 task,
+                                worker_type,
+                                interactive,
                                 ..
                             } => {
                                 api_tx
@@ -297,6 +349,8 @@ impl ApiState {
                                         channel_id: channel_id.as_deref().map(|s| s.to_string()),
                                         worker_id: worker_id.to_string(),
                                         task: task.clone(),
+                                        worker_type: worker_type.clone(),
+                                        interactive: *interactive,
                                     })
                                     .ok();
                             }
@@ -330,10 +384,24 @@ impl ApiState {
                                     })
                                     .ok();
                             }
+                            ProcessEvent::WorkerIdle {
+                                worker_id,
+                                channel_id,
+                                ..
+                            } => {
+                                api_tx
+                                    .send(ApiEvent::WorkerIdle {
+                                        agent_id: agent_id.clone(),
+                                        channel_id: channel_id.as_deref().map(|s| s.to_string()),
+                                        worker_id: worker_id.to_string(),
+                                    })
+                                    .ok();
+                            }
                             ProcessEvent::WorkerComplete {
                                 worker_id,
                                 channel_id,
                                 result,
+                                success,
                                 ..
                             } => {
                                 api_tx
@@ -342,6 +410,7 @@ impl ApiState {
                                         channel_id: channel_id.as_deref().map(|s| s.to_string()),
                                         worker_id: worker_id.to_string(),
                                         result: result.clone(),
+                                        success: *success,
                                     })
                                     .ok();
                             }
@@ -364,6 +433,7 @@ impl ApiState {
                                 process_id,
                                 channel_id,
                                 tool_name,
+                                args,
                                 ..
                             } => {
                                 let (process_type, id_str) = process_id_info(process_id);
@@ -374,6 +444,7 @@ impl ApiState {
                                         process_type,
                                         process_id: id_str,
                                         tool_name: tool_name.clone(),
+                                        args: args.clone(),
                                     })
                                     .ok();
                             }
@@ -381,6 +452,7 @@ impl ApiState {
                                 process_id,
                                 channel_id,
                                 tool_name,
+                                result,
                                 ..
                             } => {
                                 let (process_type, id_str) = process_id_info(process_id);
@@ -391,6 +463,7 @@ impl ApiState {
                                         process_type,
                                         process_id: id_str,
                                         tool_name: tool_name.clone(),
+                                        result: result.clone(),
                                     })
                                     .ok();
                             }
@@ -426,13 +499,67 @@ impl ApiState {
                                     })
                                     .ok();
                             }
+                            ProcessEvent::TaskUpdated {
+                                task_number,
+                                status,
+                                action,
+                                ..
+                            } => {
+                                api_tx
+                                    .send(ApiEvent::TaskUpdated {
+                                        agent_id: agent_id.clone(),
+                                        task_number: *task_number,
+                                        status: status.clone(),
+                                        action: action.clone(),
+                                    })
+                                    .ok();
+                            }
+                            ProcessEvent::TextDelta {
+                                channel_id: Some(channel_id),
+                                text_delta,
+                                aggregated_text,
+                                ..
+                            } => {
+                                api_tx
+                                    .send(ApiEvent::OutboundMessageDelta {
+                                        agent_id: agent_id.clone(),
+                                        channel_id: channel_id.to_string(),
+                                        text_delta: text_delta.clone(),
+                                        aggregated_text: aggregated_text.clone(),
+                                    })
+                                    .ok();
+                            }
+                            ProcessEvent::OpenCodePartUpdated {
+                                worker_id, part, ..
+                            } => {
+                                api_tx
+                                    .send(ApiEvent::OpenCodePartUpdated {
+                                        agent_id: agent_id.clone(),
+                                        worker_id: worker_id.to_string(),
+                                        part: part.clone(),
+                                    })
+                                    .ok();
+                            }
                             _ => {}
                         }
                     }
-                    Err(broadcast::error::RecvError::Lagged(count)) => {
-                        tracing::debug!(agent_id = %agent_id, count, "API event forwarder lagged, skipped events");
+                    Err(error) => {
+                        match crate::classify_broadcast_recv_result::<crate::ProcessEvent>(Err(
+                            error,
+                        )) {
+                            crate::BroadcastRecvResult::Lagged(count) => {
+                                tracing::debug!(
+                                    agent_id = %agent_id,
+                                    count,
+                                    "API event forwarder lagged, skipped events"
+                                );
+                            }
+                            crate::BroadcastRecvResult::Closed => break,
+                            crate::BroadcastRecvResult::Event(_) => unreachable!(
+                                "classifying an Err recv result should never produce Event"
+                            ),
+                        }
                     }
-                    Err(broadcast::error::RecvError::Closed) => break,
                 }
             }
         });
@@ -479,6 +606,11 @@ impl ApiState {
         self.cron_schedulers.store(Arc::new(schedulers));
     }
 
+    /// Set the task stores for all agents.
+    pub fn set_task_stores(&self, stores: HashMap<String, Arc<TaskStore>>) {
+        self.task_stores.store(Arc::new(stores));
+    }
+
     /// Set the runtime configs for all agents.
     pub fn set_runtime_configs(&self, configs: HashMap<String, Arc<RuntimeConfig>>) {
         self.runtime_configs.store(Arc::new(configs));
@@ -494,6 +626,11 @@ impl ApiState {
         self.sandboxes.store(Arc::new(sandboxes));
     }
 
+    /// Set the instance-level secrets store.
+    pub fn set_secrets_store(&self, store: Arc<crate::secrets::store::SecretsStore>) {
+        self.secrets_store.store(Arc::new(Some(store)));
+    }
+
     /// Share the Discord permissions ArcSwap with the API so reads get hot-reloaded values.
     pub async fn set_discord_permissions(&self, permissions: Arc<ArcSwap<DiscordPermissions>>) {
         *self.discord_permissions.write().await = Some(permissions);
diff --git a/src/api/system.rs b/src/api/system.rs
index d56f2ae51..2891caa9e 100644
--- a/src/api/system.rs
+++ b/src/api/system.rs
@@ -84,9 +84,11 @@ pub(super) async fn events_sse(
                         let event_type = match &event {
                             ApiEvent::InboundMessage { .. } => "inbound_message",
                             ApiEvent::OutboundMessage { .. } => "outbound_message",
+                            ApiEvent::OutboundMessageDelta { .. } => "outbound_message_delta",
                             ApiEvent::TypingState { .. } => "typing_state",
                             ApiEvent::WorkerStarted { .. } => "worker_started",
                             ApiEvent::WorkerStatusUpdate { .. } => "worker_status",
+                            ApiEvent::WorkerIdle { .. } => "worker_idle",
                             ApiEvent::WorkerCompleted { .. } => "worker_completed",
                             ApiEvent::BranchStarted { .. } => "branch_started",
                             ApiEvent::BranchCompleted { .. } => "branch_completed",
@@ -95,19 +97,28 @@ pub(super) async fn events_sse(
                             ApiEvent::ConfigReloaded => "config_reloaded",
                             ApiEvent::AgentMessageSent { .. } => "agent_message_sent",
                             ApiEvent::AgentMessageReceived { .. } => "agent_message_received",
+                            ApiEvent::TaskUpdated { .. } => "task_updated",
+                            ApiEvent::OpenCodePartUpdated { .. } => "opencode_part_updated",
                         };
                         yield Ok(axum::response::sse::Event::default()
                             .event(event_type)
                             .data(json));
                     }
                 }
-                Err(tokio::sync::broadcast::error::RecvError::Lagged(count)) => {
-                    tracing::debug!(count, "SSE client lagged");
-                    yield Ok(axum::response::sse::Event::default()
-                        .event("lagged")
-                        .data(format!("{{\"skipped\":{count}}}")));
+                Err(error) => {
+                    match crate::classify_broadcast_recv_result::<ApiEvent>(Err(error)) {
+                        crate::BroadcastRecvResult::Lagged(count) => {
+                            tracing::debug!(count, "SSE client lagged");
+                            yield Ok(axum::response::sse::Event::default()
+                                .event("lagged")
+                                .data(format!("{{\"skipped\":{count}}}")));
+                        }
+                        crate::BroadcastRecvResult::Closed => break,
+                        crate::BroadcastRecvResult::Event(_) => unreachable!(
+                            "classifying an Err recv result should never produce Event"
+                        ),
+                    }
                 }
-                Err(tokio::sync::broadcast::error::RecvError::Closed) => break,
             }
         }
     };
diff --git a/src/api/tasks.rs b/src/api/tasks.rs
new file mode 100644
index 000000000..d496c0441
--- /dev/null
+++ b/src/api/tasks.rs
@@ -0,0 +1,375 @@
+use super::state::ApiState;
+
+use axum::Json;
+use axum::extract::{Path, Query, State};
+use axum::http::StatusCode;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+#[derive(Deserialize)]
+pub(super) struct TaskListQuery {
+    agent_id: String,
+    #[serde(default)]
+    status: Option<String>,
+    #[serde(default)]
+    priority: Option<String>,
+    #[serde(default = "default_task_limit")]
+    limit: i64,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TaskGetQuery {
+    agent_id: String,
+}
+
+#[derive(Deserialize)]
+pub(super) struct CreateTaskRequest {
+    agent_id: String,
+    title: String,
+    #[serde(default)]
+    description: Option<String>,
+    #[serde(default)]
+    status: Option<String>,
+    #[serde(default)]
+    priority: Option<String>,
+    #[serde(default)]
+    subtasks: Vec<crate::tasks::TaskSubtask>,
+    #[serde(default)]
+    metadata: Option<serde_json::Value>,
+    #[serde(default)]
+    source_memory_id: Option<String>,
+    #[serde(default)]
+    created_by: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct UpdateTaskRequest {
+    agent_id: String,
+    #[serde(default)]
+    title: Option<String>,
+    #[serde(default)]
+    description: Option<String>,
+    #[serde(default)]
+    status: Option<String>,
+    #[serde(default)]
+    priority: Option<String>,
+    #[serde(default)]
+    subtasks: Option<Vec<crate::tasks::TaskSubtask>>,
+    #[serde(default)]
+    metadata: Option<serde_json::Value>,
+    #[serde(default)]
+    complete_subtask: Option<usize>,
+    #[serde(default)]
+    worker_id: Option<String>,
+    #[serde(default)]
+    approved_by: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct DeleteTaskQuery {
+    agent_id: String,
+}
+
+#[derive(Serialize)]
+pub(super) struct TaskListResponse {
+    tasks: Vec<crate::tasks::Task>,
+}
+
+#[derive(Serialize)]
+pub(super) struct TaskResponse {
+    task: crate::tasks::Task,
+}
+
+#[derive(Serialize)]
+pub(super) struct TaskActionResponse {
+    success: bool,
+    message: String,
+}
+
+fn default_task_limit() -> i64 {
+    20
+}
+
+pub(super) async fn list_tasks(
+    State(state): State<Arc<ApiState>>,
+    Query(query): Query<TaskListQuery>,
+) -> Result<Json<TaskListResponse>, StatusCode> {
+    let stores = state.task_stores.load();
+    let store = stores.get(&query.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+
+    let status = match query.status.as_deref() {
+        None => None,
+        Some(value) => Some(crate::tasks::TaskStatus::parse(value).ok_or(StatusCode::BAD_REQUEST)?),
+    };
+    let priority = match query.priority.as_deref() {
+        None => None,
+        Some(value) => {
+            Some(crate::tasks::TaskPriority::parse(value).ok_or(StatusCode::BAD_REQUEST)?)
+        }
+    };
+
+    let tasks = store
+        .list(&query.agent_id, status, priority, query.limit.clamp(1, 500))
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %query.agent_id, "failed to list tasks");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    Ok(Json(TaskListResponse { tasks }))
+}
+
+pub(super) async fn get_task(
+    State(state): State<Arc<ApiState>>,
+    Path(number): Path<i64>,
+    Query(query): Query<TaskGetQuery>,
+) -> Result<Json<TaskResponse>, StatusCode> {
+    let stores = state.task_stores.load();
+    let store = stores.get(&query.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+
+    let task = store
+        .get_by_number(&query.agent_id, number)
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %query.agent_id, task_number = number, "failed to get task");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?
+        .ok_or(StatusCode::NOT_FOUND)?;
+
+    Ok(Json(TaskResponse { task }))
+}
+
+pub(super) async fn create_task(
+    State(state): State<Arc<ApiState>>,
+    Json(request): Json<CreateTaskRequest>,
+) -> Result<Json<TaskResponse>, StatusCode> {
+    let stores = state.task_stores.load();
+    let store = stores.get(&request.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+
+    let status = match request.status.as_deref() {
+        None => crate::tasks::TaskStatus::Backlog,
+        Some(value) => crate::tasks::TaskStatus::parse(value).ok_or(StatusCode::BAD_REQUEST)?,
+    };
+    let priority = match request.priority.as_deref() {
+        None => crate::tasks::TaskPriority::Medium,
+        Some(value) => crate::tasks::TaskPriority::parse(value).ok_or(StatusCode::BAD_REQUEST)?,
+    };
+
+    let task = store
+        .create(crate::tasks::CreateTaskInput {
+            agent_id: request.agent_id.clone(),
+            title: request.title,
+            description: request.description,
+            status,
+            priority,
+            subtasks: request.subtasks,
+            metadata: request.metadata.unwrap_or_else(|| serde_json::json!({})),
+            source_memory_id: request.source_memory_id,
+            created_by: request.created_by.unwrap_or_else(|| "human".to_string()),
+        })
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %request.agent_id, "failed to create task");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    state
+        .event_tx
+        .send(super::state::ApiEvent::TaskUpdated {
+            agent_id: task.agent_id.clone(),
+            task_number: task.task_number,
+            status: task.status.to_string(),
+            action: "created".to_string(),
+        })
+        .ok();
+
+    Ok(Json(TaskResponse { task }))
+}
+
+pub(super) async fn update_task(
+    State(state): State<Arc<ApiState>>,
+    Path(number): Path<i64>,
+    Json(request): Json<UpdateTaskRequest>,
+) -> Result<Json<TaskResponse>, StatusCode> {
+    let stores = state.task_stores.load();
+    let store = stores.get(&request.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+
+    let status = match request.status.as_deref() {
+        None => None,
+        Some(value) => Some(crate::tasks::TaskStatus::parse(value).ok_or(StatusCode::BAD_REQUEST)?),
+    };
+    let priority = match request.priority.as_deref() {
+        None => None,
+        Some(value) => {
+            Some(crate::tasks::TaskPriority::parse(value).ok_or(StatusCode::BAD_REQUEST)?)
+        }
+    };
+
+    let task = store
+        .update(
+            &request.agent_id,
+            number,
+            crate::tasks::UpdateTaskInput {
+                title: request.title,
+                description: request.description,
+                status,
+                priority,
+                subtasks: request.subtasks,
+                metadata: request.metadata,
+                worker_id: request.worker_id,
+                clear_worker_id: false,
+                approved_by: request.approved_by,
+                complete_subtask: request.complete_subtask,
+            },
+        )
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %request.agent_id, task_number = number, "failed to update task");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?
+        .ok_or(StatusCode::NOT_FOUND)?;
+
+    state
+        .event_tx
+        .send(super::state::ApiEvent::TaskUpdated {
+            agent_id: task.agent_id.clone(),
+            task_number: task.task_number,
+            status: task.status.to_string(),
+            action: "updated".to_string(),
+        })
+        .ok();
+
+    Ok(Json(TaskResponse { task }))
+}
+
+pub(super) async fn delete_task(
+    State(state): State<Arc<ApiState>>,
+    Path(number): Path<i64>,
+    Query(query): Query<DeleteTaskQuery>,
+) -> Result<Json<TaskActionResponse>, StatusCode> {
+    let stores = state.task_stores.load();
+    let store = stores.get(&query.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+
+    let deleted = store
+        .delete(&query.agent_id, number)
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %query.agent_id, task_number = number, "failed to delete task");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    if !deleted {
+        return Err(StatusCode::NOT_FOUND);
+    }
+
+    state
+        .event_tx
+        .send(super::state::ApiEvent::TaskUpdated {
+            agent_id: query.agent_id.clone(),
+            task_number: number,
+            status: "deleted".to_string(),
+            action: "deleted".to_string(),
+        })
+        .ok();
+
+    Ok(Json(TaskActionResponse {
+        success: true,
+        message: format!("Task #{number} deleted"),
+    }))
+}
+
+pub(super) async fn approve_task(
+    State(state): State<Arc<ApiState>>,
+    Path(number): Path<i64>,
+    Json(request): Json<UpdateTaskRequest>,
+) -> Result<Json<TaskResponse>, StatusCode> {
+    let stores = state.task_stores.load();
+    let store = stores.get(&request.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+
+    let task = store
+        .update(
+            &request.agent_id,
+            number,
+            crate::tasks::UpdateTaskInput {
+                status: Some(crate::tasks::TaskStatus::Ready),
+                approved_by: request.approved_by,
+                ..Default::default()
+            },
+        )
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %request.agent_id, task_number = number, "failed to approve task");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?
+        .ok_or(StatusCode::NOT_FOUND)?;
+
+    state
+        .event_tx
+        .send(super::state::ApiEvent::TaskUpdated {
+            agent_id: task.agent_id.clone(),
+            task_number: task.task_number,
+            status: task.status.to_string(),
+            action: "updated".to_string(),
+        })
+        .ok();
+
+    Ok(Json(TaskResponse { task }))
+}
+
+/// Move a task to `ready` so the cortex ready-task loop picks it up and spawns
+/// a worker. Tasks already in `ready` or `in_progress` are returned as-is.
+pub(super) async fn execute_task(
+    State(state): State<Arc<ApiState>>,
+    Path(number): Path<i64>,
+    Json(request): Json<UpdateTaskRequest>,
+) -> Result<Json<TaskResponse>, StatusCode> {
+    let stores = state.task_stores.load();
+    let store = stores.get(&request.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+
+    // Fetch current task to check if transition is needed.
+    let current = store
+        .get_by_number(&request.agent_id, number)
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %request.agent_id, task_number = number, "failed to get task for execution");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?
+        .ok_or(StatusCode::NOT_FOUND)?;
+
+    // If already ready or in-progress, return as-is — cortex will handle it.
+    if matches!(
+        current.status,
+        crate::tasks::TaskStatus::Ready | crate::tasks::TaskStatus::InProgress
+    ) {
+        return Ok(Json(TaskResponse { task: current }));
+    }
+
+    let task = store
+        .update(
+            &request.agent_id,
+            number,
+            crate::tasks::UpdateTaskInput {
+                status: Some(crate::tasks::TaskStatus::Ready),
+                approved_by: request.approved_by,
+                ..Default::default()
+            },
+        )
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, agent_id = %request.agent_id, task_number = number, "failed to execute task");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?
+        .ok_or(StatusCode::NOT_FOUND)?;
+
+    state
+        .event_tx
+        .send(super::state::ApiEvent::TaskUpdated {
+            agent_id: task.agent_id.clone(),
+            task_number: task.task_number,
+            status: task.status.to_string(),
+            action: "updated".to_string(),
+        })
+        .ok();
+
+    Ok(Json(TaskResponse { task }))
+}
diff --git a/src/api/tools.rs b/src/api/tools.rs
new file mode 100644
index 000000000..401e2e432
--- /dev/null
+++ b/src/api/tools.rs
@@ -0,0 +1,89 @@
+//! Durable binary location observability.
+
+use super::state::ApiState;
+
+use axum::Json;
+use axum::extract::State;
+use axum::http::StatusCode;
+use serde::Serialize;
+use std::io::ErrorKind;
+use std::sync::Arc;
+
+#[derive(Serialize)]
+pub(super) struct ToolsResponse {
+    tools_bin: String,
+    binaries: Vec<BinaryEntry>,
+}
+
+#[derive(Serialize)]
+pub(super) struct BinaryEntry {
+    name: String,
+    size: u64,
+    modified: Option<String>,
+}
+
+/// List the contents of the durable `tools/bin` directory.
+pub(super) async fn list_tools(
+    State(state): State<Arc<ApiState>>,
+) -> Result<Json<ToolsResponse>, StatusCode> {
+    let instance_dir = state.instance_dir.load();
+    let tools_bin = instance_dir.join("tools/bin");
+
+    let mut binaries = Vec::new();
+
+    let tools_bin_is_dir = match tokio::fs::metadata(&tools_bin).await {
+        Ok(metadata) => metadata.is_dir(),
+        Err(error) if error.kind() == ErrorKind::NotFound => false,
+        Err(error) => {
+            tracing::warn!(path = %tools_bin.display(), %error, "failed to stat tools/bin");
+            return Err(StatusCode::INTERNAL_SERVER_ERROR);
+        }
+    };
+
+    if tools_bin_is_dir {
+        let mut entries = tokio::fs::read_dir(&tools_bin).await.map_err(|error| {
+            tracing::warn!(path = %tools_bin.display(), %error, "failed to read tools/bin");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+        while let Some(entry) = entries.next_entry().await.map_err(|error| {
+            tracing::warn!(path = %tools_bin.display(), %error, "failed during tools/bin iteration");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })? {
+            let entry_path = entry.path();
+            let metadata = match tokio::fs::symlink_metadata(&entry_path).await {
+                Ok(metadata) => metadata,
+                Err(error) => {
+                    tracing::debug!(
+                        path = %entry_path.display(),
+                        %error,
+                        "skipping entry with unreadable metadata"
+                    );
+                    continue;
+                }
+            };
+
+            if metadata.file_type().is_symlink() || !metadata.is_file() {
+                continue;
+            }
+
+            let modified = metadata.modified().ok().map(|time| {
+                let datetime: chrono::DateTime<chrono::Utc> = time.into();
+                datetime.to_rfc3339()
+            });
+
+            binaries.push(BinaryEntry {
+                name: entry.file_name().to_string_lossy().into_owned(),
+                size: metadata.len(),
+                modified,
+            });
+        }
+    }
+
+    binaries.sort_by(|a, b| a.name.cmp(&b.name));
+
+    Ok(Json(ToolsResponse {
+        tools_bin: tools_bin.display().to_string(),
+        binaries,
+    }))
+}
diff --git a/src/api/webchat.rs b/src/api/webchat.rs
index 352d6d487..68d8ec10d 100644
--- a/src/api/webchat.rs
+++ b/src/api/webchat.rs
@@ -1,16 +1,11 @@
 use super::state::ApiState;
-use crate::conversation::ConversationLogger;
-use crate::messaging::webchat::WebChatEvent;
 use crate::{InboundMessage, MessageContent};
 
 use axum::Json;
 use axum::extract::{Query, State};
 use axum::http::StatusCode;
-use axum::response::Sse;
-use futures::stream::Stream;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use std::convert::Infallible;
 use std::sync::Arc;
 
 #[derive(Deserialize)]
@@ -26,19 +21,17 @@ fn default_sender_name() -> String {
     "user".into()
 }
 
+#[derive(Serialize)]
+pub(super) struct WebChatSendResponse {
+    ok: bool,
+}
+
+/// Fire-and-forget message injection. The response arrives via the global SSE
+/// event bus (`/api/events`), same as every other channel.
 pub(super) async fn webchat_send(
     State(state): State<Arc<ApiState>>,
     axum::Json(request): axum::Json<WebChatSendRequest>,
-) -> Result<Sse<impl Stream<Item = Result<axum::response::sse::Event, Infallible>>>, StatusCode> {
-    // ArcSwap<Option<Arc<...>>> → load guard → &Option → &Arc → clone
-    let webchat = state
-        .webchat_adapter
-        .load()
-        .as_ref()
-        .as_ref()
-        .cloned()
-        .ok_or(StatusCode::SERVICE_UNAVAILABLE)?;
-
+) -> Result<Json<WebChatSendResponse>, StatusCode> {
     let manager = state
         .messaging_manager
         .read()
@@ -48,8 +41,6 @@ pub(super) async fn webchat_send(
 
     let conversation_id = request.session_id.clone();
 
-    let mut event_rx = webchat.register_session(&conversation_id).await;
-
     let mut metadata = HashMap::new();
     metadata.insert(
         "display_name".into(),
@@ -59,7 +50,8 @@ pub(super) async fn webchat_send(
     let inbound = InboundMessage {
         id: uuid::Uuid::new_v4().to_string(),
         source: "webchat".into(),
-        conversation_id: conversation_id.clone(),
+        adapter: Some("webchat".into()),
+        conversation_id,
         sender_id: request.sender_name.clone(),
         agent_id: Some(request.agent_id.into()),
         content: MessageContent::Text(request.message),
@@ -73,40 +65,7 @@ pub(super) async fn webchat_send(
         StatusCode::INTERNAL_SERVER_ERROR
     })?;
 
-    let webchat_for_cleanup = webchat.clone();
-    let cleanup_id = conversation_id.clone();
-
-    let stream = async_stream::stream! {
-        while let Some(event) = event_rx.recv().await {
-            let event_name = match &event {
-                WebChatEvent::Thinking => "thinking",
-                WebChatEvent::Text(_) => "text",
-                WebChatEvent::StreamStart => "stream_start",
-                WebChatEvent::StreamChunk(_) => "stream_chunk",
-                WebChatEvent::StreamEnd => "stream_end",
-                WebChatEvent::ToolStarted { .. } => "tool_started",
-                WebChatEvent::ToolCompleted { .. } => "tool_completed",
-                WebChatEvent::StopTyping => "stop_typing",
-                WebChatEvent::Done => "done",
-            };
-
-            let is_done = matches!(event, WebChatEvent::Done);
-
-            if let Ok(json) = serde_json::to_string(&event) {
-                yield Ok(axum::response::sse::Event::default()
-                    .event(event_name)
-                    .data(json));
-            }
-
-            if is_done {
-                break;
-            }
-        }
-
-        webchat_for_cleanup.unregister_session(&cleanup_id).await;
-    };
-
-    Ok(Sse::new(stream))
+    Ok(Json(WebChatSendResponse { ok: true }))
 }
 
 #[derive(Deserialize)]
@@ -134,7 +93,7 @@ pub(super) async fn webchat_history(
 ) -> Result<Json<Vec<WebChatHistoryMessage>>, StatusCode> {
     let pools = state.agent_pools.load();
     let pool = pools.get(&query.agent_id).ok_or(StatusCode::NOT_FOUND)?;
-    let logger = ConversationLogger::new(pool.clone());
+    let logger = crate::conversation::ConversationLogger::new(pool.clone());
 
     let channel_id: crate::ChannelId = Arc::from(query.session_id.as_str());
 
diff --git a/src/api/workers.rs b/src/api/workers.rs
new file mode 100644
index 000000000..85a01539f
--- /dev/null
+++ b/src/api/workers.rs
@@ -0,0 +1,195 @@
+//! Workers API endpoints: list and detail views for worker runs.
+
+use super::state::ApiState;
+
+use crate::conversation::history::ProcessRunLogger;
+use crate::conversation::worker_transcript;
+
+use axum::Json;
+use axum::extract::{Query, State};
+use axum::http::StatusCode;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+#[derive(Deserialize)]
+pub(super) struct WorkerListQuery {
+    agent_id: String,
+    #[serde(default = "default_limit")]
+    limit: i64,
+    #[serde(default)]
+    offset: i64,
+    status: Option<String>,
+}
+
+fn default_limit() -> i64 {
+    50
+}
+
+#[derive(Serialize)]
+pub(super) struct WorkerListResponse {
+    workers: Vec<WorkerListItem>,
+    total: i64,
+}
+
+#[derive(Serialize)]
+pub(super) struct WorkerListItem {
+    id: String,
+    task: String,
+    status: String,
+    worker_type: String,
+    channel_id: Option<String>,
+    channel_name: Option<String>,
+    started_at: String,
+    completed_at: Option<String>,
+    has_transcript: bool,
+    /// Live status text from StatusBlock (running workers only).
+    live_status: Option<String>,
+    /// Total tool calls. From DB for completed workers, from StatusBlock for running.
+    tool_calls: i64,
+    /// OpenCode server port (for workers with an embeddable web UI).
+    opencode_port: Option<i32>,
+    /// Whether this worker accepts follow-up input via route.
+    interactive: bool,
+}
+
+#[derive(Deserialize)]
+pub(super) struct WorkerDetailQuery {
+    agent_id: String,
+    worker_id: String,
+}
+
+#[derive(Serialize)]
+pub(super) struct WorkerDetailResponse {
+    id: String,
+    task: String,
+    result: Option<String>,
+    status: String,
+    worker_type: String,
+    channel_id: Option<String>,
+    channel_name: Option<String>,
+    started_at: String,
+    completed_at: Option<String>,
+    transcript: Option<Vec<worker_transcript::TranscriptStep>>,
+    tool_calls: i64,
+    /// OpenCode session ID (for workers with an embeddable web UI).
+    opencode_session_id: Option<String>,
+    /// OpenCode server port (for workers with an embeddable web UI).
+    opencode_port: Option<i32>,
+    /// Whether this worker accepts follow-up input via route.
+    interactive: bool,
+}
+
+/// List worker runs for an agent, with live status merged from StatusBlocks.
+pub(super) async fn list_workers(
+    State(state): State<Arc<ApiState>>,
+    Query(query): Query<WorkerListQuery>,
+) -> Result<Json<WorkerListResponse>, StatusCode> {
+    let pools = state.agent_pools.load();
+    let pool = pools.get(&query.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+    let logger = ProcessRunLogger::new(pool.clone());
+
+    let limit = query.limit.clamp(1, 200);
+    let offset = query.offset.max(0);
+    let (rows, total) = logger
+        .list_worker_runs(&query.agent_id, limit, offset, query.status.as_deref())
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, "failed to list worker runs");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    // Build a live status lookup from all channel StatusBlocks
+    let live_statuses = {
+        let blocks = state.channel_status_blocks.read().await;
+        let mut map = std::collections::HashMap::new();
+        for (_channel_id, status_block) in blocks.iter() {
+            let block = status_block.read().await;
+            for worker in &block.active_workers {
+                map.insert(
+                    worker.id.to_string(),
+                    (worker.status.clone(), worker.tool_calls),
+                );
+            }
+        }
+        map
+    };
+
+    let workers = rows
+        .into_iter()
+        .map(|row| {
+            let (live_status, live_tool_calls) = live_statuses
+                .get(&row.id)
+                .map(|(status, calls)| (Some(status.clone()), *calls as i64))
+                .unwrap_or((None, 0));
+
+            // Use live tool call count for running workers, DB count for completed
+            let tool_calls = if row.status == "running" && live_tool_calls > 0 {
+                live_tool_calls
+            } else {
+                row.tool_calls
+            };
+
+            WorkerListItem {
+                id: row.id,
+                task: row.task,
+                status: row.status,
+                worker_type: row.worker_type,
+                channel_id: row.channel_id,
+                channel_name: row.channel_name,
+                started_at: row.started_at,
+                completed_at: row.completed_at,
+                has_transcript: row.has_transcript,
+                live_status,
+                tool_calls,
+                opencode_port: row.opencode_port,
+                interactive: row.interactive,
+            }
+        })
+        .collect();
+
+    Ok(Json(WorkerListResponse { workers, total }))
+}
+
+/// Get full detail for a single worker run, including decompressed transcript.
+pub(super) async fn worker_detail(
+    State(state): State<Arc<ApiState>>,
+    Query(query): Query<WorkerDetailQuery>,
+) -> Result<Json<WorkerDetailResponse>, StatusCode> {
+    let pools = state.agent_pools.load();
+    let pool = pools.get(&query.agent_id).ok_or(StatusCode::NOT_FOUND)?;
+    let logger = ProcessRunLogger::new(pool.clone());
+
+    let detail = logger
+        .get_worker_detail(&query.agent_id, &query.worker_id)
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, worker_id = %query.worker_id, "failed to load worker detail");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?
+        .ok_or(StatusCode::NOT_FOUND)?;
+
+    let transcript = detail.transcript_blob.as_deref().and_then(|blob| {
+        worker_transcript::deserialize_transcript(blob)
+            .map_err(|error| {
+                tracing::warn!(%error, worker_id = %query.worker_id, "failed to decompress transcript");
+            })
+            .ok()
+    });
+
+    Ok(Json(WorkerDetailResponse {
+        id: detail.id,
+        task: detail.task,
+        result: detail.result,
+        status: detail.status,
+        worker_type: detail.worker_type,
+        channel_id: detail.channel_id,
+        channel_name: detail.channel_name,
+        started_at: detail.started_at,
+        completed_at: detail.completed_at,
+        transcript,
+        tool_calls: detail.tool_calls,
+        opencode_session_id: detail.opencode_session_id,
+        opencode_port: detail.opencode_port,
+        interactive: detail.interactive,
+    }))
+}
diff --git a/src/config.rs b/src/config.rs
index 098c78c23..bb062aeec 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,4465 +1,54 @@
 //! Configuration loading and validation.
 
-use crate::error::{ConfigError, Result};
-use crate::llm::routing::RoutingConfig;
-use anyhow::Context as _;
-use arc_swap::ArcSwap;
-use chrono_tz::Tz;
-use serde::{Deserialize, Deserializer, Serialize};
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-
-const CRON_TIMEZONE_ENV_VAR: &str = "SPACEBOT_CRON_TIMEZONE";
-
-/// OpenTelemetry export configuration.
-///
-/// All fields are optional. If `otlp_endpoint` is not set (and the standard
-/// `OTEL_EXPORTER_OTLP_ENDPOINT` env var is not present), OTLP export is
-/// disabled and the OTel layer is omitted entirely.
-#[derive(Debug, Clone, Default)]
-pub struct TelemetryConfig {
-    /// OTLP HTTP endpoint, e.g. `http://localhost:4318`.
-    /// Falls back to the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable.
-    pub otlp_endpoint: Option<String>,
-    /// Extra OTLP headers for the exporter (e.g. `Authorization`).
-    /// Loaded from the `OTEL_EXPORTER_OTLP_HEADERS` environment variable.
-    pub otlp_headers: HashMap<String, String>,
-    /// `service.name` resource attribute sent with every span.
-    pub service_name: String,
-    /// Trace sample rate in the range 0.0–1.0. Defaults to 1.0 (sample all).
-    pub sample_rate: f64,
-}
-
-/// Top-level Spacebot configuration.
-#[derive(Debug, Clone)]
-pub struct Config {
-    /// Instance root directory (~/.spacebot or SPACEBOT_DIR).
-    pub instance_dir: PathBuf,
-    /// LLM provider credentials (shared across all agents).
-    pub llm: LlmConfig,
-    /// Default settings inherited by all agents.
-    pub defaults: DefaultsConfig,
-    /// Agent definitions.
-    pub agents: Vec<AgentConfig>,
-    /// Agent communication graph links.
-    pub links: Vec<LinkDef>,
-    /// Visual grouping of agents in the topology UI.
-    pub groups: Vec<GroupDef>,
-    /// Org-level humans (real people, shown in topology graph).
-    pub humans: Vec<HumanDef>,
-    /// Messaging platform credentials.
-    pub messaging: MessagingConfig,
-    /// Routing bindings (maps platform conversations to agents).
-    pub bindings: Vec<Binding>,
-    /// HTTP API server configuration.
-    pub api: ApiConfig,
-    /// Prometheus metrics endpoint configuration.
-    pub metrics: MetricsConfig,
-    /// OpenTelemetry export configuration.
-    pub telemetry: TelemetryConfig,
-}
-
-/// A link definition from config, connecting two nodes (agents or humans).
-#[derive(Debug, Clone)]
-pub struct LinkDef {
-    pub from: String,
-    pub to: String,
-    pub direction: String,
-    pub kind: String,
-}
-
-/// An org-level human definition.
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct HumanDef {
-    pub id: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub display_name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub role: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub bio: Option<String>,
-}
-
-/// A visual group definition for the topology UI.
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct GroupDef {
-    pub name: String,
-    pub agent_ids: Vec<String>,
-    #[serde(default)]
-    pub color: Option<String>,
-}
-
-/// HTTP API server configuration.
-#[derive(Debug, Clone)]
-pub struct ApiConfig {
-    /// Whether the HTTP API server is enabled.
-    pub enabled: bool,
-    /// Port to bind the HTTP server on.
-    pub port: u16,
-    /// Address to bind the HTTP server on.
-    pub bind: String,
-    pub auth_token: Option<String>,
-}
-
-impl Default for ApiConfig {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            port: 19898,
-            bind: "127.0.0.1".into(),
-            auth_token: None,
-        }
-    }
-}
-
-/// Prometheus metrics endpoint configuration.
-#[derive(Debug, Clone)]
-pub struct MetricsConfig {
-    /// Whether the metrics endpoint is enabled.
-    pub enabled: bool,
-    /// Port to bind the metrics HTTP server on.
-    pub port: u16,
-    /// Address to bind the metrics HTTP server on.
-    pub bind: String,
-}
-
-impl Default for MetricsConfig {
-    fn default() -> Self {
-        Self {
-            enabled: false,
-            port: 9090,
-            bind: "0.0.0.0".into(),
-        }
-    }
-}
-
-/// API types supported by LLM providers.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ApiType {
-    /// OpenAI Completions API (https://api.openai.com/v1/completions)
-    OpenAiCompletions,
-    /// OpenAI Responses API (https://api.openai.com/v1/chat/completions)
-    OpenAiResponses,
-    /// Anthropic Messages API (https://api.anthropic.com/v1/messages)
-    Anthropic,
-    /// Google Gemini API (https://generativelanguage.googleapis.com/v1beta/openai/chat/completions)
-    Gemini,
-}
-
-impl<'de> serde::Deserialize<'de> for ApiType {
-    fn deserialize<D: serde::Deserializer<'de>>(
-        deserializer: D,
-    ) -> std::result::Result<Self, D::Error> {
-        let s = String::deserialize(deserializer)?;
-        match s.as_str() {
-            "openai_completions" => Ok(Self::OpenAiCompletions),
-            "openai_responses" => Ok(Self::OpenAiResponses),
-            "anthropic" => Ok(Self::Anthropic),
-            "gemini" => Ok(Self::Gemini),
-            other => Err(serde::de::Error::invalid_value(
-                serde::de::Unexpected::Str(other),
-                &"one of \"openai_completions\", \"openai_responses\", \"anthropic\", or \"gemini\"",
-            )),
-        }
-    }
-}
-
-/// Configuration for a single LLM provider.
-#[derive(Clone)]
-pub struct ProviderConfig {
-    pub api_type: ApiType,
-    pub base_url: String,
-    pub api_key: String,
-    pub name: Option<String>,
-}
-
-impl std::fmt::Debug for ProviderConfig {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ProviderConfig")
-            .field("api_type", &self.api_type)
-            .field("base_url", &self.base_url)
-            .field("api_key", &"[REDACTED]")
-            .field("name", &self.name)
-            .finish()
-    }
-}
-
-/// LLM provider credentials (instance-level).
-#[derive(Clone)]
-pub struct LlmConfig {
-    pub anthropic_key: Option<String>,
-    pub openai_key: Option<String>,
-    pub openrouter_key: Option<String>,
-    pub zhipu_key: Option<String>,
-    pub groq_key: Option<String>,
-    pub together_key: Option<String>,
-    pub fireworks_key: Option<String>,
-    pub deepseek_key: Option<String>,
-    pub xai_key: Option<String>,
-    pub mistral_key: Option<String>,
-    pub gemini_key: Option<String>,
-    pub ollama_key: Option<String>,
-    pub ollama_base_url: Option<String>,
-    pub opencode_zen_key: Option<String>,
-    pub nvidia_key: Option<String>,
-    pub minimax_key: Option<String>,
-    pub minimax_cn_key: Option<String>,
-    pub moonshot_key: Option<String>,
-    pub zai_coding_plan_key: Option<String>,
-    pub providers: HashMap<String, ProviderConfig>,
-}
-
-impl std::fmt::Debug for LlmConfig {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("LlmConfig")
-            .field(
-                "anthropic_key",
-                &self.anthropic_key.as_ref().map(|_| "[REDACTED]"),
-            )
-            .field(
-                "openai_key",
-                &self.openai_key.as_ref().map(|_| "[REDACTED]"),
-            )
-            .field(
-                "openrouter_key",
-                &self.openrouter_key.as_ref().map(|_| "[REDACTED]"),
-            )
-            .field("zhipu_key", &self.zhipu_key.as_ref().map(|_| "[REDACTED]"))
-            .field("groq_key", &self.groq_key.as_ref().map(|_| "[REDACTED]"))
-            .field(
-                "together_key",
-                &self.together_key.as_ref().map(|_| "[REDACTED]"),
-            )
-            .field(
-                "fireworks_key",
-                &self.fireworks_key.as_ref().map(|_| "[REDACTED]"),
-            )
-            .field(
-                "deepseek_key",
-                &self.deepseek_key.as_ref().map(|_| "[REDACTED]"),
-            )
-            .field("xai_key", &self.xai_key.as_ref().map(|_| "[REDACTED]"))
-            .field(
-                "mistral_key",
-                &self.mistral_key.as_ref().map(|_| "[REDACTED]"),
-            )
-            .field(
-                "gemini_key",
-                &self.gemini_key.as_ref().map(|_| "[REDACTED]"),
-            )
-            .field(
-                "ollama_key",
-                &self.ollama_key.as_ref().map(|_| "[REDACTED]"),
-            )
-            .field("ollama_base_url", &self.ollama_base_url)
-            .field(
-                "opencode_zen_key",
-                &self.opencode_zen_key.as_ref().map(|_| "[REDACTED]"),
-            )
-            .field(
-                "nvidia_key",
-                &self.nvidia_key.as_ref().map(|_| "[REDACTED]"),
-            )
-            .field(
-                "minimax_key",
-                &self.minimax_key.as_ref().map(|_| "[REDACTED]"),
-            )
-            .field(
-                "moonshot_key",
-                &self.moonshot_key.as_ref().map(|_| "[REDACTED]"),
-            )
-            .field(
-                "zai_coding_plan_key",
-                &self.zai_coding_plan_key.as_ref().map(|_| "[REDACTED]"),
-            )
-            .field("providers", &self.providers)
-            .finish()
-    }
-}
-
-impl LlmConfig {
-    /// Check if any provider configuration is set.
-    pub fn has_any_key(&self) -> bool {
-        self.anthropic_key.is_some()
-            || self.openai_key.is_some()
-            || self.openrouter_key.is_some()
-            || self.zhipu_key.is_some()
-            || self.groq_key.is_some()
-            || self.together_key.is_some()
-            || self.fireworks_key.is_some()
-            || self.deepseek_key.is_some()
-            || self.xai_key.is_some()
-            || self.mistral_key.is_some()
-            || self.gemini_key.is_some()
-            || self.ollama_key.is_some()
-            || self.ollama_base_url.is_some()
-            || self.opencode_zen_key.is_some()
-            || self.nvidia_key.is_some()
-            || self.minimax_key.is_some()
-            || self.minimax_cn_key.is_some()
-            || self.moonshot_key.is_some()
-            || self.zai_coding_plan_key.is_some()
-            || !self.providers.is_empty()
-    }
-}
-
-const ANTHROPIC_PROVIDER_BASE_URL: &str = "https://api.anthropic.com";
-const OPENAI_PROVIDER_BASE_URL: &str = "https://api.openai.com";
-const OPENROUTER_PROVIDER_BASE_URL: &str = "https://openrouter.ai/api";
-const OPENCODE_ZEN_PROVIDER_BASE_URL: &str = "https://opencode.ai/zen";
-const MINIMAX_PROVIDER_BASE_URL: &str = "https://api.minimax.io/anthropic";
-const MINIMAX_CN_PROVIDER_BASE_URL: &str = "https://api.minimaxi.com/anthropic";
-const MOONSHOT_PROVIDER_BASE_URL: &str = "https://api.moonshot.ai";
-
-const ZHIPU_PROVIDER_BASE_URL: &str = "https://api.z.ai/api/paas/v4";
-const ZAI_CODING_PLAN_BASE_URL: &str = "https://api.z.ai/api/coding/paas/v4";
-const DEEPSEEK_PROVIDER_BASE_URL: &str = "https://api.deepseek.com";
-const GROQ_PROVIDER_BASE_URL: &str = "https://api.groq.com/openai";
-const TOGETHER_PROVIDER_BASE_URL: &str = "https://api.together.xyz";
-const XAI_PROVIDER_BASE_URL: &str = "https://api.x.ai";
-const MISTRAL_PROVIDER_BASE_URL: &str = "https://api.mistral.ai";
-const NVIDIA_PROVIDER_BASE_URL: &str = "https://integrate.api.nvidia.com";
-const FIREWORKS_PROVIDER_BASE_URL: &str = "https://api.fireworks.ai/inference";
-pub(crate) const GEMINI_PROVIDER_BASE_URL: &str =
-    "https://generativelanguage.googleapis.com/v1beta/openai";
-
-/// Defaults inherited by all agents. Individual agents can override any field.
-#[derive(Clone)]
-pub struct DefaultsConfig {
-    pub routing: RoutingConfig,
-    pub max_concurrent_branches: usize,
-    pub max_concurrent_workers: usize,
-    pub max_turns: usize,
-    pub branch_max_turns: usize,
-    pub context_window: usize,
-    pub compaction: CompactionConfig,
-    pub memory_persistence: MemoryPersistenceConfig,
-    pub coalesce: CoalesceConfig,
-    pub ingestion: IngestionConfig,
-    pub cortex: CortexConfig,
-    pub warmup: WarmupConfig,
-    pub browser: BrowserConfig,
-    pub mcp: Vec<McpServerConfig>,
-    /// Brave Search API key for web search tool. Supports "env:VAR_NAME" references.
-    pub brave_search_key: Option<String>,
-    /// Default timezone used when evaluating cron active hours.
-    pub cron_timezone: Option<String>,
-    pub history_backfill_count: usize,
-    pub cron: Vec<CronDef>,
-    pub opencode: OpenCodeConfig,
-    /// Worker log mode: "errors_only", "all_separate", or "all_combined".
-    pub worker_log_mode: crate::settings::WorkerLogMode,
-}
-
-impl std::fmt::Debug for DefaultsConfig {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("DefaultsConfig")
-            .field("routing", &self.routing)
-            .field("max_concurrent_branches", &self.max_concurrent_branches)
-            .field("max_concurrent_workers", &self.max_concurrent_workers)
-            .field("max_turns", &self.max_turns)
-            .field("branch_max_turns", &self.branch_max_turns)
-            .field("context_window", &self.context_window)
-            .field("compaction", &self.compaction)
-            .field("memory_persistence", &self.memory_persistence)
-            .field("coalesce", &self.coalesce)
-            .field("ingestion", &self.ingestion)
-            .field("cortex", &self.cortex)
-            .field("warmup", &self.warmup)
-            .field("browser", &self.browser)
-            .field("mcp", &self.mcp)
-            .field(
-                "brave_search_key",
-                &self.brave_search_key.as_ref().map(|_| "[REDACTED]"),
-            )
-            .field("history_backfill_count", &self.history_backfill_count)
-            .field("cron", &self.cron)
-            .field("opencode", &self.opencode)
-            .field("worker_log_mode", &self.worker_log_mode)
-            .finish()
-    }
-}
-
-/// MCP server configuration.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct McpServerConfig {
-    pub name: String,
-    pub transport: McpTransport,
-    pub enabled: bool,
-}
-
-/// MCP transport configuration.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum McpTransport {
-    Stdio {
-        command: String,
-        args: Vec<String>,
-        env: HashMap<String, String>,
-    },
-    Http {
-        url: String,
-        headers: HashMap<String, String>,
-    },
-}
-
-impl McpTransport {
-    pub fn kind(&self) -> &'static str {
-        match self {
-            McpTransport::Stdio { .. } => "stdio",
-            McpTransport::Http { .. } => "http",
-        }
-    }
-}
-
-/// Compaction threshold configuration.
-#[derive(Debug, Clone, Copy)]
-pub struct CompactionConfig {
-    pub background_threshold: f32,
-    pub aggressive_threshold: f32,
-    pub emergency_threshold: f32,
-}
-
-/// Auto-branching memory persistence configuration.
-///
-/// Spawns a silent branch every N messages to recall existing memories and save
-/// new ones from the recent conversation. Runs without blocking the channel and
-/// the result is never injected into channel history.
-#[derive(Debug, Clone, Copy)]
-pub struct MemoryPersistenceConfig {
-    /// Whether auto memory persistence branches are enabled.
-    pub enabled: bool,
-    /// Number of user messages between automatic memory persistence branches.
-    pub message_interval: usize,
-}
-
-impl Default for MemoryPersistenceConfig {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            message_interval: 50,
-        }
-    }
-}
-
-impl Default for CompactionConfig {
-    fn default() -> Self {
-        Self {
-            background_threshold: 0.80,
-            aggressive_threshold: 0.85,
-            emergency_threshold: 0.95,
-        }
-    }
-}
-
-/// Message coalescing configuration for handling rapid-fire messages.
-///
-/// When enabled, messages arriving in quick succession are accumulated and
-/// presented to the LLM as a single batched turn with a hint that this is
-/// a fast-moving conversation.
-#[derive(Debug, Clone, Copy)]
-pub struct CoalesceConfig {
-    /// Enable message coalescing for multi-user channels.
-    pub enabled: bool,
-    /// Initial debounce window after first message (milliseconds).
-    pub debounce_ms: u64,
-    /// Maximum time to wait before flushing regardless (milliseconds).
-    pub max_wait_ms: u64,
-    /// Min messages to trigger coalesce mode (1 = always debounce, 2 = only when burst detected).
-    pub min_messages: usize,
-    /// Apply only to multi-user conversations (skip for DMs).
-    pub multi_user_only: bool,
-}
-
-impl Default for CoalesceConfig {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            debounce_ms: 1500,
-            max_wait_ms: 5000,
-            min_messages: 2,
-            multi_user_only: true,
-        }
-    }
-}
-
-/// File-based memory ingestion configuration.
-///
-/// Watches a directory in the agent workspace for text files, chunks them, and
-/// processes each chunk through the memory recall + save flow. Files are deleted
-/// after successful ingestion.
-#[derive(Debug, Clone, Copy)]
-pub struct IngestionConfig {
-    /// Whether file-based memory ingestion is enabled.
-    pub enabled: bool,
-    /// How often to scan the ingest directory for new files, in seconds.
-    pub poll_interval_secs: u64,
-    /// Target chunk size in characters. Chunks may be slightly larger to avoid
-    /// splitting mid-line.
-    pub chunk_size: usize,
-}
-
-impl Default for IngestionConfig {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            poll_interval_secs: 30,
-            chunk_size: 4000,
-        }
-    }
-}
-
-/// Browser automation configuration for workers.
-#[derive(Debug, Clone)]
-pub struct BrowserConfig {
-    /// Whether browser tools are available to workers.
-    pub enabled: bool,
-    /// Run Chrome in headless mode.
-    pub headless: bool,
-    /// Allow JavaScript evaluation via the browser tool.
-    pub evaluate_enabled: bool,
-    /// Custom Chrome/Chromium executable path.
-    pub executable_path: Option<String>,
-    /// Directory for storing screenshots and other browser artifacts.
-    pub screenshot_dir: Option<PathBuf>,
-}
-
-impl Default for BrowserConfig {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            headless: true,
-            evaluate_enabled: false,
-            executable_path: None,
-            screenshot_dir: None,
-        }
-    }
-}
-
-/// OpenCode subprocess worker configuration.
-#[derive(Debug, Clone)]
-pub struct OpenCodeConfig {
-    /// Whether OpenCode workers are available.
-    pub enabled: bool,
-    /// Path to the OpenCode binary. Supports "env:VAR_NAME" references.
-    /// Falls back to "opencode" on PATH.
-    pub path: String,
-    /// Maximum concurrent OpenCode server processes.
-    pub max_servers: usize,
-    /// Timeout in seconds waiting for a server to become healthy.
-    pub server_startup_timeout_secs: u64,
-    /// Maximum restart attempts before giving up on a server.
-    pub max_restart_retries: u32,
-    /// Permission settings passed to OpenCode's config.
-    pub permissions: crate::opencode::OpenCodePermissions,
-}
-
-impl Default for OpenCodeConfig {
-    fn default() -> Self {
-        Self {
-            enabled: false,
-            path: "opencode".to_string(),
-            max_servers: 5,
-            server_startup_timeout_secs: 30,
-            max_restart_retries: 5,
-            permissions: crate::opencode::OpenCodePermissions::default(),
-        }
-    }
-}
-
-/// Cortex configuration.
-#[derive(Debug, Clone, Copy)]
-pub struct CortexConfig {
-    pub tick_interval_secs: u64,
-    pub worker_timeout_secs: u64,
-    pub branch_timeout_secs: u64,
-    pub circuit_breaker_threshold: u8,
-    /// Interval in seconds between memory bulletin refreshes.
-    pub bulletin_interval_secs: u64,
-    /// Target word count for the memory bulletin.
-    pub bulletin_max_words: usize,
-    /// Max LLM turns for bulletin generation.
-    pub bulletin_max_turns: usize,
-    /// Interval in seconds between association passes.
-    pub association_interval_secs: u64,
-    /// Minimum cosine similarity to create a RelatedTo edge.
-    pub association_similarity_threshold: f32,
-    /// Minimum cosine similarity to create an Updates edge (near-duplicate).
-    pub association_updates_threshold: f32,
-    /// Max associations to create per pass (rate limit).
-    pub association_max_per_pass: usize,
-}
-
-impl Default for CortexConfig {
-    fn default() -> Self {
-        Self {
-            tick_interval_secs: 30,
-            worker_timeout_secs: 300,
-            branch_timeout_secs: 60,
-            circuit_breaker_threshold: 3,
-            bulletin_interval_secs: 3600,
-            bulletin_max_words: 1500,
-            bulletin_max_turns: 15,
-            association_interval_secs: 300,
-            association_similarity_threshold: 0.85,
-            association_updates_threshold: 0.95,
-            association_max_per_pass: 100,
-        }
-    }
-}
-
-/// Warmup configuration.
-#[derive(Debug, Clone, Copy)]
-pub struct WarmupConfig {
-    /// Enable background warmup passes.
-    pub enabled: bool,
-    /// Force-load the embedding model before first recall/write workloads.
-    pub eager_embedding_load: bool,
-    /// Interval in seconds between warmup refresh passes.
-    pub refresh_secs: u64,
-    /// Startup delay before the first warmup pass.
-    pub startup_delay_secs: u64,
-}
-
-impl Default for WarmupConfig {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            eager_embedding_load: true,
-            refresh_secs: 900,
-            startup_delay_secs: 5,
-        }
-    }
-}
-
-/// Current warmup lifecycle state.
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "snake_case")]
-pub enum WarmupState {
-    Cold,
-    Warming,
-    Warm,
-    Degraded,
-}
-
-/// Warmup runtime status snapshot for API and observability.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct WarmupStatus {
-    pub state: WarmupState,
-    pub embedding_ready: bool,
-    pub last_refresh_unix_ms: Option<i64>,
-    pub last_error: Option<String>,
-    pub bulletin_age_secs: Option<u64>,
-}
-
-impl Default for WarmupStatus {
-    fn default() -> Self {
-        Self {
-            state: WarmupState::Cold,
-            embedding_ready: false,
-            last_refresh_unix_ms: None,
-            last_error: None,
-            bulletin_age_secs: None,
-        }
-    }
-}
-
-/// Why `ready_for_work` is currently false.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum WorkReadinessReason {
-    StateNotWarm,
-    EmbeddingNotReady,
-    BulletinMissing,
-    BulletinStale,
-}
-
-impl WorkReadinessReason {
-    pub fn as_str(self) -> &'static str {
-        match self {
-            Self::StateNotWarm => "state_not_warm",
-            Self::EmbeddingNotReady => "embedding_not_ready",
-            Self::BulletinMissing => "bulletin_missing",
-            Self::BulletinStale => "bulletin_stale",
-        }
-    }
-}
-
-/// Derived readiness signal used to gate dispatch behavior.
-#[derive(Debug, Clone, Copy)]
-pub struct WorkReadiness {
-    pub ready: bool,
-    pub reason: Option<WorkReadinessReason>,
-    pub warmup_state: WarmupState,
-    pub embedding_ready: bool,
-    pub bulletin_age_secs: Option<u64>,
-    pub stale_after_secs: u64,
-}
-
-fn evaluate_work_readiness(
-    warmup_config: WarmupConfig,
-    status: WarmupStatus,
-    now_unix_ms: i64,
-) -> WorkReadiness {
-    let stale_after_secs = warmup_config.refresh_secs.max(1).saturating_mul(2).max(60);
-    let bulletin_age_secs = status
-        .last_refresh_unix_ms
-        .map(|refresh_ms| {
-            if now_unix_ms > refresh_ms {
-                ((now_unix_ms - refresh_ms) / 1000) as u64
-            } else {
-                0
-            }
-        })
-        .or(status.bulletin_age_secs);
-
-    let reason = if status.state != WarmupState::Warm {
-        Some(WorkReadinessReason::StateNotWarm)
-    } else if warmup_config.eager_embedding_load && !status.embedding_ready {
-        Some(WorkReadinessReason::EmbeddingNotReady)
-    } else if bulletin_age_secs.is_none() {
-        Some(WorkReadinessReason::BulletinMissing)
-    } else if bulletin_age_secs.is_some_and(|age| age > stale_after_secs) {
-        Some(WorkReadinessReason::BulletinStale)
-    } else {
-        None
-    };
-
-    WorkReadiness {
-        ready: reason.is_none(),
-        reason,
-        warmup_state: status.state,
-        embedding_ready: status.embedding_ready,
-        bulletin_age_secs,
-        stale_after_secs,
-    }
-}
-
-/// Per-agent configuration (raw, before resolution with defaults).
-#[derive(Debug, Clone)]
-pub struct AgentConfig {
-    pub id: String,
-    pub default: bool,
-    /// User-defined display name for the agent (shown in UI).
-    pub display_name: Option<String>,
-    /// User-defined role description (e.g. "handles tier 1 support").
-    pub role: Option<String>,
-    /// Custom workspace path. If None, resolved to instance_dir/agents/{id}/workspace.
-    pub workspace: Option<PathBuf>,
-    /// Per-agent routing overrides. None inherits from defaults.
-    pub routing: Option<RoutingConfig>,
-    pub max_concurrent_branches: Option<usize>,
-    pub max_concurrent_workers: Option<usize>,
-    pub max_turns: Option<usize>,
-    pub branch_max_turns: Option<usize>,
-    pub context_window: Option<usize>,
-    pub compaction: Option<CompactionConfig>,
-    pub memory_persistence: Option<MemoryPersistenceConfig>,
-    pub coalesce: Option<CoalesceConfig>,
-    pub ingestion: Option<IngestionConfig>,
-    pub cortex: Option<CortexConfig>,
-    pub warmup: Option<WarmupConfig>,
-    pub browser: Option<BrowserConfig>,
-    pub mcp: Option<Vec<McpServerConfig>>,
-    /// Per-agent Brave Search API key override. None inherits from defaults.
-    pub brave_search_key: Option<String>,
-    /// Optional timezone override for cron active-hours evaluation.
-    pub cron_timezone: Option<String>,
-    /// Sandbox configuration for process containment.
-    pub sandbox: Option<crate::sandbox::SandboxConfig>,
-    /// Cron job definitions for this agent.
-    pub cron: Vec<CronDef>,
-}
-
-/// A cron job definition from config.
-#[derive(Debug, Clone)]
-pub struct CronDef {
-    pub id: String,
-    pub prompt: String,
-    pub interval_secs: u64,
-    /// Delivery target in "adapter:target" format (e.g. "discord:123456789").
-    pub delivery_target: String,
-    /// Optional active hours window (start_hour, end_hour) in 24h format.
-    pub active_hours: Option<(u8, u8)>,
-    pub enabled: bool,
-    pub run_once: bool,
-    /// Maximum wall-clock seconds to wait for the job to complete.
-    /// `None` uses the default of 120 seconds.
-    pub timeout_secs: Option<u64>,
-}
-
-/// Fully resolved agent config (merged with defaults, paths resolved).
-#[derive(Debug, Clone)]
-pub struct ResolvedAgentConfig {
-    pub id: String,
-    pub display_name: Option<String>,
-    pub role: Option<String>,
-    pub workspace: PathBuf,
-    pub data_dir: PathBuf,
-    pub archives_dir: PathBuf,
-    pub routing: RoutingConfig,
-    pub max_concurrent_branches: usize,
-    pub max_concurrent_workers: usize,
-    pub max_turns: usize,
-    pub branch_max_turns: usize,
-    pub context_window: usize,
-    pub compaction: CompactionConfig,
-    pub memory_persistence: MemoryPersistenceConfig,
-    pub coalesce: CoalesceConfig,
-    pub ingestion: IngestionConfig,
-    pub cortex: CortexConfig,
-    pub warmup: WarmupConfig,
-    pub browser: BrowserConfig,
-    pub mcp: Vec<McpServerConfig>,
-    pub brave_search_key: Option<String>,
-    pub cron_timezone: Option<String>,
-    /// Sandbox configuration for process containment.
-    pub sandbox: crate::sandbox::SandboxConfig,
-    /// Number of messages to fetch from the platform when a new channel is created.
-    pub history_backfill_count: usize,
-    pub cron: Vec<CronDef>,
-}
-
-impl Default for DefaultsConfig {
-    fn default() -> Self {
-        Self {
-            routing: RoutingConfig::default(),
-            max_concurrent_branches: 5,
-            max_concurrent_workers: 5,
-            max_turns: 5,
-            branch_max_turns: 50,
-            context_window: 128_000,
-            compaction: CompactionConfig::default(),
-            memory_persistence: MemoryPersistenceConfig::default(),
-            coalesce: CoalesceConfig::default(),
-            ingestion: IngestionConfig::default(),
-            cortex: CortexConfig::default(),
-            warmup: WarmupConfig::default(),
-            browser: BrowserConfig::default(),
-            mcp: Vec::new(),
-            brave_search_key: None,
-            cron_timezone: None,
-            history_backfill_count: 50,
-            cron: Vec::new(),
-            opencode: OpenCodeConfig::default(),
-            worker_log_mode: crate::settings::WorkerLogMode::default(),
-        }
-    }
-}
-
-impl AgentConfig {
-    /// Resolve this agent config against instance defaults and base paths.
-    pub fn resolve(&self, instance_dir: &Path, defaults: &DefaultsConfig) -> ResolvedAgentConfig {
-        let agent_root = instance_dir.join("agents").join(&self.id);
-
-        ResolvedAgentConfig {
-            id: self.id.clone(),
-            display_name: self.display_name.clone(),
-            role: self.role.clone(),
-            workspace: self
-                .workspace
-                .clone()
-                .unwrap_or_else(|| agent_root.join("workspace")),
-            data_dir: agent_root.join("data"),
-            archives_dir: agent_root.join("archives"),
-            routing: self
-                .routing
-                .clone()
-                .unwrap_or_else(|| defaults.routing.clone()),
-            max_concurrent_branches: self
-                .max_concurrent_branches
-                .unwrap_or(defaults.max_concurrent_branches),
-            max_concurrent_workers: self
-                .max_concurrent_workers
-                .unwrap_or(defaults.max_concurrent_workers),
-            max_turns: self.max_turns.unwrap_or(defaults.max_turns),
-            branch_max_turns: self.branch_max_turns.unwrap_or(defaults.branch_max_turns),
-            context_window: self.context_window.unwrap_or(defaults.context_window),
-            compaction: self.compaction.unwrap_or(defaults.compaction),
-            memory_persistence: self
-                .memory_persistence
-                .unwrap_or(defaults.memory_persistence),
-            coalesce: self.coalesce.unwrap_or(defaults.coalesce),
-            ingestion: self.ingestion.unwrap_or(defaults.ingestion),
-            cortex: self.cortex.unwrap_or(defaults.cortex),
-            warmup: self.warmup.unwrap_or(defaults.warmup),
-            browser: self
-                .browser
-                .clone()
-                .unwrap_or_else(|| defaults.browser.clone()),
-            mcp: resolve_mcp_configs(&defaults.mcp, self.mcp.as_deref()),
-            brave_search_key: self
-                .brave_search_key
-                .clone()
-                .or_else(|| defaults.brave_search_key.clone()),
-            cron_timezone: resolve_cron_timezone(
-                &self.id,
-                self.cron_timezone.as_deref(),
-                defaults.cron_timezone.as_deref(),
-            ),
-            sandbox: self.sandbox.clone().unwrap_or_default(),
-            history_backfill_count: defaults.history_backfill_count,
-            cron: self.cron.clone(),
-        }
-    }
-}
-
-impl ResolvedAgentConfig {
-    pub fn sqlite_path(&self) -> PathBuf {
-        self.data_dir.join("spacebot.db")
-    }
-    pub fn lancedb_path(&self) -> PathBuf {
-        self.data_dir.join("lancedb")
-    }
-    pub fn redb_path(&self) -> PathBuf {
-        self.data_dir.join("config.redb")
-    }
-    pub fn history_backfill_count(&self) -> usize {
-        self.history_backfill_count
-    }
-    /// Resolved screenshot directory, falling back to data_dir/screenshots.
-    pub fn screenshot_dir(&self) -> PathBuf {
-        self.browser
-            .screenshot_dir
-            .clone()
-            .unwrap_or_else(|| self.data_dir.join("screenshots"))
-    }
-
-    /// Directory for worker execution logs written on failure.
-    pub fn logs_dir(&self) -> PathBuf {
-        self.data_dir.join("logs")
-    }
-
-    /// Path to agent workspace skills directory.
-    pub fn skills_dir(&self) -> PathBuf {
-        self.workspace.join("skills")
-    }
-
-    /// Path to the memory ingestion directory where users drop files.
-    pub fn ingest_dir(&self) -> PathBuf {
-        self.workspace.join("ingest")
-    }
-}
-
-/// Routes a messaging platform conversation to a specific agent.
-#[derive(Debug, Clone)]
-pub struct Binding {
-    pub agent_id: String,
-    pub channel: String,
-    pub guild_id: Option<String>,
-    pub workspace_id: Option<String>, // Slack workspace (team) ID
-    pub chat_id: Option<String>,
-    /// Channel IDs this binding applies to. If empty, all channels in the guild/workspace are allowed.
-    pub channel_ids: Vec<String>,
-    /// Require explicit @mention (or reply-to-bot) for inbound messages.
-    pub require_mention: bool,
-    /// User IDs allowed to DM the bot through this binding.
-    pub dm_allowed_users: Vec<String>,
-}
-
-impl Binding {
-    /// Check if this binding matches an inbound message.
-    fn matches(&self, message: &crate::InboundMessage) -> bool {
-        if self.channel != message.source {
-            return false;
-        }
-
-        // For webchat messages, match based on agent_id in the message
-        if message.source == "webchat"
-            && let Some(message_agent_id) = &message.agent_id
-        {
-            return message_agent_id.as_ref() == self.agent_id;
-        }
-
-        // DM messages have no guild_id — match if the sender is in dm_allowed_users
-        let is_dm =
-            !message.metadata.contains_key("discord_guild_id") && message.source == "discord";
-        if is_dm {
-            return !self.dm_allowed_users.is_empty()
-                && self.dm_allowed_users.contains(&message.sender_id);
-        }
-
-        if let Some(guild_id) = &self.guild_id {
-            let message_guild = message
-                .metadata
-                .get("discord_guild_id")
-                .and_then(|v| v.as_u64())
-                .map(|v| v.to_string());
-            if message_guild.as_deref() != Some(guild_id) {
-                return false;
-            }
-        }
-
-        if let Some(workspace_id) = &self.workspace_id {
-            let message_workspace = message
-                .metadata
-                .get("slack_workspace_id")
-                .and_then(|v| v.as_str());
-            if message_workspace != Some(workspace_id) {
-                return false;
-            }
-        }
-
-        if !self.channel_ids.is_empty() {
-            let message_channel = message
-                .metadata
-                .get("discord_channel_id")
-                .and_then(|v| v.as_u64())
-                .map(|v| v.to_string());
-            let parent_channel = message
-                .metadata
-                .get("discord_parent_channel_id")
-                .and_then(|v| v.as_u64())
-                .map(|v| v.to_string());
-
-            // Also check Slack and Twitch channel IDs
-            let slack_channel = message
-                .metadata
-                .get("slack_channel_id")
-                .and_then(|v| v.as_str());
-            let twitch_channel = message
-                .metadata
-                .get("twitch_channel")
-                .and_then(|v| v.as_str());
-
-            let direct_match = message_channel
-                .as_ref()
-                .is_some_and(|id| self.channel_ids.contains(id))
-                || slack_channel.is_some_and(|id| self.channel_ids.contains(&id.to_string()))
-                || twitch_channel.is_some_and(|id| self.channel_ids.contains(&id.to_string()));
-            let parent_match = parent_channel
-                .as_ref()
-                .is_some_and(|id| self.channel_ids.contains(id));
-
-            if !direct_match && !parent_match {
-                return false;
-            }
-        }
-
-        if self.channel == "discord" && self.require_mention {
-            let is_guild_message = message
-                .metadata
-                .get("discord_guild_id")
-                .and_then(|v| v.as_u64())
-                .is_some();
-            if is_guild_message {
-                let mentions_or_replies_to_bot = message
-                    .metadata
-                    .get("discord_mentions_or_replies_to_bot")
-                    .and_then(|v| v.as_bool())
-                    .unwrap_or(false);
-                if !mentions_or_replies_to_bot {
-                    return false;
-                }
-            }
-        }
-
-        if let Some(chat_id) = &self.chat_id {
-            let message_chat = message.metadata.get("telegram_chat_id").and_then(|value| {
-                value
-                    .as_str()
-                    .map(std::borrow::ToOwned::to_owned)
-                    .or_else(|| value.as_i64().map(|id| id.to_string()))
-            });
-            if message_chat.as_deref() != Some(chat_id.as_str()) {
-                return false;
-            }
-        }
-
-        true
-    }
-}
-
-/// Resolve which agent should handle an inbound message.
-///
-/// Checks bindings in order. First match wins. Falls back to the default
-/// agent if no binding matches.
-pub fn resolve_agent_for_message(
-    bindings: &[Binding],
-    message: &crate::InboundMessage,
-    default_agent_id: &str,
-) -> crate::AgentId {
-    for binding in bindings {
-        if binding.matches(message) {
-            return std::sync::Arc::from(binding.agent_id.as_str());
-        }
-    }
-    std::sync::Arc::from(default_agent_id)
-}
-
-/// Messaging platform credentials (instance-level).
-#[derive(Debug, Clone, Default)]
-pub struct MessagingConfig {
-    pub discord: Option<DiscordConfig>,
-    pub slack: Option<SlackConfig>,
-    pub telegram: Option<TelegramConfig>,
-    pub webhook: Option<WebhookConfig>,
-    pub twitch: Option<TwitchConfig>,
-}
-
-#[derive(Clone)]
-pub struct DiscordConfig {
-    pub enabled: bool,
-    pub token: String,
-    /// User IDs allowed to DM the bot. If empty, DMs are ignored entirely.
-    pub dm_allowed_users: Vec<String>,
-    /// Whether to process messages from other bots (self-messages are always ignored).
-    pub allow_bot_messages: bool,
-}
-
-impl std::fmt::Debug for DiscordConfig {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("DiscordConfig")
-            .field("enabled", &self.enabled)
-            .field("token", &"[REDACTED]")
-            .field("dm_allowed_users", &self.dm_allowed_users)
-            .field("allow_bot_messages", &self.allow_bot_messages)
-            .finish()
-    }
-}
-
-/// A single slash command definition for the Slack adapter.
-///
-/// Maps a Slack slash command (e.g. `/ask`) to a target agent.
-/// Commands not listed here are acknowledged but produce a "not configured" reply.
-#[derive(Debug, Clone)]
-pub struct SlackCommandConfig {
-    /// The slash command string exactly as Slack sends it, e.g. `"/ask"`.
-    pub command: String,
-    /// ID of the agent that should handle this command.
-    pub agent_id: String,
-    /// Short description shown in Slack's command autocomplete hint (optional).
-    pub description: Option<String>,
-}
-
-#[derive(Clone)]
-pub struct SlackConfig {
-    pub enabled: bool,
-    pub bot_token: String,
-    pub app_token: String,
-    /// User IDs allowed to DM the bot. If empty, DMs are ignored entirely.
-    pub dm_allowed_users: Vec<String>,
-    /// Slash command definitions. If empty, all slash commands are ignored.
-    pub commands: Vec<SlackCommandConfig>,
-}
-
-impl std::fmt::Debug for SlackConfig {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("SlackConfig")
-            .field("enabled", &self.enabled)
-            .field("bot_token", &"[REDACTED]")
-            .field("app_token", &"[REDACTED]")
-            .field("dm_allowed_users", &self.dm_allowed_users)
-            .field("commands", &self.commands)
-            .finish()
-    }
-}
-
-/// Hot-reloadable Discord permission filters.
-///
-/// Derived from bindings + discord config. Shared with the Discord adapter
-/// via `Arc<ArcSwap<..>>` so the file watcher can swap in new values without
-/// restarting the gateway connection.
-#[derive(Debug, Clone, Default)]
-pub struct DiscordPermissions {
-    pub guild_filter: Option<Vec<u64>>,
-    pub channel_filter: std::collections::HashMap<u64, Vec<u64>>,
-    pub dm_allowed_users: Vec<u64>,
-    pub allow_bot_messages: bool,
-}
-
-/// Hot-reloadable Slack permission filters.
-///
-/// Shared with the Slack adapter via `Arc<ArcSwap<..>>` for hot-reloading.
-#[derive(Debug, Clone, Default)]
-pub struct SlackPermissions {
-    pub workspace_filter: Option<Vec<String>>, // team IDs
-    pub channel_filter: std::collections::HashMap<String, Vec<String>>, // team_id -> allowed channel_ids
-    pub dm_allowed_users: Vec<String>,                                  // user IDs
-}
-
-impl SlackPermissions {
-    /// Build from the current config's slack settings and bindings.
-    pub fn from_config(slack: &SlackConfig, bindings: &[Binding]) -> Self {
-        let slack_bindings: Vec<&Binding> =
-            bindings.iter().filter(|b| b.channel == "slack").collect();
-
-        let workspace_filter = {
-            let workspace_ids: Vec<String> = slack_bindings
-                .iter()
-                .filter_map(|b| b.workspace_id.clone())
-                .collect();
-            if workspace_ids.is_empty() {
-                None
-            } else {
-                Some(workspace_ids)
-            }
-        };
-
-        let channel_filter = {
-            let mut filter: std::collections::HashMap<String, Vec<String>> =
-                std::collections::HashMap::new();
-            for binding in &slack_bindings {
-                if let Some(workspace_id) = &binding.workspace_id
-                    && !binding.channel_ids.is_empty()
-                {
-                    filter
-                        .entry(workspace_id.clone())
-                        .or_default()
-                        .extend(binding.channel_ids.clone());
-                }
-            }
-            filter
-        };
-
-        let mut dm_allowed_users = slack.dm_allowed_users.clone();
-
-        for binding in &slack_bindings {
-            for id in &binding.dm_allowed_users {
-                if !dm_allowed_users.contains(id) {
-                    dm_allowed_users.push(id.clone());
-                }
-            }
-        }
-
-        Self {
-            workspace_filter,
-            channel_filter,
-            dm_allowed_users,
-        }
-    }
-}
-
-impl DiscordPermissions {
-    /// Build from the current config's discord settings and bindings.
-    pub fn from_config(discord: &DiscordConfig, bindings: &[Binding]) -> Self {
-        let discord_bindings: Vec<&Binding> =
-            bindings.iter().filter(|b| b.channel == "discord").collect();
-
-        let guild_filter = {
-            let guild_ids: Vec<u64> = discord_bindings
-                .iter()
-                .filter_map(|b| b.guild_id.as_ref()?.parse::<u64>().ok())
-                .collect();
-            if guild_ids.is_empty() {
-                None
-            } else {
-                Some(guild_ids)
-            }
-        };
-
-        let channel_filter = {
-            let mut filter: std::collections::HashMap<u64, Vec<u64>> =
-                std::collections::HashMap::new();
-            for binding in &discord_bindings {
-                if let Some(guild_id) = binding
-                    .guild_id
-                    .as_ref()
-                    .and_then(|g| g.parse::<u64>().ok())
-                    && !binding.channel_ids.is_empty()
-                {
-                    let channel_ids: Vec<u64> = binding
-                        .channel_ids
-                        .iter()
-                        .filter_map(|id| id.parse::<u64>().ok())
-                        .collect();
-                    filter.entry(guild_id).or_default().extend(channel_ids);
-                }
-            }
-            filter
-        };
-
-        let mut dm_allowed_users: Vec<u64> = discord
-            .dm_allowed_users
-            .iter()
-            .filter_map(|id| id.parse::<u64>().ok())
-            .collect();
-
-        // Also collect dm_allowed_users from bindings
-        for binding in &discord_bindings {
-            for id in &binding.dm_allowed_users {
-                if let Ok(uid) = id.parse::<u64>()
-                    && !dm_allowed_users.contains(&uid)
-                {
-                    dm_allowed_users.push(uid);
-                }
-            }
-        }
-
-        Self {
-            guild_filter,
-            channel_filter,
-            dm_allowed_users,
-            allow_bot_messages: discord.allow_bot_messages,
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct TelegramConfig {
-    pub enabled: bool,
-    pub token: String,
-    /// User IDs allowed to DM the bot. If empty, DMs are ignored entirely.
-    pub dm_allowed_users: Vec<String>,
-}
-
-impl std::fmt::Debug for TelegramConfig {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("TelegramConfig")
-            .field("enabled", &self.enabled)
-            .field("token", &"[REDACTED]")
-            .field("dm_allowed_users", &self.dm_allowed_users)
-            .finish()
-    }
-}
-
-/// Hot-reloadable Telegram permission filters.
-///
-/// Shared with the Telegram adapter via `Arc<ArcSwap<..>>` for hot-reloading.
-#[derive(Debug, Clone, Default)]
-pub struct TelegramPermissions {
-    /// Allowed chat IDs (None = all chats accepted).
-    pub chat_filter: Option<Vec<i64>>,
-    /// User IDs allowed in private chats.
-    pub dm_allowed_users: Vec<i64>,
-}
-
-impl TelegramPermissions {
-    /// Build from the current config's telegram settings and bindings.
-    pub fn from_config(telegram: &TelegramConfig, bindings: &[Binding]) -> Self {
-        let telegram_bindings: Vec<&Binding> = bindings
-            .iter()
-            .filter(|b| b.channel == "telegram")
-            .collect();
-
-        let chat_filter = {
-            let chat_ids: Vec<i64> = telegram_bindings
-                .iter()
-                .filter_map(|b| b.chat_id.as_ref()?.parse::<i64>().ok())
-                .collect();
-            if chat_ids.is_empty() {
-                None
-            } else {
-                Some(chat_ids)
-            }
-        };
-
-        let mut dm_allowed_users: Vec<i64> = telegram
-            .dm_allowed_users
-            .iter()
-            .filter_map(|id| id.parse::<i64>().ok())
-            .collect();
-
-        for binding in &telegram_bindings {
-            for id in &binding.dm_allowed_users {
-                if let Ok(uid) = id.parse::<i64>()
-                    && !dm_allowed_users.contains(&uid)
-                {
-                    dm_allowed_users.push(uid);
-                }
-            }
-        }
-
-        Self {
-            chat_filter,
-            dm_allowed_users,
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct TwitchConfig {
-    pub enabled: bool,
-    pub username: String,
-    pub oauth_token: String,
-    pub client_id: Option<String>,
-    pub client_secret: Option<String>,
-    pub refresh_token: Option<String>,
-    /// Channels to join (without the # prefix).
-    pub channels: Vec<String>,
-    /// Optional prefix that triggers the bot (e.g. "!ask"). If empty, all messages are processed.
-    pub trigger_prefix: Option<String>,
-}
-
-impl std::fmt::Debug for TwitchConfig {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("TwitchConfig")
-            .field("enabled", &self.enabled)
-            .field("username", &self.username)
-            .field("oauth_token", &"[REDACTED]")
-            .field("channels", &self.channels)
-            .field("trigger_prefix", &self.trigger_prefix)
-            .finish()
-    }
-}
-
-/// Hot-reloadable Twitch permission filters.
-///
-/// Shared with the Twitch adapter via `Arc<ArcSwap<..>>` for hot-reloading.
-#[derive(Debug, Clone, Default)]
-pub struct TwitchPermissions {
-    /// Allowed channel names (None = all joined channels accepted).
-    pub channel_filter: Option<Vec<String>>,
-    /// User login names allowed to interact with the bot. Empty = all users.
-    pub allowed_users: Vec<String>,
-}
-
-impl TwitchPermissions {
-    /// Build from the current config's twitch settings and bindings.
-    pub fn from_config(_twitch: &TwitchConfig, bindings: &[Binding]) -> Self {
-        let twitch_bindings: Vec<&Binding> =
-            bindings.iter().filter(|b| b.channel == "twitch").collect();
-
-        let channel_filter = {
-            let channel_ids: Vec<String> = twitch_bindings
-                .iter()
-                .flat_map(|b| b.channel_ids.clone())
-                .collect();
-            if channel_ids.is_empty() {
-                None
-            } else {
-                Some(channel_ids)
-            }
-        };
-
-        let mut allowed_users: Vec<String> = Vec::new();
-        for binding in &twitch_bindings {
-            for id in &binding.dm_allowed_users {
-                if !allowed_users.contains(id) {
-                    allowed_users.push(id.clone());
-                }
-            }
-        }
-
-        Self {
-            channel_filter,
-            allowed_users,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct WebhookConfig {
-    pub enabled: bool,
-    pub port: u16,
-    pub bind: String,
-    pub auth_token: Option<String>,
-}
-
-// -- TOML deserialization types --
-
-#[derive(Deserialize)]
-struct TomlConfig {
-    #[serde(default)]
-    llm: TomlLlmConfig,
-    #[serde(default)]
-    defaults: TomlDefaultsConfig,
-    #[serde(default)]
-    agents: Vec<TomlAgentConfig>,
-    #[serde(default)]
-    links: Vec<TomlLinkDef>,
-    #[serde(default)]
-    groups: Vec<TomlGroupDef>,
-    #[serde(default)]
-    humans: Vec<TomlHumanDef>,
-    #[serde(default)]
-    messaging: TomlMessagingConfig,
-    #[serde(default)]
-    bindings: Vec<TomlBinding>,
-    #[serde(default)]
-    api: TomlApiConfig,
-    #[serde(default)]
-    metrics: TomlMetricsConfig,
-    #[serde(default)]
-    telemetry: TomlTelemetryConfig,
-}
-
-#[derive(Deserialize)]
-struct TomlLinkDef {
-    from: String,
-    to: String,
-    #[serde(default = "default_link_direction")]
-    direction: String,
-    #[serde(default = "default_link_kind")]
-    kind: String,
-    /// Backward compat: old configs use `relationship` instead of `kind`
-    #[serde(default)]
-    relationship: Option<String>,
-}
-
-fn default_link_direction() -> String {
-    "two_way".into()
-}
-
-fn default_link_kind() -> String {
-    "peer".into()
-}
-
-#[derive(Deserialize)]
-struct TomlGroupDef {
-    name: String,
-    #[serde(default)]
-    agent_ids: Vec<String>,
-    color: Option<String>,
-}
-
-#[derive(Deserialize)]
-struct TomlHumanDef {
-    id: String,
-    display_name: Option<String>,
-    role: Option<String>,
-    bio: Option<String>,
-}
-
-#[derive(Deserialize, Default)]
-struct TomlTelemetryConfig {
-    otlp_endpoint: Option<String>,
-    otlp_headers: Option<String>,
-    service_name: Option<String>,
-    sample_rate: Option<f64>,
-}
-
-#[derive(Deserialize)]
-struct TomlApiConfig {
-    #[serde(default = "default_api_enabled")]
-    enabled: bool,
-    #[serde(default = "default_api_port")]
-    port: u16,
-    #[serde(default = "default_api_bind")]
-    bind: String,
-    #[serde(default)]
-    auth_token: Option<String>,
-}
-
-impl Default for TomlApiConfig {
-    fn default() -> Self {
-        Self {
-            enabled: default_api_enabled(),
-            port: default_api_port(),
-            bind: default_api_bind(),
-            auth_token: None,
-        }
-    }
-}
-
-fn default_api_enabled() -> bool {
-    true
-}
-fn default_api_port() -> u16 {
-    19898
-}
-fn default_api_bind() -> String {
-    "127.0.0.1".into()
-}
-
-fn hosted_api_bind(bind: String) -> String {
-    match std::env::var("SPACEBOT_DEPLOYMENT") {
-        Ok(deployment) if deployment.eq_ignore_ascii_case("hosted") => "[::]".into(),
-        _ => bind,
-    }
-}
-
-#[derive(Deserialize)]
-struct TomlMetricsConfig {
-    #[serde(default)]
-    enabled: bool,
-    #[serde(default = "default_metrics_port")]
-    port: u16,
-    #[serde(default = "default_metrics_bind")]
-    bind: String,
-}
-
-impl Default for TomlMetricsConfig {
-    fn default() -> Self {
-        Self {
-            enabled: false,
-            port: default_metrics_port(),
-            bind: default_metrics_bind(),
-        }
-    }
-}
-
-fn default_metrics_port() -> u16 {
-    9090
-}
-fn default_metrics_bind() -> String {
-    "0.0.0.0".into()
-}
-
-#[derive(Deserialize, Debug)]
-struct TomlProviderConfig {
-    api_type: ApiType,
-    base_url: String,
-    api_key: String,
-    name: Option<String>,
-}
-
-#[derive(Deserialize, Default)]
-struct TomlLlmConfigFields {
-    anthropic_key: Option<String>,
-    openai_key: Option<String>,
-    openrouter_key: Option<String>,
-    zhipu_key: Option<String>,
-    groq_key: Option<String>,
-    together_key: Option<String>,
-    fireworks_key: Option<String>,
-    deepseek_key: Option<String>,
-    xai_key: Option<String>,
-    mistral_key: Option<String>,
-    gemini_key: Option<String>,
-    ollama_key: Option<String>,
-    ollama_base_url: Option<String>,
-    opencode_zen_key: Option<String>,
-    nvidia_key: Option<String>,
-    minimax_key: Option<String>,
-    minimax_cn_key: Option<String>,
-    moonshot_key: Option<String>,
-    zai_coding_plan_key: Option<String>,
-    #[serde(default)]
-    providers: HashMap<String, TomlProviderConfig>,
-    #[serde(default)]
-    #[serde(flatten)]
-    extra: HashMap<String, toml::Value>,
-}
-
-#[derive(Default)]
-struct TomlLlmConfig {
-    anthropic_key: Option<String>,
-    openai_key: Option<String>,
-    openrouter_key: Option<String>,
-    zhipu_key: Option<String>,
-    groq_key: Option<String>,
-    together_key: Option<String>,
-    fireworks_key: Option<String>,
-    deepseek_key: Option<String>,
-    xai_key: Option<String>,
-    mistral_key: Option<String>,
-    gemini_key: Option<String>,
-    ollama_key: Option<String>,
-    ollama_base_url: Option<String>,
-    opencode_zen_key: Option<String>,
-    nvidia_key: Option<String>,
-    minimax_key: Option<String>,
-    minimax_cn_key: Option<String>,
-    moonshot_key: Option<String>,
-    zai_coding_plan_key: Option<String>,
-    providers: HashMap<String, TomlProviderConfig>,
-}
-
-impl<'de> Deserialize<'de> for TomlLlmConfig {
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let mut fields = TomlLlmConfigFields::deserialize(deserializer)?;
-        let mut providers = fields.providers;
-
-        for (key, value) in fields.extra {
-            if key == "provider" {
-                let table = value
-                    .as_table()
-                    .ok_or_else(|| serde::de::Error::custom("`llm.provider` must be a table"))?;
-                for (provider_id, provider_value) in table {
-                    let provider_config = provider_value
-                        .clone()
-                        .try_into()
-                        .map_err(serde::de::Error::custom)?;
-                    providers.insert(provider_id.to_string(), provider_config);
-                }
-            }
-
-            if let Some(provider_id) = key.strip_prefix("provider.") {
-                let provider_config = value.try_into().map_err(serde::de::Error::custom)?;
-                providers.insert(provider_id.to_string(), provider_config);
-            }
-        }
-
-        fields.providers = providers;
-
-        Ok(Self {
-            anthropic_key: fields.anthropic_key,
-            openai_key: fields.openai_key,
-            openrouter_key: fields.openrouter_key,
-            zhipu_key: fields.zhipu_key,
-            groq_key: fields.groq_key,
-            together_key: fields.together_key,
-            fireworks_key: fields.fireworks_key,
-            deepseek_key: fields.deepseek_key,
-            xai_key: fields.xai_key,
-            mistral_key: fields.mistral_key,
-            gemini_key: fields.gemini_key,
-            ollama_key: fields.ollama_key,
-            ollama_base_url: fields.ollama_base_url,
-            opencode_zen_key: fields.opencode_zen_key,
-            nvidia_key: fields.nvidia_key,
-            minimax_key: fields.minimax_key,
-            minimax_cn_key: fields.minimax_cn_key,
-            moonshot_key: fields.moonshot_key,
-            zai_coding_plan_key: fields.zai_coding_plan_key,
-            providers: fields.providers,
-        })
-    }
-}
-
-#[derive(Deserialize, Default)]
-struct TomlDefaultsConfig {
-    routing: Option<TomlRoutingConfig>,
-    max_concurrent_branches: Option<usize>,
-    max_concurrent_workers: Option<usize>,
-    max_turns: Option<usize>,
-    branch_max_turns: Option<usize>,
-    context_window: Option<usize>,
-    compaction: Option<TomlCompactionConfig>,
-    memory_persistence: Option<TomlMemoryPersistenceConfig>,
-    coalesce: Option<TomlCoalesceConfig>,
-    ingestion: Option<TomlIngestionConfig>,
-    cortex: Option<TomlCortexConfig>,
-    warmup: Option<TomlWarmupConfig>,
-    browser: Option<TomlBrowserConfig>,
-    #[serde(default)]
-    mcp: Vec<TomlMcpServerConfig>,
-    brave_search_key: Option<String>,
-    cron_timezone: Option<String>,
-    opencode: Option<TomlOpenCodeConfig>,
-    worker_log_mode: Option<String>,
-}
-
-#[derive(Deserialize, Default)]
-struct TomlRoutingConfig {
-    channel: Option<String>,
-    branch: Option<String>,
-    worker: Option<String>,
-    compactor: Option<String>,
-    cortex: Option<String>,
-    voice: Option<String>,
-    rate_limit_cooldown_secs: Option<u64>,
-    channel_thinking_effort: Option<String>,
-    branch_thinking_effort: Option<String>,
-    worker_thinking_effort: Option<String>,
-    compactor_thinking_effort: Option<String>,
-    cortex_thinking_effort: Option<String>,
-    #[serde(default)]
-    task_overrides: HashMap<String, String>,
-    fallbacks: Option<HashMap<String, Vec<String>>>,
-}
-
-#[derive(Deserialize)]
-struct TomlMemoryPersistenceConfig {
-    enabled: Option<bool>,
-    message_interval: Option<usize>,
-}
-
-#[derive(Deserialize)]
-struct TomlCoalesceConfig {
-    enabled: Option<bool>,
-    debounce_ms: Option<u64>,
-    max_wait_ms: Option<u64>,
-    min_messages: Option<usize>,
-    multi_user_only: Option<bool>,
-}
-
-#[derive(Deserialize)]
-struct TomlIngestionConfig {
-    enabled: Option<bool>,
-    poll_interval_secs: Option<u64>,
-    chunk_size: Option<usize>,
-}
-
-#[derive(Deserialize)]
-struct TomlCompactionConfig {
-    background_threshold: Option<f32>,
-    aggressive_threshold: Option<f32>,
-    emergency_threshold: Option<f32>,
-}
-
-#[derive(Deserialize)]
-struct TomlCortexConfig {
-    tick_interval_secs: Option<u64>,
-    worker_timeout_secs: Option<u64>,
-    branch_timeout_secs: Option<u64>,
-    circuit_breaker_threshold: Option<u8>,
-    bulletin_interval_secs: Option<u64>,
-    bulletin_max_words: Option<usize>,
-    bulletin_max_turns: Option<usize>,
-    association_interval_secs: Option<u64>,
-    association_similarity_threshold: Option<f32>,
-    association_updates_threshold: Option<f32>,
-    association_max_per_pass: Option<usize>,
-}
-
-#[derive(Deserialize)]
-struct TomlWarmupConfig {
-    enabled: Option<bool>,
-    eager_embedding_load: Option<bool>,
-    refresh_secs: Option<u64>,
-    startup_delay_secs: Option<u64>,
-}
-
-#[derive(Deserialize)]
-struct TomlBrowserConfig {
-    enabled: Option<bool>,
-    headless: Option<bool>,
-    evaluate_enabled: Option<bool>,
-    executable_path: Option<String>,
-    screenshot_dir: Option<String>,
-}
-
-#[derive(Deserialize)]
-struct TomlOpenCodeConfig {
-    enabled: Option<bool>,
-    path: Option<String>,
-    max_servers: Option<usize>,
-    server_startup_timeout_secs: Option<u64>,
-    max_restart_retries: Option<u32>,
-    permissions: Option<TomlOpenCodePermissions>,
-}
-
-#[derive(Deserialize)]
-struct TomlOpenCodePermissions {
-    edit: Option<String>,
-    bash: Option<String>,
-    webfetch: Option<String>,
-}
-
-#[derive(Deserialize, Clone)]
-struct TomlMcpServerConfig {
-    name: String,
-    transport: String,
-    #[serde(default = "default_mcp_enabled")]
-    enabled: bool,
-    command: Option<String>,
-    #[serde(default)]
-    args: Vec<String>,
-    #[serde(default)]
-    env: HashMap<String, String>,
-    url: Option<String>,
-    #[serde(default)]
-    headers: HashMap<String, String>,
-}
-
-fn default_mcp_enabled() -> bool {
-    true
-}
-
-#[derive(Deserialize)]
-struct TomlAgentConfig {
-    id: String,
-    #[serde(default)]
-    default: bool,
-    display_name: Option<String>,
-    role: Option<String>,
-    workspace: Option<String>,
-    routing: Option<TomlRoutingConfig>,
-    max_concurrent_branches: Option<usize>,
-    max_concurrent_workers: Option<usize>,
-    max_turns: Option<usize>,
-    branch_max_turns: Option<usize>,
-    context_window: Option<usize>,
-    compaction: Option<TomlCompactionConfig>,
-    memory_persistence: Option<TomlMemoryPersistenceConfig>,
-    coalesce: Option<TomlCoalesceConfig>,
-    ingestion: Option<TomlIngestionConfig>,
-    cortex: Option<TomlCortexConfig>,
-    warmup: Option<TomlWarmupConfig>,
-    browser: Option<TomlBrowserConfig>,
-    mcp: Option<Vec<TomlMcpServerConfig>>,
-    brave_search_key: Option<String>,
-    cron_timezone: Option<String>,
-    sandbox: Option<crate::sandbox::SandboxConfig>,
-    #[serde(default)]
-    cron: Vec<TomlCronDef>,
-}
-
-#[derive(Deserialize)]
-struct TomlCronDef {
-    id: String,
-    prompt: String,
-    interval_secs: Option<u64>,
-    delivery_target: String,
-    active_start_hour: Option<u8>,
-    active_end_hour: Option<u8>,
-    #[serde(default = "default_enabled")]
-    enabled: bool,
-    #[serde(default)]
-    run_once: bool,
-    timeout_secs: Option<u64>,
-}
-
-fn default_enabled() -> bool {
-    true
-}
-
-#[derive(Deserialize, Default)]
-struct TomlMessagingConfig {
-    discord: Option<TomlDiscordConfig>,
-    slack: Option<TomlSlackConfig>,
-    telegram: Option<TomlTelegramConfig>,
-    webhook: Option<TomlWebhookConfig>,
-    twitch: Option<TomlTwitchConfig>,
-}
-
-#[derive(Deserialize)]
-struct TomlDiscordConfig {
-    #[serde(default)]
-    enabled: bool,
-    token: Option<String>,
-    #[serde(default)]
-    dm_allowed_users: Vec<String>,
-    #[serde(default)]
-    allow_bot_messages: bool,
-}
-
-#[derive(Deserialize)]
-struct TomlSlackConfig {
-    #[serde(default)]
-    enabled: bool,
-    bot_token: Option<String>,
-    app_token: Option<String>,
-    #[serde(default)]
-    dm_allowed_users: Vec<String>,
-    #[serde(default)]
-    commands: Vec<TomlSlackCommandConfig>,
-}
-
-#[derive(Deserialize)]
-struct TomlSlackCommandConfig {
-    command: String,
-    agent_id: String,
-    description: Option<String>,
-}
-
-#[derive(Deserialize)]
-struct TomlTelegramConfig {
-    #[serde(default)]
-    enabled: bool,
-    token: Option<String>,
-    #[serde(default)]
-    dm_allowed_users: Vec<String>,
-}
-
-#[derive(Deserialize)]
-struct TomlWebhookConfig {
-    #[serde(default)]
-    enabled: bool,
-    #[serde(default = "default_webhook_port")]
-    port: u16,
-    #[serde(default = "default_webhook_bind")]
-    bind: String,
-    auth_token: Option<String>,
-}
-
-#[derive(Deserialize)]
-struct TomlTwitchConfig {
-    #[serde(default)]
-    enabled: bool,
-    username: Option<String>,
-    oauth_token: Option<String>,
-    client_id: Option<String>,
-    client_secret: Option<String>,
-    refresh_token: Option<String>,
-    #[serde(default)]
-    channels: Vec<String>,
-    trigger_prefix: Option<String>,
-}
-
-fn default_webhook_port() -> u16 {
-    18789
-}
-fn default_webhook_bind() -> String {
-    "127.0.0.1".into()
-}
-
-#[derive(Deserialize)]
-struct TomlBinding {
-    agent_id: String,
-    channel: String,
-    guild_id: Option<String>,
-    workspace_id: Option<String>,
-    chat_id: Option<String>,
-    #[serde(default)]
-    channel_ids: Vec<String>,
-    #[serde(default)]
-    require_mention: bool,
-    #[serde(default)]
-    dm_allowed_users: Vec<String>,
-}
-
-/// Resolve a value that might be an "env:VAR_NAME" reference.
-fn resolve_env_value(value: &str) -> Option<String> {
-    if let Some(var_name) = value.strip_prefix("env:") {
-        std::env::var(var_name).ok()
-    } else {
-        Some(value.to_string())
-    }
-}
-
-fn normalize_timezone(value: &str) -> Option<String> {
-    let timezone = value.trim();
-    if timezone.is_empty() {
-        return None;
-    }
-    Some(timezone.to_string())
-}
-
-fn resolve_cron_timezone(
-    agent_id: &str,
-    agent_timezone: Option<&str>,
-    default_timezone: Option<&str>,
-) -> Option<String> {
-    let timezone = agent_timezone
-        .and_then(normalize_timezone)
-        .or_else(|| default_timezone.and_then(normalize_timezone))
-        .or_else(|| {
-            std::env::var(CRON_TIMEZONE_ENV_VAR)
-                .ok()
-                .and_then(|value| normalize_timezone(&value))
-        });
-
-    let timezone = timezone?;
-
-    if timezone.parse::<Tz>().is_err() {
-        tracing::warn!(
-            agent_id,
-            cron_timezone = %timezone,
-            "invalid cron timezone configured, falling back to system local timezone"
-        );
-        return None;
-    }
-
-    Some(timezone)
-}
-
-fn parse_otlp_headers(value: Option<String>) -> Result<HashMap<String, String>> {
-    let Some(raw) = value else {
-        return Ok(HashMap::new());
-    };
-
-    let raw = raw.trim();
-    if raw.is_empty() {
-        return Ok(HashMap::new());
-    }
-
-    let mut headers = HashMap::new();
-    for entry in raw.split(',') {
-        let entry = entry.trim();
-        if entry.is_empty() {
-            continue;
-        }
-        let Some((key, value)) = entry.split_once('=') else {
-            return Err(ConfigError::Invalid(format!(
-                "invalid OTEL_EXPORTER_OTLP_HEADERS entry '{entry}', expected key=value"
-            )))?;
-        };
-        let key = key.trim();
-        let value = value.trim();
-        if key.is_empty() {
-            Err(ConfigError::Invalid(
-                "invalid OTEL_EXPORTER_OTLP_HEADERS entry: empty header name".into(),
-            ))?;
-        }
-        headers.insert(key.to_string(), value.to_string());
-    }
-
-    Ok(headers)
-}
-
-fn parse_mcp_server_config(raw: TomlMcpServerConfig) -> Result<McpServerConfig> {
-    if raw.name.trim().is_empty() {
-        return Err(ConfigError::Invalid("mcp server name cannot be empty".into()).into());
-    }
-
-    let transport = match raw.transport.as_str() {
-        "stdio" => {
-            let command = raw.command.ok_or_else(|| {
-                ConfigError::Invalid(format!(
-                    "mcp server '{}' with stdio transport requires 'command'",
-                    raw.name
-                ))
-            })?;
-            McpTransport::Stdio {
-                command,
-                args: raw.args,
-                env: raw.env,
-            }
-        }
-        "http" => {
-            let url = raw.url.ok_or_else(|| {
-                ConfigError::Invalid(format!(
-                    "mcp server '{}' with http transport requires 'url'",
-                    raw.name
-                ))
-            })?;
-            McpTransport::Http {
-                url,
-                headers: raw.headers,
-            }
-        }
-        other => {
-            return Err(ConfigError::Invalid(format!(
-                "mcp server '{}' has invalid transport '{}', expected 'stdio' or 'http'",
-                raw.name, other
-            ))
-            .into());
-        }
-    };
-
-    Ok(McpServerConfig {
-        name: raw.name,
-        transport,
-        enabled: raw.enabled,
-    })
-}
-
-/// Resolve a TomlRoutingConfig against a base RoutingConfig.
-fn resolve_routing(toml: Option<TomlRoutingConfig>, base: &RoutingConfig) -> RoutingConfig {
-    let Some(t) = toml else { return base.clone() };
-
-    let mut task_overrides = base.task_overrides.clone();
-    task_overrides.extend(t.task_overrides);
-
-    let fallbacks = match t.fallbacks {
-        Some(f) => f,
-        None => base.fallbacks.clone(),
-    };
-
-    RoutingConfig {
-        channel: t.channel.unwrap_or_else(|| base.channel.clone()),
-        branch: t.branch.unwrap_or_else(|| base.branch.clone()),
-        worker: t.worker.unwrap_or_else(|| base.worker.clone()),
-        compactor: t.compactor.unwrap_or_else(|| base.compactor.clone()),
-        cortex: t.cortex.unwrap_or_else(|| base.cortex.clone()),
-        voice: t.voice.unwrap_or_else(|| base.voice.clone()),
-        task_overrides,
-        fallbacks,
-        rate_limit_cooldown_secs: t
-            .rate_limit_cooldown_secs
-            .unwrap_or(base.rate_limit_cooldown_secs),
-        channel_thinking_effort: t
-            .channel_thinking_effort
-            .unwrap_or_else(|| base.channel_thinking_effort.clone()),
-        branch_thinking_effort: t
-            .branch_thinking_effort
-            .unwrap_or_else(|| base.branch_thinking_effort.clone()),
-        worker_thinking_effort: t
-            .worker_thinking_effort
-            .unwrap_or_else(|| base.worker_thinking_effort.clone()),
-        compactor_thinking_effort: t
-            .compactor_thinking_effort
-            .unwrap_or_else(|| base.compactor_thinking_effort.clone()),
-        cortex_thinking_effort: t
-            .cortex_thinking_effort
-            .unwrap_or_else(|| base.cortex_thinking_effort.clone()),
-    }
-}
-
-fn resolve_mcp_configs(
-    default_configs: &[McpServerConfig],
-    agent_configs: Option<&[McpServerConfig]>,
-) -> Vec<McpServerConfig> {
-    let mut merged = default_configs.to_vec();
-
-    if let Some(agent_configs) = agent_configs {
-        for agent_config in agent_configs {
-            if let Some(existing_index) = merged
-                .iter()
-                .position(|existing| existing.name == agent_config.name)
-            {
-                merged[existing_index] = agent_config.clone();
-            } else {
-                merged.push(agent_config.clone());
-            }
-        }
-    }
-
-    merged
-}
-
-impl Config {
-    /// Resolve the instance directory from env or default (~/.spacebot).
-    pub fn default_instance_dir() -> PathBuf {
-        std::env::var("SPACEBOT_DIR")
-            .map(PathBuf::from)
-            .unwrap_or_else(|_| {
-                dirs::home_dir()
-                    .map(|d| d.join(".spacebot"))
-                    .unwrap_or_else(|| PathBuf::from("./.spacebot"))
-            })
-    }
-
-    /// Check whether a first-run onboarding is needed (no config file and no env keys/providers).
-    pub fn needs_onboarding() -> bool {
-        let instance_dir = Self::default_instance_dir();
-        let config_path = instance_dir.join("config.toml");
-        if config_path.exists() {
-            return false;
-        }
-
-        // OAuth credentials count as configured
-        if crate::auth::credentials_path(&instance_dir).exists()
-            || crate::openai_auth::credentials_path(&instance_dir).exists()
-        {
-            return false;
-        }
-
-        // Check if we have any legacy env keys configured
-        let has_legacy_keys = std::env::var("ANTHROPIC_API_KEY").is_ok()
-            || std::env::var("OPENAI_API_KEY").is_ok()
-            || std::env::var("OPENROUTER_API_KEY").is_ok()
-            || std::env::var("ZHIPU_API_KEY").is_ok()
-            || std::env::var("GROQ_API_KEY").is_ok()
-            || std::env::var("TOGETHER_API_KEY").is_ok()
-            || std::env::var("FIREWORKS_API_KEY").is_ok()
-            || std::env::var("DEEPSEEK_API_KEY").is_ok()
-            || std::env::var("XAI_API_KEY").is_ok()
-            || std::env::var("MISTRAL_API_KEY").is_ok()
-            || std::env::var("NVIDIA_API_KEY").is_ok()
-            || std::env::var("OLLAMA_API_KEY").is_ok()
-            || std::env::var("OLLAMA_BASE_URL").is_ok()
-            || std::env::var("OPENCODE_ZEN_API_KEY").is_ok()
-            || std::env::var("MINIMAX_API_KEY").is_ok()
-            || std::env::var("MOONSHOT_API_KEY").is_ok()
-            || std::env::var("ZAI_CODING_PLAN_API_KEY").is_ok();
-
-        // If we have any legacy keys, no onboarding needed
-        if has_legacy_keys {
-            return false;
-        }
-
-        // Check if we have any provider-specific env variables (provider.<name>.*)
-        let has_provider_env_vars = std::env::vars().any(|(key, _)| {
-            key.starts_with("SPACEBOT_PROVIDER_")
-                || key.starts_with("PROVIDER_")
-                || key.contains("PROVIDER") && key.contains("API_KEY")
-        });
-
-        // Also check for specific legacy env vars that can bootstrap
-        let has_legacy_bootstrap_vars = std::env::var("ANTHROPIC_API_KEY").is_ok()
-            || std::env::var("ANTHROPIC_OAUTH_TOKEN").is_ok()
-            || std::env::var("OPENAI_API_KEY").is_ok()
-            || std::env::var("OPENROUTER_API_KEY").is_ok()
-            || std::env::var("OPENCODE_ZEN_API_KEY").is_ok();
-
-        !has_provider_env_vars && !has_legacy_bootstrap_vars
-    }
-
-    /// Load configuration from the default config file, falling back to env vars.
-    pub fn load() -> Result<Self> {
-        let instance_dir = Self::default_instance_dir();
-
-        let config_path = instance_dir.join("config.toml");
-        if config_path.exists() {
-            Self::load_from_path(&config_path)
-        } else {
-            Self::load_from_env(&instance_dir)
-        }
-    }
-
-    /// Load from a specific TOML config file.
-    pub fn load_from_path(path: &Path) -> Result<Self> {
-        let instance_dir = path
-            .parent()
-            .map(|p| p.to_path_buf())
-            .unwrap_or_else(|| PathBuf::from("."));
-
-        let content = std::fs::read_to_string(path)
-            .with_context(|| format!("failed to read config from {}", path.display()))?;
-
-        let toml_config: TomlConfig = toml::from_str(&content)
-            .with_context(|| format!("failed to parse config from {}", path.display()))?;
-
-        Self::from_toml(toml_config, instance_dir)
-    }
-
-    /// Load from environment variables only (no config file).
-    pub fn load_from_env(instance_dir: &Path) -> Result<Self> {
-        let mut llm = LlmConfig {
-            anthropic_key: std::env::var("ANTHROPIC_API_KEY")
-                .ok()
-                .or_else(|| std::env::var("ANTHROPIC_AUTH_TOKEN").ok()),
-            openai_key: std::env::var("OPENAI_API_KEY").ok(),
-            openrouter_key: std::env::var("OPENROUTER_API_KEY").ok(),
-            zhipu_key: std::env::var("ZHIPU_API_KEY").ok(),
-            groq_key: std::env::var("GROQ_API_KEY").ok(),
-            together_key: std::env::var("TOGETHER_API_KEY").ok(),
-            fireworks_key: std::env::var("FIREWORKS_API_KEY").ok(),
-            deepseek_key: std::env::var("DEEPSEEK_API_KEY").ok(),
-            xai_key: std::env::var("XAI_API_KEY").ok(),
-            mistral_key: std::env::var("MISTRAL_API_KEY").ok(),
-            gemini_key: std::env::var("GEMINI_API_KEY").ok(),
-            ollama_key: std::env::var("OLLAMA_API_KEY").ok(),
-            ollama_base_url: std::env::var("OLLAMA_BASE_URL").ok(),
-            opencode_zen_key: std::env::var("OPENCODE_ZEN_API_KEY").ok(),
-            nvidia_key: std::env::var("NVIDIA_API_KEY").ok(),
-            minimax_key: std::env::var("MINIMAX_API_KEY").ok(),
-            minimax_cn_key: std::env::var("MINIMAX_CN_API_KEY").ok(),
-            moonshot_key: std::env::var("MOONSHOT_API_KEY").ok(),
-            zai_coding_plan_key: std::env::var("ZAI_CODING_PLAN_API_KEY").ok(),
-            providers: HashMap::new(),
-        };
-
-        // Populate providers from env vars (same as from_toml does)
-        if let Some(anthropic_key) = llm.anthropic_key.clone() {
-            let base_url = std::env::var("ANTHROPIC_BASE_URL")
-                .unwrap_or_else(|_| ANTHROPIC_PROVIDER_BASE_URL.to_string());
-            llm.providers
-                .entry("anthropic".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::Anthropic,
-                    base_url,
-                    api_key: anthropic_key,
-                    name: None,
-                });
-        }
-
-        if let Some(openai_key) = llm.openai_key.clone() {
-            llm.providers
-                .entry("openai".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: OPENAI_PROVIDER_BASE_URL.to_string(),
-                    api_key: openai_key,
-                    name: None,
-                });
-        }
-
-        if let Some(openrouter_key) = llm.openrouter_key.clone() {
-            llm.providers
-                .entry("openrouter".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: OPENROUTER_PROVIDER_BASE_URL.to_string(),
-                    api_key: openrouter_key,
-                    name: None,
-                });
-        }
-
-        if let Some(zhipu_key) = llm.zhipu_key.clone() {
-            llm.providers
-                .entry("zhipu".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: ZHIPU_PROVIDER_BASE_URL.to_string(),
-                    api_key: zhipu_key,
-                    name: None,
-                });
-        }
-
-        if let Some(zai_coding_plan_key) = llm.zai_coding_plan_key.clone() {
-            llm.providers
-                .entry("zai-coding-plan".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: ZAI_CODING_PLAN_BASE_URL.to_string(),
-                    api_key: zai_coding_plan_key,
-                    name: None,
-                });
-        }
-
-        if let Some(opencode_zen_key) = llm.opencode_zen_key.clone() {
-            llm.providers
-                .entry("opencode-zen".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: OPENCODE_ZEN_PROVIDER_BASE_URL.to_string(),
-                    api_key: opencode_zen_key,
-                    name: None,
-                });
-        }
-
-        if let Some(minimax_key) = llm.minimax_key.clone() {
-            llm.providers
-                .entry("minimax".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::Anthropic,
-                    base_url: MINIMAX_PROVIDER_BASE_URL.to_string(),
-                    api_key: minimax_key,
-                    name: None,
-                });
-        }
-
-        if let Some(minimax_cn_key) = llm.minimax_cn_key.clone() {
-            llm.providers
-                .entry("minimax-cn".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::Anthropic,
-                    base_url: MINIMAX_CN_PROVIDER_BASE_URL.to_string(),
-                    api_key: minimax_cn_key,
-                    name: None,
-                });
-        }
-
-        if let Some(moonshot_key) = llm.moonshot_key.clone() {
-            llm.providers
-                .entry("moonshot".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: MOONSHOT_PROVIDER_BASE_URL.to_string(),
-                    api_key: moonshot_key,
-                    name: None,
-                });
-        }
-
-        if let Some(nvidia_key) = llm.nvidia_key.clone() {
-            llm.providers
-                .entry("nvidia".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: NVIDIA_PROVIDER_BASE_URL.to_string(),
-                    api_key: nvidia_key,
-                    name: None,
-                });
-        }
-
-        if let Some(fireworks_key) = llm.fireworks_key.clone() {
-            llm.providers
-                .entry("fireworks".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: FIREWORKS_PROVIDER_BASE_URL.to_string(),
-                    api_key: fireworks_key,
-                    name: None,
-                });
-        }
-
-        if let Some(deepseek_key) = llm.deepseek_key.clone() {
-            llm.providers
-                .entry("deepseek".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: DEEPSEEK_PROVIDER_BASE_URL.to_string(),
-                    api_key: deepseek_key,
-                    name: None,
-                });
-        }
-
-        if let Some(gemini_key) = llm.gemini_key.clone() {
-            llm.providers
-                .entry("gemini".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::Gemini,
-                    base_url: GEMINI_PROVIDER_BASE_URL.to_string(),
-                    api_key: gemini_key,
-                    name: None,
-                });
-        }
-
-        if let Some(groq_key) = llm.groq_key.clone() {
-            llm.providers
-                .entry("groq".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: GROQ_PROVIDER_BASE_URL.to_string(),
-                    api_key: groq_key,
-                    name: None,
-                });
-        }
-
-        if let Some(together_key) = llm.together_key.clone() {
-            llm.providers
-                .entry("together".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: TOGETHER_PROVIDER_BASE_URL.to_string(),
-                    api_key: together_key,
-                    name: None,
-                });
-        }
-
-        if let Some(xai_key) = llm.xai_key.clone() {
-            llm.providers
-                .entry("xai".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: XAI_PROVIDER_BASE_URL.to_string(),
-                    api_key: xai_key,
-                    name: None,
-                });
-        }
-
-        if let Some(mistral_key) = llm.mistral_key.clone() {
-            llm.providers
-                .entry("mistral".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: MISTRAL_PROVIDER_BASE_URL.to_string(),
-                    api_key: mistral_key,
-                    name: None,
-                });
-        }
-
-        if llm.ollama_base_url.is_some() || llm.ollama_key.is_some() {
-            llm.providers
-                .entry("ollama".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: llm
-                        .ollama_base_url
-                        .clone()
-                        .unwrap_or_else(|| "http://localhost:11434".to_string()),
-                    api_key: llm.ollama_key.clone().unwrap_or_default(),
-                    name: None,
-                });
-        }
-
-        // Note: We allow boot without provider keys now. System starts in setup mode.
-        // Agents are initialized later when keys are added via API.
-
-        // Env-only routing: check for env overrides on channel/worker models.
-        // SPACEBOT_MODEL overrides all process types at once; specific vars take precedence.
-        let mut routing = RoutingConfig::default();
-        if let Ok(model) = std::env::var("SPACEBOT_MODEL") {
-            routing.channel = model.clone();
-            routing.branch = model.clone();
-            routing.worker = model.clone();
-            routing.compactor = model.clone();
-            routing.cortex = model;
-        }
-        if let Ok(channel_model) = std::env::var("SPACEBOT_CHANNEL_MODEL") {
-            routing.channel = channel_model;
-        }
-        if let Ok(worker_model) = std::env::var("SPACEBOT_WORKER_MODEL") {
-            routing.worker = worker_model;
-        }
-        if let Ok(voice_model) = std::env::var("SPACEBOT_VOICE_MODEL") {
-            routing.voice = voice_model;
-        }
-
-        let agents = vec![AgentConfig {
-            id: "main".into(),
-            default: true,
-            display_name: None,
-            role: None,
-            workspace: None,
-            routing: Some(routing),
-            max_concurrent_branches: None,
-            max_concurrent_workers: None,
-            max_turns: None,
-            branch_max_turns: None,
-            context_window: None,
-            compaction: None,
-            memory_persistence: None,
-            coalesce: None,
-            ingestion: None,
-            cortex: None,
-            warmup: None,
-            browser: None,
-            mcp: None,
-            brave_search_key: None,
-            cron_timezone: None,
-            sandbox: None,
-            cron: Vec::new(),
-        }];
-
-        let mut api = ApiConfig::default();
-        api.bind = hosted_api_bind(api.bind);
-
-        Ok(Self {
-            instance_dir: instance_dir.to_path_buf(),
-            llm,
-            defaults: DefaultsConfig::default(),
-            agents,
-            links: Vec::new(),
-            groups: Vec::new(),
-            humans: vec![HumanDef {
-                id: "admin".into(),
-                display_name: None,
-                role: None,
-                bio: None,
-            }],
-            messaging: MessagingConfig::default(),
-            bindings: Vec::new(),
-            api,
-            metrics: MetricsConfig::default(),
-            telemetry: TelemetryConfig {
-                otlp_endpoint: std::env::var("OTEL_EXPORTER_OTLP_ENDPOINT").ok(),
-                otlp_headers: parse_otlp_headers(std::env::var("OTEL_EXPORTER_OTLP_HEADERS").ok())?,
-                service_name: std::env::var("OTEL_SERVICE_NAME")
-                    .unwrap_or_else(|_| "spacebot".into()),
-                sample_rate: 1.0,
-            },
-        })
-    }
-
-    /// Validate a raw TOML string as a valid Spacebot config.
-    /// Returns Ok(()) if the config is structurally valid, or an error describing what's wrong.
-    pub fn validate_toml(content: &str) -> Result<()> {
-        let toml_config: TomlConfig =
-            toml::from_str(content).context("failed to parse config TOML")?;
-        // Run full conversion to catch semantic errors (env resolution, defaults, etc.)
-        let instance_dir = Self::default_instance_dir();
-        Self::from_toml(toml_config, instance_dir)?;
-        Ok(())
-    }
-
-    fn from_toml(toml: TomlConfig, instance_dir: PathBuf) -> Result<Self> {
-        // Validate providers before processing
-        for (provider_id, config) in &toml.llm.providers {
-            // Validate provider_id
-            if provider_id.is_empty() || provider_id.len() > 64 {
-                return Err(ConfigError::Invalid(format!(
-                    "Provider ID '{}' must be between 1 and 64 characters long",
-                    provider_id
-                ))
-                .into());
-            }
-            if provider_id.contains('/') || provider_id.contains(char::is_whitespace) {
-                return Err(ConfigError::Invalid(format!(
-                    "Provider ID '{}' contains invalid characters (cannot contain '/' or whitespace)",
-                    provider_id
-                ))
-                .into());
-            }
-
-            // Validate base_url
-            if let Err(e) = reqwest::Url::parse(&config.base_url) {
-                return Err(ConfigError::Invalid(format!(
-                    "Invalid base URL '{}' for provider '{}': {}",
-                    config.base_url, provider_id, e
-                ))
-                .into());
-            }
-        }
-
-        let mut llm = LlmConfig {
-            anthropic_key: toml
-                .llm
-                .anthropic_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("ANTHROPIC_API_KEY").ok())
-                .or_else(|| std::env::var("ANTHROPIC_AUTH_TOKEN").ok()),
-            openai_key: toml
-                .llm
-                .openai_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("OPENAI_API_KEY").ok()),
-            openrouter_key: toml
-                .llm
-                .openrouter_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("OPENROUTER_API_KEY").ok()),
-            zhipu_key: toml
-                .llm
-                .zhipu_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("ZHIPU_API_KEY").ok()),
-            groq_key: toml
-                .llm
-                .groq_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("GROQ_API_KEY").ok()),
-            together_key: toml
-                .llm
-                .together_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("TOGETHER_API_KEY").ok()),
-            fireworks_key: toml
-                .llm
-                .fireworks_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("FIREWORKS_API_KEY").ok()),
-            deepseek_key: toml
-                .llm
-                .deepseek_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("DEEPSEEK_API_KEY").ok()),
-            xai_key: toml
-                .llm
-                .xai_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("XAI_API_KEY").ok()),
-            mistral_key: toml
-                .llm
-                .mistral_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("MISTRAL_API_KEY").ok()),
-            gemini_key: toml
-                .llm
-                .gemini_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("GEMINI_API_KEY").ok()),
-            ollama_key: toml
-                .llm
-                .ollama_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("OLLAMA_API_KEY").ok()),
-            ollama_base_url: toml
-                .llm
-                .ollama_base_url
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("OLLAMA_BASE_URL").ok()),
-            opencode_zen_key: toml
-                .llm
-                .opencode_zen_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("OPENCODE_ZEN_API_KEY").ok()),
-            nvidia_key: toml
-                .llm
-                .nvidia_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("NVIDIA_API_KEY").ok()),
-            minimax_key: toml
-                .llm
-                .minimax_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("MINIMAX_API_KEY").ok()),
-            minimax_cn_key: toml
-                .llm
-                .minimax_cn_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("MINIMAX_CN_API_KEY").ok()),
-            moonshot_key: toml
-                .llm
-                .moonshot_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("MOONSHOT_API_KEY").ok()),
-            zai_coding_plan_key: toml
-                .llm
-                .zai_coding_plan_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("ZAI_CODING_PLAN_API_KEY").ok()),
-            providers: toml
-                .llm
-                .providers
-                .into_iter()
-                .map(|(provider_id, config)| {
-                    let api_key = resolve_env_value(&config.api_key).ok_or_else(|| {
-                        anyhow::anyhow!("failed to resolve API key for provider '{}'", provider_id)
-                    })?;
-                    Ok((
-                        provider_id.to_lowercase(),
-                        ProviderConfig {
-                            api_type: config.api_type,
-                            base_url: config.base_url,
-                            api_key,
-                            name: config.name,
-                        },
-                    ))
-                })
-                .collect::<anyhow::Result<_>>()?,
-        };
-
-        if let Some(anthropic_key) = llm.anthropic_key.clone() {
-            let base_url = std::env::var("ANTHROPIC_BASE_URL")
-                .unwrap_or_else(|_| ANTHROPIC_PROVIDER_BASE_URL.to_string());
-            llm.providers
-                .entry("anthropic".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::Anthropic,
-                    base_url,
-                    api_key: anthropic_key,
-                    name: None,
-                });
-        }
-
-        if let Some(openai_key) = llm.openai_key.clone() {
-            llm.providers
-                .entry("openai".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: OPENAI_PROVIDER_BASE_URL.to_string(),
-                    api_key: openai_key,
-                    name: None,
-                });
-        }
-
-        if let Some(openrouter_key) = llm.openrouter_key.clone() {
-            llm.providers
-                .entry("openrouter".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: OPENROUTER_PROVIDER_BASE_URL.to_string(),
-                    api_key: openrouter_key,
-                    name: None,
-                });
-        }
-
-        if let Some(zhipu_key) = llm.zhipu_key.clone() {
-            llm.providers
-                .entry("zhipu".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: ZHIPU_PROVIDER_BASE_URL.to_string(),
-                    api_key: zhipu_key,
-                    name: None,
-                });
-        }
-
-        if let Some(zai_coding_plan_key) = llm.zai_coding_plan_key.clone() {
-            llm.providers
-                .entry("zai-coding-plan".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: ZAI_CODING_PLAN_BASE_URL.to_string(),
-                    api_key: zai_coding_plan_key,
-                    name: None,
-                });
-        }
-
-        if let Some(opencode_zen_key) = llm.opencode_zen_key.clone() {
-            llm.providers
-                .entry("opencode-zen".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: OPENCODE_ZEN_PROVIDER_BASE_URL.to_string(),
-                    api_key: opencode_zen_key,
-                    name: None,
-                });
-        }
-
-        if let Some(minimax_key) = llm.minimax_key.clone() {
-            llm.providers
-                .entry("minimax".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::Anthropic,
-                    base_url: MINIMAX_PROVIDER_BASE_URL.to_string(),
-                    api_key: minimax_key,
-                    name: None,
-                });
-        }
-
-        if let Some(minimax_cn_key) = llm.minimax_cn_key.clone() {
-            llm.providers
-                .entry("minimax-cn".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::Anthropic,
-                    base_url: MINIMAX_CN_PROVIDER_BASE_URL.to_string(),
-                    api_key: minimax_cn_key,
-                    name: None,
-                });
-        }
-
-        if let Some(moonshot_key) = llm.moonshot_key.clone() {
-            llm.providers
-                .entry("moonshot".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: MOONSHOT_PROVIDER_BASE_URL.to_string(),
-                    api_key: moonshot_key,
-                    name: None,
-                });
-        }
-
-        if let Some(nvidia_key) = llm.nvidia_key.clone() {
-            llm.providers
-                .entry("nvidia".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: NVIDIA_PROVIDER_BASE_URL.to_string(),
-                    api_key: nvidia_key,
-                    name: None,
-                });
-        }
-
-        if let Some(fireworks_key) = llm.fireworks_key.clone() {
-            llm.providers
-                .entry("fireworks".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: FIREWORKS_PROVIDER_BASE_URL.to_string(),
-                    api_key: fireworks_key,
-                    name: None,
-                });
-        }
-
-        if let Some(deepseek_key) = llm.deepseek_key.clone() {
-            llm.providers
-                .entry("deepseek".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: DEEPSEEK_PROVIDER_BASE_URL.to_string(),
-                    api_key: deepseek_key,
-                    name: None,
-                });
-        }
-
-        if let Some(gemini_key) = llm.gemini_key.clone() {
-            llm.providers
-                .entry("gemini".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::Gemini,
-                    base_url: GEMINI_PROVIDER_BASE_URL.to_string(),
-                    api_key: gemini_key,
-                    name: None,
-                });
-        }
-
-        if let Some(groq_key) = llm.groq_key.clone() {
-            llm.providers
-                .entry("groq".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: GROQ_PROVIDER_BASE_URL.to_string(),
-                    api_key: groq_key,
-                    name: None,
-                });
-        }
-
-        if let Some(together_key) = llm.together_key.clone() {
-            llm.providers
-                .entry("together".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: TOGETHER_PROVIDER_BASE_URL.to_string(),
-                    api_key: together_key,
-                    name: None,
-                });
-        }
-
-        if let Some(xai_key) = llm.xai_key.clone() {
-            llm.providers
-                .entry("xai".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: XAI_PROVIDER_BASE_URL.to_string(),
-                    api_key: xai_key,
-                    name: None,
-                });
-        }
-
-        if let Some(mistral_key) = llm.mistral_key.clone() {
-            llm.providers
-                .entry("mistral".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: MISTRAL_PROVIDER_BASE_URL.to_string(),
-                    api_key: mistral_key,
-                    name: None,
-                });
-        }
-
-        if llm.ollama_base_url.is_some() || llm.ollama_key.is_some() {
-            llm.providers
-                .entry("ollama".to_string())
-                .or_insert_with(|| ProviderConfig {
-                    api_type: ApiType::OpenAiCompletions,
-                    base_url: llm
-                        .ollama_base_url
-                        .clone()
-                        .unwrap_or_else(|| "http://localhost:11434".to_string()),
-                    api_key: llm.ollama_key.clone().unwrap_or_default(),
-                    name: None,
-                });
-        }
-
-        // Note: We allow boot without provider keys now. System starts in setup mode.
-        // Agents are initialized later when keys are added via API.
-
-        let default_mcp = toml
-            .defaults
-            .mcp
-            .into_iter()
-            .map(parse_mcp_server_config)
-            .collect::<Result<Vec<_>>>()?;
-
-        let base_defaults = DefaultsConfig::default();
-        let defaults = DefaultsConfig {
-            routing: resolve_routing(toml.defaults.routing, &base_defaults.routing),
-            max_concurrent_branches: toml
-                .defaults
-                .max_concurrent_branches
-                .unwrap_or(base_defaults.max_concurrent_branches),
-            max_concurrent_workers: toml
-                .defaults
-                .max_concurrent_workers
-                .unwrap_or(base_defaults.max_concurrent_workers),
-            max_turns: toml.defaults.max_turns.unwrap_or(base_defaults.max_turns),
-            branch_max_turns: toml
-                .defaults
-                .branch_max_turns
-                .unwrap_or(base_defaults.branch_max_turns),
-            context_window: toml
-                .defaults
-                .context_window
-                .unwrap_or(base_defaults.context_window),
-            compaction: toml
-                .defaults
-                .compaction
-                .map(|c| CompactionConfig {
-                    background_threshold: c
-                        .background_threshold
-                        .unwrap_or(base_defaults.compaction.background_threshold),
-                    aggressive_threshold: c
-                        .aggressive_threshold
-                        .unwrap_or(base_defaults.compaction.aggressive_threshold),
-                    emergency_threshold: c
-                        .emergency_threshold
-                        .unwrap_or(base_defaults.compaction.emergency_threshold),
-                })
-                .unwrap_or(base_defaults.compaction),
-            memory_persistence: toml
-                .defaults
-                .memory_persistence
-                .map(|mp| MemoryPersistenceConfig {
-                    enabled: mp
-                        .enabled
-                        .unwrap_or(base_defaults.memory_persistence.enabled),
-                    message_interval: mp
-                        .message_interval
-                        .unwrap_or(base_defaults.memory_persistence.message_interval),
-                })
-                .unwrap_or(base_defaults.memory_persistence),
-            coalesce: toml
-                .defaults
-                .coalesce
-                .map(|c| CoalesceConfig {
-                    enabled: c.enabled.unwrap_or(base_defaults.coalesce.enabled),
-                    debounce_ms: c.debounce_ms.unwrap_or(base_defaults.coalesce.debounce_ms),
-                    max_wait_ms: c.max_wait_ms.unwrap_or(base_defaults.coalesce.max_wait_ms),
-                    min_messages: c
-                        .min_messages
-                        .unwrap_or(base_defaults.coalesce.min_messages),
-                    multi_user_only: c
-                        .multi_user_only
-                        .unwrap_or(base_defaults.coalesce.multi_user_only),
-                })
-                .unwrap_or(base_defaults.coalesce),
-            ingestion: toml
-                .defaults
-                .ingestion
-                .map(|ig| IngestionConfig {
-                    enabled: ig.enabled.unwrap_or(base_defaults.ingestion.enabled),
-                    poll_interval_secs: ig
-                        .poll_interval_secs
-                        .unwrap_or(base_defaults.ingestion.poll_interval_secs),
-                    chunk_size: ig.chunk_size.unwrap_or(base_defaults.ingestion.chunk_size),
-                })
-                .unwrap_or(base_defaults.ingestion),
-            cortex: toml
-                .defaults
-                .cortex
-                .map(|c| CortexConfig {
-                    tick_interval_secs: c
-                        .tick_interval_secs
-                        .unwrap_or(base_defaults.cortex.tick_interval_secs),
-                    worker_timeout_secs: c
-                        .worker_timeout_secs
-                        .unwrap_or(base_defaults.cortex.worker_timeout_secs),
-                    branch_timeout_secs: c
-                        .branch_timeout_secs
-                        .unwrap_or(base_defaults.cortex.branch_timeout_secs),
-                    circuit_breaker_threshold: c
-                        .circuit_breaker_threshold
-                        .unwrap_or(base_defaults.cortex.circuit_breaker_threshold),
-                    bulletin_interval_secs: c
-                        .bulletin_interval_secs
-                        .unwrap_or(base_defaults.cortex.bulletin_interval_secs),
-                    bulletin_max_words: c
-                        .bulletin_max_words
-                        .unwrap_or(base_defaults.cortex.bulletin_max_words),
-                    bulletin_max_turns: c
-                        .bulletin_max_turns
-                        .unwrap_or(base_defaults.cortex.bulletin_max_turns),
-                    association_interval_secs: c
-                        .association_interval_secs
-                        .unwrap_or(base_defaults.cortex.association_interval_secs),
-                    association_similarity_threshold: c
-                        .association_similarity_threshold
-                        .unwrap_or(base_defaults.cortex.association_similarity_threshold),
-                    association_updates_threshold: c
-                        .association_updates_threshold
-                        .unwrap_or(base_defaults.cortex.association_updates_threshold),
-                    association_max_per_pass: c
-                        .association_max_per_pass
-                        .unwrap_or(base_defaults.cortex.association_max_per_pass),
-                })
-                .unwrap_or(base_defaults.cortex),
-            warmup: toml
-                .defaults
-                .warmup
-                .map(|w| WarmupConfig {
-                    enabled: w.enabled.unwrap_or(base_defaults.warmup.enabled),
-                    eager_embedding_load: w
-                        .eager_embedding_load
-                        .unwrap_or(base_defaults.warmup.eager_embedding_load),
-                    refresh_secs: w.refresh_secs.unwrap_or(base_defaults.warmup.refresh_secs),
-                    startup_delay_secs: w
-                        .startup_delay_secs
-                        .unwrap_or(base_defaults.warmup.startup_delay_secs),
-                })
-                .unwrap_or(base_defaults.warmup),
-            browser: toml
-                .defaults
-                .browser
-                .map(|b| {
-                    let base = &base_defaults.browser;
-                    BrowserConfig {
-                        enabled: b.enabled.unwrap_or(base.enabled),
-                        headless: b.headless.unwrap_or(base.headless),
-                        evaluate_enabled: b.evaluate_enabled.unwrap_or(base.evaluate_enabled),
-                        executable_path: b.executable_path.or_else(|| base.executable_path.clone()),
-                        screenshot_dir: b
-                            .screenshot_dir
-                            .map(PathBuf::from)
-                            .or_else(|| base.screenshot_dir.clone()),
-                    }
-                })
-                .unwrap_or_else(|| base_defaults.browser.clone()),
-            mcp: default_mcp,
-            brave_search_key: toml
-                .defaults
-                .brave_search_key
-                .as_deref()
-                .and_then(resolve_env_value)
-                .or_else(|| std::env::var("BRAVE_SEARCH_API_KEY").ok()),
-            cron_timezone: toml
-                .defaults
-                .cron_timezone
-                .as_deref()
-                .and_then(resolve_env_value),
-            history_backfill_count: base_defaults.history_backfill_count,
-            cron: Vec::new(),
-            opencode: toml
-                .defaults
-                .opencode
-                .map(|oc| {
-                    let base = &base_defaults.opencode;
-                    let path_raw = oc.path.unwrap_or_else(|| base.path.clone());
-                    let resolved_path =
-                        resolve_env_value(&path_raw).unwrap_or_else(|| base.path.clone());
-                    OpenCodeConfig {
-                        enabled: oc.enabled.unwrap_or(base.enabled),
-                        path: resolved_path,
-                        max_servers: oc.max_servers.unwrap_or(base.max_servers),
-                        server_startup_timeout_secs: oc
-                            .server_startup_timeout_secs
-                            .unwrap_or(base.server_startup_timeout_secs),
-                        max_restart_retries: oc
-                            .max_restart_retries
-                            .unwrap_or(base.max_restart_retries),
-                        permissions: oc
-                            .permissions
-                            .map(|p| crate::opencode::OpenCodePermissions {
-                                edit: p.edit.unwrap_or_else(|| base.permissions.edit.clone()),
-                                bash: p.bash.unwrap_or_else(|| base.permissions.bash.clone()),
-                                webfetch: p
-                                    .webfetch
-                                    .unwrap_or_else(|| base.permissions.webfetch.clone()),
-                            })
-                            .unwrap_or_else(|| base.permissions.clone()),
-                    }
-                })
-                .unwrap_or_else(|| base_defaults.opencode.clone()),
-            worker_log_mode: toml
-                .defaults
-                .worker_log_mode
-                .as_deref()
-                .and_then(|s| s.parse().ok())
-                .unwrap_or(base_defaults.worker_log_mode),
-        };
-
-        let mut agents: Vec<AgentConfig> = toml
-            .agents
-            .into_iter()
-            .map(|a| -> Result<AgentConfig> {
-                // Per-agent routing resolves against instance defaults
-                let agent_routing = a
-                    .routing
-                    .map(|r| resolve_routing(Some(r), &defaults.routing));
-
-                let cron = a
-                    .cron
-                    .into_iter()
-                    .map(|h| CronDef {
-                        id: h.id,
-                        prompt: h.prompt,
-                        interval_secs: h.interval_secs.unwrap_or(3600),
-                        delivery_target: h.delivery_target,
-                        active_hours: match (h.active_start_hour, h.active_end_hour) {
-                            (Some(s), Some(e)) => Some((s, e)),
-                            _ => None,
-                        },
-                        enabled: h.enabled,
-                        run_once: h.run_once,
-                        timeout_secs: h.timeout_secs,
-                    })
-                    .collect();
-
-                Ok(AgentConfig {
-                    id: a.id,
-                    default: a.default,
-                    display_name: a.display_name,
-                    role: a.role,
-                    workspace: a.workspace.map(PathBuf::from),
-                    routing: agent_routing,
-                    max_concurrent_branches: a.max_concurrent_branches,
-                    max_concurrent_workers: a.max_concurrent_workers,
-                    max_turns: a.max_turns,
-                    branch_max_turns: a.branch_max_turns,
-                    context_window: a.context_window,
-                    compaction: a.compaction.map(|c| CompactionConfig {
-                        background_threshold: c
-                            .background_threshold
-                            .unwrap_or(defaults.compaction.background_threshold),
-                        aggressive_threshold: c
-                            .aggressive_threshold
-                            .unwrap_or(defaults.compaction.aggressive_threshold),
-                        emergency_threshold: c
-                            .emergency_threshold
-                            .unwrap_or(defaults.compaction.emergency_threshold),
-                    }),
-                    memory_persistence: a.memory_persistence.map(|mp| MemoryPersistenceConfig {
-                        enabled: mp.enabled.unwrap_or(defaults.memory_persistence.enabled),
-                        message_interval: mp
-                            .message_interval
-                            .unwrap_or(defaults.memory_persistence.message_interval),
-                    }),
-                    coalesce: a.coalesce.map(|c| CoalesceConfig {
-                        enabled: c.enabled.unwrap_or(defaults.coalesce.enabled),
-                        debounce_ms: c.debounce_ms.unwrap_or(defaults.coalesce.debounce_ms),
-                        max_wait_ms: c.max_wait_ms.unwrap_or(defaults.coalesce.max_wait_ms),
-                        min_messages: c.min_messages.unwrap_or(defaults.coalesce.min_messages),
-                        multi_user_only: c
-                            .multi_user_only
-                            .unwrap_or(defaults.coalesce.multi_user_only),
-                    }),
-                    ingestion: a.ingestion.map(|ig| IngestionConfig {
-                        enabled: ig.enabled.unwrap_or(defaults.ingestion.enabled),
-                        poll_interval_secs: ig
-                            .poll_interval_secs
-                            .unwrap_or(defaults.ingestion.poll_interval_secs),
-                        chunk_size: ig.chunk_size.unwrap_or(defaults.ingestion.chunk_size),
-                    }),
-                    cortex: a.cortex.map(|c| CortexConfig {
-                        tick_interval_secs: c
-                            .tick_interval_secs
-                            .unwrap_or(defaults.cortex.tick_interval_secs),
-                        worker_timeout_secs: c
-                            .worker_timeout_secs
-                            .unwrap_or(defaults.cortex.worker_timeout_secs),
-                        branch_timeout_secs: c
-                            .branch_timeout_secs
-                            .unwrap_or(defaults.cortex.branch_timeout_secs),
-                        circuit_breaker_threshold: c
-                            .circuit_breaker_threshold
-                            .unwrap_or(defaults.cortex.circuit_breaker_threshold),
-                        bulletin_interval_secs: c
-                            .bulletin_interval_secs
-                            .unwrap_or(defaults.cortex.bulletin_interval_secs),
-                        bulletin_max_words: c
-                            .bulletin_max_words
-                            .unwrap_or(defaults.cortex.bulletin_max_words),
-                        bulletin_max_turns: c
-                            .bulletin_max_turns
-                            .unwrap_or(defaults.cortex.bulletin_max_turns),
-                        association_interval_secs: c
-                            .association_interval_secs
-                            .unwrap_or(defaults.cortex.association_interval_secs),
-                        association_similarity_threshold: c
-                            .association_similarity_threshold
-                            .unwrap_or(defaults.cortex.association_similarity_threshold),
-                        association_updates_threshold: c
-                            .association_updates_threshold
-                            .unwrap_or(defaults.cortex.association_updates_threshold),
-                        association_max_per_pass: c
-                            .association_max_per_pass
-                            .unwrap_or(defaults.cortex.association_max_per_pass),
-                    }),
-                    warmup: a.warmup.map(|w| WarmupConfig {
-                        enabled: w.enabled.unwrap_or(defaults.warmup.enabled),
-                        eager_embedding_load: w
-                            .eager_embedding_load
-                            .unwrap_or(defaults.warmup.eager_embedding_load),
-                        refresh_secs: w.refresh_secs.unwrap_or(defaults.warmup.refresh_secs),
-                        startup_delay_secs: w
-                            .startup_delay_secs
-                            .unwrap_or(defaults.warmup.startup_delay_secs),
-                    }),
-                    browser: a.browser.map(|b| BrowserConfig {
-                        enabled: b.enabled.unwrap_or(defaults.browser.enabled),
-                        headless: b.headless.unwrap_or(defaults.browser.headless),
-                        evaluate_enabled: b
-                            .evaluate_enabled
-                            .unwrap_or(defaults.browser.evaluate_enabled),
-                        executable_path: b
-                            .executable_path
-                            .or_else(|| defaults.browser.executable_path.clone()),
-                        screenshot_dir: b
-                            .screenshot_dir
-                            .map(PathBuf::from)
-                            .or_else(|| defaults.browser.screenshot_dir.clone()),
-                    }),
-                    mcp: match a.mcp {
-                        Some(mcp_servers) => Some(
-                            mcp_servers
-                                .into_iter()
-                                .map(parse_mcp_server_config)
-                                .collect::<Result<Vec<_>>>()?,
-                        ),
-                        None => None,
-                    },
-                    brave_search_key: a.brave_search_key.as_deref().and_then(resolve_env_value),
-                    cron_timezone: a.cron_timezone.as_deref().and_then(resolve_env_value),
-                    sandbox: a.sandbox,
-                    cron,
-                })
-            })
-            .collect::<Result<Vec<_>>>()?;
-
-        if agents.is_empty() {
-            agents.push(AgentConfig {
-                id: "main".into(),
-                default: true,
-                display_name: None,
-                role: None,
-                workspace: None,
-                routing: None,
-                max_concurrent_branches: None,
-                max_concurrent_workers: None,
-                max_turns: None,
-                branch_max_turns: None,
-                context_window: None,
-                compaction: None,
-                memory_persistence: None,
-                coalesce: None,
-                ingestion: None,
-                cortex: None,
-                warmup: None,
-                browser: None,
-                mcp: None,
-                brave_search_key: None,
-                cron_timezone: None,
-                sandbox: None,
-                cron: Vec::new(),
-            });
-        }
-
-        if !agents.iter().any(|a| a.default)
-            && let Some(first) = agents.first_mut()
-        {
-            first.default = true;
-        }
-
-        let messaging = MessagingConfig {
-            discord: toml.messaging.discord.and_then(|d| {
-                let token = d
-                    .token
-                    .as_deref()
-                    .and_then(resolve_env_value)
-                    .or_else(|| std::env::var("DISCORD_BOT_TOKEN").ok())?;
-                Some(DiscordConfig {
-                    enabled: d.enabled,
-                    token,
-                    dm_allowed_users: d.dm_allowed_users,
-                    allow_bot_messages: d.allow_bot_messages,
-                })
-            }),
-            slack: toml.messaging.slack.and_then(|s| {
-                let bot_token = s
-                    .bot_token
-                    .as_deref()
-                    .and_then(resolve_env_value)
-                    .or_else(|| std::env::var("SLACK_BOT_TOKEN").ok())?;
-                let app_token = s
-                    .app_token
-                    .as_deref()
-                    .and_then(resolve_env_value)
-                    .or_else(|| std::env::var("SLACK_APP_TOKEN").ok())?;
-                Some(SlackConfig {
-                    enabled: s.enabled,
-                    bot_token,
-                    app_token,
-                    dm_allowed_users: s.dm_allowed_users,
-                    commands: s
-                        .commands
-                        .into_iter()
-                        .map(|c| SlackCommandConfig {
-                            command: c.command,
-                            agent_id: c.agent_id,
-                            description: c.description,
-                        })
-                        .collect(),
-                })
-            }),
-            telegram: toml.messaging.telegram.and_then(|t| {
-                let token = t
-                    .token
-                    .as_deref()
-                    .and_then(resolve_env_value)
-                    .or_else(|| std::env::var("TELEGRAM_BOT_TOKEN").ok())?;
-                Some(TelegramConfig {
-                    enabled: t.enabled,
-                    token,
-                    dm_allowed_users: t.dm_allowed_users,
-                })
-            }),
-            webhook: toml.messaging.webhook.map(|w| WebhookConfig {
-                enabled: w.enabled,
-                port: w.port,
-                bind: w.bind,
-                auth_token: w.auth_token.as_deref().and_then(resolve_env_value),
-            }),
-            twitch: toml.messaging.twitch.and_then(|t| {
-                let username = t
-                    .username
-                    .as_deref()
-                    .and_then(resolve_env_value)
-                    .or_else(|| std::env::var("TWITCH_BOT_USERNAME").ok())?;
-                let oauth_token = t
-                    .oauth_token
-                    .as_deref()
-                    .and_then(resolve_env_value)
-                    .or_else(|| std::env::var("TWITCH_OAUTH_TOKEN").ok())?;
-                let client_id = t
-                    .client_id
-                    .as_deref()
-                    .and_then(resolve_env_value)
-                    .or_else(|| std::env::var("TWITCH_CLIENT_ID").ok());
-                let client_secret = t
-                    .client_secret
-                    .as_deref()
-                    .and_then(resolve_env_value)
-                    .or_else(|| std::env::var("TWITCH_CLIENT_SECRET").ok());
-                let refresh_token = t
-                    .refresh_token
-                    .as_deref()
-                    .and_then(resolve_env_value)
-                    .or_else(|| std::env::var("TWITCH_REFRESH_TOKEN").ok());
-                Some(TwitchConfig {
-                    enabled: t.enabled,
-                    username,
-                    oauth_token,
-                    client_id,
-                    client_secret,
-                    refresh_token,
-                    channels: t.channels,
-                    trigger_prefix: t.trigger_prefix,
-                })
-            }),
-        };
-
-        let bindings = toml
-            .bindings
-            .into_iter()
-            .map(|b| Binding {
-                agent_id: b.agent_id,
-                channel: b.channel,
-                guild_id: b.guild_id,
-                workspace_id: b.workspace_id,
-                chat_id: b.chat_id,
-                channel_ids: b.channel_ids,
-                require_mention: b.require_mention,
-                dm_allowed_users: b.dm_allowed_users,
-            })
-            .collect();
-
-        let api = ApiConfig {
-            enabled: toml.api.enabled,
-            port: toml.api.port,
-            bind: hosted_api_bind(toml.api.bind),
-            auth_token: toml.api.auth_token.as_deref().and_then(resolve_env_value),
-        };
-
-        let metrics = MetricsConfig {
-            enabled: toml.metrics.enabled,
-            port: toml.metrics.port,
-            bind: toml.metrics.bind,
-        };
-
-        let telemetry = {
-            // env var takes precedence over config file value
-            let otlp_endpoint = std::env::var("OTEL_EXPORTER_OTLP_ENDPOINT")
-                .ok()
-                .or(toml.telemetry.otlp_endpoint);
-            let otlp_headers = parse_otlp_headers(
-                std::env::var("OTEL_EXPORTER_OTLP_HEADERS")
-                    .ok()
-                    .or(toml.telemetry.otlp_headers),
-            )?;
-            let service_name = std::env::var("OTEL_SERVICE_NAME")
-                .ok()
-                .or(toml.telemetry.service_name)
-                .unwrap_or_else(|| "spacebot".into());
-            let sample_rate = toml.telemetry.sample_rate.unwrap_or(1.0);
-            TelemetryConfig {
-                otlp_endpoint,
-                otlp_headers,
-                service_name,
-                sample_rate,
-            }
-        };
-
-        let links = toml
-            .links
-            .into_iter()
-            .map(|l| {
-                // Backward compat: use `relationship` field if `kind` is default and `relationship` is set
-                let kind = if l.kind == "peer" {
-                    l.relationship.unwrap_or(l.kind)
-                } else {
-                    l.kind
-                };
-                LinkDef {
-                    from: l.from,
-                    to: l.to,
-                    direction: l.direction,
-                    kind,
-                }
-            })
-            .collect();
-
-        let groups = toml
-            .groups
-            .into_iter()
-            .map(|g| GroupDef {
-                name: g.name,
-                agent_ids: g.agent_ids,
-                color: g.color,
-            })
-            .collect();
-
-        let mut humans: Vec<HumanDef> = toml
-            .humans
-            .into_iter()
-            .map(|h| HumanDef {
-                id: h.id,
-                display_name: h.display_name,
-                role: h.role,
-                bio: h.bio,
-            })
-            .collect();
-
-        // Default admin human if none defined
-        if humans.is_empty() {
-            humans.push(HumanDef {
-                id: "admin".into(),
-                display_name: None,
-                role: None,
-                bio: None,
-            });
-        }
-
-        Ok(Config {
-            instance_dir,
-            llm,
-            defaults,
-            agents,
-            links,
-            groups,
-            humans,
-            messaging,
-            bindings,
-            api,
-            metrics,
-            telemetry,
-        })
-    }
-
-    /// Get the default agent ID.
-    pub fn default_agent_id(&self) -> &str {
-        self.agents
-            .iter()
-            .find(|a| a.default)
-            .map(|a| a.id.as_str())
-            .unwrap_or("main")
-    }
-
-    /// Resolve all agent configs against defaults.
-    pub fn resolve_agents(&self) -> Vec<ResolvedAgentConfig> {
-        self.agents
-            .iter()
-            .map(|a| a.resolve(&self.instance_dir, &self.defaults))
-            .collect()
-    }
-
-    /// Path to instance-level skills directory.
-    pub fn skills_dir(&self) -> PathBuf {
-        self.instance_dir.join("skills")
-    }
-}
-
-/// Live configuration that can be hot-reloaded without restarting.
-///
-/// All fields use ArcSwap for lock-free reads. Consumers call `.load()` on
-/// individual fields to get a snapshot — cheap and contention-free.
-/// The file watcher calls `.store()` to atomically swap in new values.
-pub struct RuntimeConfig {
-    /// Instance root directory (e.g., ~/.spacebot). Immutable after startup.
-    pub instance_dir: PathBuf,
-    /// Agent workspace directory (e.g., ~/.spacebot/agents/{id}/workspace). Immutable after startup.
-    pub workspace_dir: PathBuf,
-    pub routing: ArcSwap<RoutingConfig>,
-    pub compaction: ArcSwap<CompactionConfig>,
-    pub memory_persistence: ArcSwap<MemoryPersistenceConfig>,
-    pub coalesce: ArcSwap<CoalesceConfig>,
-    pub ingestion: ArcSwap<IngestionConfig>,
-    pub max_turns: ArcSwap<usize>,
-    pub branch_max_turns: ArcSwap<usize>,
-    pub context_window: ArcSwap<usize>,
-    pub max_concurrent_branches: ArcSwap<usize>,
-    pub max_concurrent_workers: ArcSwap<usize>,
-    pub browser_config: ArcSwap<BrowserConfig>,
-    pub mcp: ArcSwap<Vec<McpServerConfig>>,
-    pub history_backfill_count: ArcSwap<usize>,
-    pub brave_search_key: ArcSwap<Option<String>>,
-    pub cron_timezone: ArcSwap<Option<String>>,
-    pub cortex: ArcSwap<CortexConfig>,
-    pub warmup: ArcSwap<WarmupConfig>,
-    /// Current warmup lifecycle status for API and observability.
-    pub warmup_status: ArcSwap<WarmupStatus>,
-    /// Synchronizes warmup passes so periodic and API-triggered runs don't overlap.
-    pub warmup_lock: Arc<tokio::sync::Mutex<()>>,
-    /// Cached memory bulletin generated by the cortex. Injected into every
-    /// channel's system prompt. Empty string until the first cortex run.
-    pub memory_bulletin: ArcSwap<String>,
-    pub prompts: ArcSwap<crate::prompts::PromptEngine>,
-    pub identity: ArcSwap<crate::identity::Identity>,
-    pub skills: ArcSwap<crate::skills::SkillSet>,
-    pub opencode: ArcSwap<OpenCodeConfig>,
-    /// Shared pool of OpenCode server processes. Lazily initialized on first use.
-    pub opencode_server_pool: Arc<crate::opencode::OpenCodeServerPool>,
-    /// Cron store, set after agent initialization.
-    pub cron_store: ArcSwap<Option<Arc<crate::cron::CronStore>>>,
-    /// Cron scheduler, set after agent initialization.
-    pub cron_scheduler: ArcSwap<Option<Arc<crate::cron::Scheduler>>>,
-    /// Settings store for agent-specific configuration.
-    pub settings: ArcSwap<Option<Arc<crate::settings::SettingsStore>>>,
-    /// Sandbox configuration for process containment.
-    pub sandbox: ArcSwap<crate::sandbox::SandboxConfig>,
-}
-
-impl RuntimeConfig {
-    /// Build from a resolved agent config, loaded prompts, identity, and skills.
-    pub fn new(
-        instance_dir: &Path,
-        agent_config: &ResolvedAgentConfig,
-        defaults: &DefaultsConfig,
-        prompts: crate::prompts::PromptEngine,
-        identity: crate::identity::Identity,
-        skills: crate::skills::SkillSet,
-    ) -> Self {
-        let opencode_config = &defaults.opencode;
-        let server_pool = crate::opencode::OpenCodeServerPool::new(
-            opencode_config.path.clone(),
-            opencode_config.permissions.clone(),
-            opencode_config.max_servers,
-        );
-
-        Self {
-            instance_dir: instance_dir.to_path_buf(),
-            workspace_dir: agent_config.workspace.clone(),
-            routing: ArcSwap::from_pointee(agent_config.routing.clone()),
-            compaction: ArcSwap::from_pointee(agent_config.compaction),
-            memory_persistence: ArcSwap::from_pointee(agent_config.memory_persistence),
-            coalesce: ArcSwap::from_pointee(agent_config.coalesce),
-            ingestion: ArcSwap::from_pointee(agent_config.ingestion),
-            max_turns: ArcSwap::from_pointee(agent_config.max_turns),
-            branch_max_turns: ArcSwap::from_pointee(agent_config.branch_max_turns),
-            context_window: ArcSwap::from_pointee(agent_config.context_window),
-            max_concurrent_branches: ArcSwap::from_pointee(agent_config.max_concurrent_branches),
-            max_concurrent_workers: ArcSwap::from_pointee(agent_config.max_concurrent_workers),
-            browser_config: ArcSwap::from_pointee(agent_config.browser.clone()),
-            mcp: ArcSwap::from_pointee(agent_config.mcp.clone()),
-            history_backfill_count: ArcSwap::from_pointee(agent_config.history_backfill_count),
-            brave_search_key: ArcSwap::from_pointee(agent_config.brave_search_key.clone()),
-            cron_timezone: ArcSwap::from_pointee(agent_config.cron_timezone.clone()),
-            cortex: ArcSwap::from_pointee(agent_config.cortex),
-            warmup: ArcSwap::from_pointee(agent_config.warmup),
-            warmup_status: ArcSwap::from_pointee(WarmupStatus::default()),
-            warmup_lock: Arc::new(tokio::sync::Mutex::new(())),
-            memory_bulletin: ArcSwap::from_pointee(String::new()),
-            prompts: ArcSwap::from_pointee(prompts),
-            identity: ArcSwap::from_pointee(identity),
-            skills: ArcSwap::from_pointee(skills),
-            opencode: ArcSwap::from_pointee(defaults.opencode.clone()),
-            opencode_server_pool: Arc::new(server_pool),
-            cron_store: ArcSwap::from_pointee(None),
-            cron_scheduler: ArcSwap::from_pointee(None),
-            settings: ArcSwap::from_pointee(None),
-            sandbox: ArcSwap::from_pointee(agent_config.sandbox.clone()),
-        }
-    }
-
-    /// Set the cron store and scheduler after initialization.
-    pub fn set_cron(
-        &self,
-        store: Arc<crate::cron::CronStore>,
-        scheduler: Arc<crate::cron::Scheduler>,
-    ) {
-        self.cron_store.store(Arc::new(Some(store)));
-        self.cron_scheduler.store(Arc::new(Some(scheduler)));
-    }
-
-    /// Set the settings store after initialization.
-    pub fn set_settings(&self, settings: Arc<crate::settings::SettingsStore>) {
-        self.settings.store(Arc::new(Some(settings)));
-    }
-
-    /// Compute the current dispatch-readiness signal.
-    pub fn work_readiness(&self) -> WorkReadiness {
-        let warmup_config = **self.warmup.load();
-        let status = self.warmup_status.load().as_ref().clone();
-        evaluate_work_readiness(warmup_config, status, chrono::Utc::now().timestamp_millis())
-    }
-
-    /// True when branch/worker/cron dispatches should run in fully-ready mode.
-    pub fn ready_for_work(&self) -> bool {
-        self.work_readiness().ready
-    }
-
-    /// Reload tunable config values from a freshly parsed Config.
-    ///
-    /// Finds the matching agent by ID, re-resolves it against defaults, and
-    /// swaps all reloadable fields. Does not handle API keys (those are
-    /// reloaded via LlmManager), DB paths, messaging adapters, or agent
-    /// topology.
-    pub async fn reload_config(
-        &self,
-        config: &Config,
-        agent_id: &str,
-        mcp_manager: &crate::mcp::McpManager,
-    ) {
-        let agent = config.agents.iter().find(|a| a.id == agent_id);
-        let Some(agent) = agent else {
-            tracing::warn!(agent_id, "agent not found in reloaded config, skipping");
-            return;
-        };
-
-        let resolved = agent.resolve(&config.instance_dir, &config.defaults);
-        let old_mcp = (**self.mcp.load()).clone();
-        let new_mcp = resolved.mcp.clone();
-
-        self.routing.store(Arc::new(resolved.routing));
-        self.compaction.store(Arc::new(resolved.compaction));
-        self.memory_persistence
-            .store(Arc::new(resolved.memory_persistence));
-        self.coalesce.store(Arc::new(resolved.coalesce));
-        self.ingestion.store(Arc::new(resolved.ingestion));
-        self.max_turns.store(Arc::new(resolved.max_turns));
-        self.branch_max_turns
-            .store(Arc::new(resolved.branch_max_turns));
-        self.context_window.store(Arc::new(resolved.context_window));
-        self.max_concurrent_branches
-            .store(Arc::new(resolved.max_concurrent_branches));
-        self.max_concurrent_workers
-            .store(Arc::new(resolved.max_concurrent_workers));
-        self.browser_config.store(Arc::new(resolved.browser));
-        self.mcp.store(Arc::new(new_mcp.clone()));
-        self.history_backfill_count
-            .store(Arc::new(resolved.history_backfill_count));
-        self.brave_search_key
-            .store(Arc::new(resolved.brave_search_key));
-        self.cron_timezone.store(Arc::new(resolved.cron_timezone));
-        self.cortex.store(Arc::new(resolved.cortex));
-        self.warmup.store(Arc::new(resolved.warmup));
-        // sandbox config is not hot-reloaded here because the Sandbox instance
-        // is constructed once at startup and shared via Arc. Changing sandbox
-        // settings requires an agent restart.
-
-        mcp_manager.reconcile(&old_mcp, &new_mcp).await;
-
-        tracing::info!(agent_id, "runtime config reloaded");
-    }
-
-    /// Reload identity files from disk.
-    pub fn reload_identity(&self, identity: crate::identity::Identity) {
-        self.identity.store(Arc::new(identity));
-        tracing::info!("identity reloaded");
-    }
-
-    /// Reload skills from disk.
-    pub fn reload_skills(&self, skills: crate::skills::SkillSet) {
-        self.skills.store(Arc::new(skills));
-        tracing::info!("skills reloaded");
-    }
-}
-
-impl std::fmt::Debug for RuntimeConfig {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("RuntimeConfig").finish_non_exhaustive()
-    }
-}
-
-/// Watches config, prompt, identity, and skill files for changes and triggers
-/// hot reload on the corresponding RuntimeConfig.
-///
-/// Returns a JoinHandle that runs until dropped. File events are debounced
-/// to 2 seconds so rapid edits (e.g. :w in vim hitting multiple writes) are
-/// collapsed into a single reload.
-#[allow(clippy::too_many_arguments)]
-pub fn spawn_file_watcher(
-    config_path: PathBuf,
-    instance_dir: PathBuf,
-    agents: Vec<(
-        String,
-        PathBuf,
-        Arc<RuntimeConfig>,
-        Arc<crate::mcp::McpManager>,
-    )>,
-    discord_permissions: Option<Arc<arc_swap::ArcSwap<DiscordPermissions>>>,
-    slack_permissions: Option<Arc<arc_swap::ArcSwap<SlackPermissions>>>,
-    telegram_permissions: Option<Arc<arc_swap::ArcSwap<TelegramPermissions>>>,
-    twitch_permissions: Option<Arc<arc_swap::ArcSwap<TwitchPermissions>>>,
-    bindings: Arc<arc_swap::ArcSwap<Vec<Binding>>>,
-    messaging_manager: Option<Arc<crate::messaging::MessagingManager>>,
-    llm_manager: Arc<crate::llm::LlmManager>,
-    agent_links: Arc<arc_swap::ArcSwap<Vec<crate::links::AgentLink>>>,
-) -> tokio::task::JoinHandle<()> {
-    use notify::{Event, RecursiveMode, Watcher};
-    use std::time::Duration;
-
-    tokio::task::spawn_blocking(move || {
-        let (tx, rx) = std::sync::mpsc::channel::<Event>();
-
-        let mut watcher = match notify::recommended_watcher(
-            move |result: std::result::Result<Event, notify::Error>| {
-                if let Ok(event) = result {
-                    // Only forward data modification events, not metadata/access changes
-                    use notify::EventKind;
-                    match &event.kind {
-                        EventKind::Create(_)
-                        | EventKind::Modify(notify::event::ModifyKind::Data(_))
-                        | EventKind::Remove(_) => {
-                            let _ = tx.send(event);
-                        }
-                        // Also forward Any/Other modify events (some backends don't distinguish)
-                        EventKind::Modify(notify::event::ModifyKind::Any) => {
-                            let _ = tx.send(event);
-                        }
-                        _ => {}
-                    }
-                }
-            },
-        ) {
-            Ok(w) => w,
-            Err(error) => {
-                tracing::error!(%error, "failed to create file watcher");
-                return;
-            }
-        };
-
-        // Watch config.toml
-        if let Err(error) = watcher.watch(&config_path, RecursiveMode::NonRecursive) {
-            tracing::warn!(%error, path = %config_path.display(), "failed to watch config file");
-        }
-
-        // Watch instance-level skills directory
-        let instance_skills_dir = instance_dir.join("skills");
-        if instance_skills_dir.is_dir()
-            && let Err(error) = watcher.watch(&instance_skills_dir, RecursiveMode::Recursive)
-        {
-            tracing::warn!(%error, path = %instance_skills_dir.display(), "failed to watch instance skills dir");
-        }
-
-        // Watch per-agent workspace directories (skills, identity)
-        for (_, workspace, _, _) in &agents {
-            {
-                let path = workspace.join("skills");
-                if path.is_dir()
-                    && let Err(error) = watcher.watch(&path, RecursiveMode::Recursive)
-                {
-                    tracing::warn!(%error, path = %path.display(), "failed to watch agent dir");
-                }
-            }
-            // Identity files are in the workspace root
-            if let Err(error) = watcher.watch(workspace, RecursiveMode::NonRecursive) {
-                tracing::warn!(%error, path = %workspace.display(), "failed to watch workspace");
-            }
-        }
-
-        tracing::info!("file watcher started");
-
-        // Track config.toml content hash to skip no-op reloads
-        let mut last_config_hash: u64 = std::fs::read(&config_path)
-            .map(|bytes| {
-                use std::hash::{Hash, Hasher};
-                let mut hasher = std::collections::hash_map::DefaultHasher::new();
-                bytes.hash(&mut hasher);
-                hasher.finish()
-            })
-            .unwrap_or(0);
-
-        // Debounce loop: collect events for 2 seconds, then reload
-        let debounce = Duration::from_secs(2);
-
-        while let Ok(first) = rx.recv() {
-            // Drain any additional events within the debounce window
-            let mut changed_paths: Vec<PathBuf> = first.paths;
-            while let Ok(event) = rx.recv_timeout(debounce) {
-                changed_paths.extend(event.paths);
-            }
-
-            // Categorize what changed
-            let mut config_changed = changed_paths.iter().any(|p| p.ends_with("config.toml"));
-            let identity_changed = changed_paths.iter().any(|p| {
-                let name = p.file_name().and_then(|n| n.to_str()).unwrap_or("");
-                matches!(name, "SOUL.md" | "IDENTITY.md" | "USER.md" | "ROLE.md")
-            });
-            let skills_changed = changed_paths
-                .iter()
-                .any(|p| p.to_string_lossy().contains("skills"));
-
-            // Skip entirely if nothing relevant changed
-            if !config_changed && !identity_changed && !skills_changed {
-                continue;
-            }
-
-            // Skip config reload if file content hasn't actually changed
-            if config_changed {
-                let current_hash: u64 = std::fs::read(&config_path)
-                    .map(|bytes| {
-                        use std::hash::{Hash, Hasher};
-                        let mut hasher = std::collections::hash_map::DefaultHasher::new();
-                        bytes.hash(&mut hasher);
-                        hasher.finish()
-                    })
-                    .unwrap_or(0);
-                if current_hash == last_config_hash {
-                    config_changed = false;
-                    // If config was the only thing that "changed", skip entirely
-                    if !identity_changed && !skills_changed {
-                        continue;
-                    }
-                } else {
-                    last_config_hash = current_hash;
-                }
-            }
-
-            let changed_summary: Vec<&str> = [
-                config_changed.then_some("config"),
-                identity_changed.then_some("identity"),
-                skills_changed.then_some("skills"),
-            ]
-            .into_iter()
-            .flatten()
-            .collect();
-
-            tracing::info!(
-                changed = %changed_summary.join(", "),
-                "file change detected, reloading"
-            );
-
-            // Reload config.toml if it changed
-            let new_config = if config_changed {
-                match Config::load_from_path(&config_path) {
-                    Ok(config) => Some(config),
-                    Err(error) => {
-                        tracing::error!(%error, "failed to reload config.toml, keeping previous values");
-                        None
-                    }
-                }
-            } else {
-                None
-            };
-
-            // Reload instance-level bindings, provider keys, and permissions
-            if let Some(config) = &new_config {
-                llm_manager.reload_config(config.llm.clone());
-
-                bindings.store(Arc::new(config.bindings.clone()));
-                tracing::info!("bindings reloaded ({} entries)", config.bindings.len());
-
-                match crate::links::AgentLink::from_config(&config.links) {
-                    Ok(links) => {
-                        agent_links.store(Arc::new(links));
-                        tracing::info!("agent links reloaded ({} entries)", config.links.len());
-                    }
-                    Err(error) => {
-                        tracing::error!(%error, "failed to parse links from reloaded config");
-                    }
-                }
-
-                if let Some(ref perms) = discord_permissions
-                    && let Some(discord_config) = &config.messaging.discord
-                {
-                    let new_perms =
-                        DiscordPermissions::from_config(discord_config, &config.bindings);
-                    perms.store(Arc::new(new_perms));
-                    tracing::info!("discord permissions reloaded");
-                }
-
-                if let Some(ref perms) = slack_permissions
-                    && let Some(slack_config) = &config.messaging.slack
-                {
-                    let new_perms = SlackPermissions::from_config(slack_config, &config.bindings);
-                    perms.store(Arc::new(new_perms));
-                    tracing::info!("slack permissions reloaded");
-                }
-
-                if let Some(ref perms) = telegram_permissions
-                    && let Some(telegram_config) = &config.messaging.telegram
-                {
-                    let new_perms =
-                        TelegramPermissions::from_config(telegram_config, &config.bindings);
-                    perms.store(Arc::new(new_perms));
-                    tracing::info!("telegram permissions reloaded");
-                }
-
-                if let Some(ref perms) = twitch_permissions
-                    && let Some(twitch_config) = &config.messaging.twitch
-                {
-                    let new_perms = TwitchPermissions::from_config(twitch_config, &config.bindings);
-                    perms.store(Arc::new(new_perms));
-                    tracing::info!("twitch permissions reloaded");
-                }
-
-                // Hot-start adapters that are newly enabled in the config
-                if let Some(ref manager) = messaging_manager {
-                    let rt = tokio::runtime::Handle::current();
-                    let manager = manager.clone();
-                    let config = config.clone();
-                    let discord_permissions = discord_permissions.clone();
-                    let slack_permissions = slack_permissions.clone();
-                    let telegram_permissions = telegram_permissions.clone();
-                    let twitch_permissions = twitch_permissions.clone();
-                    let instance_dir = instance_dir.clone();
-
-                    rt.spawn(async move {
-                        // Discord: start if enabled and not already running
-                        if let Some(discord_config) = &config.messaging.discord
-                            && discord_config.enabled && !manager.has_adapter("discord").await {
-                                let perms = match discord_permissions {
-                                    Some(ref existing) => existing.clone(),
-                                    None => {
-                                        let perms = DiscordPermissions::from_config(discord_config, &config.bindings);
-                                        Arc::new(arc_swap::ArcSwap::from_pointee(perms))
-                                    }
-                                };
-                                let adapter = crate::messaging::discord::DiscordAdapter::new(
-                                    &discord_config.token,
-                                    perms,
-                                );
-                                if let Err(error) = manager.register_and_start(adapter).await {
-                                    tracing::error!(%error, "failed to hot-start discord adapter from config change");
-                                }
-                            }
-
-                        // Slack: start if enabled and not already running
-                        if let Some(slack_config) = &config.messaging.slack
-                            && slack_config.enabled && !manager.has_adapter("slack").await {
-                                let perms = match slack_permissions {
-                                    Some(ref existing) => existing.clone(),
-                                    None => {
-                                        let perms = SlackPermissions::from_config(slack_config, &config.bindings);
-                                        Arc::new(arc_swap::ArcSwap::from_pointee(perms))
-                                    }
-                                };
-                                match crate::messaging::slack::SlackAdapter::new(
-                                    &slack_config.bot_token,
-                                    &slack_config.app_token,
-                                    perms,
-                                    slack_config.commands.clone(),
-                                ) {
-                                    Ok(adapter) => {
-                                        if let Err(error) = manager.register_and_start(adapter).await {
-                                            tracing::error!(%error, "failed to hot-start slack adapter from config change");
-                                        }
-                                    }
-                                    Err(error) => {
-                                        tracing::error!(%error, "failed to build slack adapter from config change");
-                                    }
-                                }
-                            }
-
-                        // Telegram: start if enabled and not already running
-                        if let Some(telegram_config) = &config.messaging.telegram
-                            && telegram_config.enabled && !manager.has_adapter("telegram").await {
-                                let perms = match telegram_permissions {
-                                    Some(ref existing) => existing.clone(),
-                                    None => {
-                                        let perms = TelegramPermissions::from_config(telegram_config, &config.bindings);
-                                        Arc::new(arc_swap::ArcSwap::from_pointee(perms))
-                                    }
-                                };
-                                let adapter = crate::messaging::telegram::TelegramAdapter::new(
-                                    &telegram_config.token,
-                                    perms,
-                                );
-                                if let Err(error) = manager.register_and_start(adapter).await {
-                                    tracing::error!(%error, "failed to hot-start telegram adapter from config change");
-                                }
-                            }
-
-                        // Twitch: start if enabled and not already running
-                        if let Some(twitch_config) = &config.messaging.twitch
-                            && twitch_config.enabled && !manager.has_adapter("twitch").await {
-                                let perms = match twitch_permissions {
-                                    Some(ref existing) => existing.clone(),
-                                    None => {
-                                        let perms = TwitchPermissions::from_config(twitch_config, &config.bindings);
-                                        Arc::new(arc_swap::ArcSwap::from_pointee(perms))
-                                    }
-                                };
-                                let token_path = instance_dir.join("twitch_token.json");
-                                let adapter = crate::messaging::twitch::TwitchAdapter::new(
-                                    &twitch_config.username,
-                                    &twitch_config.oauth_token,
-                                    twitch_config.client_id.clone(),
-                                    twitch_config.client_secret.clone(),
-                                    twitch_config.refresh_token.clone(),
-                                    Some(token_path),
-                                    twitch_config.channels.clone(),
-                                    twitch_config.trigger_prefix.clone(),
-                                    perms,
-                                );
-                                if let Err(error) = manager.register_and_start(adapter).await {
-                                    tracing::error!(%error, "failed to hot-start twitch adapter from config change");
-                                }
-                            }
-                    });
-                }
-            }
-
-            // Apply reloads to each agent's RuntimeConfig
-            for (agent_id, workspace, runtime_config, mcp_manager) in &agents {
-                if let Some(config) = &new_config {
-                    let rt = tokio::runtime::Handle::current();
-                    rt.block_on(runtime_config.reload_config(config, agent_id, mcp_manager));
-                }
-
-                if identity_changed {
-                    let rt = tokio::runtime::Handle::current();
-                    let identity = rt.block_on(crate::identity::Identity::load(workspace));
-                    runtime_config.reload_identity(identity);
-                }
-
-                if skills_changed {
-                    let rt = tokio::runtime::Handle::current();
-                    let skills = rt.block_on(crate::skills::SkillSet::load(
-                        &instance_dir.join("skills"),
-                        &workspace.join("skills"),
-                    ));
-                    runtime_config.reload_skills(skills);
-                }
-            }
-        }
-
-        tracing::info!("file watcher stopped");
-    })
-}
-
-/// Interactive first-run onboarding. Creates ~/.spacebot with a minimal config.
-///
-/// Returns `Some(path)` if the CLI wizard created a config file, or `None` if
-/// the user chose to set up via the embedded UI (setup mode).
-pub fn run_onboarding() -> anyhow::Result<Option<PathBuf>> {
-    use dialoguer::{Input, Password, Select};
-    use std::io::Write;
-
-    println!();
-    println!("  Welcome to Spacebot");
-    println!("  -------------------");
-    println!();
-    println!("  No configuration found. Let's set things up.");
-    println!();
-
-    let setup_method = Select::new()
-        .with_prompt("How do you want to set up?")
-        .items(&["Set up here (CLI)", "Set up in the browser (localhost)"])
-        .default(0)
-        .interact()?;
-
-    if setup_method == 1 {
-        println!();
-        println!("  Starting in setup mode. Open the UI to finish configuration:");
-        println!();
-        println!("    http://localhost:19898");
-        println!();
-        return Ok(None);
-    }
-
-    println!();
-
-    // 1. Pick a provider
-    let providers = &[
-        "Anthropic",
-        "OpenRouter",
-        "OpenAI",
-        "Z.ai (GLM)",
-        "Groq",
-        "Together AI",
-        "Fireworks AI",
-        "DeepSeek",
-        "xAI (Grok)",
-        "Mistral AI",
-        "Ollama",
-        "OpenCode Zen",
-        "MiniMax",
-        "Moonshot AI (Kimi)",
-        "Z.AI Coding Plan",
-    ];
-    let provider_idx = Select::new()
-        .with_prompt("Which LLM provider do you want to use?")
-        .items(providers)
-        .default(0)
-        .interact()?;
-
-    // For Anthropic, offer OAuth login as an option
-    let anthropic_oauth = if provider_idx == 0 {
-        let auth_method = Select::new()
-            .with_prompt("How do you want to authenticate with Anthropic?")
-            .items(&[
-                "Log in with Claude Pro/Max (OAuth)",
-                "Log in via API Console (OAuth)",
-                "Enter an API key manually",
-            ])
-            .default(0)
-            .interact()?;
-
-        if auth_method <= 1 {
-            let mode = if auth_method == 0 {
-                crate::auth::AuthMode::Max
-            } else {
-                crate::auth::AuthMode::Console
-            };
-            let instance_dir = Config::default_instance_dir();
-            std::fs::create_dir_all(&instance_dir)?;
-
-            let runtime = tokio::runtime::Builder::new_current_thread()
-                .enable_all()
-                .build()
-                .with_context(|| "failed to build tokio runtime")?;
-
-            runtime.block_on(crate::auth::login_interactive(&instance_dir, mode))?;
-            Some(true)
-        } else {
-            None
-        }
-    } else {
-        None
-    };
-
-    let (provider_input_name, toml_key, provider_id) = match provider_idx {
-        0 => ("Anthropic API key", "anthropic_key", "anthropic"),
-        1 => ("OpenRouter API key", "openrouter_key", "openrouter"),
-        2 => ("OpenAI API key", "openai_key", "openai"),
-        3 => ("Z.ai (GLM) API key", "zhipu_key", "zhipu"),
-        4 => ("Groq API key", "groq_key", "groq"),
-        5 => ("Together AI API key", "together_key", "together"),
-        6 => ("Fireworks AI API key", "fireworks_key", "fireworks"),
-        7 => ("DeepSeek API key", "deepseek_key", "deepseek"),
-        8 => ("xAI API key", "xai_key", "xai"),
-        9 => ("Mistral API key", "mistral_key", "mistral"),
-        10 => ("Google Gemini API key", "gemini_key", "gemini"),
-        11 => ("Ollama base URL (optional)", "ollama_base_url", "ollama"),
-        12 => ("OpenCode Zen API key", "opencode_zen_key", "opencode-zen"),
-        13 => ("MiniMax API key", "minimax_key", "minimax"),
-        14 => ("Moonshot API key", "moonshot_key", "moonshot"),
-        15 => (
-            "Z.AI Coding Plan API key",
-            "zai_coding_plan_key",
-            "zai-coding-plan",
-        ),
-        _ => unreachable!(),
-    };
-    let is_secret = provider_id != "ollama";
-
-    // 2. Get provider credential/endpoint (skip if OAuth was used)
-    let provider_value = if anthropic_oauth.is_some() {
-        // OAuth tokens are stored in anthropic_oauth.json, not in config.toml.
-        // Use a placeholder so the config still has an [llm] section.
-        String::new()
-    } else if is_secret {
-        let api_key: String = Password::new()
-            .with_prompt(format!("Enter your {provider_input_name}"))
-            .interact()?;
-
-        let api_key = api_key.trim().to_string();
-        if api_key.is_empty() {
-            anyhow::bail!("API key cannot be empty");
-        }
-        api_key
-    } else {
-        let base_url: String = Input::new()
-            .with_prompt(format!("Enter your {provider_input_name}"))
-            .default("http://localhost:11434".to_string())
-            .interact_text()?;
-
-        let base_url = base_url.trim().to_string();
-        if base_url.is_empty() {
-            anyhow::bail!("Ollama base URL cannot be empty");
-        }
-        base_url
-    };
-
-    // 3. Agent name
-    let agent_id: String = Input::new()
-        .with_prompt("Agent name")
-        .default("main".to_string())
-        .interact_text()?;
-
-    let agent_id = agent_id.trim().to_lowercase().replace(' ', "-");
-
-    // 4. Optional Discord setup
-    let setup_discord = Select::new()
-        .with_prompt("Set up Discord integration?")
-        .items(&["Not now", "Yes"])
-        .default(0)
-        .interact()?;
-
-    struct DiscordSetup {
-        token: String,
-        guild_id: Option<String>,
-        channel_ids: Vec<String>,
-        dm_user_ids: Vec<String>,
-    }
-
-    let discord = if setup_discord == 1 {
-        let token: String = Password::new()
-            .with_prompt("Discord bot token")
-            .interact()?;
-        let token = token.trim().to_string();
-
-        if token.is_empty() {
-            None
-        } else {
-            println!();
-            println!("  Tip: Right-click a server or channel in Discord with");
-            println!("  Developer Mode enabled to copy IDs. Leave blank to skip.");
-            println!();
-
-            let guild_id: String = Input::new()
-                .with_prompt("Server (guild) ID")
-                .allow_empty(true)
-                .default(String::new())
-                .interact_text()?;
-            let guild_id = guild_id.trim().to_string();
-            let guild_id = if guild_id.is_empty() {
-                None
-            } else {
-                Some(guild_id)
-            };
-
-            let channel_ids_raw: String = Input::new()
-                .with_prompt("Channel IDs (comma-separated, or blank for all)")
-                .allow_empty(true)
-                .default(String::new())
-                .interact_text()?;
-            let channel_ids: Vec<String> = channel_ids_raw
-                .split(',')
-                .map(|s| s.trim().to_string())
-                .filter(|s| !s.is_empty())
-                .collect();
-
-            let dm_user_ids_raw: String = Input::new()
-                .with_prompt("User IDs allowed to DM the bot (comma-separated, or blank)")
-                .allow_empty(true)
-                .default(String::new())
-                .interact_text()?;
-            let dm_user_ids: Vec<String> = dm_user_ids_raw
-                .split(',')
-                .map(|s| s.trim().to_string())
-                .filter(|s| !s.is_empty())
-                .collect();
-
-            Some(DiscordSetup {
-                token,
-                guild_id,
-                channel_ids,
-                dm_user_ids,
-            })
-        }
-    } else {
-        None
-    };
-
-    // 5. Build config.toml
-    let instance_dir = Config::default_instance_dir();
-    let config_path = instance_dir.join("config.toml");
-
-    // Create directory structure
-    std::fs::create_dir_all(&instance_dir)
-        .with_context(|| format!("failed to create {}", instance_dir.display()))?;
-
-    let mut config_content = String::new();
-    config_content.push_str("[llm]\n");
-    if anthropic_oauth.is_some() {
-        config_content
-            .push_str("# Anthropic authentication via OAuth (see anthropic_oauth.json)\n");
-    } else {
-        config_content.push_str(&format!("{toml_key} = \"{provider_value}\"\n"));
-    }
-    config_content.push('\n');
-
-    // Write routing defaults for the chosen provider
-    let routing = crate::llm::routing::defaults_for_provider(provider_id);
-    config_content.push_str("[defaults.routing]\n");
-    config_content.push_str(&format!("channel = \"{}\"\n", routing.channel));
-    config_content.push_str(&format!("branch = \"{}\"\n", routing.branch));
-    config_content.push_str(&format!("worker = \"{}\"\n", routing.worker));
-    config_content.push_str(&format!("compactor = \"{}\"\n", routing.compactor));
-    config_content.push_str(&format!("cortex = \"{}\"\n", routing.cortex));
-    config_content.push('\n');
-
-    config_content.push_str("[[agents]]\n");
-    config_content.push_str(&format!("id = \"{agent_id}\"\n"));
-    config_content.push_str("default = true\n");
-
-    if let Some(discord) = &discord {
-        config_content.push_str("\n[messaging.discord]\n");
-        config_content.push_str("enabled = true\n");
-        config_content.push_str(&format!("token = \"{}\"\n", discord.token));
-
-        // Write the binding
-        config_content.push_str("\n[[bindings]]\n");
-        config_content.push_str(&format!("agent_id = \"{agent_id}\"\n"));
-        config_content.push_str("channel = \"discord\"\n");
-        if let Some(guild_id) = &discord.guild_id {
-            config_content.push_str(&format!("guild_id = \"{guild_id}\"\n"));
-        }
-        if !discord.channel_ids.is_empty() {
-            let ids: Vec<String> = discord
-                .channel_ids
-                .iter()
-                .map(|id| format!("\"{id}\""))
-                .collect();
-            config_content.push_str(&format!("channel_ids = [{}]\n", ids.join(", ")));
-        }
-        if !discord.dm_user_ids.is_empty() {
-            let ids: Vec<String> = discord
-                .dm_user_ids
-                .iter()
-                .map(|id| format!("\"{id}\""))
-                .collect();
-            config_content.push_str(&format!("dm_allowed_users = [{}]\n", ids.join(", ")));
-        }
-    }
-
-    let mut file = std::fs::File::create(&config_path)
-        .with_context(|| format!("failed to create {}", config_path.display()))?;
-    file.write_all(config_content.as_bytes())?;
-
-    println!();
-    println!("  Config written to {}", config_path.display());
-    println!("  Agent '{}' created.", agent_id);
-    println!();
-    println!("  You can customize identity files in:");
-    println!(
-        "    {}/agents/{}/workspace/",
-        instance_dir.display(),
-        agent_id
-    );
-    println!();
-
-    Ok(Some(config_path))
-}
+mod load;
+mod onboarding;
+mod permissions;
+mod providers;
+mod runtime;
+mod toml_schema;
+mod types;
+mod watcher;
+
+// Re-export all public types from submodules so external consumers
+// continue to use `crate::config::TypeName` unchanged.
+pub use load::set_resolve_secrets_store;
+pub use onboarding::run_onboarding;
+pub use permissions::{
+    DiscordPermissions, SlackPermissions, TelegramPermissions, TwitchPermissions,
+};
+pub(crate) use providers::default_provider_config;
+pub use runtime::RuntimeConfig;
+pub use types::*;
+pub use watcher::spawn_file_watcher;
+
+// Re-export pub(crate) items that need crate-wide visibility.
+// (GEMINI_PROVIDER_BASE_URL is only used within config submodules, no re-export needed.)
+
+// Make toml_schema types and internal helpers visible to tests in this module.
+#[cfg(test)]
+use load::warn_unknown_config_keys;
+#[cfg(test)]
+use providers::ANTHROPIC_PROVIDER_BASE_URL;
+#[cfg(test)]
+use providers::OPENAI_PROVIDER_BASE_URL;
+#[cfg(test)]
+use providers::OPENROUTER_PROVIDER_BASE_URL;
+#[cfg(test)]
+use toml_schema::*;
+#[cfg(test)]
+use types::binding_adapter_matches;
+#[cfg(test)]
+use types::validate_instance_names;
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::path::PathBuf;
     use std::result::Result as StdResult;
-    use std::sync::{Mutex, OnceLock};
 
-    fn env_test_lock() -> &'static Mutex<()> {
-        static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
-        LOCK.get_or_init(|| Mutex::new(()))
+    fn env_test_lock() -> &'static parking_lot::Mutex<()> {
+        static LOCK: std::sync::OnceLock<parking_lot::Mutex<()>> = std::sync::OnceLock::new();
+        LOCK.get_or_init(|| parking_lot::Mutex::new(()))
     }
 
     struct EnvGuard {
@@ -4469,14 +58,18 @@ mod tests {
 
     impl EnvGuard {
         fn new() -> Self {
-            const KEYS: [&str; 22] = [
+            // NOTE: Keep in sync with provider env vars that affect test behavior
+            const KEYS: [&str; 27] = [
                 "SPACEBOT_DIR",
                 "SPACEBOT_DEPLOYMENT",
                 "SPACEBOT_CRON_TIMEZONE",
+                "SPACEBOT_USER_TIMEZONE",
                 "ANTHROPIC_API_KEY",
+                "ANTHROPIC_BASE_URL",
                 "ANTHROPIC_OAUTH_TOKEN",
                 "OPENAI_API_KEY",
                 "OPENROUTER_API_KEY",
+                "KILO_API_KEY",
                 "ZHIPU_API_KEY",
                 "GROQ_API_KEY",
                 "TOGETHER_API_KEY",
@@ -4489,7 +82,9 @@ mod tests {
                 "OLLAMA_API_KEY",
                 "OLLAMA_BASE_URL",
                 "OPENCODE_ZEN_API_KEY",
+                "OPENCODE_GO_API_KEY",
                 "MINIMAX_API_KEY",
+                "MINIMAX_CN_API_KEY",
                 "MOONSHOT_API_KEY",
                 "ZAI_CODING_PLAN_API_KEY",
             ];
@@ -4548,22 +143,40 @@ api_key = "test-key"
         assert_eq!(result1.unwrap().api_type, ApiType::OpenAiCompletions);
 
         let toml2 = r#"
-api_type = "openai_responses"
-base_url = "https://api.openai.com"
+api_type = "openai_chat_completions"
+base_url = "https://api.example.com"
 api_key = "test-key"
 "#;
         let result2: StdResult<TomlProviderConfig, toml::de::Error> = toml::from_str(toml2);
         assert!(result2.is_ok(), "Error: {:?}", result2.err());
-        assert_eq!(result2.unwrap().api_type, ApiType::OpenAiResponses);
+        assert_eq!(result2.unwrap().api_type, ApiType::OpenAiChatCompletions);
 
         let toml3 = r#"
-api_type = "anthropic"
-base_url = "https://api.anthropic.com"
+api_type = "kilo_gateway"
+base_url = "https://api.kilo.ai/api/gateway"
 api_key = "test-key"
 "#;
         let result3: StdResult<TomlProviderConfig, toml::de::Error> = toml::from_str(toml3);
         assert!(result3.is_ok(), "Error: {:?}", result3.err());
-        assert_eq!(result3.unwrap().api_type, ApiType::Anthropic);
+        assert_eq!(result3.unwrap().api_type, ApiType::KiloGateway);
+
+        let toml4 = r#"
+api_type = "openai_responses"
+base_url = "https://api.openai.com"
+api_key = "test-key"
+"#;
+        let result4: StdResult<TomlProviderConfig, toml::de::Error> = toml::from_str(toml4);
+        assert!(result4.is_ok(), "Error: {:?}", result4.err());
+        assert_eq!(result4.unwrap().api_type, ApiType::OpenAiResponses);
+
+        let toml5 = r#"
+api_type = "anthropic"
+base_url = "https://api.anthropic.com"
+api_key = "test-key"
+"#;
+        let result5: StdResult<TomlProviderConfig, toml::de::Error> = toml::from_str(toml5);
+        assert!(result5.is_ok(), "Error: {:?}", result5.err());
+        assert_eq!(result5.unwrap().api_type, ApiType::Anthropic);
     }
 
     #[test]
@@ -4574,6 +187,8 @@ api_key = "test-key"
         let error = result.unwrap_err();
         assert!(error.to_string().contains("invalid value"));
         assert!(error.to_string().contains("openai_completions"));
+        assert!(error.to_string().contains("openai_chat_completions"));
+        assert!(error.to_string().contains("kilo_gateway"));
         assert!(error.to_string().contains("openai_responses"));
         assert!(error.to_string().contains("anthropic"));
     }
@@ -4613,7 +228,7 @@ api_key = "sk-proj-xyz789"
 
     #[test]
     fn test_llm_provider_tables_parse_with_env_and_lowercase_keys() {
-        let _lock = env_test_lock().lock().unwrap_or_else(|e| e.into_inner());
+        let _lock = env_test_lock().lock();
         let _env = EnvGuard::new();
 
         let toml = r#"
@@ -4659,6 +274,9 @@ api_key = "static-provider-key"
 
     #[test]
     fn test_legacy_llm_keys_auto_migrate_to_providers() {
+        let _lock = env_test_lock().lock();
+        let _env = EnvGuard::new();
+
         let toml = r#"
 [llm]
 anthropic_key = "legacy-anthropic-key"
@@ -4677,6 +295,10 @@ openrouter_key = "legacy-openrouter-key"
         assert_eq!(anthropic_provider.api_type, ApiType::Anthropic);
         assert_eq!(anthropic_provider.base_url, ANTHROPIC_PROVIDER_BASE_URL);
         assert_eq!(anthropic_provider.api_key, "legacy-anthropic-key");
+        assert!(
+            anthropic_provider.extra_headers.is_empty(),
+            "anthropic provider should have no extra_headers"
+        );
 
         let openai_provider = config
             .llm
@@ -4686,6 +308,10 @@ openrouter_key = "legacy-openrouter-key"
         assert_eq!(openai_provider.api_type, ApiType::OpenAiCompletions);
         assert_eq!(openai_provider.base_url, OPENAI_PROVIDER_BASE_URL);
         assert_eq!(openai_provider.api_key, "legacy-openai-key");
+        assert!(
+            openai_provider.extra_headers.is_empty(),
+            "openai provider should have no extra_headers"
+        );
 
         let openrouter_provider = config
             .llm
@@ -4695,6 +321,21 @@ openrouter_key = "legacy-openrouter-key"
         assert_eq!(openrouter_provider.api_type, ApiType::OpenAiCompletions);
         assert_eq!(openrouter_provider.base_url, OPENROUTER_PROVIDER_BASE_URL);
         assert_eq!(openrouter_provider.api_key, "legacy-openrouter-key");
+        assert_eq!(openrouter_provider.extra_headers.len(), 4);
+        let find_header = |name: &str| -> Option<&str> {
+            openrouter_provider
+                .extra_headers
+                .iter()
+                .find(|(key, _)| key == name)
+                .map(|(_, value)| value.as_str())
+        };
+        assert_eq!(find_header("HTTP-Referer"), Some("https://spacebot.sh/"));
+        assert_eq!(find_header("X-Title"), Some("Spacebot"));
+        assert_eq!(find_header("X-OpenRouter-Title"), Some("Spacebot"));
+        assert_eq!(
+            find_header("X-OpenRouter-Categories"),
+            Some("cloud-agent,cli-agent")
+        );
     }
 
     #[test]
@@ -4725,11 +366,50 @@ name = "Custom OpenAI"
         assert_eq!(config.llm.openai_key.as_deref(), Some("legacy-openai-key"));
     }
 
+    #[test]
+    fn test_explicit_openrouter_provider_toml_injects_extra_headers() {
+        let toml = r#"
+[llm.provider.openrouter]
+api_type = "openai_completions"
+base_url = "https://openrouter.ai/api/v1"
+api_key = "explicit-openrouter-key"
+name = "My OpenRouter"
+"#;
+
+        let parsed: TomlConfig = toml::from_str(toml).expect("failed to parse test TOML");
+        let config = Config::from_toml(parsed, PathBuf::from(".")).expect("failed to build Config");
+
+        let openrouter_provider = config
+            .llm
+            .providers
+            .get("openrouter")
+            .expect("openrouter provider missing");
+        assert_eq!(openrouter_provider.api_type, ApiType::OpenAiCompletions);
+        assert_eq!(openrouter_provider.base_url, "https://openrouter.ai/api/v1");
+        assert_eq!(openrouter_provider.api_key, "explicit-openrouter-key");
+        assert_eq!(openrouter_provider.name.as_deref(), Some("My OpenRouter"));
+
+        // Verify attribution headers are injected even for explicit TOML config
+        assert_eq!(openrouter_provider.extra_headers.len(), 4);
+        let find_header = |name: &str| -> Option<&str> {
+            openrouter_provider
+                .extra_headers
+                .iter()
+                .find(|(key, _)| key == name)
+                .map(|(_, value)| value.as_str())
+        };
+        assert_eq!(find_header("HTTP-Referer"), Some("https://spacebot.sh/"));
+        assert_eq!(find_header("X-Title"), Some("Spacebot"));
+        assert_eq!(find_header("X-OpenRouter-Title"), Some("Spacebot"));
+        assert_eq!(
+            find_header("X-OpenRouter-Categories"),
+            Some("cloud-agent,cli-agent")
+        );
+    }
+
     #[test]
     fn test_needs_onboarding_without_config_or_env() {
-        let _lock = env_test_lock()
-            .lock()
-            .expect("failed to lock env test mutex");
+        let _lock = env_test_lock().lock();
         let _env = EnvGuard::new();
 
         assert!(Config::needs_onboarding());
@@ -4737,9 +417,7 @@ name = "Custom OpenAI"
 
     #[test]
     fn test_needs_onboarding_with_anthropic_env_key() {
-        let _lock = env_test_lock()
-            .lock()
-            .expect("failed to lock env test mutex");
+        let _lock = env_test_lock().lock();
         let _env = EnvGuard::new();
 
         unsafe {
@@ -4751,9 +429,7 @@ name = "Custom OpenAI"
 
     #[test]
     fn test_needs_onboarding_false_with_oauth_credentials() {
-        let _lock = env_test_lock()
-            .lock()
-            .expect("failed to lock env test mutex");
+        let _lock = env_test_lock().lock();
         let _env = EnvGuard::new();
 
         // Create an OAuth credentials file in the EnvGuard's temp dir
@@ -4770,9 +446,7 @@ name = "Custom OpenAI"
 
     #[test]
     fn test_needs_onboarding_false_with_openai_oauth_credentials() {
-        let _lock = env_test_lock()
-            .lock()
-            .expect("failed to lock env test mutex");
+        let _lock = env_test_lock().lock();
         let _env = EnvGuard::new();
 
         let instance_dir = Config::default_instance_dir();
@@ -4790,9 +464,7 @@ name = "Custom OpenAI"
 
     #[test]
     fn test_load_from_env_populates_legacy_key_and_provider() {
-        let _lock = env_test_lock()
-            .lock()
-            .expect("failed to lock env test mutex");
+        let _lock = env_test_lock().lock();
         let _env = EnvGuard::new();
 
         unsafe {
@@ -4814,9 +486,7 @@ name = "Custom OpenAI"
 
     #[test]
     fn test_hosted_deployment_forces_api_bind_from_toml() {
-        let _lock = env_test_lock()
-            .lock()
-            .expect("failed to lock env test mutex");
+        let _lock = env_test_lock().lock();
         let _env = EnvGuard::new();
 
         unsafe {
@@ -4836,9 +506,7 @@ bind = "127.0.0.1"
 
     #[test]
     fn test_hosted_deployment_forces_api_bind_from_env_defaults() {
-        let _lock = env_test_lock()
-            .lock()
-            .expect("failed to lock env test mutex");
+        let _lock = env_test_lock().lock();
         let _env = EnvGuard::new();
 
         unsafe {
@@ -4857,6 +525,7 @@ bind = "127.0.0.1"
             enabled: true,
             bot_token: "xoxb-test".into(),
             app_token: "xapp-test".into(),
+            instances: vec![],
             dm_allowed_users,
             commands: vec![],
         }
@@ -4867,6 +536,7 @@ bind = "127.0.0.1"
         Binding {
             agent_id: "test-agent".into(),
             channel: "slack".into(),
+            adapter: None,
             guild_id: None,
             workspace_id: workspace_id.map(String::from),
             chat_id: None,
@@ -4952,9 +622,84 @@ bind = "127.0.0.1"
 
     #[test]
     fn test_cron_timezone_resolution_precedence() {
-        let _lock = env_test_lock()
-            .lock()
-            .expect("failed to lock env test mutex");
+        let _lock = env_test_lock().lock();
+        let _env = EnvGuard::new();
+
+        unsafe {
+            std::env::set_var(CRON_TIMEZONE_ENV_VAR, "Asia/Tokyo");
+        }
+
+        let toml = r#"
+[defaults]
+cron_timezone = "America/New_York"
+
+[[agents]]
+id = "main"
+cron_timezone = "Europe/Berlin"
+"#;
+
+        let parsed: TomlConfig = toml::from_str(toml).expect("failed to parse test TOML");
+        let config = Config::from_toml(parsed, PathBuf::from(".")).expect("failed to build Config");
+
+        assert_eq!(
+            config.defaults.cron_timezone.as_deref(),
+            Some("America/New_York")
+        );
+        assert_eq!(
+            config.agents[0].cron_timezone.as_deref(),
+            Some("Europe/Berlin")
+        );
+
+        let resolved = config.agents[0].resolve(&config.instance_dir, &config.defaults);
+        assert_eq!(resolved.cron_timezone.as_deref(), Some("Europe/Berlin"));
+
+        let toml_without_agent_override = r#"
+[defaults]
+cron_timezone = "America/New_York"
+
+[[agents]]
+id = "main"
+"#;
+        let parsed: TomlConfig =
+            toml::from_str(toml_without_agent_override).expect("failed to parse test TOML");
+        let config = Config::from_toml(parsed, PathBuf::from(".")).expect("failed to build Config");
+        let resolved = config.agents[0].resolve(&config.instance_dir, &config.defaults);
+        assert_eq!(resolved.cron_timezone.as_deref(), Some("America/New_York"));
+
+        let toml_without_default = r#"
+[[agents]]
+id = "main"
+"#;
+        let parsed: TomlConfig =
+            toml::from_str(toml_without_default).expect("failed to parse test TOML");
+        let config = Config::from_toml(parsed, PathBuf::from(".")).expect("failed to build Config");
+        let resolved = config.agents[0].resolve(&config.instance_dir, &config.defaults);
+        assert_eq!(resolved.cron_timezone.as_deref(), Some("Asia/Tokyo"));
+    }
+
+    #[test]
+    fn test_cron_timezone_invalid_falls_back_to_system() {
+        let _lock = env_test_lock().lock();
+        let _env = EnvGuard::new();
+
+        unsafe {
+            std::env::set_var(CRON_TIMEZONE_ENV_VAR, "Not/A-Real-Tz");
+        }
+
+        let toml = r#"
+[[agents]]
+id = "main"
+"#;
+
+        let parsed: TomlConfig = toml::from_str(toml).expect("failed to parse test TOML");
+        let config = Config::from_toml(parsed, PathBuf::from(".")).expect("failed to build Config");
+        let resolved = config.agents[0].resolve(&config.instance_dir, &config.defaults);
+        assert_eq!(resolved.cron_timezone, None);
+    }
+
+    #[test]
+    fn test_cron_timezone_invalid_default_uses_env_fallback() {
+        let _lock = env_test_lock().lock();
         let _env = EnvGuard::new();
 
         unsafe {
@@ -4963,64 +708,128 @@ bind = "127.0.0.1"
 
         let toml = r#"
 [defaults]
-cron_timezone = "America/New_York"
+cron_timezone = "Not/A-Real-Tz"
+
+[[agents]]
+id = "main"
+"#;
+
+        let parsed: TomlConfig = toml::from_str(toml).expect("failed to parse test TOML");
+        let config = Config::from_toml(parsed, PathBuf::from(".")).expect("failed to build Config");
+        let resolved = config.agents[0].resolve(&config.instance_dir, &config.defaults);
+        assert_eq!(resolved.cron_timezone.as_deref(), Some("Asia/Tokyo"));
+    }
+
+    #[test]
+    fn test_user_timezone_resolution_precedence() {
+        let _lock = env_test_lock().lock();
+        let _env = EnvGuard::new();
+
+        unsafe {
+            std::env::set_var(USER_TIMEZONE_ENV_VAR, "Asia/Tokyo");
+        }
+
+        let toml = r#"
+[defaults]
+user_timezone = "America/New_York"
+
+[[agents]]
+id = "main"
+user_timezone = "Europe/Berlin"
+"#;
+
+        let parsed: TomlConfig = toml::from_str(toml).expect("failed to parse test TOML");
+        let config = Config::from_toml(parsed, PathBuf::from(".")).expect("failed to build Config");
+        let resolved = config.agents[0].resolve(&config.instance_dir, &config.defaults);
+        assert_eq!(resolved.user_timezone.as_deref(), Some("Europe/Berlin"));
+
+        let toml_without_agent_override = r#"
+[defaults]
+user_timezone = "America/New_York"
+
+[[agents]]
+id = "main"
+"#;
+        let parsed: TomlConfig =
+            toml::from_str(toml_without_agent_override).expect("failed to parse test TOML");
+        let config = Config::from_toml(parsed, PathBuf::from(".")).expect("failed to build Config");
+        let resolved = config.agents[0].resolve(&config.instance_dir, &config.defaults);
+        assert_eq!(resolved.user_timezone.as_deref(), Some("America/New_York"));
+
+        let toml_without_default = r#"
+[[agents]]
+id = "main"
+"#;
+        let parsed: TomlConfig =
+            toml::from_str(toml_without_default).expect("failed to parse test TOML");
+        let config = Config::from_toml(parsed, PathBuf::from(".")).expect("failed to build Config");
+        let resolved = config.agents[0].resolve(&config.instance_dir, &config.defaults);
+        assert_eq!(resolved.user_timezone.as_deref(), Some("Asia/Tokyo"));
+    }
+
+    #[test]
+    fn test_user_timezone_falls_back_to_cron_timezone() {
+        let _lock = env_test_lock().lock();
+        let _env = EnvGuard::new();
+
+        let toml = r#"
+[defaults]
+cron_timezone = "America/Los_Angeles"
 
 [[agents]]
 id = "main"
-cron_timezone = "Europe/Berlin"
 "#;
 
         let parsed: TomlConfig = toml::from_str(toml).expect("failed to parse test TOML");
         let config = Config::from_toml(parsed, PathBuf::from(".")).expect("failed to build Config");
-
+        let resolved = config.agents[0].resolve(&config.instance_dir, &config.defaults);
         assert_eq!(
-            config.defaults.cron_timezone.as_deref(),
-            Some("America/New_York")
+            resolved.cron_timezone.as_deref(),
+            Some("America/Los_Angeles")
         );
         assert_eq!(
-            config.agents[0].cron_timezone.as_deref(),
-            Some("Europe/Berlin")
+            resolved.user_timezone.as_deref(),
+            Some("America/Los_Angeles")
         );
+    }
 
-        let resolved = config.agents[0].resolve(&config.instance_dir, &config.defaults);
-        assert_eq!(resolved.cron_timezone.as_deref(), Some("Europe/Berlin"));
+    #[test]
+    fn test_user_timezone_invalid_falls_back_to_cron_timezone() {
+        let _lock = env_test_lock().lock();
+        let _env = EnvGuard::new();
 
-        let toml_without_agent_override = r#"
+        let toml = r#"
 [defaults]
-cron_timezone = "America/New_York"
+cron_timezone = "America/Los_Angeles"
+user_timezone = "Not/A-Real-Tz"
 
 [[agents]]
 id = "main"
 "#;
-        let parsed: TomlConfig =
-            toml::from_str(toml_without_agent_override).expect("failed to parse test TOML");
-        let config = Config::from_toml(parsed, PathBuf::from(".")).expect("failed to build Config");
-        let resolved = config.agents[0].resolve(&config.instance_dir, &config.defaults);
-        assert_eq!(resolved.cron_timezone.as_deref(), Some("America/New_York"));
 
-        let toml_without_default = r#"
-[[agents]]
-id = "main"
-"#;
-        let parsed: TomlConfig =
-            toml::from_str(toml_without_default).expect("failed to parse test TOML");
+        let parsed: TomlConfig = toml::from_str(toml).expect("failed to parse test TOML");
         let config = Config::from_toml(parsed, PathBuf::from(".")).expect("failed to build Config");
         let resolved = config.agents[0].resolve(&config.instance_dir, &config.defaults);
-        assert_eq!(resolved.cron_timezone.as_deref(), Some("Asia/Tokyo"));
+        assert_eq!(
+            resolved.user_timezone.as_deref(),
+            Some("America/Los_Angeles")
+        );
     }
 
     #[test]
-    fn test_cron_timezone_invalid_falls_back_to_system() {
-        let _lock = env_test_lock()
-            .lock()
-            .expect("failed to lock env test mutex");
+    fn test_user_timezone_invalid_config_uses_env_fallback() {
+        let _lock = env_test_lock().lock();
         let _env = EnvGuard::new();
 
         unsafe {
-            std::env::set_var(CRON_TIMEZONE_ENV_VAR, "Not/A-Real-Tz");
+            std::env::set_var(USER_TIMEZONE_ENV_VAR, "Asia/Tokyo");
         }
 
         let toml = r#"
+[defaults]
+cron_timezone = "America/Los_Angeles"
+user_timezone = "Not/A-Real-Tz"
+
 [[agents]]
 id = "main"
 "#;
@@ -5028,7 +837,7 @@ id = "main"
         let parsed: TomlConfig = toml::from_str(toml).expect("failed to parse test TOML");
         let config = Config::from_toml(parsed, PathBuf::from(".")).expect("failed to build Config");
         let resolved = config.agents[0].resolve(&config.instance_dir, &config.defaults);
-        assert_eq!(resolved.cron_timezone, None);
+        assert_eq!(resolved.user_timezone.as_deref(), Some("Asia/Tokyo"));
     }
 
     #[test]
@@ -5097,6 +906,15 @@ id = "main"
         assert_eq!(provider.base_url, "http://remote-ollama:11434");
     }
 
+    #[test]
+    fn default_provider_config_ollama_uses_base_url_and_empty_api_key() {
+        let provider = default_provider_config("ollama", "http://remote-ollama.local:11434")
+            .expect("ollama provider should be supported");
+        assert_eq!(provider.api_type, ApiType::OpenAiCompletions);
+        assert_eq!(provider.base_url, "http://remote-ollama.local:11434");
+        assert_eq!(provider.api_key, "");
+    }
+
     #[test]
     fn test_warmup_defaults_applied_when_not_configured() {
         let toml = r#"
@@ -5158,6 +976,43 @@ startup_delay_secs = 2
         assert_eq!(resolved.warmup.startup_delay_secs, 2);
     }
 
+    #[test]
+    fn test_cortex_default_and_agent_override_resolution() {
+        let toml = r#"
+[defaults.cortex]
+tick_interval_secs = 45
+detached_worker_timeout_retry_limit = 4
+supervisor_kill_budget_per_tick = 12
+bulletin_max_words = 1200
+
+[[agents]]
+id = "main"
+
+[agents.cortex]
+branch_timeout_secs = 77
+supervisor_kill_budget_per_tick = 3
+association_max_per_pass = 55
+"#;
+        let parsed: TomlConfig = toml::from_str(toml).expect("failed to parse test TOML");
+        let config = Config::from_toml(parsed, PathBuf::from(".")).expect("failed to build Config");
+        let resolved = config.agents[0].resolve(&config.instance_dir, &config.defaults);
+
+        assert_eq!(config.defaults.cortex.tick_interval_secs, 45);
+        assert_eq!(
+            config.defaults.cortex.detached_worker_timeout_retry_limit,
+            4
+        );
+        assert_eq!(config.defaults.cortex.supervisor_kill_budget_per_tick, 12);
+        assert_eq!(config.defaults.cortex.bulletin_max_words, 1200);
+
+        assert_eq!(resolved.cortex.tick_interval_secs, 45);
+        assert_eq!(resolved.cortex.branch_timeout_secs, 77);
+        assert_eq!(resolved.cortex.detached_worker_timeout_retry_limit, 4);
+        assert_eq!(resolved.cortex.supervisor_kill_budget_per_tick, 3);
+        assert_eq!(resolved.cortex.bulletin_max_words, 1200);
+        assert_eq!(resolved.cortex.association_max_per_pass, 55);
+    }
+
     #[test]
     fn test_work_readiness_requires_warm_state() {
         let readiness = evaluate_work_readiness(
@@ -5288,11 +1143,15 @@ startup_delay_secs = 2
     /// `LlmConfig` without wiring it up in `load_from_env` / `from_toml`, this test fails.
     #[test]
     fn all_shorthand_keys_register_providers_via_toml() {
+        let _lock = env_test_lock().lock();
+        let _env = EnvGuard::new();
+
         // (toml_key, toml_value, provider_name, expected_base_url_substring)
         let cases: &[(&str, &str, &str, &str)] = &[
             ("anthropic_key", "test-key", "anthropic", "anthropic.com"),
             ("openai_key", "test-key", "openai", "openai.com"),
             ("openrouter_key", "test-key", "openrouter", "openrouter.ai"),
+            ("kilo_key", "test-key", "kilo", "api.kilo.ai"),
             ("deepseek_key", "test-key", "deepseek", "deepseek.com"),
             ("minimax_key", "test-key", "minimax", "minimax.io"),
             ("minimax_cn_key", "test-key", "minimax-cn", "minimaxi.com"),
@@ -5305,6 +1164,18 @@ startup_delay_secs = 2
             ("together_key", "test-key", "together", "together"),
             ("xai_key", "test-key", "xai", "x.ai"),
             ("mistral_key", "test-key", "mistral", "mistral.ai"),
+            (
+                "opencode_zen_key",
+                "test-key",
+                "opencode-zen",
+                "opencode.ai/zen",
+            ),
+            (
+                "opencode_go_key",
+                "test-key",
+                "opencode-go",
+                "opencode.ai/zen/go",
+            ),
             (
                 "ollama_base_url",
                 "http://localhost:11434",
@@ -5339,7 +1210,7 @@ startup_delay_secs = 2
 
     #[test]
     fn all_shorthand_keys_register_providers_via_env() {
-        let _lock = env_test_lock().lock().unwrap();
+        let _lock = env_test_lock().lock();
 
         // (env_var, env_value, provider_name, expected_base_url_substring)
         let cases: &[(&str, &str, &str, &str)] = &[
@@ -5356,6 +1227,7 @@ startup_delay_secs = 2
                 "openrouter",
                 "openrouter.ai",
             ),
+            ("KILO_API_KEY", "test-key", "kilo", "api.kilo.ai"),
             ("DEEPSEEK_API_KEY", "test-key", "deepseek", "deepseek.com"),
             ("MINIMAX_API_KEY", "test-key", "minimax", "minimax.io"),
             ("NVIDIA_API_KEY", "test-key", "nvidia", "nvidia.com"),
@@ -5366,6 +1238,18 @@ startup_delay_secs = 2
             ("TOGETHER_API_KEY", "test-key", "together", "together"),
             ("XAI_API_KEY", "test-key", "xai", "x.ai"),
             ("MISTRAL_API_KEY", "test-key", "mistral", "mistral.ai"),
+            (
+                "OPENCODE_ZEN_API_KEY",
+                "test-key",
+                "opencode-zen",
+                "opencode.ai/zen",
+            ),
+            (
+                "OPENCODE_GO_API_KEY",
+                "test-key",
+                "opencode-go",
+                "opencode.ai/zen/go",
+            ),
             (
                 "OLLAMA_BASE_URL",
                 "http://localhost:11434",
@@ -5398,4 +1282,485 @@ startup_delay_secs = 2
             );
         }
     }
+
+    // --- Named Messaging Adapter Tests ---
+
+    #[test]
+    fn runtime_adapter_key_default() {
+        assert_eq!(binding_runtime_adapter_key("telegram", None), "telegram");
+    }
+
+    #[test]
+    fn runtime_adapter_key_named() {
+        assert_eq!(
+            binding_runtime_adapter_key("telegram", Some("support")),
+            "telegram:support"
+        );
+    }
+
+    #[test]
+    fn runtime_adapter_key_empty_name_is_default() {
+        assert_eq!(binding_runtime_adapter_key("discord", Some("")), "discord");
+    }
+
+    #[test]
+    fn binding_runtime_adapter_key_method() {
+        let binding = Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: Some("sales".into()),
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        };
+        assert_eq!(binding.runtime_adapter_key(), "telegram:sales");
+    }
+
+    #[test]
+    fn binding_uses_default_adapter() {
+        let binding = Binding {
+            agent_id: "main".into(),
+            channel: "discord".into(),
+            adapter: None,
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        };
+        assert!(binding.uses_default_adapter());
+    }
+
+    fn test_inbound_message(source: &str, adapter: Option<&str>) -> crate::InboundMessage {
+        crate::InboundMessage {
+            id: "test".into(),
+            source: source.into(),
+            adapter: adapter.map(String::from),
+            conversation_id: "conv".into(),
+            sender_id: "user1".into(),
+            agent_id: None,
+            content: crate::MessageContent::Text("hello".into()),
+            timestamp: chrono::Utc::now(),
+            metadata: Default::default(),
+            formatted_author: None,
+        }
+    }
+
+    #[test]
+    fn adapter_matches_default_binding_default_message() {
+        let binding = Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: None,
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        };
+        let message = test_inbound_message("telegram", None);
+        assert!(binding_adapter_matches(&binding, &message));
+    }
+
+    #[test]
+    fn adapter_matches_named_binding_named_message() {
+        let binding = Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: Some("support".into()),
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        };
+        let message = test_inbound_message("telegram", Some("telegram:support"));
+        assert!(binding_adapter_matches(&binding, &message));
+    }
+
+    #[test]
+    fn adapter_mismatch_named_vs_default() {
+        let binding = Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: Some("support".into()),
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        };
+        let message = test_inbound_message("telegram", None);
+        assert!(!binding_adapter_matches(&binding, &message));
+    }
+
+    #[test]
+    fn adapter_mismatch_default_vs_named() {
+        let binding = Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: None,
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        };
+        let message = test_inbound_message("telegram", Some("telegram:support"));
+        assert!(!binding_adapter_matches(&binding, &message));
+    }
+
+    #[test]
+    fn adapter_mismatch_different_names() {
+        let binding = Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: Some("support".into()),
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        };
+        let message = test_inbound_message("telegram", Some("telegram:sales"));
+        assert!(!binding_adapter_matches(&binding, &message));
+    }
+
+    #[test]
+    fn validate_named_adapters_valid_config() {
+        let messaging = MessagingConfig {
+            discord: None,
+            slack: None,
+            telegram: Some(TelegramConfig {
+                enabled: true,
+                token: "tok".into(),
+                instances: vec![TelegramInstanceConfig {
+                    name: "support".into(),
+                    enabled: true,
+                    token: "tok2".into(),
+                    dm_allowed_users: vec![],
+                }],
+                dm_allowed_users: vec![],
+            }),
+            email: None,
+            webhook: None,
+            twitch: None,
+        };
+        let bindings = vec![
+            Binding {
+                agent_id: "main".into(),
+                channel: "telegram".into(),
+                adapter: None,
+                guild_id: None,
+                workspace_id: None,
+                chat_id: None,
+                channel_ids: vec![],
+                require_mention: false,
+                dm_allowed_users: vec![],
+            },
+            Binding {
+                agent_id: "support-agent".into(),
+                channel: "telegram".into(),
+                adapter: Some("support".into()),
+                guild_id: None,
+                workspace_id: None,
+                chat_id: None,
+                channel_ids: vec![],
+                require_mention: false,
+                dm_allowed_users: vec![],
+            },
+        ];
+        assert!(validate_named_messaging_adapters(&messaging, &bindings).is_ok());
+    }
+
+    #[test]
+    fn validate_named_adapters_missing_instance() {
+        let messaging = MessagingConfig {
+            discord: None,
+            slack: None,
+            telegram: Some(TelegramConfig {
+                enabled: true,
+                token: "tok".into(),
+                instances: vec![],
+                dm_allowed_users: vec![],
+            }),
+            email: None,
+            webhook: None,
+            twitch: None,
+        };
+        let bindings = vec![Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: Some("nonexistent".into()),
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        }];
+        assert!(validate_named_messaging_adapters(&messaging, &bindings).is_err());
+    }
+
+    #[test]
+    fn validate_named_adapters_duplicate_names_rejected() {
+        let result = validate_instance_names("telegram", ["support", "support"].into_iter());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn validate_named_adapters_empty_name_rejected() {
+        let result = validate_instance_names("telegram", [""].into_iter());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn validate_named_adapters_default_name_rejected() {
+        let result = validate_instance_names("telegram", ["default"].into_iter());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn validate_adapter_on_unsupported_platform_rejected() {
+        let messaging = MessagingConfig {
+            discord: None,
+            slack: None,
+            telegram: None,
+            email: Some(EmailConfig {
+                enabled: true,
+                imap_host: "imap.test.com".into(),
+                imap_port: 993,
+                imap_username: "user".into(),
+                imap_password: "pass".into(),
+                imap_use_tls: true,
+                smtp_host: "smtp.test.com".into(),
+                smtp_port: 587,
+                smtp_username: "user".into(),
+                smtp_password: "pass".into(),
+                smtp_use_starttls: true,
+                from_address: "bot@test.com".into(),
+                from_name: None,
+                poll_interval_secs: 60,
+                folders: vec![],
+                allowed_senders: vec![],
+                max_body_bytes: 1_000_000,
+                max_attachment_bytes: 10_000_000,
+                instances: vec![],
+            }),
+            webhook: None,
+            twitch: None,
+        };
+        let bindings = vec![Binding {
+            agent_id: "main".into(),
+            channel: "email".into(),
+            adapter: Some("named".into()),
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        }];
+        assert!(validate_named_messaging_adapters(&messaging, &bindings).is_err());
+    }
+
+    #[test]
+    fn validate_binding_without_default_adapter_rejected() {
+        let messaging = MessagingConfig {
+            discord: None,
+            slack: None,
+            telegram: Some(TelegramConfig {
+                enabled: true,
+                token: "".into(), // no default credential
+                instances: vec![TelegramInstanceConfig {
+                    name: "support".into(),
+                    enabled: true,
+                    token: "tok".into(),
+                    dm_allowed_users: vec![],
+                }],
+                dm_allowed_users: vec![],
+            }),
+            email: None,
+            webhook: None,
+            twitch: None,
+        };
+        // Binding targets default adapter, but no default credentials exist
+        let bindings = vec![Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: None,
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        }];
+        assert!(validate_named_messaging_adapters(&messaging, &bindings).is_err());
+    }
+
+    #[test]
+    fn inbound_message_adapter_selector_default() {
+        let message = test_inbound_message("telegram", None);
+        assert_eq!(message.adapter_selector(), None);
+    }
+
+    #[test]
+    fn inbound_message_adapter_selector_named() {
+        let message = test_inbound_message("telegram", Some("telegram:support"));
+        assert_eq!(message.adapter_selector(), Some("support"));
+    }
+
+    #[test]
+    fn inbound_message_adapter_key_default() {
+        let message = test_inbound_message("telegram", None);
+        assert_eq!(message.adapter_key(), "telegram");
+    }
+
+    #[test]
+    fn inbound_message_adapter_key_named() {
+        let message = test_inbound_message("telegram", Some("telegram:support"));
+        assert_eq!(message.adapter_key(), "telegram:support");
+    }
+
+    #[test]
+    fn toml_round_trip_with_named_instances() {
+        let _guard = env_test_lock().lock();
+        let guard = EnvGuard::new();
+
+        let toml_content = r#"
+[messaging.telegram]
+enabled = true
+token = "default-token"
+
+[[messaging.telegram.instances]]
+name = "support"
+enabled = true
+token = "support-token"
+
+[[bindings]]
+agent_id = "main"
+channel = "telegram"
+
+[[bindings]]
+agent_id = "support-bot"
+channel = "telegram"
+adapter = "support"
+chat_id = "-100111"
+"#;
+        let config_path = guard.test_dir.join("config.toml");
+        std::fs::write(&config_path, toml_content).unwrap();
+
+        let config = Config::load_from_path(&config_path).unwrap();
+        let telegram = config.messaging.telegram.as_ref().unwrap();
+        assert_eq!(telegram.token, "default-token");
+        assert_eq!(telegram.instances.len(), 1);
+        assert_eq!(telegram.instances[0].name, "support");
+        assert_eq!(telegram.instances[0].token, "support-token");
+
+        assert_eq!(config.bindings.len(), 2);
+        assert!(config.bindings[0].adapter.is_none());
+        assert_eq!(config.bindings[1].adapter.as_deref(), Some("support"));
+        assert_eq!(config.bindings[1].chat_id.as_deref(), Some("-100111"));
+    }
+
+    #[test]
+    fn toml_backward_compat_no_adapter_field() {
+        let _guard = env_test_lock().lock();
+        let guard = EnvGuard::new();
+
+        let toml_content = r#"
+[messaging.discord]
+enabled = true
+token = "my-discord-token"
+
+[[bindings]]
+agent_id = "main"
+channel = "discord"
+guild_id = "123456"
+"#;
+        let config_path = guard.test_dir.join("config.toml");
+        std::fs::write(&config_path, toml_content).unwrap();
+
+        let config = Config::load_from_path(&config_path).unwrap();
+        assert!(config.bindings[0].adapter.is_none());
+        assert_eq!(config.bindings[0].guild_id.as_deref(), Some("123456"));
+    }
+
+    #[test]
+    fn normalize_adapter_trims_and_clears_empty() {
+        assert_eq!(normalize_adapter(None), None);
+        assert_eq!(normalize_adapter(Some("".into())), None);
+        assert_eq!(normalize_adapter(Some("   ".into())), None);
+        assert_eq!(
+            normalize_adapter(Some(" support ".into())),
+            Some("support".into())
+        );
+        assert_eq!(normalize_adapter(Some("ops".into())), Some("ops".into()));
+    }
+
+    #[test]
+    fn warn_unknown_config_keys_no_panic() {
+        // Smoke test: the function should not panic for any input shape.
+        // Actual warning output goes through tracing (not asserted here).
+        let toml_with_mcp_servers = r#"
+[[mcp_servers]]
+name = "test"
+transport = "stdio"
+command = "/usr/bin/test"
+"#;
+        warn_unknown_config_keys(toml_with_mcp_servers);
+
+        // Top-level `mcp` should also be caught
+        let toml_with_mcp = r#"
+[[mcp]]
+name = "test"
+transport = "stdio"
+command = "/usr/bin/test"
+"#;
+        warn_unknown_config_keys(toml_with_mcp);
+
+        // Generic unknown key
+        let toml_with_unknown = r#"
+[foobar]
+something = true
+"#;
+        warn_unknown_config_keys(toml_with_unknown);
+
+        // Valid keys should not warn
+        let toml_valid = r#"
+[llm]
+[defaults]
+[messaging]
+[api]
+"#;
+        warn_unknown_config_keys(toml_valid);
+    }
+
+    #[test]
+    fn top_level_mcp_servers_silently_ignored_by_serde() {
+        // Demonstrates the root cause of issue #221: serde drops unknown fields.
+        // `[[mcp_servers]]` at the top level deserializes fine but the data is lost.
+        let toml = r#"
+[[agents]]
+id = "test-agent"
+
+[[mcp_servers]]
+name = "my-server"
+transport = "stdio"
+command = "/usr/bin/test"
+"#;
+        let parsed: TomlConfig = toml::from_str(toml).expect("should parse without error");
+        // The mcp_servers data is silently dropped — verify it's not accessible
+        assert!(parsed.defaults.mcp.is_empty());
+    }
 }
diff --git a/src/config/load.rs b/src/config/load.rs
new file mode 100644
index 000000000..f78657ecb
--- /dev/null
+++ b/src/config/load.rs
@@ -0,0 +1,2152 @@
+use super::providers::{
+    ANTHROPIC_PROVIDER_BASE_URL, DEEPSEEK_PROVIDER_BASE_URL, FIREWORKS_PROVIDER_BASE_URL,
+    GEMINI_PROVIDER_BASE_URL, GROQ_PROVIDER_BASE_URL, KILO_PROVIDER_BASE_URL,
+    MINIMAX_CN_PROVIDER_BASE_URL, MINIMAX_PROVIDER_BASE_URL, MISTRAL_PROVIDER_BASE_URL,
+    MOONSHOT_PROVIDER_BASE_URL, NVIDIA_PROVIDER_BASE_URL, OLLAMA_PROVIDER_BASE_URL,
+    OPENAI_PROVIDER_BASE_URL, OPENCODE_GO_PROVIDER_BASE_URL, OPENCODE_ZEN_PROVIDER_BASE_URL,
+    OPENROUTER_PROVIDER_BASE_URL, TOGETHER_PROVIDER_BASE_URL, XAI_PROVIDER_BASE_URL,
+    ZAI_CODING_PLAN_BASE_URL, ZHIPU_PROVIDER_BASE_URL, add_shorthand_provider,
+    infer_routing_from_providers, openrouter_extra_headers, resolve_routing,
+};
+use super::toml_schema::*;
+use super::{
+    AgentConfig, ApiConfig, ApiType, Binding, BrowserConfig, ChannelConfig, ClosePolicy,
+    CoalesceConfig, CompactionConfig, Config, CortexConfig, CronDef, DefaultsConfig, DiscordConfig,
+    DiscordInstanceConfig, EmailConfig, EmailInstanceConfig, GroupDef, HumanDef, IngestionConfig,
+    LinkDef, LlmConfig, McpServerConfig, McpTransport, MemoryPersistenceConfig, MessagingConfig,
+    MetricsConfig, OpenCodeConfig, ProviderConfig, SlackCommandConfig, SlackConfig,
+    SlackInstanceConfig, TelegramConfig, TelegramInstanceConfig, TelemetryConfig, TwitchConfig,
+    TwitchInstanceConfig, WarmupConfig, WebhookConfig, normalize_adapter,
+    validate_named_messaging_adapters,
+};
+use crate::error::{ConfigError, Result};
+
+use anyhow::Context as _;
+
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+
+/// Resolve a value that might be an "env:VAR_NAME" or "secret:NAME" reference.
+///
+/// Three resolution modes:
+/// - `secret:NAME` — look up from the secrets store (if available).
+/// - `env:VAR_NAME` — read from system environment variable.
+/// - Anything else — literal value.
+pub(super) fn resolve_env_value(value: &str) -> Option<String> {
+    if let Some(alias) = value.strip_prefix("secret:") {
+        let guard = RESOLVE_SECRETS_STORE.load();
+        match (*guard).as_ref() {
+            Some(store) => match store.get(alias) {
+                Ok(secret) => Some(secret.expose().to_string()),
+                Err(error) => {
+                    tracing::warn!(%error, alias, "failed to resolve secret: reference");
+                    None
+                }
+            },
+            None => None,
+        }
+    } else if let Some(var_name) = value.strip_prefix("env:") {
+        std::env::var(var_name).ok()
+    } else {
+        Some(value.to_string())
+    }
+}
+
+/// Process-wide reference to the secrets store for use during config resolution.
+///
+/// Uses `ArcSwap` so it is accessible from any thread (file watcher, API
+/// handlers, tokio workers) without the thread-affinity issues of a thread-local.
+static RESOLVE_SECRETS_STORE: std::sync::LazyLock<
+    arc_swap::ArcSwap<Option<std::sync::Arc<crate::secrets::store::SecretsStore>>>,
+> = std::sync::LazyLock::new(|| arc_swap::ArcSwap::from_pointee(None));
+
+/// Set the secrets store for config resolution (process-wide, any thread).
+pub fn set_resolve_secrets_store(store: std::sync::Arc<crate::secrets::store::SecretsStore>) {
+    RESOLVE_SECRETS_STORE.store(std::sync::Arc::new(Some(store)));
+}
+
+/// Known top-level keys in config.toml (must match `TomlConfig` field names).
+const KNOWN_TOP_LEVEL_KEYS: &[&str] = &[
+    "llm",
+    "defaults",
+    "agents",
+    "links",
+    "groups",
+    "humans",
+    "messaging",
+    "bindings",
+    "api",
+    "metrics",
+    "telemetry",
+];
+
+/// Pre-parse check that warns about unrecognised top-level keys in a config
+/// file.  Serde's default behaviour silently drops unknown fields, which leads
+/// to confusing "my setting does nothing" bugs (see issue #221).
+pub(super) fn warn_unknown_config_keys(content: &str) {
+    let table: toml::Table = match content.parse() {
+        Ok(t) => t,
+        Err(_) => return, // the typed parse will report the real error
+    };
+
+    for key in table.keys() {
+        if KNOWN_TOP_LEVEL_KEYS.contains(&key.as_str()) {
+            continue;
+        }
+
+        if key == "mcp_servers" || key == "mcp" {
+            tracing::warn!(
+                "config.toml contains top-level key `{key}` which is not recognised \
+                 and will be ignored. MCP servers should be defined under [defaults] \
+                 as [[defaults.mcp]] (or per-agent under [[agents.mcp]]). \
+                 See docs/design-docs/mcp.md for the correct format."
+            );
+        } else {
+            tracing::warn!(
+                "config.toml contains unknown top-level key `{key}` — \
+                 it will be silently ignored by the parser. Check for typos \
+                 or consult the configuration reference."
+            );
+        }
+    }
+}
+
+fn parse_close_policy(value: Option<&str>) -> Option<ClosePolicy> {
+    match value? {
+        "close_browser" => Some(ClosePolicy::CloseBrowser),
+        "close_tabs" => Some(ClosePolicy::CloseTabs),
+        "detach" => Some(ClosePolicy::Detach),
+        other => {
+            tracing::warn!(
+                value = other,
+                "unknown close_policy value, expected one of: close_browser, close_tabs, detach"
+            );
+            None
+        }
+    }
+}
+
+impl CortexConfig {
+    fn resolve(overrides: TomlCortexConfig, defaults: CortexConfig) -> CortexConfig {
+        CortexConfig {
+            tick_interval_secs: overrides
+                .tick_interval_secs
+                .unwrap_or(defaults.tick_interval_secs),
+            worker_timeout_secs: overrides
+                .worker_timeout_secs
+                .unwrap_or(defaults.worker_timeout_secs),
+            branch_timeout_secs: overrides
+                .branch_timeout_secs
+                .unwrap_or(defaults.branch_timeout_secs),
+            detached_worker_timeout_retry_limit: overrides
+                .detached_worker_timeout_retry_limit
+                .unwrap_or(defaults.detached_worker_timeout_retry_limit),
+            supervisor_kill_budget_per_tick: overrides
+                .supervisor_kill_budget_per_tick
+                .unwrap_or(defaults.supervisor_kill_budget_per_tick),
+            circuit_breaker_threshold: overrides
+                .circuit_breaker_threshold
+                .unwrap_or(defaults.circuit_breaker_threshold),
+            bulletin_interval_secs: overrides
+                .bulletin_interval_secs
+                .unwrap_or(defaults.bulletin_interval_secs),
+            bulletin_max_words: overrides
+                .bulletin_max_words
+                .unwrap_or(defaults.bulletin_max_words),
+            bulletin_max_turns: overrides
+                .bulletin_max_turns
+                .unwrap_or(defaults.bulletin_max_turns),
+            association_interval_secs: overrides
+                .association_interval_secs
+                .unwrap_or(defaults.association_interval_secs),
+            association_similarity_threshold: overrides
+                .association_similarity_threshold
+                .unwrap_or(defaults.association_similarity_threshold),
+            association_updates_threshold: overrides
+                .association_updates_threshold
+                .unwrap_or(defaults.association_updates_threshold),
+            association_max_per_pass: overrides
+                .association_max_per_pass
+                .unwrap_or(defaults.association_max_per_pass),
+        }
+    }
+}
+
+fn parse_otlp_headers(value: Option<String>) -> Result<HashMap<String, String>> {
+    let Some(raw) = value else {
+        return Ok(HashMap::new());
+    };
+
+    let raw = raw.trim();
+    if raw.is_empty() {
+        return Ok(HashMap::new());
+    }
+
+    let mut headers = HashMap::new();
+    for entry in raw.split(',') {
+        let entry = entry.trim();
+        if entry.is_empty() {
+            continue;
+        }
+        let Some((key, value)) = entry.split_once('=') else {
+            return Err(ConfigError::Invalid(format!(
+                "invalid OTEL_EXPORTER_OTLP_HEADERS entry '{entry}', expected key=value"
+            )))?;
+        };
+        let key = key.trim();
+        let value = value.trim();
+        if key.is_empty() {
+            Err(ConfigError::Invalid(
+                "invalid OTEL_EXPORTER_OTLP_HEADERS entry: empty header name".into(),
+            ))?;
+        }
+        headers.insert(key.to_string(), value.to_string());
+    }
+
+    Ok(headers)
+}
+
+fn parse_mcp_server_config(raw: TomlMcpServerConfig) -> Result<McpServerConfig> {
+    if raw.name.trim().is_empty() {
+        return Err(ConfigError::Invalid("mcp server name cannot be empty".into()).into());
+    }
+
+    let transport = match raw.transport.as_str() {
+        "stdio" => {
+            let command = raw.command.ok_or_else(|| {
+                ConfigError::Invalid(format!(
+                    "mcp server '{}' with stdio transport requires 'command'",
+                    raw.name
+                ))
+            })?;
+            McpTransport::Stdio {
+                command,
+                args: raw.args,
+                env: raw.env,
+            }
+        }
+        "http" => {
+            let url = raw.url.ok_or_else(|| {
+                ConfigError::Invalid(format!(
+                    "mcp server '{}' with http transport requires 'url'",
+                    raw.name
+                ))
+            })?;
+            McpTransport::Http {
+                url,
+                headers: raw.headers,
+            }
+        }
+        other => {
+            return Err(ConfigError::Invalid(format!(
+                "mcp server '{}' has invalid transport '{}', expected 'stdio' or 'http'",
+                raw.name, other
+            ))
+            .into());
+        }
+    };
+
+    Ok(McpServerConfig {
+        name: raw.name,
+        transport,
+        enabled: raw.enabled,
+    })
+}
+
+impl Config {
+    /// Resolve the instance directory from env or default (~/.spacebot).
+    pub fn default_instance_dir() -> PathBuf {
+        std::env::var("SPACEBOT_DIR")
+            .map(PathBuf::from)
+            .unwrap_or_else(|_| {
+                dirs::home_dir()
+                    .map(|d| d.join(".spacebot"))
+                    .unwrap_or_else(|| PathBuf::from("./.spacebot"))
+            })
+    }
+
+    /// Check whether a first-run onboarding is needed (no config file and no env keys/providers).
+    pub fn needs_onboarding() -> bool {
+        let instance_dir = Self::default_instance_dir();
+        let config_path = instance_dir.join("config.toml");
+        if config_path.exists() {
+            return false;
+        }
+
+        // OAuth credentials count as configured
+        if crate::auth::credentials_path(&instance_dir).exists()
+            || crate::openai_auth::credentials_path(&instance_dir).exists()
+        {
+            return false;
+        }
+
+        // Check if we have any legacy env keys configured
+        let has_legacy_keys = std::env::var("ANTHROPIC_API_KEY").is_ok()
+            || std::env::var("OPENAI_API_KEY").is_ok()
+            || std::env::var("OPENROUTER_API_KEY").is_ok()
+            || std::env::var("KILO_API_KEY").is_ok()
+            || std::env::var("ZHIPU_API_KEY").is_ok()
+            || std::env::var("GROQ_API_KEY").is_ok()
+            || std::env::var("TOGETHER_API_KEY").is_ok()
+            || std::env::var("FIREWORKS_API_KEY").is_ok()
+            || std::env::var("DEEPSEEK_API_KEY").is_ok()
+            || std::env::var("XAI_API_KEY").is_ok()
+            || std::env::var("MISTRAL_API_KEY").is_ok()
+            || std::env::var("NVIDIA_API_KEY").is_ok()
+            || std::env::var("OLLAMA_API_KEY").is_ok()
+            || std::env::var("OLLAMA_BASE_URL").is_ok()
+            || std::env::var("OPENCODE_ZEN_API_KEY").is_ok()
+            || std::env::var("OPENCODE_GO_API_KEY").is_ok()
+            || std::env::var("MINIMAX_API_KEY").is_ok()
+            || std::env::var("MINIMAX_CN_API_KEY").is_ok()
+            || std::env::var("MOONSHOT_API_KEY").is_ok()
+            || std::env::var("ZAI_CODING_PLAN_API_KEY").is_ok();
+
+        // If we have any legacy keys, no onboarding needed
+        if has_legacy_keys {
+            return false;
+        }
+
+        // Check if we have any provider-specific env variables (provider.<name>.*)
+        let has_provider_env_vars = std::env::vars().any(|(key, _)| {
+            key.starts_with("SPACEBOT_PROVIDER_")
+                || key.starts_with("PROVIDER_")
+                || key.contains("PROVIDER") && key.contains("API_KEY")
+        });
+
+        // Also check for specific legacy env vars that can bootstrap
+        let has_legacy_bootstrap_vars = std::env::var("ANTHROPIC_API_KEY").is_ok()
+            || std::env::var("ANTHROPIC_OAUTH_TOKEN").is_ok()
+            || std::env::var("OPENAI_API_KEY").is_ok()
+            || std::env::var("OPENROUTER_API_KEY").is_ok()
+            || std::env::var("KILO_API_KEY").is_ok()
+            || std::env::var("OPENCODE_ZEN_API_KEY").is_ok()
+            || std::env::var("OPENCODE_GO_API_KEY").is_ok()
+            || std::env::var("MINIMAX_CN_API_KEY").is_ok();
+
+        !has_provider_env_vars && !has_legacy_bootstrap_vars
+    }
+
+    /// Load configuration from the default config file, falling back to env vars.
+    pub fn load() -> Result<Self> {
+        let instance_dir = Self::default_instance_dir();
+
+        Self::load_for_instance(&instance_dir)
+    }
+
+    /// Load configuration for a specific instance directory.
+    pub fn load_for_instance(instance_dir: &Path) -> Result<Self> {
+        let config_path = instance_dir.join("config.toml");
+
+        if config_path.exists() {
+            Self::load_from_path(&config_path)
+        } else {
+            Self::load_from_env(instance_dir)
+        }
+    }
+
+    /// Load from a specific TOML config file.
+    pub fn load_from_path(path: &Path) -> Result<Self> {
+        let instance_dir = path
+            .parent()
+            .map(|p| p.to_path_buf())
+            .unwrap_or_else(|| PathBuf::from("."));
+
+        let content = std::fs::read_to_string(path)
+            .with_context(|| format!("failed to read config from {}", path.display()))?;
+
+        warn_unknown_config_keys(&content);
+
+        let toml_config: TomlConfig = toml::from_str(&content)
+            .with_context(|| format!("failed to parse config from {}", path.display()))?;
+
+        Self::from_toml(toml_config, instance_dir)
+    }
+
+    /// Load from environment variables only (no config file).
+    pub fn load_from_env(instance_dir: &Path) -> Result<Self> {
+        let anthropic_from_auth_token = std::env::var("ANTHROPIC_API_KEY").is_err()
+            && std::env::var("ANTHROPIC_AUTH_TOKEN").is_ok();
+        let mut llm = LlmConfig {
+            anthropic_key: std::env::var("ANTHROPIC_API_KEY")
+                .ok()
+                .or_else(|| std::env::var("ANTHROPIC_AUTH_TOKEN").ok()),
+            openai_key: std::env::var("OPENAI_API_KEY").ok(),
+            openrouter_key: std::env::var("OPENROUTER_API_KEY").ok(),
+            kilo_key: std::env::var("KILO_API_KEY").ok(),
+            zhipu_key: std::env::var("ZHIPU_API_KEY").ok(),
+            groq_key: std::env::var("GROQ_API_KEY").ok(),
+            together_key: std::env::var("TOGETHER_API_KEY").ok(),
+            fireworks_key: std::env::var("FIREWORKS_API_KEY").ok(),
+            deepseek_key: std::env::var("DEEPSEEK_API_KEY").ok(),
+            xai_key: std::env::var("XAI_API_KEY").ok(),
+            mistral_key: std::env::var("MISTRAL_API_KEY").ok(),
+            gemini_key: std::env::var("GEMINI_API_KEY").ok(),
+            ollama_key: std::env::var("OLLAMA_API_KEY").ok(),
+            ollama_base_url: std::env::var("OLLAMA_BASE_URL").ok(),
+            opencode_zen_key: std::env::var("OPENCODE_ZEN_API_KEY").ok(),
+            opencode_go_key: std::env::var("OPENCODE_GO_API_KEY").ok(),
+            nvidia_key: std::env::var("NVIDIA_API_KEY").ok(),
+            minimax_key: std::env::var("MINIMAX_API_KEY").ok(),
+            minimax_cn_key: std::env::var("MINIMAX_CN_API_KEY").ok(),
+            moonshot_key: std::env::var("MOONSHOT_API_KEY").ok(),
+            zai_coding_plan_key: std::env::var("ZAI_CODING_PLAN_API_KEY").ok(),
+            providers: HashMap::new(),
+        };
+
+        // Populate providers from env vars (same as from_toml does)
+        if let Some(anthropic_key) = llm.anthropic_key.clone() {
+            let base_url = std::env::var("ANTHROPIC_BASE_URL")
+                .unwrap_or_else(|_| ANTHROPIC_PROVIDER_BASE_URL.to_string());
+            llm.providers
+                .entry("anthropic".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::Anthropic,
+                    base_url,
+                    api_key: anthropic_key,
+                    name: None,
+                    use_bearer_auth: anthropic_from_auth_token,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(openrouter_key) = llm.openrouter_key.clone() {
+            llm.providers
+                .entry("openrouter".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: OPENROUTER_PROVIDER_BASE_URL.to_string(),
+                    api_key: openrouter_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: openrouter_extra_headers(),
+                });
+        }
+
+        add_shorthand_provider(
+            &mut llm.providers,
+            "kilo",
+            llm.kilo_key.clone(),
+            ApiType::KiloGateway,
+            KILO_PROVIDER_BASE_URL,
+            Some("Kilo Gateway"),
+            false,
+        );
+        add_shorthand_provider(
+            &mut llm.providers,
+            "zhipu",
+            llm.zhipu_key.clone(),
+            ApiType::OpenAiChatCompletions,
+            ZHIPU_PROVIDER_BASE_URL,
+            Some("Z.AI (GLM)"),
+            false,
+        );
+        add_shorthand_provider(
+            &mut llm.providers,
+            "zai-coding-plan",
+            llm.zai_coding_plan_key.clone(),
+            ApiType::OpenAiChatCompletions,
+            ZAI_CODING_PLAN_BASE_URL,
+            Some("Z.AI Coding Plan"),
+            false,
+        );
+
+        add_shorthand_provider(
+            &mut llm.providers,
+            "opencode-zen",
+            llm.opencode_zen_key.clone(),
+            ApiType::OpenAiCompletions,
+            OPENCODE_ZEN_PROVIDER_BASE_URL,
+            None,
+            false,
+        );
+
+        add_shorthand_provider(
+            &mut llm.providers,
+            "opencode-go",
+            llm.opencode_go_key.clone(),
+            ApiType::OpenAiCompletions,
+            OPENCODE_GO_PROVIDER_BASE_URL,
+            None,
+            false,
+        );
+
+        if let Some(minimax_key) = llm.minimax_key.clone() {
+            llm.providers
+                .entry("minimax".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::Anthropic,
+                    base_url: MINIMAX_PROVIDER_BASE_URL.to_string(),
+                    api_key: minimax_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(minimax_cn_key) = llm.minimax_cn_key.clone() {
+            llm.providers
+                .entry("minimax-cn".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::Anthropic,
+                    base_url: MINIMAX_CN_PROVIDER_BASE_URL.to_string(),
+                    api_key: minimax_cn_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(openai_key) = llm.openai_key.clone() {
+            llm.providers
+                .entry("openai".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: OPENAI_PROVIDER_BASE_URL.to_string(),
+                    api_key: openai_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(openrouter_key) = llm.openrouter_key.clone() {
+            llm.providers
+                .entry("openrouter".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: OPENROUTER_PROVIDER_BASE_URL.to_string(),
+                    api_key: openrouter_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: openrouter_extra_headers(),
+                });
+        }
+
+        add_shorthand_provider(
+            &mut llm.providers,
+            "kilo",
+            llm.kilo_key.clone(),
+            ApiType::KiloGateway,
+            KILO_PROVIDER_BASE_URL,
+            Some("Kilo Gateway"),
+            false,
+        );
+        add_shorthand_provider(
+            &mut llm.providers,
+            "zhipu",
+            llm.zhipu_key.clone(),
+            ApiType::OpenAiChatCompletions,
+            ZHIPU_PROVIDER_BASE_URL,
+            Some("Z.AI (GLM)"),
+            false,
+        );
+        add_shorthand_provider(
+            &mut llm.providers,
+            "zai-coding-plan",
+            llm.zai_coding_plan_key.clone(),
+            ApiType::OpenAiChatCompletions,
+            ZAI_CODING_PLAN_BASE_URL,
+            Some("Z.AI Coding Plan"),
+            false,
+        );
+
+        if let Some(opencode_zen_key) = llm.opencode_zen_key.clone() {
+            llm.providers
+                .entry("opencode-zen".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: OPENCODE_ZEN_PROVIDER_BASE_URL.to_string(),
+                    api_key: opencode_zen_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(opencode_go_key) = llm.opencode_go_key.clone() {
+            llm.providers
+                .entry("opencode-go".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: OPENCODE_GO_PROVIDER_BASE_URL.to_string(),
+                    api_key: opencode_go_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(minimax_key) = llm.minimax_key.clone() {
+            llm.providers
+                .entry("minimax".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::Anthropic,
+                    base_url: MINIMAX_PROVIDER_BASE_URL.to_string(),
+                    api_key: minimax_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(minimax_cn_key) = llm.minimax_cn_key.clone() {
+            llm.providers
+                .entry("minimax-cn".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::Anthropic,
+                    base_url: MINIMAX_CN_PROVIDER_BASE_URL.to_string(),
+                    api_key: minimax_cn_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(moonshot_key) = llm.moonshot_key.clone() {
+            llm.providers
+                .entry("moonshot".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: MOONSHOT_PROVIDER_BASE_URL.to_string(),
+                    api_key: moonshot_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(nvidia_key) = llm.nvidia_key.clone() {
+            llm.providers
+                .entry("nvidia".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: NVIDIA_PROVIDER_BASE_URL.to_string(),
+                    api_key: nvidia_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(fireworks_key) = llm.fireworks_key.clone() {
+            llm.providers
+                .entry("fireworks".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: FIREWORKS_PROVIDER_BASE_URL.to_string(),
+                    api_key: fireworks_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(deepseek_key) = llm.deepseek_key.clone() {
+            llm.providers
+                .entry("deepseek".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: DEEPSEEK_PROVIDER_BASE_URL.to_string(),
+                    api_key: deepseek_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(gemini_key) = llm.gemini_key.clone() {
+            llm.providers
+                .entry("gemini".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::Gemini,
+                    base_url: GEMINI_PROVIDER_BASE_URL.to_string(),
+                    api_key: gemini_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(groq_key) = llm.groq_key.clone() {
+            llm.providers
+                .entry("groq".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: GROQ_PROVIDER_BASE_URL.to_string(),
+                    api_key: groq_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(together_key) = llm.together_key.clone() {
+            llm.providers
+                .entry("together".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: TOGETHER_PROVIDER_BASE_URL.to_string(),
+                    api_key: together_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(xai_key) = llm.xai_key.clone() {
+            llm.providers
+                .entry("xai".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: XAI_PROVIDER_BASE_URL.to_string(),
+                    api_key: xai_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(mistral_key) = llm.mistral_key.clone() {
+            llm.providers
+                .entry("mistral".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: MISTRAL_PROVIDER_BASE_URL.to_string(),
+                    api_key: mistral_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if llm.ollama_base_url.is_some() || llm.ollama_key.is_some() {
+            llm.providers
+                .entry("ollama".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: llm
+                        .ollama_base_url
+                        .clone()
+                        .unwrap_or_else(|| OLLAMA_PROVIDER_BASE_URL.to_string()),
+                    api_key: llm.ollama_key.clone().unwrap_or_default(),
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        // Note: We allow boot without provider keys now. System starts in setup mode.
+        // Agents are initialized later when keys are added via API.
+
+        // Env-only routing: infer from configured providers, then apply env
+        // overrides.  This way users who only set OPENROUTER_API_KEY get
+        // openrouter/* routing instead of the hardcoded anthropic/* default.
+        let mut routing = infer_routing_from_providers(&llm.providers).unwrap_or_default();
+        if let Ok(model) = std::env::var("SPACEBOT_MODEL") {
+            routing.channel = model.clone();
+            routing.branch = model.clone();
+            routing.worker = model.clone();
+            routing.compactor = model.clone();
+            routing.cortex = model;
+        }
+        if let Ok(anthropic_model) = std::env::var("ANTHROPIC_MODEL") {
+            // ANTHROPIC_MODEL sets all anthropic/* routes to the specified model
+            let channel = format!("anthropic/{}", anthropic_model);
+            let branch = format!("anthropic/{}", anthropic_model);
+            let worker = format!("anthropic/{}", anthropic_model);
+            let compactor = format!("anthropic/{}", anthropic_model);
+            let cortex = format!("anthropic/{}", anthropic_model);
+            routing.channel = channel;
+            routing.branch = branch;
+            routing.worker = worker;
+            routing.compactor = compactor;
+            routing.cortex = cortex;
+        }
+        if let Ok(channel_model) = std::env::var("SPACEBOT_CHANNEL_MODEL") {
+            routing.channel = channel_model;
+        }
+        if let Ok(worker_model) = std::env::var("SPACEBOT_WORKER_MODEL") {
+            routing.worker = worker_model;
+        }
+        if let Ok(voice_model) = std::env::var("SPACEBOT_VOICE_MODEL") {
+            routing.voice = voice_model;
+        }
+
+        let agents = vec![AgentConfig {
+            id: "main".into(),
+            default: true,
+            display_name: None,
+            role: None,
+            workspace: None,
+            routing: Some(routing),
+            max_concurrent_branches: None,
+            max_concurrent_workers: None,
+            max_turns: None,
+            branch_max_turns: None,
+            context_window: None,
+            compaction: None,
+            memory_persistence: None,
+            coalesce: None,
+            ingestion: None,
+            cortex: None,
+            warmup: None,
+            browser: None,
+            channel: None,
+            mcp: None,
+            brave_search_key: None,
+            cron_timezone: None,
+            user_timezone: None,
+            sandbox: None,
+            cron: Vec::new(),
+        }];
+
+        let mut api = ApiConfig::default();
+        api.bind = hosted_api_bind(api.bind);
+
+        let mut defaults = DefaultsConfig::default();
+        defaults.browser.chrome_cache_dir = instance_dir.join("chrome_cache");
+
+        Ok(Self {
+            instance_dir: instance_dir.to_path_buf(),
+            llm,
+            defaults,
+            agents,
+            links: Vec::new(),
+            groups: Vec::new(),
+            humans: vec![HumanDef {
+                id: "admin".into(),
+                display_name: None,
+                role: None,
+                bio: None,
+            }],
+            messaging: MessagingConfig::default(),
+            bindings: Vec::new(),
+            api,
+            metrics: MetricsConfig::default(),
+            telemetry: TelemetryConfig {
+                otlp_endpoint: std::env::var("OTEL_EXPORTER_OTLP_ENDPOINT").ok(),
+                otlp_headers: parse_otlp_headers(std::env::var("OTEL_EXPORTER_OTLP_HEADERS").ok())?,
+                service_name: std::env::var("OTEL_SERVICE_NAME")
+                    .unwrap_or_else(|_| "spacebot".into()),
+                sample_rate: 1.0,
+            },
+        })
+    }
+
+    /// Validate a raw TOML string as a valid Spacebot config.
+    /// Returns Ok(()) if the config is structurally valid, or an error describing what's wrong.
+    pub fn validate_toml(content: &str) -> Result<()> {
+        warn_unknown_config_keys(content);
+
+        let toml_config: TomlConfig =
+            toml::from_str(content).context("failed to parse config TOML")?;
+        // Run full conversion to catch semantic errors (env resolution, defaults, etc.)
+        let instance_dir = Self::default_instance_dir();
+        Self::from_toml(toml_config, instance_dir)?;
+        Ok(())
+    }
+
+    pub(super) fn from_toml(toml: TomlConfig, instance_dir: PathBuf) -> Result<Self> {
+        // Validate providers before processing
+        for (provider_id, config) in &toml.llm.providers {
+            // Validate provider_id
+            if provider_id.is_empty() || provider_id.len() > 64 {
+                return Err(ConfigError::Invalid(format!(
+                    "Provider ID '{}' must be between 1 and 64 characters long",
+                    provider_id
+                ))
+                .into());
+            }
+            if provider_id.contains('/') || provider_id.contains(char::is_whitespace) {
+                return Err(ConfigError::Invalid(format!(
+                    "Provider ID '{}' contains invalid characters (cannot contain '/' or whitespace)",
+                    provider_id
+                ))
+                .into());
+            }
+
+            // Validate base_url
+            if let Err(e) = reqwest::Url::parse(&config.base_url) {
+                return Err(ConfigError::Invalid(format!(
+                    "Invalid base URL '{}' for provider '{}': {}",
+                    config.base_url, provider_id, e
+                ))
+                .into());
+            }
+        }
+
+        let toml_llm_anthropic_key_was_none = toml
+            .llm
+            .anthropic_key
+            .as_deref()
+            .and_then(resolve_env_value)
+            .is_none();
+
+        let mut llm = LlmConfig {
+            anthropic_key: toml
+                .llm
+                .anthropic_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("ANTHROPIC_API_KEY").ok())
+                .or_else(|| std::env::var("ANTHROPIC_AUTH_TOKEN").ok()),
+            openai_key: toml
+                .llm
+                .openai_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("OPENAI_API_KEY").ok()),
+            openrouter_key: toml
+                .llm
+                .openrouter_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("OPENROUTER_API_KEY").ok()),
+            kilo_key: std::env::var("KILO_API_KEY")
+                .ok()
+                .or_else(|| toml.llm.kilo_key.as_deref().and_then(resolve_env_value)),
+            zhipu_key: toml
+                .llm
+                .zhipu_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("ZHIPU_API_KEY").ok()),
+            groq_key: toml
+                .llm
+                .groq_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("GROQ_API_KEY").ok()),
+            together_key: toml
+                .llm
+                .together_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("TOGETHER_API_KEY").ok()),
+            fireworks_key: toml
+                .llm
+                .fireworks_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("FIREWORKS_API_KEY").ok()),
+            deepseek_key: toml
+                .llm
+                .deepseek_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("DEEPSEEK_API_KEY").ok()),
+            xai_key: toml
+                .llm
+                .xai_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("XAI_API_KEY").ok()),
+            mistral_key: toml
+                .llm
+                .mistral_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("MISTRAL_API_KEY").ok()),
+            gemini_key: toml
+                .llm
+                .gemini_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("GEMINI_API_KEY").ok()),
+            ollama_key: toml
+                .llm
+                .ollama_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("OLLAMA_API_KEY").ok()),
+            ollama_base_url: toml
+                .llm
+                .ollama_base_url
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("OLLAMA_BASE_URL").ok()),
+            opencode_zen_key: toml
+                .llm
+                .opencode_zen_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("OPENCODE_ZEN_API_KEY").ok()),
+            opencode_go_key: std::env::var("OPENCODE_GO_API_KEY").ok().or_else(|| {
+                toml.llm
+                    .opencode_go_key
+                    .as_deref()
+                    .and_then(resolve_env_value)
+            }),
+            nvidia_key: toml
+                .llm
+                .nvidia_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("NVIDIA_API_KEY").ok()),
+            minimax_key: toml
+                .llm
+                .minimax_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("MINIMAX_API_KEY").ok()),
+            minimax_cn_key: toml
+                .llm
+                .minimax_cn_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("MINIMAX_CN_API_KEY").ok()),
+            moonshot_key: toml
+                .llm
+                .moonshot_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("MOONSHOT_API_KEY").ok()),
+            zai_coding_plan_key: toml
+                .llm
+                .zai_coding_plan_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("ZAI_CODING_PLAN_API_KEY").ok()),
+            providers: toml
+                .llm
+                .providers
+                .into_iter()
+                .map(|(provider_id, config)| {
+                    let api_key = resolve_env_value(&config.api_key).ok_or_else(|| {
+                        anyhow::anyhow!("failed to resolve API key for provider '{}'", provider_id)
+                    })?;
+                    let normalized_id = provider_id.to_lowercase();
+                    let extra_headers = if normalized_id == "openrouter" {
+                        openrouter_extra_headers()
+                    } else {
+                        vec![]
+                    };
+                    Ok((
+                        normalized_id,
+                        ProviderConfig {
+                            api_type: config.api_type,
+                            base_url: config.base_url,
+                            api_key,
+                            name: config.name,
+                            use_bearer_auth: false,
+                            extra_headers,
+                        },
+                    ))
+                })
+                .collect::<anyhow::Result<_>>()?,
+        };
+
+        // Detect if the Anthropic key came from ANTHROPIC_AUTH_TOKEN (proxy auth).
+        // In from_toml, the key may come from toml config, ANTHROPIC_API_KEY, or
+        // ANTHROPIC_AUTH_TOKEN (in that priority order). We only set use_bearer_auth
+        // if AUTH_TOKEN was the actual source.
+        let anthropic_from_auth_token = toml_llm_anthropic_key_was_none
+            && std::env::var("ANTHROPIC_API_KEY").is_err()
+            && std::env::var("ANTHROPIC_AUTH_TOKEN").is_ok();
+
+        if let Some(anthropic_key) = llm.anthropic_key.clone() {
+            let base_url = std::env::var("ANTHROPIC_BASE_URL")
+                .unwrap_or_else(|_| ANTHROPIC_PROVIDER_BASE_URL.to_string());
+            llm.providers
+                .entry("anthropic".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::Anthropic,
+                    base_url,
+                    api_key: anthropic_key,
+                    name: None,
+                    use_bearer_auth: anthropic_from_auth_token,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(openai_key) = llm.openai_key.clone() {
+            llm.providers
+                .entry("openai".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: OPENAI_PROVIDER_BASE_URL.to_string(),
+                    api_key: openai_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(openrouter_key) = llm.openrouter_key.clone() {
+            llm.providers
+                .entry("openrouter".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: OPENROUTER_PROVIDER_BASE_URL.to_string(),
+                    api_key: openrouter_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: openrouter_extra_headers(),
+                });
+        }
+
+        add_shorthand_provider(
+            &mut llm.providers,
+            "kilo",
+            llm.kilo_key.clone(),
+            ApiType::KiloGateway,
+            KILO_PROVIDER_BASE_URL,
+            Some("Kilo Gateway"),
+            false,
+        );
+        add_shorthand_provider(
+            &mut llm.providers,
+            "zhipu",
+            llm.zhipu_key.clone(),
+            ApiType::OpenAiChatCompletions,
+            ZHIPU_PROVIDER_BASE_URL,
+            Some("Z.AI (GLM)"),
+            false,
+        );
+        add_shorthand_provider(
+            &mut llm.providers,
+            "zai-coding-plan",
+            llm.zai_coding_plan_key.clone(),
+            ApiType::OpenAiChatCompletions,
+            ZAI_CODING_PLAN_BASE_URL,
+            Some("Z.AI Coding Plan"),
+            false,
+        );
+
+        add_shorthand_provider(
+            &mut llm.providers,
+            "opencode-zen",
+            llm.opencode_zen_key.clone(),
+            ApiType::OpenAiCompletions,
+            OPENCODE_ZEN_PROVIDER_BASE_URL,
+            None,
+            false,
+        );
+
+        add_shorthand_provider(
+            &mut llm.providers,
+            "opencode-go",
+            llm.opencode_go_key.clone(),
+            ApiType::OpenAiCompletions,
+            OPENCODE_GO_PROVIDER_BASE_URL,
+            None,
+            false,
+        );
+
+        if let Some(minimax_key) = llm.minimax_key.clone() {
+            llm.providers
+                .entry("minimax".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::Anthropic,
+                    base_url: MINIMAX_PROVIDER_BASE_URL.to_string(),
+                    api_key: minimax_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(minimax_cn_key) = llm.minimax_cn_key.clone() {
+            llm.providers
+                .entry("minimax-cn".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::Anthropic,
+                    base_url: MINIMAX_CN_PROVIDER_BASE_URL.to_string(),
+                    api_key: minimax_cn_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(moonshot_key) = llm.moonshot_key.clone() {
+            llm.providers
+                .entry("moonshot".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: MOONSHOT_PROVIDER_BASE_URL.to_string(),
+                    api_key: moonshot_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(nvidia_key) = llm.nvidia_key.clone() {
+            llm.providers
+                .entry("nvidia".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: NVIDIA_PROVIDER_BASE_URL.to_string(),
+                    api_key: nvidia_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(fireworks_key) = llm.fireworks_key.clone() {
+            llm.providers
+                .entry("fireworks".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: FIREWORKS_PROVIDER_BASE_URL.to_string(),
+                    api_key: fireworks_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(deepseek_key) = llm.deepseek_key.clone() {
+            llm.providers
+                .entry("deepseek".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: DEEPSEEK_PROVIDER_BASE_URL.to_string(),
+                    api_key: deepseek_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(gemini_key) = llm.gemini_key.clone() {
+            llm.providers
+                .entry("gemini".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::Gemini,
+                    base_url: GEMINI_PROVIDER_BASE_URL.to_string(),
+                    api_key: gemini_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(groq_key) = llm.groq_key.clone() {
+            llm.providers
+                .entry("groq".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: GROQ_PROVIDER_BASE_URL.to_string(),
+                    api_key: groq_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(together_key) = llm.together_key.clone() {
+            llm.providers
+                .entry("together".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: TOGETHER_PROVIDER_BASE_URL.to_string(),
+                    api_key: together_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(xai_key) = llm.xai_key.clone() {
+            llm.providers
+                .entry("xai".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: XAI_PROVIDER_BASE_URL.to_string(),
+                    api_key: xai_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if let Some(mistral_key) = llm.mistral_key.clone() {
+            llm.providers
+                .entry("mistral".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: MISTRAL_PROVIDER_BASE_URL.to_string(),
+                    api_key: mistral_key,
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        if llm.ollama_base_url.is_some() || llm.ollama_key.is_some() {
+            llm.providers
+                .entry("ollama".to_string())
+                .or_insert_with(|| ProviderConfig {
+                    api_type: ApiType::OpenAiCompletions,
+                    base_url: llm
+                        .ollama_base_url
+                        .clone()
+                        .unwrap_or_else(|| OLLAMA_PROVIDER_BASE_URL.to_string()),
+                    api_key: llm.ollama_key.clone().unwrap_or_default(),
+                    name: None,
+                    use_bearer_auth: false,
+                    extra_headers: vec![],
+                });
+        }
+
+        // Note: We allow boot without provider keys now. System starts in setup mode.
+        // Agents are initialized later when keys are added via API.
+
+        let default_mcp = toml
+            .defaults
+            .mcp
+            .into_iter()
+            .map(parse_mcp_server_config)
+            .collect::<Result<Vec<_>>>()?;
+
+        let base_defaults = DefaultsConfig::default();
+        // When `[defaults.routing]` is absent, infer sane routing from the
+        // first configured provider so new agents don't fall back to the
+        // hardcoded `anthropic/claude-sonnet-4` default (which fails if the
+        // user only has e.g. OpenRouter configured).
+        let base_routing = if toml.defaults.routing.is_none() {
+            infer_routing_from_providers(&llm.providers)
+                .unwrap_or_else(|| base_defaults.routing.clone())
+        } else {
+            base_defaults.routing.clone()
+        };
+        let defaults = DefaultsConfig {
+            routing: resolve_routing(toml.defaults.routing, &base_routing),
+            max_concurrent_branches: toml
+                .defaults
+                .max_concurrent_branches
+                .unwrap_or(base_defaults.max_concurrent_branches),
+            max_concurrent_workers: toml
+                .defaults
+                .max_concurrent_workers
+                .unwrap_or(base_defaults.max_concurrent_workers),
+            max_turns: toml.defaults.max_turns.unwrap_or(base_defaults.max_turns),
+            branch_max_turns: toml
+                .defaults
+                .branch_max_turns
+                .unwrap_or(base_defaults.branch_max_turns),
+            context_window: toml
+                .defaults
+                .context_window
+                .unwrap_or(base_defaults.context_window),
+            compaction: toml
+                .defaults
+                .compaction
+                .map(|c| CompactionConfig {
+                    background_threshold: c
+                        .background_threshold
+                        .unwrap_or(base_defaults.compaction.background_threshold),
+                    aggressive_threshold: c
+                        .aggressive_threshold
+                        .unwrap_or(base_defaults.compaction.aggressive_threshold),
+                    emergency_threshold: c
+                        .emergency_threshold
+                        .unwrap_or(base_defaults.compaction.emergency_threshold),
+                })
+                .unwrap_or(base_defaults.compaction),
+            memory_persistence: toml
+                .defaults
+                .memory_persistence
+                .map(|mp| MemoryPersistenceConfig {
+                    enabled: mp
+                        .enabled
+                        .unwrap_or(base_defaults.memory_persistence.enabled),
+                    message_interval: mp
+                        .message_interval
+                        .unwrap_or(base_defaults.memory_persistence.message_interval),
+                })
+                .unwrap_or(base_defaults.memory_persistence),
+            coalesce: toml
+                .defaults
+                .coalesce
+                .map(|c| CoalesceConfig {
+                    enabled: c.enabled.unwrap_or(base_defaults.coalesce.enabled),
+                    debounce_ms: c.debounce_ms.unwrap_or(base_defaults.coalesce.debounce_ms),
+                    max_wait_ms: c.max_wait_ms.unwrap_or(base_defaults.coalesce.max_wait_ms),
+                    min_messages: c
+                        .min_messages
+                        .unwrap_or(base_defaults.coalesce.min_messages),
+                    multi_user_only: c
+                        .multi_user_only
+                        .unwrap_or(base_defaults.coalesce.multi_user_only),
+                })
+                .unwrap_or(base_defaults.coalesce),
+            ingestion: toml
+                .defaults
+                .ingestion
+                .map(|ig| IngestionConfig {
+                    enabled: ig.enabled.unwrap_or(base_defaults.ingestion.enabled),
+                    poll_interval_secs: ig
+                        .poll_interval_secs
+                        .unwrap_or(base_defaults.ingestion.poll_interval_secs),
+                    chunk_size: ig.chunk_size.unwrap_or(base_defaults.ingestion.chunk_size),
+                })
+                .unwrap_or(base_defaults.ingestion),
+            cortex: toml
+                .defaults
+                .cortex
+                .map(|c| CortexConfig::resolve(c, base_defaults.cortex))
+                .unwrap_or(base_defaults.cortex),
+            warmup: toml
+                .defaults
+                .warmup
+                .map(|w| WarmupConfig {
+                    enabled: w.enabled.unwrap_or(base_defaults.warmup.enabled),
+                    eager_embedding_load: w
+                        .eager_embedding_load
+                        .unwrap_or(base_defaults.warmup.eager_embedding_load),
+                    refresh_secs: w.refresh_secs.unwrap_or(base_defaults.warmup.refresh_secs),
+                    startup_delay_secs: w
+                        .startup_delay_secs
+                        .unwrap_or(base_defaults.warmup.startup_delay_secs),
+                })
+                .unwrap_or(base_defaults.warmup),
+            browser: {
+                let chrome_cache_dir = instance_dir.join("chrome_cache");
+                toml.defaults
+                    .browser
+                    .map(|b| {
+                        let base = &base_defaults.browser;
+                        BrowserConfig {
+                            enabled: b.enabled.unwrap_or(base.enabled),
+                            headless: b.headless.unwrap_or(base.headless),
+                            evaluate_enabled: b.evaluate_enabled.unwrap_or(base.evaluate_enabled),
+                            executable_path: b
+                                .executable_path
+                                .or_else(|| base.executable_path.clone()),
+                            screenshot_dir: b
+                                .screenshot_dir
+                                .map(PathBuf::from)
+                                .or_else(|| base.screenshot_dir.clone()),
+                            persist_session: b.persist_session.unwrap_or(base.persist_session),
+                            close_policy: parse_close_policy(b.close_policy.as_deref())
+                                .unwrap_or(base.close_policy),
+                            chrome_cache_dir: chrome_cache_dir.clone(),
+                        }
+                    })
+                    .unwrap_or_else(|| BrowserConfig {
+                        chrome_cache_dir,
+                        ..base_defaults.browser.clone()
+                    })
+            },
+            channel: toml
+                .defaults
+                .channel
+                .map(|channel_config| ChannelConfig {
+                    listen_only_mode: channel_config
+                        .listen_only_mode
+                        .unwrap_or(base_defaults.channel.listen_only_mode),
+                })
+                .unwrap_or(base_defaults.channel),
+            mcp: default_mcp,
+            brave_search_key: toml
+                .defaults
+                .brave_search_key
+                .as_deref()
+                .and_then(resolve_env_value)
+                .or_else(|| std::env::var("BRAVE_SEARCH_API_KEY").ok()),
+            cron_timezone: toml
+                .defaults
+                .cron_timezone
+                .as_deref()
+                .and_then(resolve_env_value),
+            user_timezone: toml
+                .defaults
+                .user_timezone
+                .as_deref()
+                .and_then(resolve_env_value),
+            history_backfill_count: base_defaults.history_backfill_count,
+            cron: Vec::new(),
+            opencode: toml
+                .defaults
+                .opencode
+                .map(|oc| {
+                    let base = &base_defaults.opencode;
+                    let path_raw = oc.path.unwrap_or_else(|| base.path.clone());
+                    let resolved_path =
+                        resolve_env_value(&path_raw).unwrap_or_else(|| base.path.clone());
+                    OpenCodeConfig {
+                        enabled: oc.enabled.unwrap_or(base.enabled),
+                        path: resolved_path,
+                        max_servers: oc.max_servers.unwrap_or(base.max_servers),
+                        server_startup_timeout_secs: oc
+                            .server_startup_timeout_secs
+                            .unwrap_or(base.server_startup_timeout_secs),
+                        max_restart_retries: oc
+                            .max_restart_retries
+                            .unwrap_or(base.max_restart_retries),
+                        permissions: oc
+                            .permissions
+                            .map(|p| crate::opencode::OpenCodePermissions {
+                                edit: p.edit.unwrap_or_else(|| base.permissions.edit.clone()),
+                                bash: p.bash.unwrap_or_else(|| base.permissions.bash.clone()),
+                                webfetch: p
+                                    .webfetch
+                                    .unwrap_or_else(|| base.permissions.webfetch.clone()),
+                            })
+                            .unwrap_or_else(|| base.permissions.clone()),
+                    }
+                })
+                .unwrap_or_else(|| base_defaults.opencode.clone()),
+            worker_log_mode: toml
+                .defaults
+                .worker_log_mode
+                .as_deref()
+                .and_then(|s| s.parse().ok())
+                .unwrap_or(base_defaults.worker_log_mode),
+        };
+
+        let mut agents: Vec<AgentConfig> = toml
+            .agents
+            .into_iter()
+            .map(|a| -> Result<AgentConfig> {
+                // Per-agent routing resolves against instance defaults
+                let agent_routing = a
+                    .routing
+                    .map(|r| resolve_routing(Some(r), &defaults.routing));
+
+                let cron = a
+                    .cron
+                    .into_iter()
+                    .map(|h| CronDef {
+                        id: h.id,
+                        prompt: h.prompt,
+                        cron_expr: h.cron_expr,
+                        interval_secs: h.interval_secs.unwrap_or(3600),
+                        delivery_target: h.delivery_target,
+                        active_hours: match (h.active_start_hour, h.active_end_hour) {
+                            (Some(s), Some(e)) => Some((s, e)),
+                            _ => None,
+                        },
+                        enabled: h.enabled,
+                        run_once: h.run_once,
+                        timeout_secs: h.timeout_secs,
+                    })
+                    .collect();
+
+                Ok(AgentConfig {
+                    id: a.id,
+                    default: a.default,
+                    display_name: a.display_name,
+                    role: a.role,
+                    workspace: a.workspace.map(PathBuf::from),
+                    routing: agent_routing,
+                    max_concurrent_branches: a.max_concurrent_branches,
+                    max_concurrent_workers: a.max_concurrent_workers,
+                    max_turns: a.max_turns,
+                    branch_max_turns: a.branch_max_turns,
+                    context_window: a.context_window,
+                    compaction: a.compaction.map(|c| CompactionConfig {
+                        background_threshold: c
+                            .background_threshold
+                            .unwrap_or(defaults.compaction.background_threshold),
+                        aggressive_threshold: c
+                            .aggressive_threshold
+                            .unwrap_or(defaults.compaction.aggressive_threshold),
+                        emergency_threshold: c
+                            .emergency_threshold
+                            .unwrap_or(defaults.compaction.emergency_threshold),
+                    }),
+                    memory_persistence: a.memory_persistence.map(|mp| MemoryPersistenceConfig {
+                        enabled: mp.enabled.unwrap_or(defaults.memory_persistence.enabled),
+                        message_interval: mp
+                            .message_interval
+                            .unwrap_or(defaults.memory_persistence.message_interval),
+                    }),
+                    coalesce: a.coalesce.map(|c| CoalesceConfig {
+                        enabled: c.enabled.unwrap_or(defaults.coalesce.enabled),
+                        debounce_ms: c.debounce_ms.unwrap_or(defaults.coalesce.debounce_ms),
+                        max_wait_ms: c.max_wait_ms.unwrap_or(defaults.coalesce.max_wait_ms),
+                        min_messages: c.min_messages.unwrap_or(defaults.coalesce.min_messages),
+                        multi_user_only: c
+                            .multi_user_only
+                            .unwrap_or(defaults.coalesce.multi_user_only),
+                    }),
+                    ingestion: a.ingestion.map(|ig| IngestionConfig {
+                        enabled: ig.enabled.unwrap_or(defaults.ingestion.enabled),
+                        poll_interval_secs: ig
+                            .poll_interval_secs
+                            .unwrap_or(defaults.ingestion.poll_interval_secs),
+                        chunk_size: ig.chunk_size.unwrap_or(defaults.ingestion.chunk_size),
+                    }),
+                    cortex: a.cortex.map(|c| CortexConfig::resolve(c, defaults.cortex)),
+                    warmup: a.warmup.map(|w| WarmupConfig {
+                        enabled: w.enabled.unwrap_or(defaults.warmup.enabled),
+                        eager_embedding_load: w
+                            .eager_embedding_load
+                            .unwrap_or(defaults.warmup.eager_embedding_load),
+                        refresh_secs: w.refresh_secs.unwrap_or(defaults.warmup.refresh_secs),
+                        startup_delay_secs: w
+                            .startup_delay_secs
+                            .unwrap_or(defaults.warmup.startup_delay_secs),
+                    }),
+                    browser: a.browser.map(|b| BrowserConfig {
+                        enabled: b.enabled.unwrap_or(defaults.browser.enabled),
+                        headless: b.headless.unwrap_or(defaults.browser.headless),
+                        evaluate_enabled: b
+                            .evaluate_enabled
+                            .unwrap_or(defaults.browser.evaluate_enabled),
+                        executable_path: b
+                            .executable_path
+                            .or_else(|| defaults.browser.executable_path.clone()),
+                        screenshot_dir: b
+                            .screenshot_dir
+                            .map(PathBuf::from)
+                            .or_else(|| defaults.browser.screenshot_dir.clone()),
+                        persist_session: b
+                            .persist_session
+                            .unwrap_or(defaults.browser.persist_session),
+                        close_policy: parse_close_policy(b.close_policy.as_deref())
+                            .unwrap_or(defaults.browser.close_policy),
+                        chrome_cache_dir: defaults.browser.chrome_cache_dir.clone(),
+                    }),
+                    channel: a.channel.and_then(|channel_config| {
+                        channel_config
+                            .listen_only_mode
+                            .map(|listen_only_mode| ChannelConfig { listen_only_mode })
+                    }),
+                    mcp: match a.mcp {
+                        Some(mcp_servers) => Some(
+                            mcp_servers
+                                .into_iter()
+                                .map(parse_mcp_server_config)
+                                .collect::<Result<Vec<_>>>()?,
+                        ),
+                        None => None,
+                    },
+                    brave_search_key: a.brave_search_key.as_deref().and_then(resolve_env_value),
+                    cron_timezone: a.cron_timezone.as_deref().and_then(resolve_env_value),
+                    user_timezone: a.user_timezone.as_deref().and_then(resolve_env_value),
+                    sandbox: a.sandbox,
+                    cron,
+                })
+            })
+            .collect::<Result<Vec<_>>>()?;
+
+        if agents.is_empty() {
+            agents.push(AgentConfig {
+                id: "main".into(),
+                default: true,
+                display_name: None,
+                role: None,
+                workspace: None,
+                routing: None,
+                max_concurrent_branches: None,
+                max_concurrent_workers: None,
+                max_turns: None,
+                branch_max_turns: None,
+                context_window: None,
+                compaction: None,
+                memory_persistence: None,
+                coalesce: None,
+                ingestion: None,
+                cortex: None,
+                warmup: None,
+                browser: None,
+                channel: None,
+                mcp: None,
+                brave_search_key: None,
+                cron_timezone: None,
+                user_timezone: None,
+                sandbox: None,
+                cron: Vec::new(),
+            });
+        }
+
+        if !agents.iter().any(|a| a.default)
+            && let Some(first) = agents.first_mut()
+        {
+            first.default = true;
+        }
+
+        let messaging = MessagingConfig {
+            discord: toml.messaging.discord.and_then(|d| {
+                let instances = d
+                    .instances
+                    .into_iter()
+                    .map(|instance| {
+                        let token = instance.token.as_deref().and_then(resolve_env_value);
+                        if instance.enabled && token.is_none() {
+                            tracing::warn!(
+                                adapter = %instance.name,
+                                "discord instance is enabled but token is missing/unresolvable — disabling"
+                            );
+                        }
+                        DiscordInstanceConfig {
+                            name: instance.name,
+                            enabled: instance.enabled && token.is_some(),
+                            token: token.unwrap_or_default(),
+                            dm_allowed_users: instance.dm_allowed_users,
+                            allow_bot_messages: instance.allow_bot_messages,
+                        }
+                    })
+                    .collect::<Vec<_>>();
+
+                let token = std::env::var("DISCORD_BOT_TOKEN")
+                    .ok()
+                    .or_else(|| d.token.as_deref().and_then(resolve_env_value));
+
+                if token.is_none() && instances.is_empty() {
+                    return None;
+                }
+
+                Some(DiscordConfig {
+                    enabled: d.enabled,
+                    token: token.unwrap_or_default(),
+                    instances,
+                    dm_allowed_users: d.dm_allowed_users,
+                    allow_bot_messages: d.allow_bot_messages,
+                })
+            }),
+            slack: toml.messaging.slack.and_then(|s| {
+                let instances = s
+                    .instances
+                    .into_iter()
+                    .map(|instance| {
+                        let bot_token =
+                            instance.bot_token.as_deref().and_then(resolve_env_value);
+                        let app_token =
+                            instance.app_token.as_deref().and_then(resolve_env_value);
+                        if instance.enabled && (bot_token.is_none() || app_token.is_none()) {
+                            tracing::warn!(
+                                adapter = %instance.name,
+                                "slack instance is enabled but tokens are missing/unresolvable — disabling"
+                            );
+                        }
+                        let has_credentials = bot_token.is_some() && app_token.is_some();
+                        SlackInstanceConfig {
+                            name: instance.name,
+                            enabled: instance.enabled && has_credentials,
+                            bot_token: bot_token.unwrap_or_default(),
+                            app_token: app_token.unwrap_or_default(),
+                            dm_allowed_users: instance.dm_allowed_users,
+                            commands: instance
+                                .commands
+                                .into_iter()
+                                .map(|command| SlackCommandConfig {
+                                    command: command.command,
+                                    agent_id: command.agent_id,
+                                    description: command.description,
+                                })
+                                .collect(),
+                        }
+                    })
+                    .collect::<Vec<_>>();
+
+                let bot_token = std::env::var("SLACK_BOT_TOKEN")
+                    .ok()
+                    .or_else(|| s.bot_token.as_deref().and_then(resolve_env_value));
+                let app_token = std::env::var("SLACK_APP_TOKEN")
+                    .ok()
+                    .or_else(|| s.app_token.as_deref().and_then(resolve_env_value));
+
+                if (bot_token.is_none() || app_token.is_none()) && instances.is_empty() {
+                    return None;
+                }
+
+                Some(SlackConfig {
+                    enabled: s.enabled,
+                    bot_token: bot_token.unwrap_or_default(),
+                    app_token: app_token.unwrap_or_default(),
+                    instances,
+                    dm_allowed_users: s.dm_allowed_users,
+                    commands: s
+                        .commands
+                        .into_iter()
+                        .map(|c| SlackCommandConfig {
+                            command: c.command,
+                            agent_id: c.agent_id,
+                            description: c.description,
+                        })
+                        .collect(),
+                })
+            }),
+            telegram: toml.messaging.telegram.and_then(|t| {
+                let instances = t
+                    .instances
+                    .into_iter()
+                    .map(|instance| {
+                        let token = instance.token.as_deref().and_then(resolve_env_value);
+                        if instance.enabled && token.is_none() {
+                            tracing::warn!(
+                                adapter = %instance.name,
+                                "telegram instance is enabled but token is missing/unresolvable — disabling"
+                            );
+                        }
+                        TelegramInstanceConfig {
+                            name: instance.name,
+                            enabled: instance.enabled && token.is_some(),
+                            token: token.unwrap_or_default(),
+                            dm_allowed_users: instance.dm_allowed_users,
+                        }
+                    })
+                    .collect::<Vec<_>>();
+
+                let token = std::env::var("TELEGRAM_BOT_TOKEN")
+                    .ok()
+                    .or_else(|| t.token.as_deref().and_then(resolve_env_value));
+
+                if token.is_none() && instances.is_empty() {
+                    return None;
+                }
+
+                Some(TelegramConfig {
+                    enabled: t.enabled,
+                    token: token.unwrap_or_default(),
+                    instances,
+                    dm_allowed_users: t.dm_allowed_users,
+                })
+            }),
+            email: toml.messaging.email.and_then(|email| {
+                let instances = email
+                    .instances
+                    .into_iter()
+                    .map(|instance| {
+                        let imap_host =
+                            instance.imap_host.as_deref().and_then(resolve_env_value);
+                        let imap_username =
+                            instance.imap_username.as_deref().and_then(resolve_env_value);
+                        let imap_password =
+                            instance.imap_password.as_deref().and_then(resolve_env_value);
+                        let smtp_host =
+                            instance.smtp_host.as_deref().and_then(resolve_env_value);
+
+                        let has_credentials = imap_host.is_some()
+                            && imap_username.is_some()
+                            && imap_password.is_some()
+                            && smtp_host.is_some();
+
+                        if instance.enabled && !has_credentials {
+                            tracing::warn!(
+                                adapter = %instance.name,
+                                "email instance is enabled but credentials are missing/unresolvable — disabling"
+                            );
+                        }
+
+                        let imap_username_val = imap_username.unwrap_or_default();
+                        let imap_password_val = imap_password.unwrap_or_default();
+                        let smtp_username = instance
+                            .smtp_username
+                            .as_deref()
+                            .and_then(resolve_env_value)
+                            .unwrap_or_else(|| imap_username_val.clone());
+                        let smtp_password = instance
+                            .smtp_password
+                            .as_deref()
+                            .and_then(resolve_env_value)
+                            .unwrap_or_else(|| imap_password_val.clone());
+                        let from_address = instance
+                            .from_address
+                            .as_deref()
+                            .and_then(resolve_env_value)
+                            .unwrap_or_else(|| smtp_username.clone());
+                        let from_name =
+                            instance.from_name.as_deref().and_then(resolve_env_value);
+
+                        EmailInstanceConfig {
+                            name: instance.name,
+                            enabled: instance.enabled && has_credentials,
+                            imap_host: imap_host.unwrap_or_default(),
+                            imap_port: instance.imap_port,
+                            imap_username: imap_username_val,
+                            imap_password: imap_password_val,
+                            imap_use_tls: instance.imap_use_tls,
+                            smtp_host: smtp_host.unwrap_or_default(),
+                            smtp_port: instance.smtp_port,
+                            smtp_username,
+                            smtp_password,
+                            smtp_use_starttls: instance.smtp_use_starttls,
+                            from_address,
+                            from_name,
+                            poll_interval_secs: instance.poll_interval_secs,
+                            folders: if instance.folders.is_empty() {
+                                vec!["INBOX".to_string()]
+                            } else {
+                                instance.folders
+                            },
+                            allowed_senders: instance.allowed_senders,
+                            max_body_bytes: instance.max_body_bytes,
+                            max_attachment_bytes: instance.max_attachment_bytes,
+                        }
+                    })
+                    .collect::<Vec<_>>();
+
+                let imap_host = std::env::var("EMAIL_IMAP_HOST")
+                    .ok()
+                    .or_else(|| email.imap_host.as_deref().and_then(resolve_env_value));
+                let imap_username = std::env::var("EMAIL_IMAP_USERNAME")
+                    .ok()
+                    .or_else(|| email.imap_username.as_deref().and_then(resolve_env_value));
+                let imap_password = std::env::var("EMAIL_IMAP_PASSWORD")
+                    .ok()
+                    .or_else(|| email.imap_password.as_deref().and_then(resolve_env_value));
+                let smtp_host = std::env::var("EMAIL_SMTP_HOST")
+                    .ok()
+                    .or_else(|| email.smtp_host.as_deref().and_then(resolve_env_value));
+
+                let has_default = imap_host.is_some()
+                    && imap_username.is_some()
+                    && imap_password.is_some()
+                    && smtp_host.is_some();
+
+                if !has_default && instances.is_empty() {
+                    return None;
+                }
+
+                let imap_host = imap_host.unwrap_or_default();
+                let imap_username = imap_username.unwrap_or_default();
+                let imap_password = imap_password.unwrap_or_default();
+                let smtp_host = smtp_host.unwrap_or_default();
+                let smtp_username = std::env::var("EMAIL_SMTP_USERNAME")
+                    .ok()
+                    .or_else(|| email.smtp_username.as_deref().and_then(resolve_env_value))
+                    .unwrap_or_else(|| imap_username.clone());
+                let smtp_password = std::env::var("EMAIL_SMTP_PASSWORD")
+                    .ok()
+                    .or_else(|| email.smtp_password.as_deref().and_then(resolve_env_value))
+                    .unwrap_or_else(|| imap_password.clone());
+
+                let from_address = std::env::var("EMAIL_FROM_ADDRESS")
+                    .ok()
+                    .or_else(|| email.from_address.as_deref().and_then(resolve_env_value))
+                    .unwrap_or_else(|| smtp_username.clone());
+                let from_name = std::env::var("EMAIL_FROM_NAME")
+                    .ok()
+                    .or_else(|| email.from_name.as_deref().and_then(resolve_env_value));
+
+                Some(EmailConfig {
+                    enabled: email.enabled,
+                    imap_host,
+                    imap_port: email.imap_port,
+                    imap_username,
+                    imap_password,
+                    imap_use_tls: email.imap_use_tls,
+                    smtp_host,
+                    smtp_port: email.smtp_port,
+                    smtp_username,
+                    smtp_password,
+                    smtp_use_starttls: email.smtp_use_starttls,
+                    from_address,
+                    from_name,
+                    poll_interval_secs: email.poll_interval_secs,
+                    folders: if email.folders.is_empty() {
+                        vec!["INBOX".to_string()]
+                    } else {
+                        email.folders
+                    },
+                    allowed_senders: email.allowed_senders,
+                    max_body_bytes: email.max_body_bytes,
+                    max_attachment_bytes: email.max_attachment_bytes,
+                    instances,
+                })
+            }),
+            webhook: toml.messaging.webhook.map(|w| WebhookConfig {
+                enabled: w.enabled,
+                port: w.port,
+                bind: w.bind,
+                auth_token: w.auth_token.as_deref().and_then(resolve_env_value),
+            }),
+            twitch: toml.messaging.twitch.and_then(|t| {
+                let instances = t
+                    .instances
+                    .into_iter()
+                    .map(|instance| {
+                        let username = instance.username.as_deref().and_then(resolve_env_value);
+                        let oauth_token = instance
+                            .oauth_token
+                            .as_deref()
+                            .and_then(resolve_env_value);
+                        if instance.enabled && (username.is_none() || oauth_token.is_none()) {
+                            tracing::warn!(
+                                adapter = %instance.name,
+                                "twitch instance is enabled but credentials are missing/unresolvable — disabling"
+                            );
+                        }
+                        let has_credentials = username.is_some() && oauth_token.is_some();
+                        let client_id = instance.client_id.as_deref().and_then(resolve_env_value);
+                        let client_secret = instance
+                            .client_secret
+                            .as_deref()
+                            .and_then(resolve_env_value);
+                        let refresh_token = instance
+                            .refresh_token
+                            .as_deref()
+                            .and_then(resolve_env_value);
+                        TwitchInstanceConfig {
+                            name: instance.name,
+                            enabled: instance.enabled && has_credentials,
+                            username: username.unwrap_or_default(),
+                            oauth_token: oauth_token.unwrap_or_default(),
+                            client_id,
+                            client_secret,
+                            refresh_token,
+                            channels: instance.channels,
+                            trigger_prefix: instance.trigger_prefix,
+                        }
+                    })
+                    .collect::<Vec<_>>();
+
+                let username = std::env::var("TWITCH_BOT_USERNAME")
+                    .ok()
+                    .or_else(|| t.username.as_deref().and_then(resolve_env_value));
+                let oauth_token = std::env::var("TWITCH_OAUTH_TOKEN")
+                    .ok()
+                    .or_else(|| t.oauth_token.as_deref().and_then(resolve_env_value));
+
+                if (username.is_none() || oauth_token.is_none()) && instances.is_empty() {
+                    return None;
+                }
+
+                let client_id = t
+                    .client_id
+                    .as_deref()
+                    .and_then(resolve_env_value)
+                    .or_else(|| std::env::var("TWITCH_CLIENT_ID").ok());
+                let client_secret = t
+                    .client_secret
+                    .as_deref()
+                    .and_then(resolve_env_value)
+                    .or_else(|| std::env::var("TWITCH_CLIENT_SECRET").ok());
+                let refresh_token = t
+                    .refresh_token
+                    .as_deref()
+                    .and_then(resolve_env_value)
+                    .or_else(|| std::env::var("TWITCH_REFRESH_TOKEN").ok());
+                Some(TwitchConfig {
+                    enabled: t.enabled,
+                    username: username.unwrap_or_default(),
+                    oauth_token: oauth_token.unwrap_or_default(),
+                    client_id,
+                    client_secret,
+                    refresh_token,
+                    instances,
+                    channels: t.channels,
+                    trigger_prefix: t.trigger_prefix,
+                })
+            }),
+        };
+
+        let bindings: Vec<Binding> = toml
+            .bindings
+            .into_iter()
+            .map(|b| Binding {
+                agent_id: b.agent_id,
+                channel: b.channel,
+                adapter: normalize_adapter(b.adapter),
+                guild_id: b.guild_id,
+                workspace_id: b.workspace_id,
+                chat_id: b.chat_id,
+                channel_ids: b.channel_ids,
+                require_mention: b.require_mention,
+                dm_allowed_users: b.dm_allowed_users,
+            })
+            .collect();
+
+        validate_named_messaging_adapters(&messaging, &bindings)?;
+
+        let api = ApiConfig {
+            enabled: toml.api.enabled,
+            port: toml.api.port,
+            bind: hosted_api_bind(toml.api.bind),
+            auth_token: toml.api.auth_token.as_deref().and_then(resolve_env_value),
+        };
+
+        let metrics = MetricsConfig {
+            enabled: toml.metrics.enabled,
+            port: toml.metrics.port,
+            bind: toml.metrics.bind,
+        };
+
+        let telemetry = {
+            // env var takes precedence over config file value
+            let otlp_endpoint = std::env::var("OTEL_EXPORTER_OTLP_ENDPOINT")
+                .ok()
+                .or(toml.telemetry.otlp_endpoint);
+            let otlp_headers = parse_otlp_headers(
+                std::env::var("OTEL_EXPORTER_OTLP_HEADERS")
+                    .ok()
+                    .or(toml.telemetry.otlp_headers),
+            )?;
+            let service_name = std::env::var("OTEL_SERVICE_NAME")
+                .ok()
+                .or(toml.telemetry.service_name)
+                .unwrap_or_else(|| "spacebot".into());
+            let sample_rate = toml.telemetry.sample_rate.unwrap_or(1.0);
+            TelemetryConfig {
+                otlp_endpoint,
+                otlp_headers,
+                service_name,
+                sample_rate,
+            }
+        };
+
+        let links = toml
+            .links
+            .into_iter()
+            .map(|l| {
+                // Backward compat: use `relationship` field if `kind` is default and `relationship` is set
+                let kind = if l.kind == "peer" {
+                    l.relationship.unwrap_or(l.kind)
+                } else {
+                    l.kind
+                };
+                LinkDef {
+                    from: l.from,
+                    to: l.to,
+                    direction: l.direction,
+                    kind,
+                }
+            })
+            .collect();
+
+        let groups = toml
+            .groups
+            .into_iter()
+            .map(|g| GroupDef {
+                name: g.name,
+                agent_ids: g.agent_ids,
+                color: g.color,
+            })
+            .collect();
+
+        let mut humans: Vec<HumanDef> = toml
+            .humans
+            .into_iter()
+            .map(|h| HumanDef {
+                id: h.id,
+                display_name: h.display_name,
+                role: h.role,
+                bio: h.bio,
+            })
+            .collect();
+
+        // Default admin human if none defined
+        if humans.is_empty() {
+            humans.push(HumanDef {
+                id: "admin".into(),
+                display_name: None,
+                role: None,
+                bio: None,
+            });
+        }
+
+        Ok(Config {
+            instance_dir,
+            llm,
+            defaults,
+            agents,
+            links,
+            groups,
+            humans,
+            messaging,
+            bindings,
+            api,
+            metrics,
+            telemetry,
+        })
+    }
+}
diff --git a/src/config/onboarding.rs b/src/config/onboarding.rs
new file mode 100644
index 000000000..498a465d0
--- /dev/null
+++ b/src/config/onboarding.rs
@@ -0,0 +1,316 @@
+use std::path::PathBuf;
+
+use anyhow::Context as _;
+
+use super::Config;
+
+/// Interactive first-run onboarding. Creates ~/.spacebot with a minimal config.
+///
+/// Returns `Some(path)` if the CLI wizard created a config file, or `None` if
+/// the user chose to set up via the embedded UI (setup mode).
+pub fn run_onboarding() -> anyhow::Result<Option<PathBuf>> {
+    use dialoguer::{Input, Password, Select};
+    use std::io::Write;
+
+    println!();
+    println!("  Welcome to Spacebot");
+    println!("  -------------------");
+    println!();
+    println!("  No configuration found. Let's set things up.");
+    println!();
+
+    let setup_method = Select::new()
+        .with_prompt("How do you want to set up?")
+        .items(&["Set up here (CLI)", "Set up in the browser (localhost)"])
+        .default(0)
+        .interact()?;
+
+    if setup_method == 1 {
+        println!();
+        println!("  Starting in setup mode. Open the UI to finish configuration:");
+        println!();
+        println!("    http://localhost:19898");
+        println!();
+        return Ok(None);
+    }
+
+    println!();
+
+    // 1. Pick a provider
+    let providers = &[
+        "Anthropic",
+        "OpenRouter",
+        "OpenAI",
+        "Z.ai (GLM)",
+        "Groq",
+        "Together AI",
+        "Fireworks AI",
+        "DeepSeek",
+        "xAI (Grok)",
+        "Mistral AI",
+        "Gemini",
+        "Ollama",
+        "OpenCode Zen",
+        "OpenCode Go",
+        "MiniMax",
+        "Moonshot AI (Kimi)",
+        "Z.AI Coding Plan",
+        "Kilo Gateway",
+    ];
+    let provider_idx = Select::new()
+        .with_prompt("Which LLM provider do you want to use?")
+        .items(providers)
+        .default(0)
+        .interact()?;
+
+    // For Anthropic, offer OAuth login as an option
+    let anthropic_oauth = if provider_idx == 0 {
+        let auth_method = Select::new()
+            .with_prompt("How do you want to authenticate with Anthropic?")
+            .items(&[
+                "Log in with Claude Pro/Max (OAuth)",
+                "Log in via API Console (OAuth)",
+                "Enter an API key manually",
+            ])
+            .default(0)
+            .interact()?;
+
+        if auth_method <= 1 {
+            let mode = if auth_method == 0 {
+                crate::auth::AuthMode::Max
+            } else {
+                crate::auth::AuthMode::Console
+            };
+            let instance_dir = Config::default_instance_dir();
+            std::fs::create_dir_all(&instance_dir)?;
+
+            let runtime = tokio::runtime::Builder::new_current_thread()
+                .enable_all()
+                .build()
+                .with_context(|| "failed to build tokio runtime")?;
+
+            runtime.block_on(crate::auth::login_interactive(&instance_dir, mode))?;
+            Some(true)
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    let (provider_input_name, toml_key, provider_id) = match provider_idx {
+        0 => ("Anthropic API key", "anthropic_key", "anthropic"),
+        1 => ("OpenRouter API key", "openrouter_key", "openrouter"),
+        2 => ("OpenAI API key", "openai_key", "openai"),
+        3 => ("Z.ai (GLM) API key", "zhipu_key", "zhipu"),
+        4 => ("Groq API key", "groq_key", "groq"),
+        5 => ("Together AI API key", "together_key", "together"),
+        6 => ("Fireworks AI API key", "fireworks_key", "fireworks"),
+        7 => ("DeepSeek API key", "deepseek_key", "deepseek"),
+        8 => ("xAI API key", "xai_key", "xai"),
+        9 => ("Mistral API key", "mistral_key", "mistral"),
+        10 => ("Google Gemini API key", "gemini_key", "gemini"),
+        11 => ("Ollama base URL (optional)", "ollama_base_url", "ollama"),
+        12 => ("OpenCode Zen API key", "opencode_zen_key", "opencode-zen"),
+        13 => ("OpenCode Go API key", "opencode_go_key", "opencode-go"),
+        14 => ("MiniMax API key", "minimax_key", "minimax"),
+        15 => ("Moonshot API key", "moonshot_key", "moonshot"),
+        16 => (
+            "Z.AI Coding Plan API key",
+            "zai_coding_plan_key",
+            "zai-coding-plan",
+        ),
+        17 => ("Kilo Gateway API key", "kilo_key", "kilo"),
+        _ => unreachable!(),
+    };
+    let is_secret = provider_id != "ollama";
+
+    // 2. Get provider credential/endpoint (skip if OAuth was used)
+    let provider_value = if anthropic_oauth.is_some() {
+        // OAuth tokens are stored in anthropic_oauth.json, not in config.toml.
+        // Use a placeholder so the config still has an [llm] section.
+        String::new()
+    } else if is_secret {
+        let api_key: String = Password::new()
+            .with_prompt(format!("Enter your {provider_input_name}"))
+            .interact()?;
+
+        let api_key = api_key.trim().to_string();
+        if api_key.is_empty() {
+            anyhow::bail!("API key cannot be empty");
+        }
+        api_key
+    } else {
+        let base_url: String = Input::new()
+            .with_prompt(format!("Enter your {provider_input_name}"))
+            .default("http://localhost:11434".to_string())
+            .interact_text()?;
+
+        let base_url = base_url.trim().to_string();
+        if base_url.is_empty() {
+            anyhow::bail!("Ollama base URL cannot be empty");
+        }
+        base_url
+    };
+
+    // 3. Agent name
+    let agent_id: String = Input::new()
+        .with_prompt("Agent name")
+        .default("main".to_string())
+        .interact_text()?;
+
+    let agent_id = agent_id.trim().to_lowercase().replace(' ', "-");
+
+    // 4. Optional Discord setup
+    let setup_discord = Select::new()
+        .with_prompt("Set up Discord integration?")
+        .items(&["Not now", "Yes"])
+        .default(0)
+        .interact()?;
+
+    struct DiscordSetup {
+        token: String,
+        guild_id: Option<String>,
+        channel_ids: Vec<String>,
+        dm_user_ids: Vec<String>,
+    }
+
+    let discord = if setup_discord == 1 {
+        let token: String = Password::new()
+            .with_prompt("Discord bot token")
+            .interact()?;
+        let token = token.trim().to_string();
+
+        if token.is_empty() {
+            None
+        } else {
+            println!();
+            println!("  Tip: Right-click a server or channel in Discord with");
+            println!("  Developer Mode enabled to copy IDs. Leave blank to skip.");
+            println!();
+
+            let guild_id: String = Input::new()
+                .with_prompt("Server (guild) ID")
+                .allow_empty(true)
+                .default(String::new())
+                .interact_text()?;
+            let guild_id = guild_id.trim().to_string();
+            let guild_id = if guild_id.is_empty() {
+                None
+            } else {
+                Some(guild_id)
+            };
+
+            let channel_ids_raw: String = Input::new()
+                .with_prompt("Channel IDs (comma-separated, or blank for all)")
+                .allow_empty(true)
+                .default(String::new())
+                .interact_text()?;
+            let channel_ids: Vec<String> = channel_ids_raw
+                .split(',')
+                .map(|s| s.trim().to_string())
+                .filter(|s| !s.is_empty())
+                .collect();
+
+            let dm_user_ids_raw: String = Input::new()
+                .with_prompt("User IDs allowed to DM the bot (comma-separated, or blank)")
+                .allow_empty(true)
+                .default(String::new())
+                .interact_text()?;
+            let dm_user_ids: Vec<String> = dm_user_ids_raw
+                .split(',')
+                .map(|s| s.trim().to_string())
+                .filter(|s| !s.is_empty())
+                .collect();
+
+            Some(DiscordSetup {
+                token,
+                guild_id,
+                channel_ids,
+                dm_user_ids,
+            })
+        }
+    } else {
+        None
+    };
+
+    // 5. Build config.toml
+    let instance_dir = Config::default_instance_dir();
+    let config_path = instance_dir.join("config.toml");
+
+    // Create directory structure
+    std::fs::create_dir_all(&instance_dir)
+        .with_context(|| format!("failed to create {}", instance_dir.display()))?;
+
+    let mut config_content = String::new();
+    config_content.push_str("[llm]\n");
+    if anthropic_oauth.is_some() {
+        config_content
+            .push_str("# Anthropic authentication via OAuth (see anthropic_oauth.json)\n");
+    } else {
+        config_content.push_str(&format!("{toml_key} = \"{provider_value}\"\n"));
+    }
+    config_content.push('\n');
+
+    // Write routing defaults for the chosen provider
+    let routing = crate::llm::routing::defaults_for_provider(provider_id);
+    config_content.push_str("[defaults.routing]\n");
+    config_content.push_str(&format!("channel = \"{}\"\n", routing.channel));
+    config_content.push_str(&format!("branch = \"{}\"\n", routing.branch));
+    config_content.push_str(&format!("worker = \"{}\"\n", routing.worker));
+    config_content.push_str(&format!("compactor = \"{}\"\n", routing.compactor));
+    config_content.push_str(&format!("cortex = \"{}\"\n", routing.cortex));
+    config_content.push('\n');
+
+    config_content.push_str("[[agents]]\n");
+    config_content.push_str(&format!("id = \"{agent_id}\"\n"));
+    config_content.push_str("default = true\n");
+
+    if let Some(discord) = &discord {
+        config_content.push_str("\n[messaging.discord]\n");
+        config_content.push_str("enabled = true\n");
+        config_content.push_str(&format!("token = \"{}\"\n", discord.token));
+
+        // Write the binding
+        config_content.push_str("\n[[bindings]]\n");
+        config_content.push_str(&format!("agent_id = \"{agent_id}\"\n"));
+        config_content.push_str("channel = \"discord\"\n");
+        if let Some(guild_id) = &discord.guild_id {
+            config_content.push_str(&format!("guild_id = \"{guild_id}\"\n"));
+        }
+        if !discord.channel_ids.is_empty() {
+            let ids: Vec<String> = discord
+                .channel_ids
+                .iter()
+                .map(|id| format!("\"{id}\""))
+                .collect();
+            config_content.push_str(&format!("channel_ids = [{}]\n", ids.join(", ")));
+        }
+        if !discord.dm_user_ids.is_empty() {
+            let ids: Vec<String> = discord
+                .dm_user_ids
+                .iter()
+                .map(|id| format!("\"{id}\""))
+                .collect();
+            config_content.push_str(&format!("dm_allowed_users = [{}]\n", ids.join(", ")));
+        }
+    }
+
+    let mut file = std::fs::File::create(&config_path)
+        .with_context(|| format!("failed to create {}", config_path.display()))?;
+    file.write_all(config_content.as_bytes())?;
+
+    println!();
+    println!("  Config written to {}", config_path.display());
+    println!("  Agent '{}' created.", agent_id);
+    println!();
+    println!("  You can customize identity files in:");
+    println!(
+        "    {}/agents/{}/workspace/",
+        instance_dir.display(),
+        agent_id
+    );
+    println!();
+
+    Ok(Some(config_path))
+}
diff --git a/src/config/permissions.rs b/src/config/permissions.rs
new file mode 100644
index 000000000..8844cf614
--- /dev/null
+++ b/src/config/permissions.rs
@@ -0,0 +1,335 @@
+use super::{
+    Binding, DiscordConfig, DiscordInstanceConfig, SlackConfig, SlackInstanceConfig,
+    TelegramConfig, TelegramInstanceConfig, TwitchConfig, TwitchInstanceConfig,
+};
+use std::collections::HashMap;
+
+/// Hot-reloadable Discord permission filters.
+///
+/// Derived from bindings + discord config. Shared with the Discord adapter
+/// via `Arc<ArcSwap<..>>` so the file watcher can swap in new values without
+/// restarting the gateway connection.
+#[derive(Debug, Clone, Default)]
+pub struct DiscordPermissions {
+    pub guild_filter: Option<Vec<u64>>,
+    pub channel_filter: HashMap<u64, Vec<u64>>,
+    pub dm_allowed_users: Vec<u64>,
+    pub allow_bot_messages: bool,
+}
+
+impl DiscordPermissions {
+    /// Build from the current config's discord settings and bindings.
+    pub fn from_config(discord: &DiscordConfig, bindings: &[Binding]) -> Self {
+        Self::from_bindings_for_adapter(
+            discord.dm_allowed_users.clone(),
+            discord.allow_bot_messages,
+            bindings,
+            None,
+        )
+    }
+
+    /// Build permissions for a named Discord adapter instance.
+    pub fn from_instance_config(instance: &DiscordInstanceConfig, bindings: &[Binding]) -> Self {
+        Self::from_bindings_for_adapter(
+            instance.dm_allowed_users.clone(),
+            instance.allow_bot_messages,
+            bindings,
+            Some(instance.name.as_str()),
+        )
+    }
+
+    fn from_bindings_for_adapter(
+        seed_dm_allowed_users: Vec<String>,
+        allow_bot_messages: bool,
+        bindings: &[Binding],
+        adapter_selector: Option<&str>,
+    ) -> Self {
+        let discord_bindings: Vec<&Binding> = bindings
+            .iter()
+            .filter(|binding| {
+                binding.channel == "discord"
+                    && binding_adapter_selector_matches(binding, adapter_selector)
+            })
+            .collect();
+
+        let guild_filter = {
+            let guild_ids: Vec<u64> = discord_bindings
+                .iter()
+                .filter_map(|b| b.guild_id.as_ref()?.parse::<u64>().ok())
+                .collect();
+            if guild_ids.is_empty() {
+                None
+            } else {
+                Some(guild_ids)
+            }
+        };
+
+        let channel_filter = {
+            let mut filter: HashMap<u64, Vec<u64>> = HashMap::new();
+            for binding in &discord_bindings {
+                if let Some(guild_id) = binding
+                    .guild_id
+                    .as_ref()
+                    .and_then(|g| g.parse::<u64>().ok())
+                    && !binding.channel_ids.is_empty()
+                {
+                    let channel_ids: Vec<u64> = binding
+                        .channel_ids
+                        .iter()
+                        .filter_map(|id| id.parse::<u64>().ok())
+                        .collect();
+                    filter.entry(guild_id).or_default().extend(channel_ids);
+                }
+            }
+            filter
+        };
+
+        let mut dm_allowed_users: Vec<u64> = seed_dm_allowed_users
+            .iter()
+            .filter_map(|id| id.parse::<u64>().ok())
+            .collect();
+
+        // Also collect dm_allowed_users from bindings
+        for binding in &discord_bindings {
+            for id in &binding.dm_allowed_users {
+                if let Ok(uid) = id.parse::<u64>()
+                    && !dm_allowed_users.contains(&uid)
+                {
+                    dm_allowed_users.push(uid);
+                }
+            }
+        }
+
+        Self {
+            guild_filter,
+            channel_filter,
+            dm_allowed_users,
+            allow_bot_messages,
+        }
+    }
+}
+
+/// Hot-reloadable Slack permission filters.
+///
+/// Shared with the Slack adapter via `Arc<ArcSwap<..>>` for hot-reloading.
+#[derive(Debug, Clone, Default)]
+pub struct SlackPermissions {
+    pub workspace_filter: Option<Vec<String>>, // team IDs
+    pub channel_filter: HashMap<String, Vec<String>>, // team_id -> allowed channel_ids
+    pub dm_allowed_users: Vec<String>,         // user IDs
+}
+
+impl SlackPermissions {
+    /// Build from the current config's slack settings and bindings.
+    pub fn from_config(slack: &SlackConfig, bindings: &[Binding]) -> Self {
+        Self::from_bindings_for_adapter(slack.dm_allowed_users.clone(), bindings, None)
+    }
+
+    /// Build permissions for a named Slack adapter instance.
+    pub fn from_instance_config(instance: &SlackInstanceConfig, bindings: &[Binding]) -> Self {
+        Self::from_bindings_for_adapter(
+            instance.dm_allowed_users.clone(),
+            bindings,
+            Some(instance.name.as_str()),
+        )
+    }
+
+    fn from_bindings_for_adapter(
+        seed_dm_allowed_users: Vec<String>,
+        bindings: &[Binding],
+        adapter_selector: Option<&str>,
+    ) -> Self {
+        let slack_bindings: Vec<&Binding> = bindings
+            .iter()
+            .filter(|binding| {
+                binding.channel == "slack"
+                    && binding_adapter_selector_matches(binding, adapter_selector)
+            })
+            .collect();
+
+        let workspace_filter = {
+            let workspace_ids: Vec<String> = slack_bindings
+                .iter()
+                .filter_map(|b| b.workspace_id.clone())
+                .collect();
+            if workspace_ids.is_empty() {
+                None
+            } else {
+                Some(workspace_ids)
+            }
+        };
+
+        let channel_filter = {
+            let mut filter: HashMap<String, Vec<String>> = HashMap::new();
+            for binding in &slack_bindings {
+                if let Some(workspace_id) = &binding.workspace_id
+                    && !binding.channel_ids.is_empty()
+                {
+                    filter
+                        .entry(workspace_id.clone())
+                        .or_default()
+                        .extend(binding.channel_ids.clone());
+                }
+            }
+            filter
+        };
+
+        let mut dm_allowed_users = seed_dm_allowed_users;
+
+        for binding in &slack_bindings {
+            for id in &binding.dm_allowed_users {
+                if !dm_allowed_users.contains(id) {
+                    dm_allowed_users.push(id.clone());
+                }
+            }
+        }
+
+        Self {
+            workspace_filter,
+            channel_filter,
+            dm_allowed_users,
+        }
+    }
+}
+
+/// Hot-reloadable Telegram permission filters.
+///
+/// Shared with the Telegram adapter via `Arc<ArcSwap<..>>` for hot-reloading.
+#[derive(Debug, Clone, Default)]
+pub struct TelegramPermissions {
+    /// Allowed chat IDs (None = all chats accepted).
+    pub chat_filter: Option<Vec<i64>>,
+    /// User IDs allowed in private chats.
+    pub dm_allowed_users: Vec<i64>,
+}
+
+impl TelegramPermissions {
+    /// Build from the current config's telegram settings and bindings.
+    pub fn from_config(telegram: &TelegramConfig, bindings: &[Binding]) -> Self {
+        Self::from_bindings_for_adapter(telegram.dm_allowed_users.clone(), bindings, None)
+    }
+
+    /// Build permissions for a named Telegram adapter instance.
+    pub fn from_instance_config(instance: &TelegramInstanceConfig, bindings: &[Binding]) -> Self {
+        Self::from_bindings_for_adapter(
+            instance.dm_allowed_users.clone(),
+            bindings,
+            Some(instance.name.as_str()),
+        )
+    }
+
+    fn from_bindings_for_adapter(
+        seed_dm_allowed_users: Vec<String>,
+        bindings: &[Binding],
+        adapter_selector: Option<&str>,
+    ) -> Self {
+        let telegram_bindings: Vec<&Binding> = bindings
+            .iter()
+            .filter(|binding| {
+                binding.channel == "telegram"
+                    && binding_adapter_selector_matches(binding, adapter_selector)
+            })
+            .collect();
+
+        let chat_filter = {
+            let chat_ids: Vec<i64> = telegram_bindings
+                .iter()
+                .filter_map(|b| b.chat_id.as_ref()?.parse::<i64>().ok())
+                .collect();
+            if chat_ids.is_empty() {
+                None
+            } else {
+                Some(chat_ids)
+            }
+        };
+
+        let mut dm_allowed_users: Vec<i64> = seed_dm_allowed_users
+            .iter()
+            .filter_map(|id| id.parse::<i64>().ok())
+            .collect();
+
+        for binding in &telegram_bindings {
+            for id in &binding.dm_allowed_users {
+                if let Ok(uid) = id.parse::<i64>()
+                    && !dm_allowed_users.contains(&uid)
+                {
+                    dm_allowed_users.push(uid);
+                }
+            }
+        }
+
+        Self {
+            chat_filter,
+            dm_allowed_users,
+        }
+    }
+}
+
+/// Hot-reloadable Twitch permission filters.
+///
+/// Shared with the Twitch adapter via `Arc<ArcSwap<..>>` for hot-reloading.
+#[derive(Debug, Clone, Default)]
+pub struct TwitchPermissions {
+    /// Allowed channel names (None = all joined channels accepted).
+    pub channel_filter: Option<Vec<String>>,
+    /// User login names allowed to interact with the bot. Empty = all users.
+    pub allowed_users: Vec<String>,
+}
+
+impl TwitchPermissions {
+    /// Build from the current config's twitch settings and bindings.
+    pub fn from_config(_twitch: &TwitchConfig, bindings: &[Binding]) -> Self {
+        Self::from_bindings_for_adapter(bindings, None)
+    }
+
+    /// Build permissions for a named Twitch adapter instance.
+    pub fn from_instance_config(instance: &TwitchInstanceConfig, bindings: &[Binding]) -> Self {
+        Self::from_bindings_for_adapter(bindings, Some(instance.name.as_str()))
+    }
+
+    fn from_bindings_for_adapter(bindings: &[Binding], adapter_selector: Option<&str>) -> Self {
+        let twitch_bindings: Vec<&Binding> = bindings
+            .iter()
+            .filter(|binding| {
+                binding.channel == "twitch"
+                    && binding_adapter_selector_matches(binding, adapter_selector)
+            })
+            .collect();
+
+        let channel_filter = {
+            let channel_ids: Vec<String> = twitch_bindings
+                .iter()
+                .flat_map(|b| b.channel_ids.clone())
+                .collect();
+            if channel_ids.is_empty() {
+                None
+            } else {
+                Some(channel_ids)
+            }
+        };
+
+        let mut allowed_users: Vec<String> = Vec::new();
+        for binding in &twitch_bindings {
+            for id in &binding.dm_allowed_users {
+                if !allowed_users.contains(id) {
+                    allowed_users.push(id.clone());
+                }
+            }
+        }
+
+        Self {
+            channel_filter,
+            allowed_users,
+        }
+    }
+}
+
+fn binding_adapter_selector_matches(binding: &Binding, adapter_selector: Option<&str>) -> bool {
+    match (binding.adapter.as_deref(), adapter_selector) {
+        (None, None) => true,
+        (Some(binding_selector), Some(requested_selector)) => {
+            binding_selector == requested_selector
+        }
+        _ => false,
+    }
+}
diff --git a/src/config/providers.rs b/src/config/providers.rs
new file mode 100644
index 000000000..096b58606
--- /dev/null
+++ b/src/config/providers.rs
@@ -0,0 +1,335 @@
+use super::toml_schema::TomlRoutingConfig;
+use super::{ApiType, ProviderConfig};
+use crate::llm::routing::RoutingConfig;
+
+use std::collections::HashMap;
+
+pub(super) const ANTHROPIC_PROVIDER_BASE_URL: &str = "https://api.anthropic.com";
+pub(super) const OPENAI_PROVIDER_BASE_URL: &str = "https://api.openai.com";
+pub(super) const OPENROUTER_PROVIDER_BASE_URL: &str = "https://openrouter.ai/api";
+pub(super) const KILO_PROVIDER_BASE_URL: &str = "https://api.kilo.ai/api/gateway";
+pub(super) const OLLAMA_PROVIDER_BASE_URL: &str = "http://localhost:11434";
+pub(super) const OPENCODE_ZEN_PROVIDER_BASE_URL: &str = "https://opencode.ai/zen";
+pub(super) const OPENCODE_GO_PROVIDER_BASE_URL: &str = "https://opencode.ai/zen/go";
+pub(super) const MINIMAX_PROVIDER_BASE_URL: &str = "https://api.minimax.io/anthropic";
+pub(super) const MINIMAX_CN_PROVIDER_BASE_URL: &str = "https://api.minimaxi.com/anthropic";
+pub(super) const MOONSHOT_PROVIDER_BASE_URL: &str = "https://api.moonshot.ai";
+
+pub(super) const ZHIPU_PROVIDER_BASE_URL: &str = "https://api.z.ai/api/paas/v4";
+pub(super) const ZAI_CODING_PLAN_BASE_URL: &str = "https://api.z.ai/api/coding/paas/v4";
+pub(super) const DEEPSEEK_PROVIDER_BASE_URL: &str = "https://api.deepseek.com";
+pub(super) const GROQ_PROVIDER_BASE_URL: &str = "https://api.groq.com/openai";
+pub(super) const TOGETHER_PROVIDER_BASE_URL: &str = "https://api.together.xyz";
+pub(super) const XAI_PROVIDER_BASE_URL: &str = "https://api.x.ai";
+pub(super) const MISTRAL_PROVIDER_BASE_URL: &str = "https://api.mistral.ai";
+pub(super) const NVIDIA_PROVIDER_BASE_URL: &str = "https://integrate.api.nvidia.com";
+pub(super) const FIREWORKS_PROVIDER_BASE_URL: &str = "https://api.fireworks.ai/inference";
+pub(crate) const GEMINI_PROVIDER_BASE_URL: &str =
+    "https://generativelanguage.googleapis.com/v1beta/openai";
+
+/// App attribution headers sent with every OpenRouter API request.
+/// See <https://openrouter.ai/docs/app-attribution>.
+///
+/// We send both legacy (`X-Title`) and new (`X-OpenRouter-Title`) header names
+/// because (as of 2026-03-01) OpenRouter's backend still keys on the legacy names for populating
+/// the app listing (title, etc.).
+pub(super) fn openrouter_extra_headers() -> Vec<(String, String)> {
+    vec![
+        ("HTTP-Referer".into(), "https://spacebot.sh/".into()),
+        ("X-Title".into(), "Spacebot".into()),
+        ("X-OpenRouter-Title".into(), "Spacebot".into()),
+        (
+            "X-OpenRouter-Categories".into(),
+            "cloud-agent,cli-agent".into(),
+        ),
+    ]
+}
+
+/// Returns the default ProviderConfig for a provider ID and API key.
+/// Used by API tests and other code that needs provider configs without duplicating metadata.
+pub(crate) fn default_provider_config(
+    provider_id: &str,
+    api_key: impl Into<String>,
+) -> Option<ProviderConfig> {
+    let api_key = api_key.into();
+    Some(match provider_id {
+        "anthropic" => ProviderConfig {
+            api_type: ApiType::Anthropic,
+            base_url: ANTHROPIC_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "openai" => ProviderConfig {
+            api_type: ApiType::OpenAiCompletions,
+            base_url: OPENAI_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "openrouter" => ProviderConfig {
+            api_type: ApiType::OpenAiCompletions,
+            base_url: OPENROUTER_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: openrouter_extra_headers(),
+        },
+        "kilo" => ProviderConfig {
+            api_type: ApiType::KiloGateway,
+            base_url: KILO_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: Some("Kilo Gateway".to_string()),
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "zhipu" => ProviderConfig {
+            api_type: ApiType::OpenAiChatCompletions,
+            base_url: ZHIPU_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: Some("Z.AI (GLM)".to_string()),
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "groq" => ProviderConfig {
+            api_type: ApiType::OpenAiCompletions,
+            base_url: GROQ_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "together" => ProviderConfig {
+            api_type: ApiType::OpenAiCompletions,
+            base_url: TOGETHER_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "fireworks" => ProviderConfig {
+            api_type: ApiType::OpenAiCompletions,
+            base_url: FIREWORKS_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "deepseek" => ProviderConfig {
+            api_type: ApiType::OpenAiCompletions,
+            base_url: DEEPSEEK_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "xai" => ProviderConfig {
+            api_type: ApiType::OpenAiCompletions,
+            base_url: XAI_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "mistral" => ProviderConfig {
+            api_type: ApiType::OpenAiCompletions,
+            base_url: MISTRAL_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "gemini" => ProviderConfig {
+            api_type: ApiType::Gemini,
+            base_url: GEMINI_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "ollama" => ProviderConfig {
+            api_type: ApiType::OpenAiCompletions,
+            base_url: api_key,
+            api_key: String::new(),
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "opencode-zen" => ProviderConfig {
+            api_type: ApiType::OpenAiCompletions,
+            base_url: OPENCODE_ZEN_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "opencode-go" => ProviderConfig {
+            api_type: ApiType::OpenAiCompletions,
+            base_url: OPENCODE_GO_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "nvidia" => ProviderConfig {
+            api_type: ApiType::OpenAiCompletions,
+            base_url: NVIDIA_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "minimax" => ProviderConfig {
+            api_type: ApiType::Anthropic,
+            base_url: MINIMAX_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "minimax-cn" => ProviderConfig {
+            api_type: ApiType::Anthropic,
+            base_url: MINIMAX_CN_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "moonshot" => ProviderConfig {
+            api_type: ApiType::OpenAiCompletions,
+            base_url: MOONSHOT_PROVIDER_BASE_URL.to_string(),
+            api_key,
+            name: None,
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        "zai-coding-plan" => ProviderConfig {
+            api_type: ApiType::OpenAiChatCompletions,
+            base_url: ZAI_CODING_PLAN_BASE_URL.to_string(),
+            api_key,
+            name: Some("Z.AI Coding Plan".to_string()),
+            use_bearer_auth: false,
+            extra_headers: vec![],
+        },
+        _ => return None,
+    })
+}
+
+pub(super) fn add_shorthand_provider(
+    providers: &mut HashMap<String, ProviderConfig>,
+    provider_id: &str,
+    key: Option<String>,
+    api_type: ApiType,
+    base_url: &str,
+    name: Option<&str>,
+    use_bearer_auth: bool,
+) {
+    if let Some(api_key) = key {
+        providers
+            .entry(provider_id.to_string())
+            .or_insert_with(|| ProviderConfig {
+                api_type,
+                base_url: base_url.to_string(),
+                api_key,
+                name: name.map(str::to_string),
+                use_bearer_auth,
+                extra_headers: vec![],
+            });
+    }
+}
+
+/// When `[defaults.routing]` is absent from the config file, pick routing
+/// defaults based on which provider the user actually has configured.  This
+/// avoids the common pitfall where a user sets up OpenRouter (or another
+/// non-Anthropic provider) but new agents still default to
+/// `anthropic/claude-sonnet-4` and every LLM call fails.
+///
+/// Provider priority: first-party Anthropic first, then major gateways,
+/// then smaller providers. If the user only has one provider configured
+/// this always picks the right one.
+pub(super) fn infer_routing_from_providers(
+    providers: &HashMap<String, ProviderConfig>,
+) -> Option<RoutingConfig> {
+    const PRIORITY: &[&str] = &[
+        "anthropic",
+        "openrouter",
+        "kilo",
+        "openai",
+        "openai-chatgpt",
+        "deepseek",
+        "gemini",
+        "xai",
+        "groq",
+        "together",
+        "fireworks",
+        "mistral",
+        "zhipu",
+        "ollama",
+        "opencode-zen",
+        "opencode-go",
+        "nvidia",
+        "minimax",
+        "minimax-cn",
+        "moonshot",
+        "zai-coding-plan",
+    ];
+
+    for &name in PRIORITY {
+        if providers.contains_key(name) {
+            return Some(crate::llm::routing::defaults_for_provider(name));
+        }
+    }
+
+    // Fall back to the first provider in the map (covers custom providers).
+    providers
+        .keys()
+        .next()
+        .map(|name| crate::llm::routing::defaults_for_provider(name))
+}
+
+/// Resolve a TomlRoutingConfig against a base RoutingConfig.
+pub(super) fn resolve_routing(
+    toml: Option<TomlRoutingConfig>,
+    base: &RoutingConfig,
+) -> RoutingConfig {
+    let Some(t) = toml else { return base.clone() };
+
+    let mut task_overrides = base.task_overrides.clone();
+    task_overrides.extend(t.task_overrides);
+
+    let fallbacks = match t.fallbacks {
+        Some(f) => f,
+        None => base.fallbacks.clone(),
+    };
+
+    RoutingConfig {
+        channel: t.channel.unwrap_or_else(|| base.channel.clone()),
+        branch: t.branch.unwrap_or_else(|| base.branch.clone()),
+        worker: t.worker.unwrap_or_else(|| base.worker.clone()),
+        compactor: t.compactor.unwrap_or_else(|| base.compactor.clone()),
+        cortex: t.cortex.unwrap_or_else(|| base.cortex.clone()),
+        voice: t.voice.unwrap_or_else(|| base.voice.clone()),
+        task_overrides,
+        fallbacks,
+        rate_limit_cooldown_secs: t
+            .rate_limit_cooldown_secs
+            .unwrap_or(base.rate_limit_cooldown_secs),
+        channel_thinking_effort: t
+            .channel_thinking_effort
+            .unwrap_or_else(|| base.channel_thinking_effort.clone()),
+        branch_thinking_effort: t
+            .branch_thinking_effort
+            .unwrap_or_else(|| base.branch_thinking_effort.clone()),
+        worker_thinking_effort: t
+            .worker_thinking_effort
+            .unwrap_or_else(|| base.worker_thinking_effort.clone()),
+        compactor_thinking_effort: t
+            .compactor_thinking_effort
+            .unwrap_or_else(|| base.compactor_thinking_effort.clone()),
+        cortex_thinking_effort: t
+            .cortex_thinking_effort
+            .unwrap_or_else(|| base.cortex_thinking_effort.clone()),
+    }
+}
diff --git a/src/config/runtime.rs b/src/config/runtime.rs
new file mode 100644
index 000000000..47dfb70df
--- /dev/null
+++ b/src/config/runtime.rs
@@ -0,0 +1,317 @@
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use arc_swap::ArcSwap;
+
+use super::{
+    BrowserConfig, ChannelConfig, CoalesceConfig, CompactionConfig, Config, CortexConfig,
+    DefaultsConfig, IngestionConfig, McpServerConfig, MemoryPersistenceConfig, OpenCodeConfig,
+    ResolvedAgentConfig, WarmupConfig, WarmupStatus, WorkReadiness, evaluate_work_readiness,
+};
+use crate::llm::routing::RoutingConfig;
+use crate::tools::browser::SharedBrowserHandle;
+
+/// Live configuration that can be hot-reloaded without restarting.
+///
+/// All fields use ArcSwap for lock-free reads. Consumers call `.load()` on
+/// individual fields to get a snapshot — cheap and contention-free.
+/// The file watcher calls `.store()` to atomically swap in new values.
+pub struct RuntimeConfig {
+    /// Instance root directory (e.g., ~/.spacebot). Immutable after startup.
+    pub instance_dir: PathBuf,
+    /// Agent workspace directory (e.g., ~/.spacebot/agents/{id}/workspace). Immutable after startup.
+    pub workspace_dir: PathBuf,
+    pub routing: ArcSwap<RoutingConfig>,
+    pub compaction: ArcSwap<CompactionConfig>,
+    pub memory_persistence: ArcSwap<MemoryPersistenceConfig>,
+    pub coalesce: ArcSwap<CoalesceConfig>,
+    pub ingestion: ArcSwap<IngestionConfig>,
+    pub channel_config: ArcSwap<ChannelConfig>,
+    pub max_turns: ArcSwap<usize>,
+    pub branch_max_turns: ArcSwap<usize>,
+    pub context_window: ArcSwap<usize>,
+    pub max_concurrent_branches: ArcSwap<usize>,
+    pub max_concurrent_workers: ArcSwap<usize>,
+    pub browser_config: ArcSwap<BrowserConfig>,
+    pub mcp: ArcSwap<Vec<McpServerConfig>>,
+    pub history_backfill_count: ArcSwap<usize>,
+    pub brave_search_key: ArcSwap<Option<String>>,
+    pub cron_timezone: ArcSwap<Option<String>>,
+    pub user_timezone: ArcSwap<Option<String>>,
+    pub cortex: ArcSwap<CortexConfig>,
+    pub warmup: ArcSwap<WarmupConfig>,
+    /// Current warmup lifecycle status for API and observability.
+    pub warmup_status: ArcSwap<WarmupStatus>,
+    /// Synchronizes warmup passes so periodic and API-triggered runs don't overlap.
+    pub warmup_lock: Arc<tokio::sync::Mutex<()>>,
+    /// Cached memory bulletin generated by the cortex. Injected into every
+    /// channel's system prompt. Empty string until the first cortex run.
+    pub memory_bulletin: ArcSwap<String>,
+    pub prompts: ArcSwap<crate::prompts::PromptEngine>,
+    pub identity: ArcSwap<crate::identity::Identity>,
+    pub skills: ArcSwap<crate::skills::SkillSet>,
+    pub opencode: ArcSwap<OpenCodeConfig>,
+    /// Shared pool of OpenCode server processes. Lazily initialized on first use.
+    pub opencode_server_pool: ArcSwap<crate::opencode::OpenCodeServerPool>,
+    /// Cron store, set after agent initialization.
+    pub cron_store: ArcSwap<Option<Arc<crate::cron::CronStore>>>,
+    /// Cron scheduler, set after agent initialization.
+    pub cron_scheduler: ArcSwap<Option<Arc<crate::cron::Scheduler>>>,
+    /// Settings store for agent-specific configuration.
+    pub settings: ArcSwap<Option<Arc<crate::settings::SettingsStore>>>,
+    /// Tracks whether listen_only_mode is explicitly configured via agent/env.
+    /// When set, channel-local persisted values must not override it.
+    pub channel_listen_only_explicit: ArcSwap<Option<bool>>,
+    /// Secrets store for encrypted credential storage.
+    pub secrets: ArcSwap<Option<Arc<crate::secrets::store::SecretsStore>>>,
+    /// Sandbox configuration for process containment.
+    ///
+    /// Wrapped in `Arc` so it can be shared with the `Sandbox` struct, which
+    /// reads the current mode dynamically on every `wrap()` call.
+    pub sandbox: Arc<ArcSwap<crate::sandbox::SandboxConfig>>,
+    /// Shared browser state for persistent sessions.
+    ///
+    /// When `browser.persist_session = true`, all workers share this handle so
+    /// the browser process and tabs survive across worker lifetimes. When
+    /// `persist_session = false` this is `None` and each worker creates its own.
+    pub shared_browser: Option<SharedBrowserHandle>,
+}
+
+impl RuntimeConfig {
+    /// Build from a resolved agent config, loaded prompts, identity, and skills.
+    pub fn new(
+        instance_dir: &Path,
+        agent_config: &ResolvedAgentConfig,
+        defaults: &DefaultsConfig,
+        prompts: crate::prompts::PromptEngine,
+        identity: crate::identity::Identity,
+        skills: crate::skills::SkillSet,
+    ) -> Self {
+        let opencode_config = &defaults.opencode;
+        let server_pool = crate::opencode::OpenCodeServerPool::new(
+            opencode_config.path.clone(),
+            opencode_config.permissions.clone(),
+            opencode_config.max_servers,
+        );
+
+        Self {
+            instance_dir: instance_dir.to_path_buf(),
+            workspace_dir: agent_config.workspace.clone(),
+            routing: ArcSwap::from_pointee(agent_config.routing.clone()),
+            compaction: ArcSwap::from_pointee(agent_config.compaction),
+            memory_persistence: ArcSwap::from_pointee(agent_config.memory_persistence),
+            coalesce: ArcSwap::from_pointee(agent_config.coalesce),
+            ingestion: ArcSwap::from_pointee(agent_config.ingestion),
+            channel_config: ArcSwap::from_pointee(agent_config.channel),
+            max_turns: ArcSwap::from_pointee(agent_config.max_turns),
+            branch_max_turns: ArcSwap::from_pointee(agent_config.branch_max_turns),
+            context_window: ArcSwap::from_pointee(agent_config.context_window),
+            max_concurrent_branches: ArcSwap::from_pointee(agent_config.max_concurrent_branches),
+            max_concurrent_workers: ArcSwap::from_pointee(agent_config.max_concurrent_workers),
+            browser_config: ArcSwap::from_pointee(agent_config.browser.clone()),
+            mcp: ArcSwap::from_pointee(agent_config.mcp.clone()),
+            history_backfill_count: ArcSwap::from_pointee(agent_config.history_backfill_count),
+            brave_search_key: ArcSwap::from_pointee(agent_config.brave_search_key.clone()),
+            cron_timezone: ArcSwap::from_pointee(agent_config.cron_timezone.clone()),
+            user_timezone: ArcSwap::from_pointee(agent_config.user_timezone.clone()),
+            cortex: ArcSwap::from_pointee(agent_config.cortex),
+            warmup: ArcSwap::from_pointee(agent_config.warmup),
+            warmup_status: ArcSwap::from_pointee(WarmupStatus::default()),
+            warmup_lock: Arc::new(tokio::sync::Mutex::new(())),
+            memory_bulletin: ArcSwap::from_pointee(String::new()),
+            prompts: ArcSwap::from_pointee(prompts),
+            identity: ArcSwap::from_pointee(identity),
+            skills: ArcSwap::from_pointee(skills),
+            opencode: ArcSwap::from_pointee(defaults.opencode.clone()),
+            opencode_server_pool: ArcSwap::from_pointee(server_pool),
+            cron_store: ArcSwap::from_pointee(None),
+            cron_scheduler: ArcSwap::from_pointee(None),
+            settings: ArcSwap::from_pointee(None),
+            channel_listen_only_explicit: ArcSwap::from_pointee(None),
+            secrets: ArcSwap::from_pointee(None),
+            sandbox: Arc::new(ArcSwap::from_pointee(agent_config.sandbox.clone())),
+            shared_browser: if agent_config.browser.persist_session {
+                Some(crate::tools::browser::new_shared_browser_handle())
+            } else {
+                None
+            },
+        }
+    }
+
+    /// Set the cron store and scheduler after initialization.
+    pub fn set_cron(
+        &self,
+        store: Arc<crate::cron::CronStore>,
+        scheduler: Arc<crate::cron::Scheduler>,
+    ) {
+        self.cron_store.store(Arc::new(Some(store)));
+        self.cron_scheduler.store(Arc::new(Some(scheduler)));
+    }
+
+    /// Set the settings store after initialization.
+    pub fn set_settings(
+        &self,
+        settings: Arc<crate::settings::SettingsStore>,
+        explicit_listen_only: Option<bool>,
+    ) {
+        self.settings.store(Arc::new(Some(settings.clone())));
+        self.channel_listen_only_explicit
+            .store(Arc::new(explicit_listen_only));
+        if explicit_listen_only.is_none() {
+            match settings.channel_listen_only_mode() {
+                Ok(Some(enabled)) => {
+                    self.channel_config.rcu(move |current| {
+                        let mut next = **current;
+                        next.listen_only_mode = enabled;
+                        Arc::new(next)
+                    });
+                }
+                Ok(None) => {}
+                Err(error) => {
+                    tracing::warn!(%error, "failed to load persisted channel listen_only_mode");
+                }
+            }
+        }
+    }
+
+    /// Set the secrets store after initialization.
+    pub fn set_secrets(&self, secrets: Arc<crate::secrets::store::SecretsStore>) {
+        self.secrets.store(Arc::new(Some(secrets)));
+    }
+
+    /// Compute the current dispatch-readiness signal.
+    pub fn work_readiness(&self) -> WorkReadiness {
+        let warmup_config = **self.warmup.load();
+        let status = self.warmup_status.load().as_ref().clone();
+        evaluate_work_readiness(warmup_config, status, chrono::Utc::now().timestamp_millis())
+    }
+
+    /// True when branch/worker/cron dispatches should run in fully-ready mode.
+    pub fn ready_for_work(&self) -> bool {
+        self.work_readiness().ready
+    }
+
+    /// Reload tunable config values from a freshly parsed Config.
+    ///
+    /// Finds the matching agent by ID, re-resolves it against defaults, and
+    /// swaps all reloadable fields. Does not handle API keys (those are
+    /// reloaded via LlmManager), DB paths, messaging adapters, or agent
+    /// topology.
+    pub async fn reload_config(
+        &self,
+        config: &Config,
+        agent_id: &str,
+        mcp_manager: &crate::mcp::McpManager,
+    ) {
+        let agent = config.agents.iter().find(|a| a.id == agent_id);
+        let Some(agent) = agent else {
+            tracing::warn!(agent_id, "agent not found in reloaded config, skipping");
+            return;
+        };
+
+        let resolved = agent.resolve(&config.instance_dir, &config.defaults);
+        let old_mcp = (**self.mcp.load()).clone();
+        let new_mcp = resolved.mcp.clone();
+
+        self.routing.store(Arc::new(resolved.routing));
+        self.compaction.store(Arc::new(resolved.compaction));
+        self.memory_persistence
+            .store(Arc::new(resolved.memory_persistence));
+        self.coalesce.store(Arc::new(resolved.coalesce));
+        self.ingestion.store(Arc::new(resolved.ingestion));
+        let resolved_channel = resolved.channel;
+        let configured_listen_only = agent.channel.map(|channel| channel.listen_only_mode);
+        self.channel_listen_only_explicit
+            .store(Arc::new(configured_listen_only));
+        let persisted_listen_only = self.settings.load().as_ref().as_ref().and_then(|settings| {
+            match settings.channel_listen_only_mode() {
+                Ok(value) => value,
+                Err(error) => {
+                    tracing::warn!(
+                        %error,
+                        "failed to load persisted channel listen_only_mode during reload"
+                    );
+                    None
+                }
+            }
+        });
+        self.channel_config.rcu(move |current| {
+            let mut next = resolved_channel;
+            next.listen_only_mode = configured_listen_only
+                .or(persisted_listen_only)
+                .unwrap_or(current.as_ref().listen_only_mode);
+            Arc::new(next)
+        });
+        self.max_turns.store(Arc::new(resolved.max_turns));
+        self.branch_max_turns
+            .store(Arc::new(resolved.branch_max_turns));
+        self.context_window.store(Arc::new(resolved.context_window));
+        self.max_concurrent_branches
+            .store(Arc::new(resolved.max_concurrent_branches));
+        self.max_concurrent_workers
+            .store(Arc::new(resolved.max_concurrent_workers));
+        let old_persist = self.browser_config.load().persist_session;
+        let new_persist = resolved.browser.persist_session;
+        if old_persist != new_persist {
+            tracing::warn!(
+                agent_id,
+                old = old_persist,
+                new = new_persist,
+                "persist_session changed — restart the agent for this to take effect"
+            );
+        }
+        self.browser_config.store(Arc::new(resolved.browser));
+        self.mcp.store(Arc::new(new_mcp.clone()));
+        self.history_backfill_count
+            .store(Arc::new(resolved.history_backfill_count));
+        self.brave_search_key
+            .store(Arc::new(resolved.brave_search_key));
+        self.cron_timezone.store(Arc::new(resolved.cron_timezone));
+        self.user_timezone.store(Arc::new(resolved.user_timezone));
+        self.cortex.store(Arc::new(resolved.cortex));
+        self.warmup.store(Arc::new(resolved.warmup));
+        self.sandbox.store(Arc::new(resolved.sandbox.clone()));
+
+        let old_opencode = self.opencode.load().as_ref().clone();
+        let new_opencode = config.defaults.opencode.clone();
+        self.opencode.store(Arc::new(new_opencode.clone()));
+
+        let should_rebuild_opencode_pool = old_opencode.path != new_opencode.path
+            || old_opencode.max_servers != new_opencode.max_servers
+            || old_opencode.permissions != new_opencode.permissions;
+        if should_rebuild_opencode_pool {
+            let new_pool = crate::opencode::OpenCodeServerPool::new(
+                new_opencode.path.clone(),
+                new_opencode.permissions.clone(),
+                new_opencode.max_servers,
+            );
+            self.opencode_server_pool.store(Arc::new(new_pool));
+            tracing::info!(
+                agent_id,
+                "reloaded opencode server pool with updated path/permissions/limits"
+            );
+        }
+
+        mcp_manager.reconcile(&old_mcp, &new_mcp).await;
+
+        tracing::info!(agent_id, "runtime config reloaded");
+    }
+
+    /// Reload identity files from disk.
+    pub fn reload_identity(&self, identity: crate::identity::Identity) {
+        self.identity.store(Arc::new(identity));
+        tracing::info!("identity reloaded");
+    }
+
+    /// Reload skills from disk.
+    pub fn reload_skills(&self, skills: crate::skills::SkillSet) {
+        self.skills.store(Arc::new(skills));
+        tracing::info!("skills reloaded");
+    }
+}
+
+impl std::fmt::Debug for RuntimeConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("RuntimeConfig").finish_non_exhaustive()
+    }
+}
diff --git a/src/config/toml_schema.rs b/src/config/toml_schema.rs
new file mode 100644
index 000000000..b1f3041c0
--- /dev/null
+++ b/src/config/toml_schema.rs
@@ -0,0 +1,720 @@
+// -- TOML deserialization types --
+
+use serde::{Deserialize, Deserializer};
+use std::collections::HashMap;
+
+#[derive(Deserialize)]
+pub(super) struct TomlConfig {
+    #[serde(default)]
+    pub(super) llm: TomlLlmConfig,
+    #[serde(default)]
+    pub(super) defaults: TomlDefaultsConfig,
+    #[serde(default)]
+    pub(super) agents: Vec<TomlAgentConfig>,
+    #[serde(default)]
+    pub(super) links: Vec<TomlLinkDef>,
+    #[serde(default)]
+    pub(super) groups: Vec<TomlGroupDef>,
+    #[serde(default)]
+    pub(super) humans: Vec<TomlHumanDef>,
+    #[serde(default)]
+    pub(super) messaging: TomlMessagingConfig,
+    #[serde(default)]
+    pub(super) bindings: Vec<TomlBinding>,
+    #[serde(default)]
+    pub(super) api: TomlApiConfig,
+    #[serde(default)]
+    pub(super) metrics: TomlMetricsConfig,
+    #[serde(default)]
+    pub(super) telemetry: TomlTelemetryConfig,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlLinkDef {
+    pub(super) from: String,
+    pub(super) to: String,
+    #[serde(default = "default_link_direction")]
+    pub(super) direction: String,
+    #[serde(default = "default_link_kind")]
+    pub(super) kind: String,
+    /// Backward compat: old configs use `relationship` instead of `kind`
+    #[serde(default)]
+    pub(super) relationship: Option<String>,
+}
+
+pub(super) fn default_link_direction() -> String {
+    "two_way".into()
+}
+
+pub(super) fn default_link_kind() -> String {
+    "peer".into()
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlGroupDef {
+    pub(super) name: String,
+    #[serde(default)]
+    pub(super) agent_ids: Vec<String>,
+    pub(super) color: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlHumanDef {
+    pub(super) id: String,
+    pub(super) display_name: Option<String>,
+    pub(super) role: Option<String>,
+    pub(super) bio: Option<String>,
+}
+
+#[derive(Deserialize, Default)]
+pub(super) struct TomlTelemetryConfig {
+    pub(super) otlp_endpoint: Option<String>,
+    pub(super) otlp_headers: Option<String>,
+    pub(super) service_name: Option<String>,
+    pub(super) sample_rate: Option<f64>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlApiConfig {
+    #[serde(default = "default_api_enabled")]
+    pub(super) enabled: bool,
+    #[serde(default = "default_api_port")]
+    pub(super) port: u16,
+    #[serde(default = "default_api_bind")]
+    pub(super) bind: String,
+    #[serde(default)]
+    pub(super) auth_token: Option<String>,
+}
+
+impl Default for TomlApiConfig {
+    fn default() -> Self {
+        Self {
+            enabled: default_api_enabled(),
+            port: default_api_port(),
+            bind: default_api_bind(),
+            auth_token: None,
+        }
+    }
+}
+
+pub(super) fn default_api_enabled() -> bool {
+    true
+}
+pub(super) fn default_api_port() -> u16 {
+    19898
+}
+pub(super) fn default_api_bind() -> String {
+    "127.0.0.1".into()
+}
+
+pub(super) fn hosted_api_bind(bind: String) -> String {
+    match std::env::var("SPACEBOT_DEPLOYMENT") {
+        Ok(deployment) if deployment.eq_ignore_ascii_case("hosted") => "[::]".into(),
+        _ => bind,
+    }
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlMetricsConfig {
+    #[serde(default)]
+    pub(super) enabled: bool,
+    #[serde(default = "default_metrics_port")]
+    pub(super) port: u16,
+    #[serde(default = "default_metrics_bind")]
+    pub(super) bind: String,
+}
+
+impl Default for TomlMetricsConfig {
+    fn default() -> Self {
+        Self {
+            enabled: false,
+            port: default_metrics_port(),
+            bind: default_metrics_bind(),
+        }
+    }
+}
+
+pub(super) fn default_metrics_port() -> u16 {
+    9090
+}
+pub(super) fn default_metrics_bind() -> String {
+    "0.0.0.0".into()
+}
+
+#[derive(Deserialize, Debug)]
+pub(super) struct TomlProviderConfig {
+    pub(super) api_type: super::ApiType,
+    pub(super) base_url: String,
+    pub(super) api_key: String,
+    pub(super) name: Option<String>,
+}
+
+#[derive(Deserialize, Default)]
+pub(super) struct TomlLlmConfigFields {
+    pub(super) anthropic_key: Option<String>,
+    pub(super) openai_key: Option<String>,
+    pub(super) openrouter_key: Option<String>,
+    pub(super) kilo_key: Option<String>,
+    pub(super) zhipu_key: Option<String>,
+    pub(super) groq_key: Option<String>,
+    pub(super) together_key: Option<String>,
+    pub(super) fireworks_key: Option<String>,
+    pub(super) deepseek_key: Option<String>,
+    pub(super) xai_key: Option<String>,
+    pub(super) mistral_key: Option<String>,
+    pub(super) gemini_key: Option<String>,
+    pub(super) ollama_key: Option<String>,
+    pub(super) ollama_base_url: Option<String>,
+    pub(super) opencode_zen_key: Option<String>,
+    pub(super) opencode_go_key: Option<String>,
+    pub(super) nvidia_key: Option<String>,
+    pub(super) minimax_key: Option<String>,
+    pub(super) minimax_cn_key: Option<String>,
+    pub(super) moonshot_key: Option<String>,
+    pub(super) zai_coding_plan_key: Option<String>,
+    #[serde(default)]
+    pub(super) providers: HashMap<String, TomlProviderConfig>,
+    #[serde(default)]
+    #[serde(flatten)]
+    pub(super) extra: HashMap<String, toml::Value>,
+}
+
+#[derive(Default)]
+pub(super) struct TomlLlmConfig {
+    pub(super) anthropic_key: Option<String>,
+    pub(super) openai_key: Option<String>,
+    pub(super) openrouter_key: Option<String>,
+    pub(super) kilo_key: Option<String>,
+    pub(super) zhipu_key: Option<String>,
+    pub(super) groq_key: Option<String>,
+    pub(super) together_key: Option<String>,
+    pub(super) fireworks_key: Option<String>,
+    pub(super) deepseek_key: Option<String>,
+    pub(super) xai_key: Option<String>,
+    pub(super) mistral_key: Option<String>,
+    pub(super) gemini_key: Option<String>,
+    pub(super) ollama_key: Option<String>,
+    pub(super) ollama_base_url: Option<String>,
+    pub(super) opencode_zen_key: Option<String>,
+    pub(super) opencode_go_key: Option<String>,
+    pub(super) nvidia_key: Option<String>,
+    pub(super) minimax_key: Option<String>,
+    pub(super) minimax_cn_key: Option<String>,
+    pub(super) moonshot_key: Option<String>,
+    pub(super) zai_coding_plan_key: Option<String>,
+    pub(super) providers: HashMap<String, TomlProviderConfig>,
+}
+
+impl<'de> Deserialize<'de> for TomlLlmConfig {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let mut fields = TomlLlmConfigFields::deserialize(deserializer)?;
+        let mut providers = fields.providers;
+
+        for (key, value) in fields.extra {
+            if key == "provider" {
+                let table = value
+                    .as_table()
+                    .ok_or_else(|| serde::de::Error::custom("`llm.provider` must be a table"))?;
+                for (provider_id, provider_value) in table {
+                    let provider_config = provider_value
+                        .clone()
+                        .try_into()
+                        .map_err(serde::de::Error::custom)?;
+                    providers.insert(provider_id.to_string(), provider_config);
+                }
+            }
+
+            if let Some(provider_id) = key.strip_prefix("provider.") {
+                let provider_config = value.try_into().map_err(serde::de::Error::custom)?;
+                providers.insert(provider_id.to_string(), provider_config);
+            }
+        }
+
+        fields.providers = providers;
+
+        Ok(Self {
+            anthropic_key: fields.anthropic_key,
+            openai_key: fields.openai_key,
+            openrouter_key: fields.openrouter_key,
+            kilo_key: fields.kilo_key,
+            zhipu_key: fields.zhipu_key,
+            groq_key: fields.groq_key,
+            together_key: fields.together_key,
+            fireworks_key: fields.fireworks_key,
+            deepseek_key: fields.deepseek_key,
+            xai_key: fields.xai_key,
+            mistral_key: fields.mistral_key,
+            gemini_key: fields.gemini_key,
+            ollama_key: fields.ollama_key,
+            ollama_base_url: fields.ollama_base_url,
+            opencode_zen_key: fields.opencode_zen_key,
+            opencode_go_key: fields.opencode_go_key,
+            nvidia_key: fields.nvidia_key,
+            minimax_key: fields.minimax_key,
+            minimax_cn_key: fields.minimax_cn_key,
+            moonshot_key: fields.moonshot_key,
+            zai_coding_plan_key: fields.zai_coding_plan_key,
+            providers: fields.providers,
+        })
+    }
+}
+
+#[derive(Deserialize, Default)]
+pub(super) struct TomlDefaultsConfig {
+    pub(super) routing: Option<TomlRoutingConfig>,
+    pub(super) max_concurrent_branches: Option<usize>,
+    pub(super) max_concurrent_workers: Option<usize>,
+    pub(super) max_turns: Option<usize>,
+    pub(super) branch_max_turns: Option<usize>,
+    pub(super) context_window: Option<usize>,
+    pub(super) compaction: Option<TomlCompactionConfig>,
+    pub(super) memory_persistence: Option<TomlMemoryPersistenceConfig>,
+    pub(super) coalesce: Option<TomlCoalesceConfig>,
+    pub(super) ingestion: Option<TomlIngestionConfig>,
+    pub(super) cortex: Option<TomlCortexConfig>,
+    pub(super) warmup: Option<TomlWarmupConfig>,
+    pub(super) browser: Option<TomlBrowserConfig>,
+    pub(super) channel: Option<TomlChannelConfig>,
+    #[serde(default)]
+    pub(super) mcp: Vec<TomlMcpServerConfig>,
+    pub(super) brave_search_key: Option<String>,
+    pub(super) cron_timezone: Option<String>,
+    pub(super) user_timezone: Option<String>,
+    pub(super) opencode: Option<TomlOpenCodeConfig>,
+    pub(super) worker_log_mode: Option<String>,
+}
+
+#[derive(Deserialize, Default)]
+pub(super) struct TomlRoutingConfig {
+    pub(super) channel: Option<String>,
+    pub(super) branch: Option<String>,
+    pub(super) worker: Option<String>,
+    pub(super) compactor: Option<String>,
+    pub(super) cortex: Option<String>,
+    pub(super) voice: Option<String>,
+    pub(super) rate_limit_cooldown_secs: Option<u64>,
+    pub(super) channel_thinking_effort: Option<String>,
+    pub(super) branch_thinking_effort: Option<String>,
+    pub(super) worker_thinking_effort: Option<String>,
+    pub(super) compactor_thinking_effort: Option<String>,
+    pub(super) cortex_thinking_effort: Option<String>,
+    #[serde(default)]
+    pub(super) task_overrides: HashMap<String, String>,
+    pub(super) fallbacks: Option<HashMap<String, Vec<String>>>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlMemoryPersistenceConfig {
+    pub(super) enabled: Option<bool>,
+    pub(super) message_interval: Option<usize>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlCoalesceConfig {
+    pub(super) enabled: Option<bool>,
+    pub(super) debounce_ms: Option<u64>,
+    pub(super) max_wait_ms: Option<u64>,
+    pub(super) min_messages: Option<usize>,
+    pub(super) multi_user_only: Option<bool>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlIngestionConfig {
+    pub(super) enabled: Option<bool>,
+    pub(super) poll_interval_secs: Option<u64>,
+    pub(super) chunk_size: Option<usize>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlCompactionConfig {
+    pub(super) background_threshold: Option<f32>,
+    pub(super) aggressive_threshold: Option<f32>,
+    pub(super) emergency_threshold: Option<f32>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlCortexConfig {
+    pub(super) tick_interval_secs: Option<u64>,
+    pub(super) worker_timeout_secs: Option<u64>,
+    pub(super) branch_timeout_secs: Option<u64>,
+    pub(super) detached_worker_timeout_retry_limit: Option<u8>,
+    pub(super) supervisor_kill_budget_per_tick: Option<usize>,
+    pub(super) circuit_breaker_threshold: Option<u8>,
+    pub(super) bulletin_interval_secs: Option<u64>,
+    pub(super) bulletin_max_words: Option<usize>,
+    pub(super) bulletin_max_turns: Option<usize>,
+    pub(super) association_interval_secs: Option<u64>,
+    pub(super) association_similarity_threshold: Option<f32>,
+    pub(super) association_updates_threshold: Option<f32>,
+    pub(super) association_max_per_pass: Option<usize>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlWarmupConfig {
+    pub(super) enabled: Option<bool>,
+    pub(super) eager_embedding_load: Option<bool>,
+    pub(super) refresh_secs: Option<u64>,
+    pub(super) startup_delay_secs: Option<u64>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlBrowserConfig {
+    pub(super) enabled: Option<bool>,
+    pub(super) headless: Option<bool>,
+    pub(super) evaluate_enabled: Option<bool>,
+    pub(super) executable_path: Option<String>,
+    pub(super) screenshot_dir: Option<String>,
+    pub(super) persist_session: Option<bool>,
+    pub(super) close_policy: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlChannelConfig {
+    pub(super) listen_only_mode: Option<bool>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlOpenCodeConfig {
+    pub(super) enabled: Option<bool>,
+    pub(super) path: Option<String>,
+    pub(super) max_servers: Option<usize>,
+    pub(super) server_startup_timeout_secs: Option<u64>,
+    pub(super) max_restart_retries: Option<u32>,
+    pub(super) permissions: Option<TomlOpenCodePermissions>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlOpenCodePermissions {
+    pub(super) edit: Option<String>,
+    pub(super) bash: Option<String>,
+    pub(super) webfetch: Option<String>,
+}
+
+#[derive(Deserialize, Clone)]
+pub(super) struct TomlMcpServerConfig {
+    pub(super) name: String,
+    pub(super) transport: String,
+    #[serde(default = "default_mcp_enabled")]
+    pub(super) enabled: bool,
+    pub(super) command: Option<String>,
+    #[serde(default)]
+    pub(super) args: Vec<String>,
+    #[serde(default)]
+    pub(super) env: HashMap<String, String>,
+    pub(super) url: Option<String>,
+    #[serde(default)]
+    pub(super) headers: HashMap<String, String>,
+}
+
+pub(super) fn default_mcp_enabled() -> bool {
+    true
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlAgentConfig {
+    pub(super) id: String,
+    #[serde(default)]
+    pub(super) default: bool,
+    pub(super) display_name: Option<String>,
+    pub(super) role: Option<String>,
+    pub(super) workspace: Option<String>,
+    pub(super) routing: Option<TomlRoutingConfig>,
+    pub(super) max_concurrent_branches: Option<usize>,
+    pub(super) max_concurrent_workers: Option<usize>,
+    pub(super) max_turns: Option<usize>,
+    pub(super) branch_max_turns: Option<usize>,
+    pub(super) context_window: Option<usize>,
+    pub(super) compaction: Option<TomlCompactionConfig>,
+    pub(super) memory_persistence: Option<TomlMemoryPersistenceConfig>,
+    pub(super) coalesce: Option<TomlCoalesceConfig>,
+    pub(super) ingestion: Option<TomlIngestionConfig>,
+    pub(super) cortex: Option<TomlCortexConfig>,
+    pub(super) warmup: Option<TomlWarmupConfig>,
+    pub(super) browser: Option<TomlBrowserConfig>,
+    pub(super) channel: Option<TomlChannelConfig>,
+    pub(super) mcp: Option<Vec<TomlMcpServerConfig>>,
+    pub(super) brave_search_key: Option<String>,
+    pub(super) cron_timezone: Option<String>,
+    pub(super) user_timezone: Option<String>,
+    pub(super) sandbox: Option<crate::sandbox::SandboxConfig>,
+    #[serde(default)]
+    pub(super) cron: Vec<TomlCronDef>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlCronDef {
+    pub(super) id: String,
+    pub(super) prompt: String,
+    pub(super) cron_expr: Option<String>,
+    pub(super) interval_secs: Option<u64>,
+    pub(super) delivery_target: String,
+    pub(super) active_start_hour: Option<u8>,
+    pub(super) active_end_hour: Option<u8>,
+    #[serde(default = "default_enabled")]
+    pub(super) enabled: bool,
+    #[serde(default)]
+    pub(super) run_once: bool,
+    pub(super) timeout_secs: Option<u64>,
+}
+
+pub(super) fn default_enabled() -> bool {
+    true
+}
+
+#[derive(Deserialize, Default)]
+pub(super) struct TomlMessagingConfig {
+    pub(super) discord: Option<TomlDiscordConfig>,
+    pub(super) slack: Option<TomlSlackConfig>,
+    pub(super) telegram: Option<TomlTelegramConfig>,
+    pub(super) email: Option<TomlEmailConfig>,
+    pub(super) webhook: Option<TomlWebhookConfig>,
+    pub(super) twitch: Option<TomlTwitchConfig>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlDiscordConfig {
+    #[serde(default)]
+    pub(super) enabled: bool,
+    pub(super) token: Option<String>,
+    #[serde(default)]
+    pub(super) instances: Vec<TomlDiscordInstanceConfig>,
+    #[serde(default)]
+    pub(super) dm_allowed_users: Vec<String>,
+    #[serde(default)]
+    pub(super) allow_bot_messages: bool,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlDiscordInstanceConfig {
+    pub(super) name: String,
+    #[serde(default)]
+    pub(super) enabled: bool,
+    pub(super) token: Option<String>,
+    #[serde(default)]
+    pub(super) dm_allowed_users: Vec<String>,
+    #[serde(default)]
+    pub(super) allow_bot_messages: bool,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlSlackConfig {
+    #[serde(default)]
+    pub(super) enabled: bool,
+    pub(super) bot_token: Option<String>,
+    pub(super) app_token: Option<String>,
+    #[serde(default)]
+    pub(super) instances: Vec<TomlSlackInstanceConfig>,
+    #[serde(default)]
+    pub(super) dm_allowed_users: Vec<String>,
+    #[serde(default)]
+    pub(super) commands: Vec<TomlSlackCommandConfig>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlSlackInstanceConfig {
+    pub(super) name: String,
+    #[serde(default)]
+    pub(super) enabled: bool,
+    pub(super) bot_token: Option<String>,
+    pub(super) app_token: Option<String>,
+    #[serde(default)]
+    pub(super) dm_allowed_users: Vec<String>,
+    #[serde(default)]
+    pub(super) commands: Vec<TomlSlackCommandConfig>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlSlackCommandConfig {
+    pub(super) command: String,
+    pub(super) agent_id: String,
+    pub(super) description: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlTelegramConfig {
+    #[serde(default)]
+    pub(super) enabled: bool,
+    pub(super) token: Option<String>,
+    #[serde(default)]
+    pub(super) instances: Vec<TomlTelegramInstanceConfig>,
+    #[serde(default)]
+    pub(super) dm_allowed_users: Vec<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlTelegramInstanceConfig {
+    pub(super) name: String,
+    #[serde(default)]
+    pub(super) enabled: bool,
+    pub(super) token: Option<String>,
+    #[serde(default)]
+    pub(super) dm_allowed_users: Vec<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlEmailConfig {
+    #[serde(default)]
+    pub(super) enabled: bool,
+    pub(super) imap_host: Option<String>,
+    #[serde(default = "default_email_imap_port")]
+    pub(super) imap_port: u16,
+    pub(super) imap_username: Option<String>,
+    pub(super) imap_password: Option<String>,
+    #[serde(default = "default_email_imap_use_tls")]
+    pub(super) imap_use_tls: bool,
+    pub(super) smtp_host: Option<String>,
+    #[serde(default = "default_email_smtp_port")]
+    pub(super) smtp_port: u16,
+    pub(super) smtp_username: Option<String>,
+    pub(super) smtp_password: Option<String>,
+    #[serde(default = "default_email_smtp_use_starttls")]
+    pub(super) smtp_use_starttls: bool,
+    pub(super) from_address: Option<String>,
+    pub(super) from_name: Option<String>,
+    #[serde(default = "default_email_poll_interval_secs")]
+    pub(super) poll_interval_secs: u64,
+    #[serde(default = "default_email_folders")]
+    pub(super) folders: Vec<String>,
+    #[serde(default)]
+    pub(super) allowed_senders: Vec<String>,
+    #[serde(default = "default_email_max_body_bytes")]
+    pub(super) max_body_bytes: usize,
+    #[serde(default = "default_email_max_attachment_bytes")]
+    pub(super) max_attachment_bytes: usize,
+    #[serde(default)]
+    pub(super) instances: Vec<TomlEmailInstanceConfig>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlEmailInstanceConfig {
+    pub(super) name: String,
+    #[serde(default)]
+    pub(super) enabled: bool,
+    pub(super) imap_host: Option<String>,
+    #[serde(default = "default_email_imap_port")]
+    pub(super) imap_port: u16,
+    pub(super) imap_username: Option<String>,
+    pub(super) imap_password: Option<String>,
+    #[serde(default = "default_email_imap_use_tls")]
+    pub(super) imap_use_tls: bool,
+    pub(super) smtp_host: Option<String>,
+    #[serde(default = "default_email_smtp_port")]
+    pub(super) smtp_port: u16,
+    pub(super) smtp_username: Option<String>,
+    pub(super) smtp_password: Option<String>,
+    #[serde(default = "default_email_smtp_use_starttls")]
+    pub(super) smtp_use_starttls: bool,
+    pub(super) from_address: Option<String>,
+    pub(super) from_name: Option<String>,
+    #[serde(default = "default_email_poll_interval_secs")]
+    pub(super) poll_interval_secs: u64,
+    #[serde(default = "default_email_folders")]
+    pub(super) folders: Vec<String>,
+    #[serde(default)]
+    pub(super) allowed_senders: Vec<String>,
+    #[serde(default = "default_email_max_body_bytes")]
+    pub(super) max_body_bytes: usize,
+    #[serde(default = "default_email_max_attachment_bytes")]
+    pub(super) max_attachment_bytes: usize,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlWebhookConfig {
+    #[serde(default)]
+    pub(super) enabled: bool,
+    #[serde(default = "default_webhook_port")]
+    pub(super) port: u16,
+    #[serde(default = "default_webhook_bind")]
+    pub(super) bind: String,
+    pub(super) auth_token: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlTwitchConfig {
+    #[serde(default)]
+    pub(super) enabled: bool,
+    pub(super) username: Option<String>,
+    pub(super) oauth_token: Option<String>,
+    pub(super) client_id: Option<String>,
+    pub(super) client_secret: Option<String>,
+    pub(super) refresh_token: Option<String>,
+    #[serde(default)]
+    pub(super) instances: Vec<TomlTwitchInstanceConfig>,
+    #[serde(default)]
+    pub(super) channels: Vec<String>,
+    pub(super) trigger_prefix: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlTwitchInstanceConfig {
+    pub(super) name: String,
+    #[serde(default)]
+    pub(super) enabled: bool,
+    pub(super) username: Option<String>,
+    pub(super) oauth_token: Option<String>,
+    pub(super) client_id: Option<String>,
+    pub(super) client_secret: Option<String>,
+    pub(super) refresh_token: Option<String>,
+    #[serde(default)]
+    pub(super) channels: Vec<String>,
+    pub(super) trigger_prefix: Option<String>,
+}
+
+pub(super) fn default_webhook_port() -> u16 {
+    18789
+}
+pub(super) fn default_webhook_bind() -> String {
+    "127.0.0.1".into()
+}
+
+pub(super) fn default_email_imap_port() -> u16 {
+    993
+}
+
+pub(super) fn default_email_imap_use_tls() -> bool {
+    true
+}
+
+pub(super) fn default_email_smtp_port() -> u16 {
+    587
+}
+
+pub(super) fn default_email_smtp_use_starttls() -> bool {
+    true
+}
+
+pub(super) fn default_email_poll_interval_secs() -> u64 {
+    30
+}
+
+pub(super) fn default_email_folders() -> Vec<String> {
+    vec!["INBOX".to_string()]
+}
+
+pub(super) fn default_email_max_body_bytes() -> usize {
+    256 * 1024
+}
+
+pub(super) fn default_email_max_attachment_bytes() -> usize {
+    10 * 1024 * 1024
+}
+
+#[derive(Deserialize)]
+pub(super) struct TomlBinding {
+    pub(super) agent_id: String,
+    pub(super) channel: String,
+    #[serde(default)]
+    pub(super) adapter: Option<String>,
+    pub(super) guild_id: Option<String>,
+    pub(super) workspace_id: Option<String>,
+    pub(super) chat_id: Option<String>,
+    #[serde(default)]
+    pub(super) channel_ids: Vec<String>,
+    #[serde(default)]
+    pub(super) require_mention: bool,
+    #[serde(default)]
+    pub(super) dm_allowed_users: Vec<String>,
+}
diff --git a/src/config/types.rs b/src/config/types.rs
new file mode 100644
index 000000000..3588b2618
--- /dev/null
+++ b/src/config/types.rs
@@ -0,0 +1,2255 @@
+//! Domain type definitions for Spacebot configuration.
+
+use crate::error::{ConfigError, Result};
+use crate::llm::routing::RoutingConfig;
+use crate::secrets::store::{InstancePattern, SecretField, SystemSecrets};
+
+use chrono_tz::Tz;
+use serde::{Deserialize, Serialize};
+
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+
+pub(super) const CRON_TIMEZONE_ENV_VAR: &str = "SPACEBOT_CRON_TIMEZONE";
+pub(super) const USER_TIMEZONE_ENV_VAR: &str = "SPACEBOT_USER_TIMEZONE";
+
+/// OpenTelemetry export configuration.
+///
+/// All fields are optional. If `otlp_endpoint` is not set (and the standard
+/// `OTEL_EXPORTER_OTLP_ENDPOINT` env var is not present), OTLP export is
+/// disabled and the OTel layer is omitted entirely.
+#[derive(Debug, Clone, Default)]
+pub struct TelemetryConfig {
+    /// OTLP HTTP endpoint, e.g. `http://localhost:4318`.
+    /// Falls back to the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable.
+    pub otlp_endpoint: Option<String>,
+    /// Extra OTLP headers for the exporter (e.g. `Authorization`).
+    /// Loaded from the `OTEL_EXPORTER_OTLP_HEADERS` environment variable.
+    pub otlp_headers: HashMap<String, String>,
+    /// `service.name` resource attribute sent with every span.
+    pub service_name: String,
+    /// Trace sample rate in the range 0.0–1.0. Defaults to 1.0 (sample all).
+    pub sample_rate: f64,
+}
+
+/// Top-level Spacebot configuration.
+#[derive(Debug, Clone)]
+pub struct Config {
+    /// Instance root directory (~/.spacebot or SPACEBOT_DIR).
+    pub instance_dir: PathBuf,
+    /// LLM provider credentials (shared across all agents).
+    pub llm: LlmConfig,
+    /// Default settings inherited by all agents.
+    pub defaults: DefaultsConfig,
+    /// Agent definitions.
+    pub agents: Vec<AgentConfig>,
+    /// Agent communication graph links.
+    pub links: Vec<LinkDef>,
+    /// Visual grouping of agents in the topology UI.
+    pub groups: Vec<GroupDef>,
+    /// Org-level humans (real people, shown in topology graph).
+    pub humans: Vec<HumanDef>,
+    /// Messaging platform credentials.
+    pub messaging: MessagingConfig,
+    /// Routing bindings (maps platform conversations to agents).
+    pub bindings: Vec<Binding>,
+    /// HTTP API server configuration.
+    pub api: ApiConfig,
+    /// Prometheus metrics endpoint configuration.
+    pub metrics: MetricsConfig,
+    /// OpenTelemetry export configuration.
+    pub telemetry: TelemetryConfig,
+}
+
+impl Config {
+    /// Get the default agent ID.
+    pub fn default_agent_id(&self) -> &str {
+        self.agents
+            .iter()
+            .find(|a| a.default)
+            .map(|a| a.id.as_str())
+            .unwrap_or("main")
+    }
+
+    /// Resolve all agent configs against defaults.
+    pub fn resolve_agents(&self) -> Vec<ResolvedAgentConfig> {
+        self.agents
+            .iter()
+            .map(|a| a.resolve(&self.instance_dir, &self.defaults))
+            .collect()
+    }
+
+    /// Path to instance-level skills directory.
+    pub fn skills_dir(&self) -> PathBuf {
+        self.instance_dir.join("skills")
+    }
+}
+
+/// A link definition from config, connecting two nodes (agents or humans).
+#[derive(Debug, Clone)]
+pub struct LinkDef {
+    pub from: String,
+    pub to: String,
+    pub direction: String,
+    pub kind: String,
+}
+
+/// An org-level human definition.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct HumanDef {
+    pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub role: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bio: Option<String>,
+}
+
+/// A visual group definition for the topology UI.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct GroupDef {
+    pub name: String,
+    pub agent_ids: Vec<String>,
+    #[serde(default)]
+    pub color: Option<String>,
+}
+
+/// HTTP API server configuration.
+#[derive(Debug, Clone)]
+pub struct ApiConfig {
+    /// Whether the HTTP API server is enabled.
+    pub enabled: bool,
+    /// Port to bind the HTTP server on.
+    pub port: u16,
+    /// Address to bind the HTTP server on.
+    pub bind: String,
+    pub auth_token: Option<String>,
+}
+
+impl Default for ApiConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            port: 19898,
+            bind: "127.0.0.1".into(),
+            auth_token: None,
+        }
+    }
+}
+
+/// Prometheus metrics endpoint configuration.
+#[derive(Debug, Clone)]
+pub struct MetricsConfig {
+    /// Whether the metrics endpoint is enabled.
+    pub enabled: bool,
+    /// Port to bind the metrics HTTP server on.
+    pub port: u16,
+    /// Address to bind the metrics HTTP server on.
+    pub bind: String,
+}
+
+impl Default for MetricsConfig {
+    fn default() -> Self {
+        Self {
+            enabled: false,
+            port: 9090,
+            bind: "0.0.0.0".into(),
+        }
+    }
+}
+
+/// API types supported by LLM providers.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ApiType {
+    /// OpenAI Chat Completions API (`/v1/chat/completions`)
+    OpenAiCompletions,
+    /// OpenAI-compatible Chat Completions API (`/chat/completions`)
+    OpenAiChatCompletions,
+    /// Kilo Gateway API (`/chat/completions`) with required gateway headers
+    KiloGateway,
+    /// OpenAI Responses API (`/v1/responses`)
+    OpenAiResponses,
+    /// Anthropic Messages API (https://api.anthropic.com/v1/messages)
+    Anthropic,
+    /// Google Gemini API (https://generativelanguage.googleapis.com/v1beta/openai/chat/completions)
+    Gemini,
+}
+
+impl<'de> serde::Deserialize<'de> for ApiType {
+    fn deserialize<D: serde::Deserializer<'de>>(
+        deserializer: D,
+    ) -> std::result::Result<Self, D::Error> {
+        let s = String::deserialize(deserializer)?;
+        match s.as_str() {
+            "openai_completions" => Ok(Self::OpenAiCompletions),
+            "openai_chat_completions" => Ok(Self::OpenAiChatCompletions),
+            "kilo_gateway" => Ok(Self::KiloGateway),
+            "openai_responses" => Ok(Self::OpenAiResponses),
+            "anthropic" => Ok(Self::Anthropic),
+            "gemini" => Ok(Self::Gemini),
+            other => Err(serde::de::Error::invalid_value(
+                serde::de::Unexpected::Str(other),
+                &"one of \"openai_completions\", \"openai_chat_completions\", \"kilo_gateway\", \"openai_responses\", \"anthropic\", or \"gemini\"",
+            )),
+        }
+    }
+}
+
+/// Configuration for a single LLM provider.
+#[derive(Clone)]
+pub struct ProviderConfig {
+    pub api_type: ApiType,
+    pub base_url: String,
+    pub api_key: String,
+    pub name: Option<String>,
+    /// When true, use `Authorization: Bearer` instead of `x-api-key` for
+    /// Anthropic requests. Set automatically when the key originates from
+    /// `ANTHROPIC_AUTH_TOKEN` (proxy-compatible auth).
+    pub use_bearer_auth: bool,
+    /// Additional HTTP headers included in requests to this provider.
+    /// Currently applied in `call_openai()` (the `OpenAiCompletions` path).
+    pub extra_headers: Vec<(String, String)>,
+}
+
+impl std::fmt::Debug for ProviderConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ProviderConfig")
+            .field("api_type", &self.api_type)
+            .field("base_url", &self.base_url)
+            .field("api_key", &"[REDACTED]")
+            .field("name", &self.name)
+            .field("use_bearer_auth", &self.use_bearer_auth)
+            .field(
+                "extra_headers",
+                &self
+                    .extra_headers
+                    .iter()
+                    .map(|(key, _)| key.as_str())
+                    .collect::<Vec<_>>(),
+            )
+            .finish()
+    }
+}
+
+/// LLM provider credentials (instance-level).
+#[derive(Clone)]
+pub struct LlmConfig {
+    pub anthropic_key: Option<String>,
+    pub openai_key: Option<String>,
+    pub openrouter_key: Option<String>,
+    pub kilo_key: Option<String>,
+    pub zhipu_key: Option<String>,
+    pub groq_key: Option<String>,
+    pub together_key: Option<String>,
+    pub fireworks_key: Option<String>,
+    pub deepseek_key: Option<String>,
+    pub xai_key: Option<String>,
+    pub mistral_key: Option<String>,
+    pub gemini_key: Option<String>,
+    pub ollama_key: Option<String>,
+    pub ollama_base_url: Option<String>,
+    pub opencode_zen_key: Option<String>,
+    pub opencode_go_key: Option<String>,
+    pub nvidia_key: Option<String>,
+    pub minimax_key: Option<String>,
+    pub minimax_cn_key: Option<String>,
+    pub moonshot_key: Option<String>,
+    pub zai_coding_plan_key: Option<String>,
+    pub providers: HashMap<String, ProviderConfig>,
+}
+
+impl std::fmt::Debug for LlmConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("LlmConfig")
+            .field(
+                "anthropic_key",
+                &self.anthropic_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field(
+                "openai_key",
+                &self.openai_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field(
+                "openrouter_key",
+                &self.openrouter_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field("kilo_key", &self.kilo_key.as_ref().map(|_| "[REDACTED]"))
+            .field("zhipu_key", &self.zhipu_key.as_ref().map(|_| "[REDACTED]"))
+            .field("groq_key", &self.groq_key.as_ref().map(|_| "[REDACTED]"))
+            .field(
+                "together_key",
+                &self.together_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field(
+                "fireworks_key",
+                &self.fireworks_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field(
+                "deepseek_key",
+                &self.deepseek_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field("xai_key", &self.xai_key.as_ref().map(|_| "[REDACTED]"))
+            .field(
+                "mistral_key",
+                &self.mistral_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field(
+                "gemini_key",
+                &self.gemini_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field(
+                "ollama_key",
+                &self.ollama_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field("ollama_base_url", &self.ollama_base_url)
+            .field(
+                "opencode_zen_key",
+                &self.opencode_zen_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field(
+                "opencode_go_key",
+                &self.opencode_go_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field(
+                "nvidia_key",
+                &self.nvidia_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field(
+                "minimax_key",
+                &self.minimax_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field(
+                "moonshot_key",
+                &self.moonshot_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field(
+                "zai_coding_plan_key",
+                &self.zai_coding_plan_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field("providers", &self.providers)
+            .finish()
+    }
+}
+
+impl LlmConfig {
+    /// Check if any provider configuration is set.
+    pub fn has_any_key(&self) -> bool {
+        self.anthropic_key.is_some()
+            || self.openai_key.is_some()
+            || self.openrouter_key.is_some()
+            || self.kilo_key.is_some()
+            || self.zhipu_key.is_some()
+            || self.groq_key.is_some()
+            || self.together_key.is_some()
+            || self.fireworks_key.is_some()
+            || self.deepseek_key.is_some()
+            || self.xai_key.is_some()
+            || self.mistral_key.is_some()
+            || self.gemini_key.is_some()
+            || self.ollama_key.is_some()
+            || self.ollama_base_url.is_some()
+            || self.opencode_zen_key.is_some()
+            || self.opencode_go_key.is_some()
+            || self.nvidia_key.is_some()
+            || self.minimax_key.is_some()
+            || self.minimax_cn_key.is_some()
+            || self.moonshot_key.is_some()
+            || self.zai_coding_plan_key.is_some()
+            || !self.providers.is_empty()
+    }
+}
+
+impl SystemSecrets for LlmConfig {
+    fn section() -> &'static str {
+        "llm"
+    }
+
+    fn secret_fields() -> &'static [SecretField] {
+        &[
+            SecretField {
+                toml_key: "anthropic_key",
+                secret_name: "ANTHROPIC_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "anthropic_key",
+                secret_name: "ANTHROPIC_AUTH_TOKEN",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "openai_key",
+                secret_name: "OPENAI_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "openrouter_key",
+                secret_name: "OPENROUTER_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "kilo_key",
+                secret_name: "KILO_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "zhipu_key",
+                secret_name: "ZHIPU_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "groq_key",
+                secret_name: "GROQ_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "together_key",
+                secret_name: "TOGETHER_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "fireworks_key",
+                secret_name: "FIREWORKS_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "deepseek_key",
+                secret_name: "DEEPSEEK_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "xai_key",
+                secret_name: "XAI_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "mistral_key",
+                secret_name: "MISTRAL_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "gemini_key",
+                secret_name: "GEMINI_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "gemini_key",
+                secret_name: "GOOGLE_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "ollama_key",
+                secret_name: "OLLAMA_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "opencode_zen_key",
+                secret_name: "OPENCODE_ZEN_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "opencode_go_key",
+                secret_name: "OPENCODE_GO_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "nvidia_key",
+                secret_name: "NVIDIA_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "minimax_key",
+                secret_name: "MINIMAX_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "minimax_cn_key",
+                secret_name: "MINIMAX_CN_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "moonshot_key",
+                secret_name: "MOONSHOT_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "zai_coding_plan_key",
+                secret_name: "ZAI_CODING_PLAN_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "cerebras_key",
+                secret_name: "CEREBRAS_API_KEY",
+                instance_pattern: None,
+            },
+            SecretField {
+                toml_key: "sambanova_key",
+                secret_name: "SAMBANOVA_API_KEY",
+                instance_pattern: None,
+            },
+        ]
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Defaults, agent configs, and resolution helpers
+// ---------------------------------------------------------------------------
+
+/// Defaults inherited by all agents. Individual agents can override any field.
+#[derive(Clone)]
+pub struct DefaultsConfig {
+    pub routing: RoutingConfig,
+    pub max_concurrent_branches: usize,
+    pub max_concurrent_workers: usize,
+    pub max_turns: usize,
+    pub branch_max_turns: usize,
+    pub context_window: usize,
+    pub compaction: CompactionConfig,
+    pub memory_persistence: MemoryPersistenceConfig,
+    pub coalesce: CoalesceConfig,
+    pub ingestion: IngestionConfig,
+    pub cortex: CortexConfig,
+    pub warmup: WarmupConfig,
+    pub browser: BrowserConfig,
+    pub channel: ChannelConfig,
+    pub mcp: Vec<McpServerConfig>,
+    /// Brave Search API key for web search tool. Supports "env:VAR_NAME" references.
+    pub brave_search_key: Option<String>,
+    /// Default timezone used when evaluating cron active hours.
+    pub cron_timezone: Option<String>,
+    /// Default timezone for channel/worker temporal context.
+    pub user_timezone: Option<String>,
+    pub history_backfill_count: usize,
+    pub cron: Vec<CronDef>,
+    pub opencode: OpenCodeConfig,
+    /// Worker log mode: "errors_only", "all_separate", or "all_combined".
+    pub worker_log_mode: crate::settings::WorkerLogMode,
+}
+
+impl std::fmt::Debug for DefaultsConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DefaultsConfig")
+            .field("routing", &self.routing)
+            .field("max_concurrent_branches", &self.max_concurrent_branches)
+            .field("max_concurrent_workers", &self.max_concurrent_workers)
+            .field("max_turns", &self.max_turns)
+            .field("branch_max_turns", &self.branch_max_turns)
+            .field("context_window", &self.context_window)
+            .field("compaction", &self.compaction)
+            .field("memory_persistence", &self.memory_persistence)
+            .field("coalesce", &self.coalesce)
+            .field("ingestion", &self.ingestion)
+            .field("cortex", &self.cortex)
+            .field("warmup", &self.warmup)
+            .field("browser", &self.browser)
+            .field("channel", &self.channel)
+            .field("mcp", &self.mcp)
+            .field(
+                "brave_search_key",
+                &self.brave_search_key.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field("cron_timezone", &self.cron_timezone)
+            .field("user_timezone", &self.user_timezone)
+            .field("history_backfill_count", &self.history_backfill_count)
+            .field("cron", &self.cron)
+            .field("opencode", &self.opencode)
+            .field("worker_log_mode", &self.worker_log_mode)
+            .finish()
+    }
+}
+
+impl SystemSecrets for DefaultsConfig {
+    fn section() -> &'static str {
+        "defaults"
+    }
+
+    fn secret_fields() -> &'static [SecretField] {
+        &[SecretField {
+            toml_key: "brave_search_key",
+            secret_name: "BRAVE_SEARCH_API_KEY",
+            instance_pattern: None,
+        }]
+    }
+}
+
+/// MCP server configuration.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct McpServerConfig {
+    pub name: String,
+    pub transport: McpTransport,
+    pub enabled: bool,
+}
+
+/// MCP transport configuration.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum McpTransport {
+    Stdio {
+        command: String,
+        args: Vec<String>,
+        env: HashMap<String, String>,
+    },
+    Http {
+        url: String,
+        headers: HashMap<String, String>,
+    },
+}
+
+impl McpTransport {
+    pub fn kind(&self) -> &'static str {
+        match self {
+            McpTransport::Stdio { .. } => "stdio",
+            McpTransport::Http { .. } => "http",
+        }
+    }
+}
+
+/// Compaction threshold configuration.
+#[derive(Debug, Clone, Copy)]
+pub struct CompactionConfig {
+    pub background_threshold: f32,
+    pub aggressive_threshold: f32,
+    pub emergency_threshold: f32,
+}
+
+/// Auto-branching memory persistence configuration.
+///
+/// Spawns a silent branch every N messages to recall existing memories and save
+/// new ones from the recent conversation. Runs without blocking the channel and
+/// the result is never injected into channel history.
+#[derive(Debug, Clone, Copy)]
+pub struct MemoryPersistenceConfig {
+    /// Whether auto memory persistence branches are enabled.
+    pub enabled: bool,
+    /// Number of user messages between automatic memory persistence branches.
+    pub message_interval: usize,
+}
+
+impl Default for MemoryPersistenceConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            message_interval: 50,
+        }
+    }
+}
+
+impl Default for CompactionConfig {
+    fn default() -> Self {
+        Self {
+            background_threshold: 0.80,
+            aggressive_threshold: 0.85,
+            emergency_threshold: 0.95,
+        }
+    }
+}
+
+/// Message coalescing configuration for handling rapid-fire messages.
+///
+/// When enabled, messages arriving in quick succession are accumulated and
+/// presented to the LLM as a single batched turn with a hint that this is
+/// a fast-moving conversation.
+#[derive(Debug, Clone, Copy)]
+pub struct CoalesceConfig {
+    /// Enable message coalescing for multi-user channels.
+    pub enabled: bool,
+    /// Initial debounce window after first message (milliseconds).
+    pub debounce_ms: u64,
+    /// Maximum time to wait before flushing regardless (milliseconds).
+    pub max_wait_ms: u64,
+    /// Min messages to trigger coalesce mode (1 = always debounce, 2 = only when burst detected).
+    pub min_messages: usize,
+    /// Apply only to multi-user conversations (skip for DMs).
+    pub multi_user_only: bool,
+}
+
+impl Default for CoalesceConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            debounce_ms: 1500,
+            max_wait_ms: 5000,
+            min_messages: 2,
+            multi_user_only: true,
+        }
+    }
+}
+
+/// File-based memory ingestion configuration.
+///
+/// Watches a directory in the agent workspace for text files, chunks them, and
+/// processes each chunk through the memory recall + save flow. Files are deleted
+/// after successful ingestion.
+#[derive(Debug, Clone, Copy)]
+pub struct IngestionConfig {
+    /// Whether file-based memory ingestion is enabled.
+    pub enabled: bool,
+    /// How often to scan the ingest directory for new files, in seconds.
+    pub poll_interval_secs: u64,
+    /// Target chunk size in characters. Chunks may be slightly larger to avoid
+    /// splitting mid-line.
+    pub chunk_size: usize,
+}
+
+impl Default for IngestionConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            poll_interval_secs: 30,
+            chunk_size: 4000,
+        }
+    }
+}
+
+/// What happens when a worker explicitly calls "close" on the browser.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ClosePolicy {
+    /// Kill the browser process and reset all state (current default behavior).
+    #[default]
+    CloseBrowser,
+    /// Close all tabs but leave the browser process running.
+    CloseTabs,
+    /// Disconnect from the browser without touching tabs or the process.
+    Detach,
+}
+
+impl ClosePolicy {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::CloseBrowser => "close_browser",
+            Self::CloseTabs => "close_tabs",
+            Self::Detach => "detach",
+        }
+    }
+}
+
+impl std::fmt::Display for ClosePolicy {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
+/// Browser automation configuration for workers.
+#[derive(Debug, Clone)]
+pub struct BrowserConfig {
+    /// Whether browser tools are available to workers.
+    pub enabled: bool,
+    /// Run Chrome in headless mode.
+    pub headless: bool,
+    /// Allow JavaScript evaluation via the browser tool.
+    pub evaluate_enabled: bool,
+    /// Custom Chrome/Chromium executable path.
+    pub executable_path: Option<String>,
+    /// Directory for storing screenshots and other browser artifacts.
+    pub screenshot_dir: Option<PathBuf>,
+    /// Keep the browser alive across worker lifetimes. When true, all workers
+    /// for this agent share a single browser connection and tabs survive between
+    /// worker runs. Cookies, localStorage, and login sessions persist.
+    pub persist_session: bool,
+    /// Controls what happens when a worker calls "close" or finishes.
+    pub close_policy: ClosePolicy,
+    /// Directory for caching a fetcher-downloaded Chromium binary.
+    /// Populated from `{instance_dir}/chrome_cache` during config resolution.
+    pub chrome_cache_dir: PathBuf,
+}
+
+impl Default for BrowserConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            headless: true,
+            evaluate_enabled: false,
+            executable_path: None,
+            screenshot_dir: None,
+            persist_session: false,
+            close_policy: ClosePolicy::default(),
+            chrome_cache_dir: PathBuf::from("chrome_cache"),
+        }
+    }
+}
+
+/// Channel behavior configuration.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct ChannelConfig {
+    /// When true, unsolicited chat messages are ignored unless command/mention/reply.
+    pub listen_only_mode: bool,
+}
+
+/// OpenCode subprocess worker configuration.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct OpenCodeConfig {
+    /// Whether OpenCode workers are available.
+    pub enabled: bool,
+    /// Path to the OpenCode binary. Supports "env:VAR_NAME" references.
+    /// Falls back to "opencode" on PATH.
+    pub path: String,
+    /// Maximum concurrent OpenCode server processes.
+    pub max_servers: usize,
+    /// Timeout in seconds waiting for a server to become healthy.
+    pub server_startup_timeout_secs: u64,
+    /// Maximum restart attempts before giving up on a server.
+    pub max_restart_retries: u32,
+    /// Permission settings passed to OpenCode's config.
+    pub permissions: crate::opencode::OpenCodePermissions,
+}
+
+impl Default for OpenCodeConfig {
+    fn default() -> Self {
+        Self {
+            enabled: false,
+            path: "opencode".to_string(),
+            max_servers: 5,
+            server_startup_timeout_secs: 30,
+            max_restart_retries: 5,
+            permissions: crate::opencode::OpenCodePermissions::default(),
+        }
+    }
+}
+
+/// Cortex configuration.
+#[derive(Debug, Clone, Copy)]
+pub struct CortexConfig {
+    pub tick_interval_secs: u64,
+    pub worker_timeout_secs: u64,
+    pub branch_timeout_secs: u64,
+    pub detached_worker_timeout_retry_limit: u8,
+    pub supervisor_kill_budget_per_tick: usize,
+    pub circuit_breaker_threshold: u8,
+    /// Interval in seconds between memory bulletin refreshes.
+    pub bulletin_interval_secs: u64,
+    /// Target word count for the memory bulletin.
+    pub bulletin_max_words: usize,
+    /// Max LLM turns for bulletin generation.
+    pub bulletin_max_turns: usize,
+    /// Interval in seconds between association passes.
+    pub association_interval_secs: u64,
+    /// Minimum cosine similarity to create a RelatedTo edge.
+    pub association_similarity_threshold: f32,
+    /// Minimum cosine similarity to create an Updates edge (near-duplicate).
+    pub association_updates_threshold: f32,
+    /// Max associations to create per pass (rate limit).
+    pub association_max_per_pass: usize,
+}
+
+impl Default for CortexConfig {
+    fn default() -> Self {
+        Self {
+            tick_interval_secs: 30,
+            worker_timeout_secs: 600,
+            branch_timeout_secs: 60,
+            detached_worker_timeout_retry_limit: 2,
+            supervisor_kill_budget_per_tick: 8,
+            circuit_breaker_threshold: 3,
+            bulletin_interval_secs: 3600,
+            bulletin_max_words: 1500,
+            bulletin_max_turns: 15,
+            association_interval_secs: 300,
+            association_similarity_threshold: 0.85,
+            association_updates_threshold: 0.95,
+            association_max_per_pass: 100,
+        }
+    }
+}
+
+/// Warmup configuration.
+#[derive(Debug, Clone, Copy)]
+pub struct WarmupConfig {
+    /// Enable background warmup passes.
+    pub enabled: bool,
+    /// Force-load the embedding model before first recall/write workloads.
+    pub eager_embedding_load: bool,
+    /// Interval in seconds between warmup refresh passes.
+    pub refresh_secs: u64,
+    /// Startup delay before the first warmup pass.
+    pub startup_delay_secs: u64,
+}
+
+impl Default for WarmupConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            eager_embedding_load: true,
+            refresh_secs: 900,
+            startup_delay_secs: 5,
+        }
+    }
+}
+
+/// Current warmup lifecycle state.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum WarmupState {
+    Cold,
+    Warming,
+    Warm,
+    Degraded,
+}
+
+/// Warmup runtime status snapshot for API and observability.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WarmupStatus {
+    pub state: WarmupState,
+    pub embedding_ready: bool,
+    pub last_refresh_unix_ms: Option<i64>,
+    pub last_error: Option<String>,
+    pub bulletin_age_secs: Option<u64>,
+}
+
+impl Default for WarmupStatus {
+    fn default() -> Self {
+        Self {
+            state: WarmupState::Cold,
+            embedding_ready: false,
+            last_refresh_unix_ms: None,
+            last_error: None,
+            bulletin_age_secs: None,
+        }
+    }
+}
+
+/// Why `ready_for_work` is currently false.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum WorkReadinessReason {
+    StateNotWarm,
+    EmbeddingNotReady,
+    BulletinMissing,
+    BulletinStale,
+}
+
+impl WorkReadinessReason {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::StateNotWarm => "state_not_warm",
+            Self::EmbeddingNotReady => "embedding_not_ready",
+            Self::BulletinMissing => "bulletin_missing",
+            Self::BulletinStale => "bulletin_stale",
+        }
+    }
+}
+
+/// Derived readiness signal used to gate dispatch behavior.
+#[derive(Debug, Clone, Copy)]
+pub struct WorkReadiness {
+    pub ready: bool,
+    pub reason: Option<WorkReadinessReason>,
+    pub warmup_state: WarmupState,
+    pub embedding_ready: bool,
+    pub bulletin_age_secs: Option<u64>,
+    pub stale_after_secs: u64,
+}
+
+pub(super) fn evaluate_work_readiness(
+    warmup_config: WarmupConfig,
+    status: WarmupStatus,
+    now_unix_ms: i64,
+) -> WorkReadiness {
+    let stale_after_secs = warmup_config.refresh_secs.max(1).saturating_mul(2).max(60);
+    let bulletin_age_secs = status
+        .last_refresh_unix_ms
+        .map(|refresh_ms| {
+            if now_unix_ms > refresh_ms {
+                ((now_unix_ms - refresh_ms) / 1000) as u64
+            } else {
+                0
+            }
+        })
+        .or(status.bulletin_age_secs);
+
+    let reason = if status.state != WarmupState::Warm {
+        Some(WorkReadinessReason::StateNotWarm)
+    } else if warmup_config.eager_embedding_load && !status.embedding_ready {
+        Some(WorkReadinessReason::EmbeddingNotReady)
+    } else if bulletin_age_secs.is_none() {
+        Some(WorkReadinessReason::BulletinMissing)
+    } else if bulletin_age_secs.is_some_and(|age| age > stale_after_secs) {
+        Some(WorkReadinessReason::BulletinStale)
+    } else {
+        None
+    };
+
+    WorkReadiness {
+        ready: reason.is_none(),
+        reason,
+        warmup_state: status.state,
+        embedding_ready: status.embedding_ready,
+        bulletin_age_secs,
+        stale_after_secs,
+    }
+}
+
+/// Per-agent configuration (raw, before resolution with defaults).
+#[derive(Debug, Clone)]
+pub struct AgentConfig {
+    pub id: String,
+    pub default: bool,
+    /// User-defined display name for the agent (shown in UI).
+    pub display_name: Option<String>,
+    /// User-defined role description (e.g. "handles tier 1 support").
+    pub role: Option<String>,
+    /// Custom workspace path. If None, resolved to instance_dir/agents/{id}/workspace.
+    pub workspace: Option<PathBuf>,
+    /// Per-agent routing overrides. None inherits from defaults.
+    pub routing: Option<RoutingConfig>,
+    pub max_concurrent_branches: Option<usize>,
+    pub max_concurrent_workers: Option<usize>,
+    pub max_turns: Option<usize>,
+    pub branch_max_turns: Option<usize>,
+    pub context_window: Option<usize>,
+    pub compaction: Option<CompactionConfig>,
+    pub memory_persistence: Option<MemoryPersistenceConfig>,
+    pub coalesce: Option<CoalesceConfig>,
+    pub ingestion: Option<IngestionConfig>,
+    pub cortex: Option<CortexConfig>,
+    pub warmup: Option<WarmupConfig>,
+    pub browser: Option<BrowserConfig>,
+    pub channel: Option<ChannelConfig>,
+    pub mcp: Option<Vec<McpServerConfig>>,
+    /// Per-agent Brave Search API key override. None inherits from defaults.
+    pub brave_search_key: Option<String>,
+    /// Optional timezone override for cron active-hours evaluation.
+    pub cron_timezone: Option<String>,
+    /// Optional timezone override for channel/worker temporal context.
+    pub user_timezone: Option<String>,
+    /// Sandbox configuration for process containment.
+    pub sandbox: Option<crate::sandbox::SandboxConfig>,
+    /// Cron job definitions for this agent.
+    pub cron: Vec<CronDef>,
+}
+
+/// A cron job definition from config.
+#[derive(Debug, Clone)]
+pub struct CronDef {
+    pub id: String,
+    pub prompt: String,
+    /// Optional cron expression (wall-clock schedule) in standard 5-field format.
+    /// When set, this takes precedence over `interval_secs`.
+    pub cron_expr: Option<String>,
+    pub interval_secs: u64,
+    /// Delivery target in "adapter:target" format (e.g. "discord:123456789").
+    pub delivery_target: String,
+    /// Optional active hours window (start_hour, end_hour) in 24h format.
+    pub active_hours: Option<(u8, u8)>,
+    pub enabled: bool,
+    pub run_once: bool,
+    /// Maximum wall-clock seconds to wait for the job to complete.
+    /// `None` uses the default of 120 seconds.
+    pub timeout_secs: Option<u64>,
+}
+
+/// Fully resolved agent config (merged with defaults, paths resolved).
+#[derive(Debug, Clone)]
+pub struct ResolvedAgentConfig {
+    pub id: String,
+    pub display_name: Option<String>,
+    pub role: Option<String>,
+    pub workspace: PathBuf,
+    pub data_dir: PathBuf,
+    pub archives_dir: PathBuf,
+    pub routing: RoutingConfig,
+    pub max_concurrent_branches: usize,
+    pub max_concurrent_workers: usize,
+    pub max_turns: usize,
+    pub branch_max_turns: usize,
+    pub context_window: usize,
+    pub compaction: CompactionConfig,
+    pub memory_persistence: MemoryPersistenceConfig,
+    pub coalesce: CoalesceConfig,
+    pub ingestion: IngestionConfig,
+    pub cortex: CortexConfig,
+    pub warmup: WarmupConfig,
+    pub browser: BrowserConfig,
+    pub channel: ChannelConfig,
+    pub mcp: Vec<McpServerConfig>,
+    pub brave_search_key: Option<String>,
+    pub cron_timezone: Option<String>,
+    pub user_timezone: Option<String>,
+    /// Sandbox configuration for process containment.
+    pub sandbox: crate::sandbox::SandboxConfig,
+    /// Number of messages to fetch from the platform when a new channel is created.
+    pub history_backfill_count: usize,
+    pub cron: Vec<CronDef>,
+}
+
+impl Default for DefaultsConfig {
+    fn default() -> Self {
+        Self {
+            routing: RoutingConfig::default(),
+            max_concurrent_branches: 5,
+            max_concurrent_workers: 5,
+            max_turns: 5,
+            branch_max_turns: 50,
+            context_window: 128_000,
+            compaction: CompactionConfig::default(),
+            memory_persistence: MemoryPersistenceConfig::default(),
+            coalesce: CoalesceConfig::default(),
+            ingestion: IngestionConfig::default(),
+            cortex: CortexConfig::default(),
+            warmup: WarmupConfig::default(),
+            browser: BrowserConfig::default(),
+            channel: ChannelConfig::default(),
+            mcp: Vec::new(),
+            brave_search_key: None,
+            cron_timezone: None,
+            user_timezone: None,
+            history_backfill_count: 50,
+            cron: Vec::new(),
+            opencode: OpenCodeConfig::default(),
+            worker_log_mode: crate::settings::WorkerLogMode::default(),
+        }
+    }
+}
+
+impl AgentConfig {
+    /// Resolve this agent config against instance defaults and base paths.
+    pub fn resolve(&self, instance_dir: &Path, defaults: &DefaultsConfig) -> ResolvedAgentConfig {
+        let agent_root = instance_dir.join("agents").join(&self.id);
+        let resolved_cron_timezone = resolve_cron_timezone(
+            &self.id,
+            self.cron_timezone.as_deref(),
+            defaults.cron_timezone.as_deref(),
+        );
+        let resolved_user_timezone = resolve_user_timezone(
+            &self.id,
+            self.user_timezone.as_deref(),
+            defaults.user_timezone.as_deref(),
+            resolved_cron_timezone.as_deref(),
+        );
+
+        ResolvedAgentConfig {
+            id: self.id.clone(),
+            display_name: self.display_name.clone(),
+            role: self.role.clone(),
+            workspace: self
+                .workspace
+                .clone()
+                .unwrap_or_else(|| agent_root.join("workspace")),
+            data_dir: agent_root.join("data"),
+            archives_dir: agent_root.join("archives"),
+            routing: self
+                .routing
+                .clone()
+                .unwrap_or_else(|| defaults.routing.clone()),
+            max_concurrent_branches: self
+                .max_concurrent_branches
+                .unwrap_or(defaults.max_concurrent_branches),
+            max_concurrent_workers: self
+                .max_concurrent_workers
+                .unwrap_or(defaults.max_concurrent_workers),
+            max_turns: self.max_turns.unwrap_or(defaults.max_turns),
+            branch_max_turns: self.branch_max_turns.unwrap_or(defaults.branch_max_turns),
+            context_window: self.context_window.unwrap_or(defaults.context_window),
+            compaction: self.compaction.unwrap_or(defaults.compaction),
+            memory_persistence: self
+                .memory_persistence
+                .unwrap_or(defaults.memory_persistence),
+            coalesce: self.coalesce.unwrap_or(defaults.coalesce),
+            ingestion: self.ingestion.unwrap_or(defaults.ingestion),
+            cortex: self.cortex.unwrap_or(defaults.cortex),
+            warmup: self.warmup.unwrap_or(defaults.warmup),
+            browser: self
+                .browser
+                .clone()
+                .unwrap_or_else(|| defaults.browser.clone()),
+            channel: self.channel.unwrap_or(defaults.channel),
+            mcp: resolve_mcp_configs(&defaults.mcp, self.mcp.as_deref()),
+            brave_search_key: self
+                .brave_search_key
+                .clone()
+                .or_else(|| defaults.brave_search_key.clone()),
+            cron_timezone: resolved_cron_timezone,
+            user_timezone: resolved_user_timezone,
+            sandbox: self.sandbox.clone().unwrap_or_default(),
+            history_backfill_count: defaults.history_backfill_count,
+            cron: self.cron.clone(),
+        }
+    }
+}
+
+impl ResolvedAgentConfig {
+    pub fn sqlite_path(&self) -> PathBuf {
+        self.data_dir.join("spacebot.db")
+    }
+    pub fn lancedb_path(&self) -> PathBuf {
+        self.data_dir.join("lancedb")
+    }
+    pub fn redb_path(&self) -> PathBuf {
+        self.data_dir.join("config.redb")
+    }
+    pub fn history_backfill_count(&self) -> usize {
+        self.history_backfill_count
+    }
+    /// Resolved screenshot directory, falling back to data_dir/screenshots.
+    pub fn screenshot_dir(&self) -> PathBuf {
+        self.browser
+            .screenshot_dir
+            .clone()
+            .unwrap_or_else(|| self.data_dir.join("screenshots"))
+    }
+
+    /// Directory for worker execution logs written on failure.
+    pub fn logs_dir(&self) -> PathBuf {
+        self.data_dir.join("logs")
+    }
+
+    /// Path to agent workspace skills directory.
+    pub fn skills_dir(&self) -> PathBuf {
+        self.workspace.join("skills")
+    }
+
+    /// Path to the memory ingestion directory where users drop files.
+    pub fn ingest_dir(&self) -> PathBuf {
+        self.workspace.join("ingest")
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Timezone and MCP resolution helpers
+// ---------------------------------------------------------------------------
+
+fn normalize_timezone(value: &str) -> Option<String> {
+    let timezone = value.trim();
+    if timezone.is_empty() {
+        return None;
+    }
+    Some(timezone.to_string())
+}
+
+fn resolve_cron_timezone(
+    agent_id: &str,
+    agent_timezone: Option<&str>,
+    default_timezone: Option<&str>,
+) -> Option<String> {
+    let env_timezone = std::env::var(CRON_TIMEZONE_ENV_VAR)
+        .ok()
+        .and_then(|value| normalize_timezone(&value));
+
+    for timezone in [
+        agent_timezone.and_then(normalize_timezone),
+        default_timezone.and_then(normalize_timezone),
+        env_timezone,
+    ] {
+        let Some(timezone) = timezone else {
+            continue;
+        };
+
+        if timezone.parse::<Tz>().is_ok() {
+            return Some(timezone);
+        }
+
+        tracing::warn!(
+            agent_id,
+            cron_timezone = %timezone,
+            "invalid cron timezone configured, falling back to system local timezone"
+        );
+    }
+
+    None
+}
+
+fn resolve_user_timezone(
+    agent_id: &str,
+    agent_timezone: Option<&str>,
+    default_timezone: Option<&str>,
+    fallback_timezone: Option<&str>,
+) -> Option<String> {
+    let env_timezone = std::env::var(USER_TIMEZONE_ENV_VAR)
+        .ok()
+        .and_then(|value| normalize_timezone(&value));
+
+    for (source, timezone) in [
+        ("agent", agent_timezone.and_then(normalize_timezone)),
+        ("defaults", default_timezone.and_then(normalize_timezone)),
+        ("env", env_timezone),
+        (
+            "cron_or_system",
+            fallback_timezone.and_then(normalize_timezone),
+        ),
+    ] {
+        let Some(timezone) = timezone else {
+            continue;
+        };
+        if timezone.parse::<Tz>().is_ok() {
+            return Some(timezone);
+        }
+        tracing::warn!(
+            agent_id,
+            user_timezone = %timezone,
+            user_timezone_source = source,
+            "invalid user timezone configured, trying next fallback"
+        );
+    }
+
+    None
+}
+
+fn resolve_mcp_configs(
+    default_configs: &[McpServerConfig],
+    agent_configs: Option<&[McpServerConfig]>,
+) -> Vec<McpServerConfig> {
+    let mut merged = default_configs.to_vec();
+
+    if let Some(agent_configs) = agent_configs {
+        for agent_config in agent_configs {
+            if let Some(existing_index) = merged
+                .iter()
+                .position(|existing| existing.name == agent_config.name)
+            {
+                merged[existing_index] = agent_config.clone();
+            } else {
+                merged.push(agent_config.clone());
+            }
+        }
+    }
+
+    merged
+}
+
+// ---------------------------------------------------------------------------
+// Binding types and adapter validation
+// ---------------------------------------------------------------------------
+
+/// Normalize an adapter selector: trim whitespace, return `None` if empty.
+pub(super) fn normalize_adapter(adapter: Option<String>) -> Option<String> {
+    adapter
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+}
+
+/// Routes a messaging platform conversation to a specific agent.
+#[derive(Debug, Clone)]
+pub struct Binding {
+    pub agent_id: String,
+    pub channel: String,
+    /// Optional named adapter selector (platform-scoped).
+    ///
+    /// `None` targets the default adapter for this platform.
+    pub adapter: Option<String>,
+    pub guild_id: Option<String>,
+    pub workspace_id: Option<String>, // Slack workspace (team) ID
+    pub chat_id: Option<String>,
+    /// Channel IDs this binding applies to. If empty, all channels in the guild/workspace are allowed.
+    pub channel_ids: Vec<String>,
+    /// Require explicit @mention (or reply-to-bot) for inbound messages.
+    pub require_mention: bool,
+    /// User IDs allowed to DM the bot through this binding.
+    pub dm_allowed_users: Vec<String>,
+}
+
+impl Binding {
+    /// Runtime adapter key for this binding.
+    pub fn runtime_adapter_key(&self) -> String {
+        binding_runtime_adapter_key(self.channel.as_str(), self.adapter.as_deref())
+    }
+
+    /// Whether this binding targets the default adapter for its platform.
+    pub fn uses_default_adapter(&self) -> bool {
+        self.adapter.is_none()
+    }
+
+    /// Check if this binding matches an inbound message.
+    fn matches(&self, message: &crate::InboundMessage) -> bool {
+        if self.channel != message.source {
+            return false;
+        }
+
+        if !binding_adapter_matches(self, message) {
+            return false;
+        }
+
+        // For webchat messages, match based on agent_id in the message
+        if message.source == "webchat"
+            && let Some(message_agent_id) = &message.agent_id
+        {
+            return message_agent_id.as_ref() == self.agent_id;
+        }
+
+        // DM messages have no guild_id — match if the sender is in dm_allowed_users
+        let is_dm =
+            !message.metadata.contains_key("discord_guild_id") && message.source == "discord";
+        if is_dm {
+            return !self.dm_allowed_users.is_empty()
+                && self.dm_allowed_users.contains(&message.sender_id);
+        }
+
+        if let Some(guild_id) = &self.guild_id {
+            let message_guild = message
+                .metadata
+                .get("discord_guild_id")
+                .and_then(|v| v.as_u64())
+                .map(|v| v.to_string());
+            if message_guild.as_deref() != Some(guild_id) {
+                return false;
+            }
+        }
+
+        if let Some(workspace_id) = &self.workspace_id {
+            let message_workspace = message
+                .metadata
+                .get("slack_workspace_id")
+                .and_then(|v| v.as_str());
+            if message_workspace != Some(workspace_id) {
+                return false;
+            }
+        }
+
+        if !self.channel_ids.is_empty() {
+            let message_channel = message
+                .metadata
+                .get("discord_channel_id")
+                .and_then(|v| v.as_u64())
+                .map(|v| v.to_string());
+            let parent_channel = message
+                .metadata
+                .get("discord_parent_channel_id")
+                .and_then(|v| v.as_u64())
+                .map(|v| v.to_string());
+
+            // Also check Slack and Twitch channel IDs
+            let slack_channel = message
+                .metadata
+                .get("slack_channel_id")
+                .and_then(|v| v.as_str());
+            let twitch_channel = message
+                .metadata
+                .get("twitch_channel")
+                .and_then(|v| v.as_str());
+
+            let direct_match = message_channel
+                .as_ref()
+                .is_some_and(|id| self.channel_ids.contains(id))
+                || slack_channel.is_some_and(|id| self.channel_ids.contains(&id.to_string()))
+                || twitch_channel.is_some_and(|id| self.channel_ids.contains(&id.to_string()));
+            let parent_match = parent_channel
+                .as_ref()
+                .is_some_and(|id| self.channel_ids.contains(id));
+
+            if !direct_match && !parent_match {
+                return false;
+            }
+        }
+
+        if self.channel == "discord" && self.require_mention {
+            let is_guild_message = message
+                .metadata
+                .get("discord_guild_id")
+                .and_then(|v| v.as_u64())
+                .is_some();
+            if is_guild_message {
+                let mentions_or_replies_to_bot = message
+                    .metadata
+                    .get("discord_mentions_or_replies_to_bot")
+                    .and_then(|v| v.as_bool())
+                    .unwrap_or(false);
+                if !mentions_or_replies_to_bot {
+                    return false;
+                }
+            }
+        }
+
+        if let Some(chat_id) = &self.chat_id {
+            let message_chat = message.metadata.get("telegram_chat_id").and_then(|value| {
+                value
+                    .as_str()
+                    .map(std::borrow::ToOwned::to_owned)
+                    .or_else(|| value.as_i64().map(|id| id.to_string()))
+            });
+            if message_chat.as_deref() != Some(chat_id.as_str()) {
+                return false;
+            }
+        }
+
+        true
+    }
+}
+
+/// Build a runtime adapter key from platform and optional named selector.
+pub fn binding_runtime_adapter_key(platform: &str, adapter: Option<&str>) -> String {
+    if let Some(name) = adapter
+        && !name.is_empty()
+    {
+        return format!("{platform}:{name}");
+    }
+    platform.to_string()
+}
+
+/// Match a binding's adapter selector against an inbound message adapter.
+pub(super) fn binding_adapter_matches(binding: &Binding, message: &crate::InboundMessage) -> bool {
+    match (&binding.adapter, message.adapter_selector()) {
+        (None, None) => true,
+        (Some(expected), Some(actual)) => expected == actual,
+        _ => false,
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(super) struct AdapterValidationState {
+    default_present: bool,
+    named_instances: std::collections::HashSet<String>,
+}
+
+pub(super) fn is_named_adapter_platform(platform: &str) -> bool {
+    matches!(
+        platform,
+        "discord" | "slack" | "telegram" | "twitch" | "email"
+    )
+}
+
+pub(super) fn validate_named_messaging_adapters(
+    messaging: &MessagingConfig,
+    bindings: &[Binding],
+) -> Result<()> {
+    let adapter_states = build_adapter_validation_states(messaging)?;
+
+    for binding in bindings {
+        if !is_named_adapter_platform(binding.channel.as_str()) {
+            if binding.adapter.is_some() {
+                return Err(ConfigError::Invalid(format!(
+                    "binding for channel '{}' can't set adapter: this platform does not support named adapters",
+                    binding.channel
+                ))
+                .into());
+            }
+            continue;
+        }
+
+        let state = adapter_states.get(binding.channel.as_str()).ok_or_else(|| {
+            ConfigError::Invalid(format!(
+                "binding for channel '{}' can't be resolved: no messaging config exists for that platform",
+                binding.channel
+            ))
+        })?;
+
+        // adapter is already normalized at ingest time via normalize_adapter().
+        match binding.adapter.as_deref() {
+            Some(adapter_name) => {
+                if !state.named_instances.contains(adapter_name) {
+                    return Err(ConfigError::Invalid(format!(
+                        "binding for channel '{}' references missing adapter '{}'",
+                        binding.channel, adapter_name
+                    ))
+                    .into());
+                }
+            }
+            None => {
+                if !state.default_present {
+                    return Err(ConfigError::Invalid(format!(
+                        "binding for channel '{}' requires the default adapter, but no default credentials are configured",
+                        binding.channel
+                    ))
+                    .into());
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+pub(super) fn build_adapter_validation_states(
+    messaging: &MessagingConfig,
+) -> Result<std::collections::HashMap<&'static str, AdapterValidationState>> {
+    let mut states = std::collections::HashMap::new();
+
+    if let Some(discord) = &messaging.discord {
+        let named_instances = validate_instance_names(
+            "discord",
+            discord
+                .instances
+                .iter()
+                .map(|instance| instance.name.as_str()),
+        )?;
+        validate_runtime_keys(
+            "discord",
+            !discord.token.trim().is_empty(),
+            &named_instances,
+        )?;
+        states.insert(
+            "discord",
+            AdapterValidationState {
+                default_present: !discord.token.trim().is_empty(),
+                named_instances,
+            },
+        );
+    }
+
+    if let Some(slack) = &messaging.slack {
+        let named_instances = validate_instance_names(
+            "slack",
+            slack
+                .instances
+                .iter()
+                .map(|instance| instance.name.as_str()),
+        )?;
+        let default_present =
+            !slack.bot_token.trim().is_empty() && !slack.app_token.trim().is_empty();
+        validate_runtime_keys("slack", default_present, &named_instances)?;
+        states.insert(
+            "slack",
+            AdapterValidationState {
+                default_present,
+                named_instances,
+            },
+        );
+    }
+
+    if let Some(telegram) = &messaging.telegram {
+        let named_instances = validate_instance_names(
+            "telegram",
+            telegram
+                .instances
+                .iter()
+                .map(|instance| instance.name.as_str()),
+        )?;
+        let default_present = !telegram.token.trim().is_empty();
+        validate_runtime_keys("telegram", default_present, &named_instances)?;
+        states.insert(
+            "telegram",
+            AdapterValidationState {
+                default_present,
+                named_instances,
+            },
+        );
+    }
+
+    if let Some(twitch) = &messaging.twitch {
+        let named_instances = validate_instance_names(
+            "twitch",
+            twitch
+                .instances
+                .iter()
+                .map(|instance| instance.name.as_str()),
+        )?;
+        let default_present =
+            !twitch.username.trim().is_empty() && !twitch.oauth_token.trim().is_empty();
+        validate_runtime_keys("twitch", default_present, &named_instances)?;
+        states.insert(
+            "twitch",
+            AdapterValidationState {
+                default_present,
+                named_instances,
+            },
+        );
+    }
+
+    if let Some(email) = &messaging.email {
+        let named_instances = validate_instance_names(
+            "email",
+            email
+                .instances
+                .iter()
+                .map(|instance| instance.name.as_str()),
+        )?;
+        let default_present = !email.imap_host.trim().is_empty()
+            && !email.imap_username.trim().is_empty()
+            && !email.imap_password.trim().is_empty()
+            && !email.smtp_host.trim().is_empty();
+        validate_runtime_keys("email", default_present, &named_instances)?;
+        states.insert(
+            "email",
+            AdapterValidationState {
+                default_present,
+                named_instances,
+            },
+        );
+    }
+
+    Ok(states)
+}
+
+pub(super) fn validate_instance_names<'a>(
+    platform: &str,
+    names: impl Iterator<Item = &'a str>,
+) -> Result<std::collections::HashSet<String>> {
+    let mut seen = std::collections::HashSet::new();
+
+    for name in names {
+        let trimmed = name.trim();
+        if trimmed.is_empty() {
+            return Err(ConfigError::Invalid(format!(
+                "messaging.{platform}.instances name can't be empty"
+            ))
+            .into());
+        }
+        if trimmed != name {
+            return Err(ConfigError::Invalid(format!(
+                "messaging.{platform}.instances name '{}' can't contain leading or trailing whitespace",
+                name
+            ))
+            .into());
+        }
+        if trimmed.eq_ignore_ascii_case("default") {
+            return Err(ConfigError::Invalid(format!(
+                "messaging.{platform}.instances name '{}' is reserved",
+                name
+            ))
+            .into());
+        }
+        if trimmed.contains(':') {
+            return Err(ConfigError::Invalid(format!(
+                "messaging.{platform}.instances name '{}' can't contain ':'",
+                name
+            ))
+            .into());
+        }
+        if !seen.insert(trimmed.to_string()) {
+            return Err(ConfigError::Invalid(format!(
+                "messaging.{platform}.instances has duplicate name '{}'",
+                name
+            ))
+            .into());
+        }
+    }
+
+    Ok(seen)
+}
+
+fn validate_runtime_keys(
+    platform: &str,
+    default_present: bool,
+    named_instances: &std::collections::HashSet<String>,
+) -> Result<()> {
+    let mut runtime_keys = std::collections::HashSet::new();
+
+    if default_present && !runtime_keys.insert(platform.to_string()) {
+        return Err(ConfigError::Invalid(format!(
+            "messaging.{platform} has duplicate runtime adapter key '{platform}'"
+        ))
+        .into());
+    }
+
+    for instance_name in named_instances {
+        let runtime_key = format!("{platform}:{instance_name}");
+        if !runtime_keys.insert(runtime_key.clone()) {
+            return Err(ConfigError::Invalid(format!(
+                "messaging.{platform} has duplicate runtime adapter key '{runtime_key}'"
+            ))
+            .into());
+        }
+    }
+
+    Ok(())
+}
+
+/// Resolve which agent should handle an inbound message.
+///
+/// Checks bindings in order. First match wins. Falls back to the default
+/// agent if no binding matches.
+pub fn resolve_agent_for_message(
+    bindings: &[Binding],
+    message: &crate::InboundMessage,
+    default_agent_id: &str,
+) -> crate::AgentId {
+    for binding in bindings {
+        if binding.matches(message) {
+            return std::sync::Arc::from(binding.agent_id.as_str());
+        }
+    }
+    std::sync::Arc::from(default_agent_id)
+}
+
+// ---------------------------------------------------------------------------
+// Messaging platform configs
+// ---------------------------------------------------------------------------
+
+/// Messaging platform credentials (instance-level).
+#[derive(Debug, Clone, Default)]
+pub struct MessagingConfig {
+    pub discord: Option<DiscordConfig>,
+    pub slack: Option<SlackConfig>,
+    pub telegram: Option<TelegramConfig>,
+    pub email: Option<EmailConfig>,
+    pub webhook: Option<WebhookConfig>,
+    pub twitch: Option<TwitchConfig>,
+}
+
+#[derive(Clone)]
+pub struct DiscordConfig {
+    pub enabled: bool,
+    pub token: String,
+    /// Additional named Discord bot instances for this platform.
+    pub instances: Vec<DiscordInstanceConfig>,
+    /// User IDs allowed to DM the bot. If empty, DMs are ignored entirely.
+    pub dm_allowed_users: Vec<String>,
+    /// Whether to process messages from other bots (self-messages are always ignored).
+    pub allow_bot_messages: bool,
+}
+
+#[derive(Clone)]
+pub struct DiscordInstanceConfig {
+    pub name: String,
+    pub enabled: bool,
+    pub token: String,
+    /// User IDs allowed to DM this bot instance.
+    pub dm_allowed_users: Vec<String>,
+    /// Whether this bot instance processes messages from other bots.
+    pub allow_bot_messages: bool,
+}
+
+impl std::fmt::Debug for DiscordInstanceConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DiscordInstanceConfig")
+            .field("name", &self.name)
+            .field("enabled", &self.enabled)
+            .field("token", &"[REDACTED]")
+            .field("dm_allowed_users", &self.dm_allowed_users)
+            .field("allow_bot_messages", &self.allow_bot_messages)
+            .finish()
+    }
+}
+
+impl std::fmt::Debug for DiscordConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DiscordConfig")
+            .field("enabled", &self.enabled)
+            .field("token", &"[REDACTED]")
+            .field("instances", &self.instances)
+            .field("dm_allowed_users", &self.dm_allowed_users)
+            .field("allow_bot_messages", &self.allow_bot_messages)
+            .finish()
+    }
+}
+
+impl SystemSecrets for DiscordConfig {
+    fn section() -> &'static str {
+        "discord"
+    }
+
+    fn is_messaging_adapter() -> bool {
+        true
+    }
+
+    fn secret_fields() -> &'static [SecretField] {
+        &[SecretField {
+            toml_key: "token",
+            secret_name: "DISCORD_BOT_TOKEN",
+            instance_pattern: Some(InstancePattern {
+                platform_prefix: "DISCORD",
+                field_suffix: "BOT_TOKEN",
+            }),
+        }]
+    }
+}
+
+/// A single slash command definition for the Slack adapter.
+///
+/// Maps a Slack slash command (e.g. `/ask`) to a target agent.
+/// Commands not listed here are acknowledged but produce a "not configured" reply.
+#[derive(Debug, Clone)]
+pub struct SlackCommandConfig {
+    /// The slash command string exactly as Slack sends it, e.g. `"/ask"`.
+    pub command: String,
+    /// ID of the agent that should handle this command.
+    pub agent_id: String,
+    /// Short description shown in Slack's command autocomplete hint (optional).
+    pub description: Option<String>,
+}
+
+#[derive(Clone)]
+pub struct SlackConfig {
+    pub enabled: bool,
+    pub bot_token: String,
+    pub app_token: String,
+    /// Additional named Slack app instances for this platform.
+    pub instances: Vec<SlackInstanceConfig>,
+    /// User IDs allowed to DM the bot. If empty, DMs are ignored entirely.
+    pub dm_allowed_users: Vec<String>,
+    /// Slash command definitions. If empty, all slash commands are ignored.
+    pub commands: Vec<SlackCommandConfig>,
+}
+
+#[derive(Clone)]
+pub struct SlackInstanceConfig {
+    pub name: String,
+    pub enabled: bool,
+    pub bot_token: String,
+    pub app_token: String,
+    /// User IDs allowed to DM this app instance.
+    pub dm_allowed_users: Vec<String>,
+    /// Slash command definitions for this app instance.
+    pub commands: Vec<SlackCommandConfig>,
+}
+
+impl std::fmt::Debug for SlackInstanceConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SlackInstanceConfig")
+            .field("name", &self.name)
+            .field("enabled", &self.enabled)
+            .field("bot_token", &"[REDACTED]")
+            .field("app_token", &"[REDACTED]")
+            .field("dm_allowed_users", &self.dm_allowed_users)
+            .field("commands", &self.commands)
+            .finish()
+    }
+}
+
+impl std::fmt::Debug for SlackConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SlackConfig")
+            .field("enabled", &self.enabled)
+            .field("bot_token", &"[REDACTED]")
+            .field("app_token", &"[REDACTED]")
+            .field("instances", &self.instances)
+            .field("dm_allowed_users", &self.dm_allowed_users)
+            .field("commands", &self.commands)
+            .finish()
+    }
+}
+
+impl SystemSecrets for SlackConfig {
+    fn section() -> &'static str {
+        "slack"
+    }
+
+    fn is_messaging_adapter() -> bool {
+        true
+    }
+
+    fn secret_fields() -> &'static [SecretField] {
+        &[
+            SecretField {
+                toml_key: "bot_token",
+                secret_name: "SLACK_BOT_TOKEN",
+                instance_pattern: Some(InstancePattern {
+                    platform_prefix: "SLACK",
+                    field_suffix: "BOT_TOKEN",
+                }),
+            },
+            SecretField {
+                toml_key: "app_token",
+                secret_name: "SLACK_APP_TOKEN",
+                instance_pattern: Some(InstancePattern {
+                    platform_prefix: "SLACK",
+                    field_suffix: "APP_TOKEN",
+                }),
+            },
+        ]
+    }
+}
+
+#[derive(Clone)]
+pub struct TelegramConfig {
+    pub enabled: bool,
+    pub token: String,
+    /// Additional named Telegram bot instances for this platform.
+    pub instances: Vec<TelegramInstanceConfig>,
+    /// User IDs allowed to DM the bot. If empty, DMs are ignored entirely.
+    pub dm_allowed_users: Vec<String>,
+}
+
+#[derive(Clone)]
+pub struct TelegramInstanceConfig {
+    pub name: String,
+    pub enabled: bool,
+    pub token: String,
+    /// User IDs allowed to DM this bot instance.
+    pub dm_allowed_users: Vec<String>,
+}
+
+impl std::fmt::Debug for TelegramInstanceConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("TelegramInstanceConfig")
+            .field("name", &self.name)
+            .field("enabled", &self.enabled)
+            .field("token", &"[REDACTED]")
+            .field("dm_allowed_users", &self.dm_allowed_users)
+            .finish()
+    }
+}
+
+impl std::fmt::Debug for TelegramConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("TelegramConfig")
+            .field("enabled", &self.enabled)
+            .field("token", &"[REDACTED]")
+            .field("instances", &self.instances)
+            .field("dm_allowed_users", &self.dm_allowed_users)
+            .finish()
+    }
+}
+
+impl SystemSecrets for TelegramConfig {
+    fn section() -> &'static str {
+        "telegram"
+    }
+
+    fn is_messaging_adapter() -> bool {
+        true
+    }
+
+    fn secret_fields() -> &'static [SecretField] {
+        &[SecretField {
+            toml_key: "token",
+            secret_name: "TELEGRAM_BOT_TOKEN",
+            instance_pattern: Some(InstancePattern {
+                platform_prefix: "TELEGRAM",
+                field_suffix: "BOT_TOKEN",
+            }),
+        }]
+    }
+}
+
+#[derive(Clone)]
+pub struct EmailConfig {
+    pub enabled: bool,
+    pub imap_host: String,
+    pub imap_port: u16,
+    pub imap_username: String,
+    pub imap_password: String,
+    pub imap_use_tls: bool,
+    pub smtp_host: String,
+    pub smtp_port: u16,
+    pub smtp_username: String,
+    pub smtp_password: String,
+    pub smtp_use_starttls: bool,
+    pub from_address: String,
+    pub from_name: Option<String>,
+    pub poll_interval_secs: u64,
+    pub folders: Vec<String>,
+    pub allowed_senders: Vec<String>,
+    pub max_body_bytes: usize,
+    pub max_attachment_bytes: usize,
+    pub instances: Vec<EmailInstanceConfig>,
+}
+
+/// Per-instance config for a named email adapter.
+#[derive(Clone)]
+pub struct EmailInstanceConfig {
+    pub name: String,
+    pub enabled: bool,
+    pub imap_host: String,
+    pub imap_port: u16,
+    pub imap_username: String,
+    pub imap_password: String,
+    pub imap_use_tls: bool,
+    pub smtp_host: String,
+    pub smtp_port: u16,
+    pub smtp_username: String,
+    pub smtp_password: String,
+    pub smtp_use_starttls: bool,
+    pub from_address: String,
+    pub from_name: Option<String>,
+    pub poll_interval_secs: u64,
+    pub folders: Vec<String>,
+    pub allowed_senders: Vec<String>,
+    pub max_body_bytes: usize,
+    pub max_attachment_bytes: usize,
+}
+
+impl std::fmt::Debug for EmailInstanceConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("EmailInstanceConfig")
+            .field("name", &self.name)
+            .field("enabled", &self.enabled)
+            .field("imap_host", &self.imap_host)
+            .field("imap_port", &self.imap_port)
+            .field("imap_username", &"[REDACTED]")
+            .field("imap_password", &"[REDACTED]")
+            .field("imap_use_tls", &self.imap_use_tls)
+            .field("smtp_host", &self.smtp_host)
+            .field("smtp_port", &self.smtp_port)
+            .field("smtp_username", &"[REDACTED]")
+            .field("smtp_password", &"[REDACTED]")
+            .field("smtp_use_starttls", &self.smtp_use_starttls)
+            .field("from_address", &"[REDACTED]")
+            .field("from_name", &self.from_name)
+            .field("poll_interval_secs", &self.poll_interval_secs)
+            .field("folders", &self.folders)
+            .field("allowed_senders", &"[REDACTED]")
+            .field("max_body_bytes", &self.max_body_bytes)
+            .field("max_attachment_bytes", &self.max_attachment_bytes)
+            .finish()
+    }
+}
+
+impl std::fmt::Debug for EmailConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("EmailConfig")
+            .field("enabled", &self.enabled)
+            .field("imap_host", &self.imap_host)
+            .field("imap_port", &self.imap_port)
+            .field("imap_username", &"[REDACTED]")
+            .field("imap_password", &"[REDACTED]")
+            .field("imap_use_tls", &self.imap_use_tls)
+            .field("smtp_host", &self.smtp_host)
+            .field("smtp_port", &self.smtp_port)
+            .field("smtp_username", &"[REDACTED]")
+            .field("smtp_password", &"[REDACTED]")
+            .field("smtp_use_starttls", &self.smtp_use_starttls)
+            .field("from_address", &"[REDACTED]")
+            .field("from_name", &self.from_name)
+            .field("poll_interval_secs", &self.poll_interval_secs)
+            .field("folders", &self.folders)
+            .field("allowed_senders", &"[REDACTED]")
+            .field("max_body_bytes", &self.max_body_bytes)
+            .field("max_attachment_bytes", &self.max_attachment_bytes)
+            .finish()
+    }
+}
+
+impl SystemSecrets for EmailConfig {
+    fn section() -> &'static str {
+        "email"
+    }
+
+    fn is_messaging_adapter() -> bool {
+        true
+    }
+
+    fn secret_fields() -> &'static [SecretField] {
+        &[
+            SecretField {
+                toml_key: "imap_username",
+                secret_name: "EMAIL_IMAP_USERNAME",
+                instance_pattern: Some(InstancePattern {
+                    platform_prefix: "EMAIL",
+                    field_suffix: "IMAP_USERNAME",
+                }),
+            },
+            SecretField {
+                toml_key: "imap_password",
+                secret_name: "EMAIL_IMAP_PASSWORD",
+                instance_pattern: Some(InstancePattern {
+                    platform_prefix: "EMAIL",
+                    field_suffix: "IMAP_PASSWORD",
+                }),
+            },
+            SecretField {
+                toml_key: "smtp_username",
+                secret_name: "EMAIL_SMTP_USERNAME",
+                instance_pattern: Some(InstancePattern {
+                    platform_prefix: "EMAIL",
+                    field_suffix: "SMTP_USERNAME",
+                }),
+            },
+            SecretField {
+                toml_key: "smtp_password",
+                secret_name: "EMAIL_SMTP_PASSWORD",
+                instance_pattern: Some(InstancePattern {
+                    platform_prefix: "EMAIL",
+                    field_suffix: "SMTP_PASSWORD",
+                }),
+            },
+        ]
+    }
+}
+
+#[derive(Clone)]
+pub struct TwitchConfig {
+    pub enabled: bool,
+    pub username: String,
+    pub oauth_token: String,
+    pub client_id: Option<String>,
+    pub client_secret: Option<String>,
+    pub refresh_token: Option<String>,
+    /// Additional named Twitch bot instances for this platform.
+    pub instances: Vec<TwitchInstanceConfig>,
+    /// Channels to join (without the # prefix).
+    pub channels: Vec<String>,
+    /// Optional prefix that triggers the bot (e.g. "!ask"). If empty, all messages are processed.
+    pub trigger_prefix: Option<String>,
+}
+
+#[derive(Clone)]
+pub struct TwitchInstanceConfig {
+    pub name: String,
+    pub enabled: bool,
+    pub username: String,
+    pub oauth_token: String,
+    pub client_id: Option<String>,
+    pub client_secret: Option<String>,
+    pub refresh_token: Option<String>,
+    /// Channels to join (without the # prefix).
+    pub channels: Vec<String>,
+    /// Optional prefix that triggers the bot for this instance.
+    pub trigger_prefix: Option<String>,
+}
+
+impl std::fmt::Debug for TwitchInstanceConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("TwitchInstanceConfig")
+            .field("name", &self.name)
+            .field("enabled", &self.enabled)
+            .field("username", &self.username)
+            .field("oauth_token", &"[REDACTED]")
+            .field("client_id", &self.client_id)
+            .field(
+                "client_secret",
+                &self.client_secret.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field(
+                "refresh_token",
+                &self.refresh_token.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field("channels", &self.channels)
+            .field("trigger_prefix", &self.trigger_prefix)
+            .finish()
+    }
+}
+
+impl std::fmt::Debug for TwitchConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("TwitchConfig")
+            .field("enabled", &self.enabled)
+            .field("username", &self.username)
+            .field("oauth_token", &"[REDACTED]")
+            .field("instances", &self.instances)
+            .field("channels", &self.channels)
+            .field("trigger_prefix", &self.trigger_prefix)
+            .finish()
+    }
+}
+
+impl SystemSecrets for TwitchConfig {
+    fn section() -> &'static str {
+        "twitch"
+    }
+
+    fn is_messaging_adapter() -> bool {
+        true
+    }
+
+    fn secret_fields() -> &'static [SecretField] {
+        &[
+            SecretField {
+                toml_key: "oauth_token",
+                secret_name: "TWITCH_OAUTH_TOKEN",
+                instance_pattern: Some(InstancePattern {
+                    platform_prefix: "TWITCH",
+                    field_suffix: "OAUTH_TOKEN",
+                }),
+            },
+            SecretField {
+                toml_key: "client_id",
+                secret_name: "TWITCH_CLIENT_ID",
+                instance_pattern: Some(InstancePattern {
+                    platform_prefix: "TWITCH",
+                    field_suffix: "CLIENT_ID",
+                }),
+            },
+            SecretField {
+                toml_key: "client_secret",
+                secret_name: "TWITCH_CLIENT_SECRET",
+                instance_pattern: Some(InstancePattern {
+                    platform_prefix: "TWITCH",
+                    field_suffix: "CLIENT_SECRET",
+                }),
+            },
+            SecretField {
+                toml_key: "refresh_token",
+                secret_name: "TWITCH_REFRESH_TOKEN",
+                instance_pattern: Some(InstancePattern {
+                    platform_prefix: "TWITCH",
+                    field_suffix: "REFRESH_TOKEN",
+                }),
+            },
+        ]
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct WebhookConfig {
+    pub enabled: bool,
+    pub port: u16,
+    pub bind: String,
+    pub auth_token: Option<String>,
+}
diff --git a/src/config/watcher.rs b/src/config/watcher.rs
new file mode 100644
index 000000000..45abcc2f0
--- /dev/null
+++ b/src/config/watcher.rs
@@ -0,0 +1,553 @@
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use super::{
+    Binding, Config, DiscordPermissions, RuntimeConfig, SlackPermissions, TelegramPermissions,
+    TwitchPermissions, binding_runtime_adapter_key,
+};
+
+/// Watches config, prompt, identity, and skill files for changes and triggers
+/// hot reload on the corresponding RuntimeConfig.
+///
+/// Returns a JoinHandle that runs until dropped. File events are debounced
+/// to 2 seconds so rapid edits (e.g. :w in vim hitting multiple writes) are
+/// collapsed into a single reload.
+#[allow(clippy::too_many_arguments)]
+pub fn spawn_file_watcher(
+    config_path: PathBuf,
+    instance_dir: PathBuf,
+    agents: Vec<(
+        String,
+        PathBuf,
+        Arc<RuntimeConfig>,
+        Arc<crate::mcp::McpManager>,
+    )>,
+    discord_permissions: Option<Arc<arc_swap::ArcSwap<DiscordPermissions>>>,
+    slack_permissions: Option<Arc<arc_swap::ArcSwap<SlackPermissions>>>,
+    telegram_permissions: Option<Arc<arc_swap::ArcSwap<TelegramPermissions>>>,
+    twitch_permissions: Option<Arc<arc_swap::ArcSwap<TwitchPermissions>>>,
+    bindings: Arc<arc_swap::ArcSwap<Vec<Binding>>>,
+    messaging_manager: Option<Arc<crate::messaging::MessagingManager>>,
+    llm_manager: Arc<crate::llm::LlmManager>,
+    agent_links: Arc<arc_swap::ArcSwap<Vec<crate::links::AgentLink>>>,
+) -> tokio::task::JoinHandle<()> {
+    use notify::{Event, RecursiveMode, Watcher};
+    use std::time::Duration;
+
+    tokio::task::spawn_blocking(move || {
+        let (tx, rx) = std::sync::mpsc::channel::<Event>();
+
+        let mut watcher = match notify::recommended_watcher(
+            move |result: std::result::Result<Event, notify::Error>| {
+                if let Ok(event) = result {
+                    // Only forward data modification events, not metadata/access changes
+                    use notify::EventKind;
+                    match &event.kind {
+                        EventKind::Create(_)
+                        | EventKind::Modify(notify::event::ModifyKind::Data(_))
+                        | EventKind::Remove(_) => {
+                            let _ = tx.send(event);
+                        }
+                        // Also forward Any/Other modify events (some backends don't distinguish)
+                        EventKind::Modify(notify::event::ModifyKind::Any) => {
+                            let _ = tx.send(event);
+                        }
+                        _ => {}
+                    }
+                }
+            },
+        ) {
+            Ok(w) => w,
+            Err(error) => {
+                tracing::error!(%error, "failed to create file watcher");
+                return;
+            }
+        };
+
+        // Watch config.toml
+        if let Err(error) = watcher.watch(&config_path, RecursiveMode::NonRecursive) {
+            tracing::warn!(%error, path = %config_path.display(), "failed to watch config file");
+        }
+
+        // Watch instance-level skills directory
+        let instance_skills_dir = instance_dir.join("skills");
+        if instance_skills_dir.is_dir()
+            && let Err(error) = watcher.watch(&instance_skills_dir, RecursiveMode::Recursive)
+        {
+            tracing::warn!(%error, path = %instance_skills_dir.display(), "failed to watch instance skills dir");
+        }
+
+        // Watch per-agent workspace directories (skills, identity)
+        for (_, workspace, _, _) in &agents {
+            {
+                let path = workspace.join("skills");
+                if path.is_dir()
+                    && let Err(error) = watcher.watch(&path, RecursiveMode::Recursive)
+                {
+                    tracing::warn!(%error, path = %path.display(), "failed to watch agent dir");
+                }
+            }
+            // Identity files are in the workspace root
+            if let Err(error) = watcher.watch(workspace, RecursiveMode::NonRecursive) {
+                tracing::warn!(%error, path = %workspace.display(), "failed to watch workspace");
+            }
+        }
+
+        tracing::info!("file watcher started");
+
+        // Track config.toml content hash to skip no-op reloads
+        let mut last_config_hash: u64 = std::fs::read(&config_path)
+            .map(|bytes| {
+                use std::hash::{Hash, Hasher};
+                let mut hasher = std::collections::hash_map::DefaultHasher::new();
+                bytes.hash(&mut hasher);
+                hasher.finish()
+            })
+            .unwrap_or(0);
+
+        // Debounce loop: collect events for 2 seconds, then reload
+        let debounce = Duration::from_secs(2);
+
+        while let Ok(first) = rx.recv() {
+            // Drain any additional events within the debounce window
+            let mut changed_paths: Vec<PathBuf> = first.paths;
+            while let Ok(event) = rx.recv_timeout(debounce) {
+                changed_paths.extend(event.paths);
+            }
+
+            // Categorize what changed
+            let mut config_changed = changed_paths.iter().any(|p| p.ends_with("config.toml"));
+            let identity_changed = changed_paths.iter().any(|p| {
+                let name = p.file_name().and_then(|n| n.to_str()).unwrap_or("");
+                matches!(name, "SOUL.md" | "IDENTITY.md" | "USER.md" | "ROLE.md")
+            });
+            let skills_changed = changed_paths
+                .iter()
+                .any(|p| p.to_string_lossy().contains("skills"));
+
+            // Skip entirely if nothing relevant changed
+            if !config_changed && !identity_changed && !skills_changed {
+                continue;
+            }
+
+            // Skip config reload if file content hasn't actually changed
+            if config_changed {
+                let current_hash: u64 = std::fs::read(&config_path)
+                    .map(|bytes| {
+                        use std::hash::{Hash, Hasher};
+                        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+                        bytes.hash(&mut hasher);
+                        hasher.finish()
+                    })
+                    .unwrap_or(0);
+                if current_hash == last_config_hash {
+                    config_changed = false;
+                    // If config was the only thing that "changed", skip entirely
+                    if !identity_changed && !skills_changed {
+                        continue;
+                    }
+                } else {
+                    last_config_hash = current_hash;
+                }
+            }
+
+            let changed_summary: Vec<&str> = [
+                config_changed.then_some("config"),
+                identity_changed.then_some("identity"),
+                skills_changed.then_some("skills"),
+            ]
+            .into_iter()
+            .flatten()
+            .collect();
+
+            tracing::info!(
+                changed = %changed_summary.join(", "),
+                "file change detected, reloading"
+            );
+
+            // Reload config.toml if it changed
+            let new_config = if config_changed {
+                match Config::load_from_path(&config_path) {
+                    Ok(config) => Some(config),
+                    Err(error) => {
+                        tracing::error!(%error, "failed to reload config.toml, keeping previous values");
+                        None
+                    }
+                }
+            } else {
+                None
+            };
+
+            // Reload instance-level bindings, provider keys, and permissions
+            if let Some(config) = &new_config {
+                llm_manager.reload_config(config.llm.clone());
+
+                bindings.store(Arc::new(config.bindings.clone()));
+                tracing::info!("bindings reloaded ({} entries)", config.bindings.len());
+
+                match crate::links::AgentLink::from_config(&config.links) {
+                    Ok(links) => {
+                        agent_links.store(Arc::new(links));
+                        tracing::info!("agent links reloaded ({} entries)", config.links.len());
+                    }
+                    Err(error) => {
+                        tracing::error!(%error, "failed to parse links from reloaded config");
+                    }
+                }
+
+                if let Some(ref perms) = discord_permissions
+                    && let Some(discord_config) = &config.messaging.discord
+                {
+                    let new_perms =
+                        DiscordPermissions::from_config(discord_config, &config.bindings);
+                    perms.store(Arc::new(new_perms));
+                    tracing::info!("discord permissions reloaded");
+                }
+
+                if let Some(ref perms) = slack_permissions
+                    && let Some(slack_config) = &config.messaging.slack
+                {
+                    let new_perms = SlackPermissions::from_config(slack_config, &config.bindings);
+                    perms.store(Arc::new(new_perms));
+                    tracing::info!("slack permissions reloaded");
+                }
+
+                if let Some(ref perms) = telegram_permissions
+                    && let Some(telegram_config) = &config.messaging.telegram
+                {
+                    let new_perms =
+                        TelegramPermissions::from_config(telegram_config, &config.bindings);
+                    perms.store(Arc::new(new_perms));
+                    tracing::info!("telegram permissions reloaded");
+                }
+
+                if let Some(ref perms) = twitch_permissions
+                    && let Some(twitch_config) = &config.messaging.twitch
+                {
+                    let new_perms = TwitchPermissions::from_config(twitch_config, &config.bindings);
+                    perms.store(Arc::new(new_perms));
+                    tracing::info!("twitch permissions reloaded");
+                }
+
+                // Hot-start adapters that are newly enabled in the config
+                if let Some(ref manager) = messaging_manager {
+                    let rt = tokio::runtime::Handle::current();
+                    let manager = manager.clone();
+                    let config = config.clone();
+                    let discord_permissions = discord_permissions.clone();
+                    let slack_permissions = slack_permissions.clone();
+                    let telegram_permissions = telegram_permissions.clone();
+                    let twitch_permissions = twitch_permissions.clone();
+                    let instance_dir = instance_dir.clone();
+
+                    rt.spawn(async move {
+                        // Discord: start default + named instances that are enabled and not already running.
+                        if let Some(discord_config) = &config.messaging.discord
+                            && discord_config.enabled {
+                                if !discord_config.token.is_empty() && !manager.has_adapter("discord").await {
+                                    let permissions = match discord_permissions {
+                                        Some(ref existing) => existing.clone(),
+                                        None => {
+                                            let permissions = DiscordPermissions::from_config(discord_config, &config.bindings);
+                                            Arc::new(arc_swap::ArcSwap::from_pointee(permissions))
+                                        }
+                                    };
+                                    let adapter = crate::messaging::discord::DiscordAdapter::new(
+                                        "discord",
+                                        &discord_config.token,
+                                        permissions,
+                                    );
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, "failed to hot-start discord adapter from config change");
+                                    }
+                                }
+
+                                for instance in discord_config.instances.iter().filter(|instance| instance.enabled) {
+                                    let runtime_key = binding_runtime_adapter_key(
+                                        "discord",
+                                        Some(instance.name.as_str()),
+                                    );
+                                    if manager.has_adapter(runtime_key.as_str()).await {
+                                        // TODO: named instance permissions are not hot-updated on
+                                        // config reload because each instance owns its own
+                                        // Arc<ArcSwap> with no external handle. Fixing this
+                                        // requires either a permission-update method on the
+                                        // Messaging trait or a shared handle registry. Permissions
+                                        // will be correct after a full restart.
+                                        continue;
+                                    }
+
+                                    let permissions = Arc::new(arc_swap::ArcSwap::from_pointee(
+                                        DiscordPermissions::from_instance_config(instance, &config.bindings),
+                                    ));
+                                    let adapter = crate::messaging::discord::DiscordAdapter::new(
+                                        runtime_key,
+                                        &instance.token,
+                                        permissions,
+                                    );
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, adapter = %instance.name, "failed to hot-start named discord adapter from config change");
+                                    }
+                                }
+                            }
+
+                        // Slack: start default + named instances that are enabled and not already running.
+                        if let Some(slack_config) = &config.messaging.slack
+                            && slack_config.enabled {
+                                if !slack_config.bot_token.is_empty()
+                                    && !slack_config.app_token.is_empty()
+                                    && !manager.has_adapter("slack").await
+                                {
+                                    let permissions = match slack_permissions {
+                                        Some(ref existing) => existing.clone(),
+                                        None => {
+                                            let permissions = SlackPermissions::from_config(slack_config, &config.bindings);
+                                            Arc::new(arc_swap::ArcSwap::from_pointee(permissions))
+                                        }
+                                    };
+                                    match crate::messaging::slack::SlackAdapter::new(
+                                        "slack",
+                                        &slack_config.bot_token,
+                                        &slack_config.app_token,
+                                        permissions,
+                                        slack_config.commands.clone(),
+                                    ) {
+                                        Ok(adapter) => {
+                                            if let Err(error) = manager.register_and_start(adapter).await {
+                                                tracing::error!(%error, "failed to hot-start slack adapter from config change");
+                                            }
+                                        }
+                                        Err(error) => {
+                                            tracing::error!(%error, "failed to build slack adapter from config change");
+                                        }
+                                    }
+                                }
+
+                                for instance in slack_config.instances.iter().filter(|instance| instance.enabled) {
+                                    let runtime_key = binding_runtime_adapter_key(
+                                        "slack",
+                                        Some(instance.name.as_str()),
+                                    );
+                                    if manager.has_adapter(runtime_key.as_str()).await {
+                                        // TODO: named instance permissions not hot-updated (see discord block comment)
+                                        continue;
+                                    }
+
+                                    let permissions = Arc::new(arc_swap::ArcSwap::from_pointee(
+                                        SlackPermissions::from_instance_config(instance, &config.bindings),
+                                    ));
+                                    match crate::messaging::slack::SlackAdapter::new(
+                                        runtime_key,
+                                        &instance.bot_token,
+                                        &instance.app_token,
+                                        permissions,
+                                        instance.commands.clone(),
+                                    ) {
+                                        Ok(adapter) => {
+                                            if let Err(error) = manager.register_and_start(adapter).await {
+                                                tracing::error!(%error, adapter = %instance.name, "failed to hot-start named slack adapter from config change");
+                                            }
+                                        }
+                                        Err(error) => {
+                                            tracing::error!(%error, adapter = %instance.name, "failed to build named slack adapter from config change");
+                                        }
+                                    }
+                                }
+                            }
+
+                        // Telegram: start default + named instances that are enabled and not already running.
+                        if let Some(telegram_config) = &config.messaging.telegram
+                            && telegram_config.enabled {
+                                if !telegram_config.token.is_empty()
+                                    && !manager.has_adapter("telegram").await
+                                {
+                                    let permissions = match telegram_permissions {
+                                        Some(ref existing) => existing.clone(),
+                                        None => {
+                                            let permissions = TelegramPermissions::from_config(telegram_config, &config.bindings);
+                                            Arc::new(arc_swap::ArcSwap::from_pointee(permissions))
+                                        }
+                                    };
+                                    let adapter = crate::messaging::telegram::TelegramAdapter::new(
+                                        "telegram",
+                                        &telegram_config.token,
+                                        permissions,
+                                    );
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, "failed to hot-start telegram adapter from config change");
+                                    }
+                                }
+
+                                for instance in telegram_config.instances.iter().filter(|instance| instance.enabled) {
+                                    let runtime_key = binding_runtime_adapter_key(
+                                        "telegram",
+                                        Some(instance.name.as_str()),
+                                    );
+                                    if manager.has_adapter(runtime_key.as_str()).await {
+                                        // TODO: named instance permissions not hot-updated (see discord block comment)
+                                        continue;
+                                    }
+
+                                    let permissions = Arc::new(arc_swap::ArcSwap::from_pointee(
+                                        TelegramPermissions::from_instance_config(instance, &config.bindings),
+                                    ));
+                                    let adapter = crate::messaging::telegram::TelegramAdapter::new(
+                                        runtime_key,
+                                        &instance.token,
+                                        permissions,
+                                    );
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, adapter = %instance.name, "failed to hot-start named telegram adapter from config change");
+                                    }
+                                }
+                            }
+
+                        // Email: start default + named instances that are enabled and not already running.
+                        if let Some(email_config) = &config.messaging.email
+                            && email_config.enabled {
+                                if !email_config.imap_host.is_empty() && !manager.has_adapter("email").await {
+                                    match crate::messaging::email::EmailAdapter::from_config(email_config) {
+                                        Ok(adapter) => {
+                                            if let Err(error) = manager.register_and_start(adapter).await {
+                                                tracing::error!(%error, "failed to hot-start email adapter from config change");
+                                            }
+                                        }
+                                        Err(error) => {
+                                            tracing::error!(%error, "failed to build email adapter from config change");
+                                        }
+                                    }
+                                }
+
+                                for instance in email_config.instances.iter().filter(|instance| instance.enabled) {
+                                    let runtime_key = binding_runtime_adapter_key(
+                                        "email",
+                                        Some(instance.name.as_str()),
+                                    );
+                                    if manager.has_adapter(runtime_key.as_str()).await {
+                                        continue;
+                                    }
+
+                                    match crate::messaging::email::EmailAdapter::from_instance_config(
+                                        runtime_key.as_str(),
+                                        instance,
+                                    ) {
+                                        Ok(adapter) => {
+                                            if let Err(error) = manager.register_and_start(adapter).await {
+                                                tracing::error!(%error, adapter = %instance.name, "failed to hot-start named email adapter from config change");
+                                            }
+                                        }
+                                        Err(error) => {
+                                            tracing::error!(%error, adapter = %instance.name, "failed to build named email adapter from config change");
+                                        }
+                                    }
+                                }
+                            }
+
+                        // Twitch: start default + named instances that are enabled and not already running.
+                        if let Some(twitch_config) = &config.messaging.twitch
+                            && twitch_config.enabled {
+                                if !twitch_config.username.is_empty()
+                                    && !twitch_config.oauth_token.is_empty()
+                                    && !manager.has_adapter("twitch").await
+                                {
+                                    let permissions = match twitch_permissions {
+                                        Some(ref existing) => existing.clone(),
+                                        None => {
+                                            let permissions = TwitchPermissions::from_config(twitch_config, &config.bindings);
+                                            Arc::new(arc_swap::ArcSwap::from_pointee(permissions))
+                                        }
+                                    };
+                                    let token_path = instance_dir.join("twitch_token.json");
+                                    let adapter = crate::messaging::twitch::TwitchAdapter::new(
+                                        "twitch",
+                                        &twitch_config.username,
+                                        &twitch_config.oauth_token,
+                                        twitch_config.client_id.clone(),
+                                        twitch_config.client_secret.clone(),
+                                        twitch_config.refresh_token.clone(),
+                                        Some(token_path),
+                                        twitch_config.channels.clone(),
+                                        twitch_config.trigger_prefix.clone(),
+                                        permissions,
+                                    );
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, "failed to hot-start twitch adapter from config change");
+                                    }
+                                }
+
+                                for instance in twitch_config.instances.iter().filter(|instance| instance.enabled) {
+                                    let runtime_key = binding_runtime_adapter_key(
+                                        "twitch",
+                                        Some(instance.name.as_str()),
+                                    );
+                                    if manager.has_adapter(runtime_key.as_str()).await {
+                                        // TODO: named instance permissions not hot-updated (see discord block comment)
+                                        continue;
+                                    }
+
+                                    let token_file_name = {
+                                        use std::hash::{Hash, Hasher};
+                                        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+                                        instance.name.hash(&mut hasher);
+                                        let name_hash = hasher.finish();
+                                        format!(
+                                            "twitch_token_{}_{name_hash:016x}.json",
+                                            instance
+                                                .name
+                                                .chars()
+                                                .map(|ch| if ch.is_ascii_alphanumeric() { ch } else { '_' })
+                                                .collect::<String>()
+                                        )
+                                    };
+                                    let token_path = instance_dir.join(token_file_name);
+                                    let permissions = Arc::new(arc_swap::ArcSwap::from_pointee(
+                                        TwitchPermissions::from_instance_config(instance, &config.bindings),
+                                    ));
+                                    let adapter = crate::messaging::twitch::TwitchAdapter::new(
+                                        runtime_key,
+                                        &instance.username,
+                                        &instance.oauth_token,
+                                        instance.client_id.clone(),
+                                        instance.client_secret.clone(),
+                                        instance.refresh_token.clone(),
+                                        Some(token_path),
+                                        instance.channels.clone(),
+                                        instance.trigger_prefix.clone(),
+                                        permissions,
+                                    );
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, adapter = %instance.name, "failed to hot-start named twitch adapter from config change");
+                                    }
+                                }
+                            }
+                    });
+                }
+            }
+
+            // Apply reloads to each agent's RuntimeConfig
+            for (agent_id, workspace, runtime_config, mcp_manager) in &agents {
+                if let Some(config) = &new_config {
+                    let rt = tokio::runtime::Handle::current();
+                    rt.block_on(runtime_config.reload_config(config, agent_id, mcp_manager));
+                }
+
+                if identity_changed {
+                    let rt = tokio::runtime::Handle::current();
+                    let identity = rt.block_on(crate::identity::Identity::load(workspace));
+                    runtime_config.reload_identity(identity);
+                }
+
+                if skills_changed {
+                    let rt = tokio::runtime::Handle::current();
+                    let skills = rt.block_on(crate::skills::SkillSet::load(
+                        &instance_dir.join("skills"),
+                        &workspace.join("skills"),
+                    ));
+                    runtime_config.reload_skills(skills);
+                }
+            }
+        }
+
+        tracing::info!("file watcher stopped");
+    })
+}
diff --git a/src/conversation.rs b/src/conversation.rs
index 0097a7d42..bbfc5fac9 100644
--- a/src/conversation.rs
+++ b/src/conversation.rs
@@ -3,6 +3,10 @@
 pub mod channels;
 pub mod context;
 pub mod history;
+pub mod worker_transcript;
 
 pub use channels::ChannelStore;
-pub use history::{ConversationLogger, ProcessRunLogger, TimelineItem};
+pub use history::{
+    ConversationLogger, ProcessRunLogger, TimelineItem, WorkerDetailRow, WorkerRunRow,
+};
+pub use worker_transcript::{ActionContent, TranscriptStep};
diff --git a/src/conversation/channels.rs b/src/conversation/channels.rs
index 8bf7534bd..716bd82a7 100644
--- a/src/conversation/channels.rs
+++ b/src/conversation/channels.rs
@@ -81,21 +81,55 @@ impl ChannelStore {
         });
     }
 
-    /// List all active channels, most recently active first.
-    pub async fn list_active(&self) -> crate::error::Result<Vec<ChannelInfo>> {
-        let rows = sqlx::query(
-            "SELECT id, platform, display_name, platform_meta, is_active, created_at, last_activity_at \
-             FROM channels \
-             WHERE is_active = 1 \
-             ORDER BY last_activity_at DESC"
-        )
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| anyhow::anyhow!(e))?;
+    /// List channels, most recently active first.
+    ///
+    /// When `is_active_filter` is `Some(true)` or `Some(false)`, filtering is
+    /// pushed into SQL. `None` returns both active and inactive channels.
+    pub async fn list(
+        &self,
+        is_active_filter: Option<bool>,
+    ) -> crate::error::Result<Vec<ChannelInfo>> {
+        let rows = match is_active_filter {
+            Some(true) => {
+                sqlx::query(
+                    "SELECT id, platform, display_name, platform_meta, is_active, created_at, last_activity_at \
+                     FROM channels \
+                     WHERE is_active = 1 \
+                     ORDER BY last_activity_at DESC",
+                )
+                .fetch_all(&self.pool)
+                .await
+            }
+            Some(false) => {
+                sqlx::query(
+                    "SELECT id, platform, display_name, platform_meta, is_active, created_at, last_activity_at \
+                     FROM channels \
+                     WHERE is_active = 0 \
+                     ORDER BY last_activity_at DESC",
+                )
+                .fetch_all(&self.pool)
+                .await
+            }
+            None => {
+                sqlx::query(
+                    "SELECT id, platform, display_name, platform_meta, is_active, created_at, last_activity_at \
+                     FROM channels \
+                     ORDER BY last_activity_at DESC",
+                )
+                .fetch_all(&self.pool)
+                .await
+            }
+        }
+        .map_err(|error| anyhow::anyhow!(error))?;
 
         Ok(rows.into_iter().map(row_to_channel_info).collect())
     }
 
+    /// List all active channels, most recently active first.
+    pub async fn list_active(&self) -> crate::error::Result<Vec<ChannelInfo>> {
+        self.list(Some(true)).await
+    }
+
     /// Find a channel by partial name or ID match.
     ///
     /// Match priority: exact name > prefix > contains > channel ID contains.
@@ -183,6 +217,18 @@ impl ChannelStore {
 
         Ok(result.rows_affected() > 0)
     }
+
+    /// Set active/archive state for a channel.
+    pub async fn set_active(&self, channel_id: &str, active: bool) -> crate::error::Result<bool> {
+        let result = sqlx::query("UPDATE channels SET is_active = ? WHERE id = ?")
+            .bind(if active { 1_i64 } else { 0_i64 })
+            .bind(channel_id)
+            .execute(&self.pool)
+            .await
+            .map_err(|e| anyhow::anyhow!(e))?;
+
+        Ok(result.rows_affected() > 0)
+    }
 }
 
 fn row_to_channel_info(row: sqlx::sqlite::SqliteRow) -> ChannelInfo {
@@ -216,33 +262,22 @@ fn extract_platform(channel_id: &str) -> String {
 }
 
 /// Pull the best display name from inbound message metadata.
+///
+/// Adapters set `channel_name` with display-ready values (e.g. `#general`
+/// for Slack, `Email: subject` for email). Portal is the only platform
+/// without adapter-set metadata, so it uses a hardcoded fallback.
 fn extract_display_name(
     platform: &str,
-    channel_id: &str,
+    _channel_id: &str,
     metadata: &HashMap<String, serde_json::Value>,
 ) -> Option<String> {
-    match platform {
-        "discord" => metadata
-            .get("discord_channel_name")
-            .and_then(|v| v.as_str())
-            .map(|s| s.to_string()),
-        "slack" => metadata
-            .get("slack_channel_name")
-            .and_then(|v| v.as_str())
-            .map(|name| {
-                if channel_id.contains(":D") || name.starts_with("dm-") {
-                    name.to_string()
-                } else {
-                    format!("#{name}")
-                }
-            }),
-        "telegram" => metadata
-            .get("display_name")
-            .and_then(|v| v.as_str())
-            .map(|s| s.to_string()),
-        "portal" => Some("portal:chat".to_string()),
-        _ => None,
+    if platform == "portal" {
+        return Some("portal:chat".to_string());
     }
+    metadata
+        .get(crate::metadata_keys::CHANNEL_NAME)
+        .and_then(|v| v.as_str())
+        .map(|s| s.to_string())
 }
 
 /// Build a JSON blob of platform-specific metadata worth persisting.
@@ -285,6 +320,22 @@ fn extract_platform_meta(
                 meta.insert("twitch_channel".to_string(), value.clone());
             }
         }
+        "email" => {
+            for key in [
+                "email_from",
+                "email_reply_to",
+                "email_to",
+                "email_subject",
+                "email_message_id",
+                "email_in_reply_to",
+                "email_references",
+                "email_thread_key",
+            ] {
+                if let Some(value) = metadata.get(key) {
+                    meta.insert(key.to_string(), value.clone());
+                }
+            }
+        }
         _ => {}
     }
 
@@ -294,3 +345,118 @@ fn extract_platform_meta(
         serde_json::to_string(&serde_json::Value::Object(meta)).ok()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use sqlx::sqlite::SqlitePoolOptions;
+
+    async fn setup_store() -> ChannelStore {
+        let pool = SqlitePoolOptions::new()
+            .max_connections(1)
+            .connect("sqlite::memory:")
+            .await
+            .expect("in-memory sqlite should connect");
+
+        sqlx::query(
+            r#"
+            CREATE TABLE channels (
+                id TEXT PRIMARY KEY,
+                platform TEXT NOT NULL,
+                display_name TEXT,
+                platform_meta TEXT,
+                is_active INTEGER NOT NULL DEFAULT 1,
+                created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                last_activity_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+            )
+            "#,
+        )
+        .execute(&pool)
+        .await
+        .expect("channels table should create");
+
+        ChannelStore::new(pool)
+    }
+
+    #[tokio::test]
+    async fn list_is_active_filter_controls_visibility() {
+        let store = setup_store().await;
+
+        sqlx::query(
+            "INSERT INTO channels (id, platform, is_active, created_at, last_activity_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)",
+        )
+        .bind("active-channel")
+        .bind("portal")
+        .bind(1_i64)
+        .execute(&store.pool)
+        .await
+        .expect("active channel should insert");
+
+        sqlx::query(
+            "INSERT INTO channels (id, platform, is_active, created_at, last_activity_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)",
+        )
+        .bind("archived-channel")
+        .bind("portal")
+        .bind(0_i64)
+        .execute(&store.pool)
+        .await
+        .expect("archived channel should insert");
+
+        let active_only = store.list(Some(true)).await.expect("list should succeed");
+        assert_eq!(active_only.len(), 1);
+        assert_eq!(active_only[0].id, "active-channel");
+
+        let archived_only = store.list(Some(false)).await.expect("list should succeed");
+        assert_eq!(archived_only.len(), 1);
+        assert_eq!(archived_only[0].id, "archived-channel");
+
+        let all = store.list(None).await.expect("list should succeed");
+        assert_eq!(all.len(), 2);
+        assert!(all.iter().any(|c| c.id == "active-channel" && c.is_active));
+        assert!(
+            all.iter()
+                .any(|c| c.id == "archived-channel" && !c.is_active)
+        );
+    }
+
+    #[tokio::test]
+    async fn set_active_toggles_channel_state_without_deleting() {
+        let store = setup_store().await;
+
+        sqlx::query(
+            "INSERT INTO channels (id, platform, is_active, created_at, last_activity_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)",
+        )
+        .bind("chan-1")
+        .bind("portal")
+        .bind(1_i64)
+        .execute(&store.pool)
+        .await
+        .expect("channel should insert");
+
+        let archived = store
+            .set_active("chan-1", false)
+            .await
+            .expect("set_active should succeed");
+        assert!(archived, "existing channel should be updated");
+
+        let channel = store
+            .get("chan-1")
+            .await
+            .expect("get should succeed")
+            .expect("channel should still exist");
+        assert!(!channel.is_active);
+
+        let unarchived = store
+            .set_active("chan-1", true)
+            .await
+            .expect("set_active should succeed");
+        assert!(unarchived, "existing channel should be updated");
+
+        let channel = store
+            .get("chan-1")
+            .await
+            .expect("get should succeed")
+            .expect("channel should still exist");
+        assert!(channel.is_active);
+    }
+}
diff --git a/src/conversation/history.rs b/src/conversation/history.rs
index 4c62659d0..1bbe098ad 100644
--- a/src/conversation/history.rs
+++ b/src/conversation/history.rs
@@ -74,6 +74,33 @@ impl ConversationLogger {
         self.log_bot_message_with_name(channel_id, content, None);
     }
 
+    /// Log a system message (e.g. task delegation audit record). Fire-and-forget.
+    ///
+    /// System messages are persisted with role `"system"` and are not fed to any
+    /// LLM context window. They exist purely for UI display in link channel
+    /// timelines and audit logs.
+    pub fn log_system_message(&self, channel_id: &str, content: &str) {
+        let pool = self.pool.clone();
+        let id = uuid::Uuid::new_v4().to_string();
+        let channel_id = channel_id.to_string();
+        let content = content.to_string();
+
+        tokio::spawn(async move {
+            if let Err(error) = sqlx::query(
+                "INSERT INTO conversation_messages (id, channel_id, role, sender_name, content) \
+                 VALUES (?, ?, 'system', 'system', ?)",
+            )
+            .bind(&id)
+            .bind(&channel_id)
+            .bind(&content)
+            .execute(&pool)
+            .await
+            {
+                tracing::warn!(%error, %channel_id, "failed to persist system message");
+            }
+        });
+    }
+
     /// Log a bot (assistant) message with an agent display name. Fire-and-forget.
     pub fn log_bot_message_with_name(
         &self,
@@ -145,24 +172,52 @@ impl ConversationLogger {
         Ok(messages)
     }
 
-    /// Load recent messages from any channel (not just the current one).
+    /// Load messages from any channel (not just the current one).
+    ///
+    /// Supports optional temporal filtering via `before` and `after` (RFC 3339 strings)
+    /// and ordering via `oldest_first`. When `oldest_first` is true, returns the earliest
+    /// matching messages instead of the most recent.
     pub async fn load_channel_transcript(
         &self,
         channel_id: &str,
         limit: i64,
+        before: Option<&str>,
+        after: Option<&str>,
+        oldest_first: bool,
     ) -> crate::error::Result<Vec<ConversationMessage>> {
-        let rows = sqlx::query(
+        let mut sql = String::from(
             "SELECT id, channel_id, role, sender_name, sender_id, content, metadata, created_at \
              FROM conversation_messages \
-             WHERE channel_id = ? \
-             ORDER BY created_at DESC \
-             LIMIT ?",
-        )
-        .bind(channel_id)
-        .bind(limit)
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| anyhow::anyhow!(e))?;
+             WHERE channel_id = ?",
+        );
+
+        if before.is_some() {
+            sql.push_str(" AND created_at < ?");
+        }
+        if after.is_some() {
+            sql.push_str(" AND created_at > ?");
+        }
+
+        if oldest_first {
+            sql.push_str(" ORDER BY created_at ASC");
+        } else {
+            sql.push_str(" ORDER BY created_at DESC");
+        }
+        sql.push_str(" LIMIT ?");
+
+        let mut query = sqlx::query(&sql).bind(channel_id);
+        if let Some(before) = before {
+            query = query.bind(before);
+        }
+        if let Some(after) = after {
+            query = query.bind(after);
+        }
+        query = query.bind(limit);
+
+        let rows = query
+            .fetch_all(&self.pool)
+            .await
+            .map_err(|e| anyhow::anyhow!(e))?;
 
         let mut messages: Vec<ConversationMessage> = rows
             .into_iter()
@@ -180,7 +235,10 @@ impl ConversationLogger {
             })
             .collect();
 
-        messages.reverse();
+        // When fetching newest-first, reverse to chronological for the caller
+        if !oldest_first {
+            messages.reverse();
+        }
         Ok(messages)
     }
 }
@@ -280,19 +338,28 @@ impl ProcessRunLogger {
         channel_id: Option<&ChannelId>,
         worker_id: WorkerId,
         task: &str,
+        worker_type: &str,
+        agent_id: &crate::AgentId,
+        interactive: bool,
     ) {
         let pool = self.pool.clone();
         let id = worker_id.to_string();
         let channel_id = channel_id.map(|c| c.to_string());
         let task = task.to_string();
+        let worker_type = worker_type.to_string();
+        let agent_id = agent_id.to_string();
 
         tokio::spawn(async move {
             if let Err(error) = sqlx::query(
-                "INSERT OR IGNORE INTO worker_runs (id, channel_id, task) VALUES (?, ?, ?)",
+                "INSERT OR IGNORE INTO worker_runs (id, channel_id, task, worker_type, agent_id, interactive) \
+                 VALUES (?, ?, ?, ?, ?, ?)",
             )
             .bind(&id)
             .bind(&channel_id)
             .bind(&task)
+            .bind(&worker_type)
+            .bind(&agent_id)
+            .bind(interactive)
             .execute(&pool)
             .await
             {
@@ -302,34 +369,68 @@ impl ProcessRunLogger {
     }
 
     /// Update a worker's status. Fire-and-forget.
+    /// Most status text updates are transient — they're available via the
+    /// in-memory StatusBlock for live workers and don't need to be persisted.
+    /// The `status` column is reserved for the state enum (running/idle/done/failed).
+    ///
+    /// The one exception: when an idle worker resumes (status contains
+    /// "processing follow-up" or similar active-work indicators), we persist
+    /// `running` to the DB so the frontend doesn't show stale "idle" state.
     pub fn log_worker_status(&self, worker_id: WorkerId, status: &str) {
+        // Detect when an idle worker resumes active work and persist the
+        // transition. All other status text is transient.
+        if status.starts_with("processing") || status == "running" {
+            self.log_worker_resumed(worker_id);
+        }
+    }
+
+    /// Mark an interactive worker as idle (waiting for follow-up input).
+    /// Persisted so the frontend shows "idle" instead of "running".
+    pub fn log_worker_idle(&self, worker_id: WorkerId) {
         let pool = self.pool.clone();
         let id = worker_id.to_string();
-        let status = status.to_string();
 
         tokio::spawn(async move {
-            if let Err(error) = sqlx::query("UPDATE worker_runs SET status = ? WHERE id = ?")
-                .bind(&status)
+            if let Err(error) = sqlx::query("UPDATE worker_runs SET status = 'idle' WHERE id = ?")
                 .bind(&id)
                 .execute(&pool)
                 .await
             {
-                tracing::warn!(%error, worker_id = %id, "failed to persist worker status");
+                tracing::warn!(%error, worker_id = %id, "failed to persist worker idle state");
+            }
+        });
+    }
+
+    /// Mark an idle worker as running again (follow-up received).
+    pub fn log_worker_resumed(&self, worker_id: WorkerId) {
+        let pool = self.pool.clone();
+        let id = worker_id.to_string();
+
+        tokio::spawn(async move {
+            if let Err(error) =
+                sqlx::query("UPDATE worker_runs SET status = 'running' WHERE id = ?")
+                    .bind(&id)
+                    .execute(&pool)
+                    .await
+            {
+                tracing::warn!(%error, worker_id = %id, "failed to persist worker resumed state");
             }
         });
     }
 
     /// Record a worker completing with its result. Fire-and-forget.
-    pub fn log_worker_completed(&self, worker_id: WorkerId, result: &str) {
+    pub fn log_worker_completed(&self, worker_id: WorkerId, result: &str, success: bool) {
         let pool = self.pool.clone();
         let id = worker_id.to_string();
         let result = result.to_string();
+        let status = if success { "done" } else { "failed" };
 
         tokio::spawn(async move {
             if let Err(error) = sqlx::query(
-                "UPDATE worker_runs SET result = ?, status = 'done', completed_at = CURRENT_TIMESTAMP WHERE id = ?"
+                "UPDATE worker_runs SET result = ?, status = ?, completed_at = CURRENT_TIMESTAMP WHERE id = ?"
             )
             .bind(&result)
+            .bind(status)
             .bind(&id)
             .execute(&pool)
             .await
@@ -339,6 +440,111 @@ impl ProcessRunLogger {
         });
     }
 
+    /// Record OpenCode session metadata on a worker run. Fire-and-forget.
+    ///
+    /// Stores the session ID and server port so the frontend can construct
+    /// an iframe URL to the embedded OpenCode web UI.
+    pub fn log_opencode_metadata(&self, worker_id: WorkerId, session_id: &str, port: u16) {
+        let pool = self.pool.clone();
+        let id = worker_id.to_string();
+        let session_id = session_id.to_string();
+
+        tokio::spawn(async move {
+            if let Err(error) = sqlx::query(
+                "UPDATE worker_runs SET opencode_session_id = ?, opencode_port = ? WHERE id = ?",
+            )
+            .bind(&session_id)
+            .bind(port as i32)
+            .bind(&id)
+            .execute(&pool)
+            .await
+            {
+                tracing::warn!(%error, worker_id = %id, "failed to persist OpenCode metadata");
+            }
+        });
+    }
+
+    /// Mark all orphaned running/idle workers as failed for an agent.
+    ///
+    /// Called at startup to reconcile rows that were left in `running` or `idle`
+    /// when the process exited before a `WorkerComplete` event was persisted.
+    pub async fn reconcile_running_workers_for_agent(
+        &self,
+        agent_id: &str,
+        failure_message: &str,
+    ) -> crate::error::Result<u64> {
+        let result = sqlx::query(
+            "UPDATE worker_runs \
+             SET status = 'failed', \
+                 completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP), \
+                 result = CASE \
+                     WHEN result IS NULL OR result = '' THEN ? \
+                     ELSE result \
+                 END \
+             WHERE status IN ('running', 'idle') AND (agent_id = ? OR agent_id IS NULL)",
+        )
+        .bind(failure_message)
+        .bind(agent_id)
+        .execute(&self.pool)
+        .await
+        .map_err(|error| anyhow::anyhow!(error))?;
+
+        Ok(result.rows_affected())
+    }
+
+    /// Mark a detached running worker as cancelled.
+    ///
+    /// Used by API cancellation when the in-memory channel state no longer has
+    /// a live handle for this worker (for example after restart).
+    pub async fn cancel_running_worker(
+        &self,
+        channel_id: &str,
+        worker_id: WorkerId,
+    ) -> crate::error::Result<bool> {
+        let result = sqlx::query(
+            "UPDATE worker_runs \
+             SET result = CASE \
+                     WHEN result IS NULL OR result = '' THEN 'Worker cancelled' \
+                     ELSE result \
+                 END, \
+                 status = 'failed', \
+                 completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP) \
+             WHERE id = ? AND channel_id = ? AND status = 'running'",
+        )
+        .bind(worker_id.to_string())
+        .bind(channel_id)
+        .execute(&self.pool)
+        .await
+        .map_err(|error| anyhow::anyhow!(error))?;
+
+        Ok(result.rows_affected() > 0)
+    }
+
+    /// Mark a detached running worker (`channel_id IS NULL`) as cancelled.
+    ///
+    /// Used by API cancellation fallback when no in-memory channel state exists.
+    pub async fn cancel_running_detached_worker(
+        &self,
+        worker_id: WorkerId,
+    ) -> crate::error::Result<bool> {
+        let result = sqlx::query(
+            "UPDATE worker_runs \
+             SET result = CASE \
+                     WHEN result IS NULL OR result = '' THEN 'Worker cancelled' \
+                     ELSE result \
+                 END, \
+                 status = 'failed', \
+                 completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP) \
+             WHERE id = ? AND channel_id IS NULL AND status = 'running'",
+        )
+        .bind(worker_id.to_string())
+        .execute(&self.pool)
+        .await
+        .map_err(|error| anyhow::anyhow!(error))?;
+
+        Ok(result.rows_affected() > 0)
+    }
+
     /// Load a unified timeline for a channel: messages, branch runs, and worker runs
     /// interleaved chronologically (oldest first).
     ///
@@ -351,7 +557,7 @@ impl ProcessRunLogger {
         before: Option<&str>,
     ) -> crate::error::Result<Vec<TimelineItem>> {
         let before_clause = if before.is_some() {
-            "AND timestamp < ?3"
+            "AND datetime(timestamp) < datetime(?3)"
         } else {
             ""
         };
@@ -438,4 +644,260 @@ impl ProcessRunLogger {
         items.reverse();
         Ok(items)
     }
+
+    /// List worker runs for an agent, ordered by most recent first.
+    /// Does NOT include the transcript blob — that's fetched separately via `get_worker_detail`.
+    pub async fn list_worker_runs(
+        &self,
+        agent_id: &str,
+        limit: i64,
+        offset: i64,
+        status_filter: Option<&str>,
+    ) -> crate::error::Result<(Vec<WorkerRunRow>, i64)> {
+        let (count_where_clause, list_where_clause, has_status_filter) = if status_filter.is_some()
+        {
+            (
+                "WHERE w.agent_id = ?1 AND w.status = ?2",
+                "WHERE w.agent_id = ?1 AND w.status = ?4",
+                true,
+            )
+        } else {
+            ("WHERE w.agent_id = ?1", "WHERE w.agent_id = ?1", false)
+        };
+
+        let count_query =
+            format!("SELECT COUNT(*) as total FROM worker_runs w {count_where_clause}");
+        let list_query = format!(
+            "SELECT w.id, w.task, w.status, w.worker_type, w.channel_id, w.started_at, \
+                    w.completed_at, w.transcript IS NOT NULL as has_transcript, \
+                    w.tool_calls, w.opencode_port, w.interactive, \
+                    c.display_name as channel_name \
+             FROM worker_runs w \
+             LEFT JOIN channels c ON w.channel_id = c.id \
+             {list_where_clause} \
+             ORDER BY w.started_at DESC \
+             LIMIT ?2 OFFSET ?3"
+        );
+
+        let mut count_q = sqlx::query(&count_query).bind(agent_id);
+        let mut list_q = sqlx::query(&list_query)
+            .bind(agent_id)
+            .bind(limit)
+            .bind(offset);
+
+        if has_status_filter {
+            let filter = status_filter.unwrap_or("");
+            count_q = count_q.bind(filter);
+            list_q = list_q.bind(filter);
+        }
+
+        let total: i64 = count_q
+            .fetch_one(&self.pool)
+            .await
+            .map(|row| row.try_get("total").unwrap_or(0))
+            .map_err(|e| anyhow::anyhow!(e))?;
+
+        let rows = list_q
+            .fetch_all(&self.pool)
+            .await
+            .map_err(|e| anyhow::anyhow!(e))?;
+
+        let items = rows
+            .into_iter()
+            .map(|row| WorkerRunRow {
+                id: row.try_get("id").unwrap_or_default(),
+                task: row.try_get("task").unwrap_or_default(),
+                status: row.try_get("status").unwrap_or_default(),
+                worker_type: row
+                    .try_get("worker_type")
+                    .unwrap_or_else(|_| "builtin".into()),
+                channel_id: row.try_get("channel_id").ok(),
+                channel_name: row.try_get("channel_name").ok(),
+                started_at: row
+                    .try_get::<chrono::DateTime<chrono::Utc>, _>("started_at")
+                    .map(|t| t.to_rfc3339())
+                    .unwrap_or_default(),
+                completed_at: row
+                    .try_get::<chrono::DateTime<chrono::Utc>, _>("completed_at")
+                    .ok()
+                    .map(|t| t.to_rfc3339()),
+                has_transcript: row.try_get::<bool, _>("has_transcript").unwrap_or(false),
+                tool_calls: row.try_get::<i64, _>("tool_calls").unwrap_or(0),
+                opencode_port: row.try_get::<i32, _>("opencode_port").ok(),
+                interactive: row.try_get::<bool, _>("interactive").unwrap_or(false),
+            })
+            .collect();
+
+        Ok((items, total))
+    }
+
+    /// Get full detail for a single worker run, including the compressed transcript blob.
+    pub async fn get_worker_detail(
+        &self,
+        agent_id: &str,
+        worker_id: &str,
+    ) -> crate::error::Result<Option<WorkerDetailRow>> {
+        let row = sqlx::query(
+            "SELECT w.id, w.task, w.result, w.status, w.worker_type, w.channel_id, \
+                    w.started_at, w.completed_at, w.transcript, w.tool_calls, \
+                    w.opencode_session_id, w.opencode_port, w.interactive, \
+                    c.display_name as channel_name \
+             FROM worker_runs w \
+             LEFT JOIN channels c ON w.channel_id = c.id \
+             WHERE w.agent_id = ? AND w.id = ?",
+        )
+        .bind(agent_id)
+        .bind(worker_id)
+        .fetch_optional(&self.pool)
+        .await
+        .map_err(|e| anyhow::anyhow!(e))?;
+
+        Ok(row.map(|row| WorkerDetailRow {
+            id: row.try_get("id").unwrap_or_default(),
+            task: row.try_get("task").unwrap_or_default(),
+            result: row.try_get("result").ok(),
+            status: row.try_get("status").unwrap_or_default(),
+            worker_type: row
+                .try_get("worker_type")
+                .unwrap_or_else(|_| "builtin".into()),
+            channel_id: row.try_get("channel_id").ok(),
+            channel_name: row.try_get("channel_name").ok(),
+            started_at: row
+                .try_get::<chrono::DateTime<chrono::Utc>, _>("started_at")
+                .map(|t| t.to_rfc3339())
+                .unwrap_or_default(),
+            completed_at: row
+                .try_get::<chrono::DateTime<chrono::Utc>, _>("completed_at")
+                .ok()
+                .map(|t| t.to_rfc3339()),
+            transcript_blob: row.try_get("transcript").ok(),
+            tool_calls: row.try_get::<i64, _>("tool_calls").unwrap_or(0),
+            opencode_session_id: row.try_get("opencode_session_id").ok(),
+            opencode_port: row.try_get::<i32, _>("opencode_port").ok(),
+            interactive: row.try_get::<bool, _>("interactive").unwrap_or(false),
+        }))
+    }
+}
+
+/// A worker run row without the transcript blob (for list queries).
+#[derive(Debug, Clone, Serialize)]
+pub struct WorkerRunRow {
+    pub id: String,
+    pub task: String,
+    pub status: String,
+    pub worker_type: String,
+    pub channel_id: Option<String>,
+    pub channel_name: Option<String>,
+    pub started_at: String,
+    pub completed_at: Option<String>,
+    pub has_transcript: bool,
+    pub tool_calls: i64,
+    pub opencode_port: Option<i32>,
+    pub interactive: bool,
+}
+
+/// A worker run row with full detail including the transcript blob.
+#[derive(Debug, Clone)]
+pub struct WorkerDetailRow {
+    pub id: String,
+    pub task: String,
+    pub result: Option<String>,
+    pub status: String,
+    pub worker_type: String,
+    pub channel_id: Option<String>,
+    pub channel_name: Option<String>,
+    pub started_at: String,
+    pub completed_at: Option<String>,
+    pub transcript_blob: Option<Vec<u8>>,
+    pub tool_calls: i64,
+    pub opencode_session_id: Option<String>,
+    pub opencode_port: Option<i32>,
+    pub interactive: bool,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ProcessRunLogger;
+
+    async fn setup_worker_runs_table() -> sqlx::SqlitePool {
+        let pool = sqlx::sqlite::SqlitePoolOptions::new()
+            .max_connections(1)
+            .connect("sqlite::memory:")
+            .await
+            .expect("failed to create sqlite memory pool");
+
+        sqlx::query(
+            "CREATE TABLE worker_runs (
+                id TEXT PRIMARY KEY,
+                channel_id TEXT,
+                status TEXT NOT NULL,
+                result TEXT,
+                completed_at TIMESTAMP
+            )",
+        )
+        .execute(&pool)
+        .await
+        .expect("failed to create worker_runs table");
+
+        pool
+    }
+
+    #[tokio::test]
+    async fn cancel_running_detached_worker_updates_null_channel_rows() {
+        let pool = setup_worker_runs_table().await;
+        let logger = ProcessRunLogger::new(pool.clone());
+        let worker_id = uuid::Uuid::new_v4();
+
+        sqlx::query("INSERT INTO worker_runs (id, channel_id, status, result) VALUES (?, NULL, 'running', '')")
+            .bind(worker_id.to_string())
+            .execute(&pool)
+            .await
+            .expect("failed to insert detached worker row");
+
+        let cancelled = logger
+            .cancel_running_detached_worker(worker_id)
+            .await
+            .expect("cancel should succeed");
+        assert!(cancelled);
+
+        let row = sqlx::query("SELECT status, result FROM worker_runs WHERE id = ?")
+            .bind(worker_id.to_string())
+            .fetch_one(&pool)
+            .await
+            .expect("failed to fetch worker row");
+
+        let status: String = sqlx::Row::try_get(&row, "status").expect("missing status");
+        let result: String = sqlx::Row::try_get(&row, "result").expect("missing result");
+        assert_eq!(status, "failed");
+        assert_eq!(result, "Worker cancelled");
+    }
+
+    #[tokio::test]
+    async fn cancel_running_detached_worker_does_not_touch_channel_bound_rows() {
+        let pool = setup_worker_runs_table().await;
+        let logger = ProcessRunLogger::new(pool.clone());
+        let worker_id = uuid::Uuid::new_v4();
+
+        sqlx::query(
+            "INSERT INTO worker_runs (id, channel_id, status, result) VALUES (?, 'channel-1', 'running', '')",
+        )
+        .bind(worker_id.to_string())
+        .execute(&pool)
+        .await
+        .expect("failed to insert channel worker row");
+
+        let cancelled = logger
+            .cancel_running_detached_worker(worker_id)
+            .await
+            .expect("cancel should not error");
+        assert!(!cancelled);
+
+        let row = sqlx::query("SELECT status FROM worker_runs WHERE id = ?")
+            .bind(worker_id.to_string())
+            .fetch_one(&pool)
+            .await
+            .expect("failed to fetch worker row");
+        let status: String = sqlx::Row::try_get(&row, "status").expect("missing status");
+        assert_eq!(status, "running");
+    }
 }
diff --git a/src/conversation/worker_transcript.rs b/src/conversation/worker_transcript.rs
new file mode 100644
index 000000000..7dd858d8f
--- /dev/null
+++ b/src/conversation/worker_transcript.rs
@@ -0,0 +1,385 @@
+//! Worker transcript serialization and compression.
+//!
+//! Converts a Rig `Vec<Message>` history into a flat `Vec<TranscriptStep>`,
+//! then serializes to gzipped JSON for compact storage on the `worker_runs` row.
+
+use crate::tools::{MAX_TOOL_OUTPUT_BYTES, truncate_output};
+
+use flate2::Compression;
+use flate2::read::GzDecoder;
+use flate2::write::GzEncoder;
+use serde::{Deserialize, Serialize};
+use std::io::{Read, Write};
+
+/// Maximum byte length for tool call arguments in transcripts.
+const MAX_TOOL_ARGS_BYTES: usize = 2_000;
+
+/// A single step in a worker transcript.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum TranscriptStep {
+    /// Agent reasoning and/or tool calls.
+    Action { content: Vec<ActionContent> },
+    /// Tool execution result.
+    ToolResult {
+        call_id: String,
+        name: String,
+        text: String,
+    },
+}
+
+/// Content within an action step.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum ActionContent {
+    Text {
+        text: String,
+    },
+    ToolCall {
+        id: String,
+        name: String,
+        args: String,
+    },
+}
+
+/// Convert a Rig message history to transcript steps, serialize as JSON, and gzip compress.
+pub fn serialize_transcript(history: &[rig::message::Message]) -> Vec<u8> {
+    let steps = convert_history(history);
+    serialize_steps(&steps)
+}
+
+/// Serialize pre-built transcript steps as gzipped JSON.
+///
+/// Used by OpenCode workers that build transcript steps directly from SSE
+/// events rather than from a Rig message history.
+pub fn serialize_steps(steps: &[TranscriptStep]) -> Vec<u8> {
+    let json = serde_json::to_vec(steps).unwrap_or_default();
+
+    let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
+    encoder.write_all(&json).ok();
+    encoder.finish().unwrap_or_default()
+}
+
+/// Decompress and deserialize a gzipped transcript blob.
+pub fn deserialize_transcript(blob: &[u8]) -> anyhow::Result<Vec<TranscriptStep>> {
+    let mut decoder = GzDecoder::new(blob);
+    let mut json = Vec::new();
+    decoder.read_to_end(&mut json)?;
+    let steps: Vec<TranscriptStep> = serde_json::from_slice(&json)?;
+    Ok(steps)
+}
+
+/// Convert OpenCode messages (from `GET /session/:id/message`) into transcript
+/// steps and extract all assistant text as the result string.
+///
+/// The input is the raw JSON array returned by the OpenCode server. Each element
+/// has shape `{ info: Message, parts: Part[] }`. Messages are chronological.
+pub fn convert_opencode_messages(messages: &[serde_json::Value]) -> (Vec<TranscriptStep>, String) {
+    let mut steps = Vec::new();
+    let mut all_text = String::new();
+
+    for message_wrapper in messages {
+        let role = message_wrapper
+            .pointer("/info/role")
+            .and_then(|v| v.as_str())
+            .unwrap_or("");
+
+        let parts = match message_wrapper.get("parts").and_then(|p| p.as_array()) {
+            Some(parts) => parts,
+            None => continue,
+        };
+
+        for part_value in parts {
+            let part_type = part_value
+                .get("type")
+                .and_then(|t| t.as_str())
+                .unwrap_or("");
+            match part_type {
+                "text" => {
+                    let text = part_value
+                        .get("text")
+                        .and_then(|t| t.as_str())
+                        .unwrap_or("");
+                    if !text.is_empty() {
+                        if role == "assistant" {
+                            if !all_text.is_empty() {
+                                all_text.push_str("\n\n");
+                            }
+                            all_text.push_str(text);
+                        }
+                        steps.push(TranscriptStep::Action {
+                            content: vec![ActionContent::Text {
+                                text: text.to_string(),
+                            }],
+                        });
+                    }
+                }
+                "tool" => {
+                    let tool_name = part_value
+                        .get("tool")
+                        .and_then(|t| t.as_str())
+                        .unwrap_or("unknown");
+                    let call_id = part_value
+                        .get("callID")
+                        .and_then(|c| c.as_str())
+                        .or_else(|| part_value.get("id").and_then(|i| i.as_str()))
+                        .unwrap_or("")
+                        .to_string();
+
+                    let state = part_value.get("state");
+                    let status = state
+                        .and_then(|s| s.get("status"))
+                        .and_then(|s| s.as_str())
+                        .unwrap_or("");
+
+                    // Extract tool input
+                    let input = state
+                        .and_then(|s| s.get("input"))
+                        .map(|v| {
+                            let s = v.to_string();
+                            if s.len() > MAX_TOOL_ARGS_BYTES {
+                                truncate_output(&s, MAX_TOOL_ARGS_BYTES)
+                            } else {
+                                s
+                            }
+                        })
+                        .unwrap_or_default();
+
+                    // Always add the tool call
+                    steps.push(TranscriptStep::Action {
+                        content: vec![ActionContent::ToolCall {
+                            id: call_id.clone(),
+                            name: tool_name.to_string(),
+                            args: input,
+                        }],
+                    });
+
+                    // Add result if completed or errored
+                    match status {
+                        "completed" => {
+                            let output = state
+                                .and_then(|s| s.get("output"))
+                                .and_then(|o| o.as_str())
+                                .unwrap_or("");
+                            let truncated = truncate_output(output, MAX_TOOL_OUTPUT_BYTES);
+                            steps.push(TranscriptStep::ToolResult {
+                                call_id,
+                                name: tool_name.to_string(),
+                                text: truncated,
+                            });
+                        }
+                        "error" => {
+                            let error_text = state
+                                .and_then(|s| s.get("error"))
+                                .and_then(|e| e.as_str())
+                                .unwrap_or("unknown error");
+                            steps.push(TranscriptStep::ToolResult {
+                                call_id,
+                                name: tool_name.to_string(),
+                                text: format!("Error: {error_text}"),
+                            });
+                        }
+                        _ => {}
+                    }
+                }
+                _ => {
+                    // step-start, step-finish, reasoning, file, etc. — skip for transcript
+                }
+            }
+        }
+    }
+
+    (steps, all_text)
+}
+
+/// Convert SSE-accumulated `OpenCodePart`s into transcript steps.
+///
+/// This is the fallback path used when the post-completion `get_messages()` API
+/// call to the OpenCode server fails (e.g. because the server was recycled).
+/// The parts were collected during SSE streaming and contain the same data,
+/// just in a different structure.
+///
+/// Parts are upserted by ID during SSE streaming (a tool part transitions
+/// through Pending → Running → Completed with the same ID), so we deduplicate
+/// by keeping only the latest version of each part before converting.
+pub fn convert_opencode_parts(
+    parts: &[crate::opencode::types::OpenCodePart],
+) -> Vec<TranscriptStep> {
+    use crate::opencode::types::{OpenCodePart, OpenCodeToolState};
+
+    // Deduplicate: keep insertion order, but replace earlier versions with later ones.
+    let mut seen = std::collections::HashMap::<String, usize>::new();
+    let mut deduped: Vec<&OpenCodePart> = Vec::new();
+    for part in parts {
+        let id = part.id().to_string();
+        if let Some(&index) = seen.get(&id) {
+            deduped[index] = part;
+        } else {
+            seen.insert(id, deduped.len());
+            deduped.push(part);
+        }
+    }
+
+    let mut steps = Vec::new();
+    for part in deduped {
+        match part {
+            OpenCodePart::Text { text, .. } => {
+                if !text.is_empty() {
+                    steps.push(TranscriptStep::Action {
+                        content: vec![ActionContent::Text { text: text.clone() }],
+                    });
+                }
+            }
+            OpenCodePart::Tool { id, tool, state } => {
+                match state {
+                    OpenCodeToolState::Running { input, .. }
+                    | OpenCodeToolState::Completed { input, .. } => {
+                        let args = input.clone().unwrap_or_default();
+                        let args = if args.len() > MAX_TOOL_ARGS_BYTES {
+                            truncate_output(&args, MAX_TOOL_ARGS_BYTES)
+                        } else {
+                            args
+                        };
+                        steps.push(TranscriptStep::Action {
+                            content: vec![ActionContent::ToolCall {
+                                id: id.clone(),
+                                name: tool.clone(),
+                                args,
+                            }],
+                        });
+                    }
+                    OpenCodeToolState::Pending => {
+                        steps.push(TranscriptStep::Action {
+                            content: vec![ActionContent::ToolCall {
+                                id: id.clone(),
+                                name: tool.clone(),
+                                args: String::new(),
+                            }],
+                        });
+                    }
+                    OpenCodeToolState::Error { .. } => {
+                        steps.push(TranscriptStep::Action {
+                            content: vec![ActionContent::ToolCall {
+                                id: id.clone(),
+                                name: tool.clone(),
+                                args: String::new(),
+                            }],
+                        });
+                    }
+                }
+
+                // Add result for completed/error states
+                match state {
+                    OpenCodeToolState::Completed { output, .. } => {
+                        let text = output.as_deref().unwrap_or("");
+                        let truncated = truncate_output(text, MAX_TOOL_OUTPUT_BYTES);
+                        steps.push(TranscriptStep::ToolResult {
+                            call_id: id.clone(),
+                            name: tool.clone(),
+                            text: truncated,
+                        });
+                    }
+                    OpenCodeToolState::Error { error } => {
+                        let error_text = error.as_deref().unwrap_or("unknown error");
+                        steps.push(TranscriptStep::ToolResult {
+                            call_id: id.clone(),
+                            name: tool.clone(),
+                            text: format!("Error: {error_text}"),
+                        });
+                    }
+                    _ => {}
+                }
+            }
+            // step_start/step_finish are visual separators, skip for transcript
+            OpenCodePart::StepStart { .. } | OpenCodePart::StepFinish { .. } => {}
+        }
+    }
+    steps
+}
+
+/// Convert Rig `Vec<Message>` to `Vec<TranscriptStep>`.
+fn convert_history(history: &[rig::message::Message]) -> Vec<TranscriptStep> {
+    let mut steps = Vec::new();
+
+    for message in history {
+        match message {
+            rig::message::Message::Assistant { content, .. } => {
+                let mut parts = Vec::new();
+                for item in content.iter() {
+                    match item {
+                        rig::message::AssistantContent::Text(text) => {
+                            if !text.text.is_empty() {
+                                parts.push(ActionContent::Text {
+                                    text: text.text.clone(),
+                                });
+                            }
+                        }
+                        rig::message::AssistantContent::ToolCall(tool_call) => {
+                            let args_str = tool_call.function.arguments.to_string();
+                            let args = if args_str.len() > MAX_TOOL_ARGS_BYTES {
+                                truncate_output(&args_str, MAX_TOOL_ARGS_BYTES)
+                            } else {
+                                args_str
+                            };
+                            parts.push(ActionContent::ToolCall {
+                                id: tool_call.id.clone(),
+                                name: tool_call.function.name.clone(),
+                                args,
+                            });
+                        }
+                        _ => {}
+                    }
+                }
+                if !parts.is_empty() {
+                    steps.push(TranscriptStep::Action { content: parts });
+                }
+            }
+            rig::message::Message::User { content } => {
+                for item in content.iter() {
+                    match item {
+                        rig::message::UserContent::ToolResult(tool_result) => {
+                            let call_id = tool_result
+                                .call_id
+                                .clone()
+                                .unwrap_or_else(|| tool_result.id.clone());
+
+                            let text = tool_result
+                                .content
+                                .iter()
+                                .filter_map(|c| {
+                                    if let rig::message::ToolResultContent::Text(t) = c {
+                                        Some(t.text.as_str())
+                                    } else {
+                                        None
+                                    }
+                                })
+                                .collect::<Vec<_>>()
+                                .join("\n");
+
+                            let truncated = truncate_output(&text, MAX_TOOL_OUTPUT_BYTES);
+
+                            steps.push(TranscriptStep::ToolResult {
+                                call_id,
+                                name: String::new(),
+                                text: truncated,
+                            });
+                        }
+                        rig::message::UserContent::Text(text) => {
+                            // Skip compaction markers and system-injected messages
+                            if !text.text.is_empty() && !text.text.starts_with("[System:") {
+                                steps.push(TranscriptStep::Action {
+                                    content: vec![ActionContent::Text {
+                                        text: text.text.clone(),
+                                    }],
+                                });
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
+        }
+    }
+
+    steps
+}
diff --git a/src/cron/scheduler.rs b/src/cron/scheduler.rs
index bf8b841d8..3aaf32384 100644
--- a/src/cron/scheduler.rs
+++ b/src/cron/scheduler.rs
@@ -13,7 +13,9 @@ use crate::messaging::target::{BroadcastTarget, parse_delivery_target};
 use crate::{AgentDeps, InboundMessage, MessageContent, OutboundResponse};
 use chrono::Timelike;
 use chrono_tz::Tz;
+use cron::Schedule;
 use std::collections::HashMap;
+use std::str::FromStr;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 use tokio::time::Duration;
@@ -23,6 +25,8 @@ use tokio::time::Duration;
 pub struct CronJob {
     pub id: String,
     pub prompt: String,
+    /// Optional wall-clock cron expression (5-field syntax).
+    pub cron_expr: Option<String>,
     pub interval_secs: u64,
     pub delivery_target: BroadcastTarget,
     pub active_hours: Option<(u8, u8)>,
@@ -39,6 +43,8 @@ pub struct CronJob {
 pub struct CronConfig {
     pub id: String,
     pub prompt: String,
+    /// Optional wall-clock cron expression (5-field syntax).
+    pub cron_expr: Option<String>,
     #[serde(default = "default_interval")]
     pub interval_secs: u64,
     /// Delivery target in "adapter:target" format (e.g. "discord:123456789").
@@ -76,6 +82,16 @@ pub struct CronContext {
 }
 
 const MAX_CONSECUTIVE_FAILURES: u32 = 3;
+
+/// RAII guard that clears an `AtomicBool` on drop, ensuring the flag is
+/// released even if the holding task panics.
+struct ExecutionGuard(Arc<std::sync::atomic::AtomicBool>);
+
+impl Drop for ExecutionGuard {
+    fn drop(&mut self) {
+        self.0.store(false, std::sync::atomic::Ordering::Release);
+    }
+}
 const SYSTEM_TIMEZONE_LABEL: &str = "system";
 
 /// Scheduler that manages cron job timers and execution.
@@ -93,6 +109,17 @@ impl std::fmt::Debug for Scheduler {
 
 impl Scheduler {
     pub fn new(context: CronContext) -> Self {
+        let tz_label = cron_timezone_label(&context);
+        if tz_label == SYSTEM_TIMEZONE_LABEL {
+            tracing::warn!(
+                agent_id = %context.deps.agent_id,
+                "no cron_timezone configured; active_hours will use the host system's local time, \
+                 which is often UTC in Docker/containerized environments — set [defaults] \
+                 cron_timezone to an IANA timezone like \"America/New_York\" if jobs are \
+                 skipping their active window"
+            );
+        }
+
         Self {
             jobs: Arc::new(RwLock::new(HashMap::new())),
             timers: Arc::new(RwLock::new(HashMap::new())),
@@ -113,12 +140,14 @@ impl Scheduler {
             ))
         })?;
 
+        let cron_expr = normalize_cron_expr(config.cron_expr.clone())?;
         let job = CronJob {
             id: config.id.clone(),
             prompt: config.prompt,
+            cron_expr,
             interval_secs: config.interval_secs,
             delivery_target,
-            active_hours: config.active_hours,
+            active_hours: normalize_active_hours(config.active_hours),
             enabled: config.enabled,
             run_once: config.run_once,
             consecutive_failures: 0,
@@ -134,7 +163,13 @@ impl Scheduler {
             self.start_timer(&config.id).await;
         }
 
-        tracing::info!(cron_id = %config.id, interval_secs = config.interval_secs, run_once = config.run_once, "cron job registered");
+        tracing::info!(
+            cron_id = %config.id,
+            interval_secs = config.interval_secs,
+            cron_expr = ?config.cron_expr,
+            run_once = config.run_once,
+            "cron job registered"
+        );
         Ok(())
     }
 
@@ -159,46 +194,65 @@ impl Scheduler {
         }
 
         let handle = tokio::spawn(async move {
-            // Look up interval before entering the loop
-            let interval_secs = {
-                let j = jobs.read().await;
-                j.get(&job_id).map(|j| j.interval_secs).unwrap_or(3600)
-            };
+            let execution_lock = Arc::new(std::sync::atomic::AtomicBool::new(false));
+            let mut interval_first_tick = true;
 
-            // For sub-daily intervals that divide evenly into 86400 (e.g. 1800s, 3600s, 21600s),
-            // align the first tick to the next UTC clock boundary so the job fires on clean marks
-            // like :00 and :30 rather than at an arbitrary offset from service start.
-            // Daily/weekly jobs are left on relative timing (interval_at with one interval offset)
-            // to avoid overcomplicating scheduling for jobs with active_hours constraints.
-            let first_tick = if interval_secs < 86400 && 86400 % interval_secs == 0 {
-                let now_unix = std::time::SystemTime::now()
-                    .duration_since(std::time::UNIX_EPOCH)
-                    .unwrap_or_default()
-                    .as_secs();
-                let remainder = now_unix % interval_secs;
-                let secs_until = if remainder == 0 {
-                    interval_secs
-                } else {
-                    interval_secs - remainder
+            loop {
+                let job = {
+                    let j = jobs.read().await;
+                    match j.get(&job_id) {
+                        Some(j) if !j.enabled => {
+                            tracing::debug!(cron_id = %job_id, "cron job disabled, stopping timer");
+                            break;
+                        }
+                        Some(j) => j.clone(),
+                        None => {
+                            tracing::debug!(cron_id = %job_id, "cron job removed, stopping timer");
+                            break;
+                        }
+                    }
                 };
-                tracing::info!(
-                    cron_id = %job_id,
-                    interval_secs,
-                    secs_until_first_tick = secs_until,
-                    "clock-aligned timer: first tick in {secs_until}s"
-                );
-                tokio::time::Instant::now() + Duration::from_secs(secs_until)
-            } else {
-                tokio::time::Instant::now() + Duration::from_secs(interval_secs)
-            };
 
-            let mut ticker =
-                tokio::time::interval_at(first_tick, Duration::from_secs(interval_secs));
-            // Skip catch-up ticks if processing falls behind — maintain original cadence.
-            ticker.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+                let sleep_duration = if let Some(cron_expr) = job.cron_expr.as_deref() {
+                    match next_fire_duration(&context, &job_id, cron_expr) {
+                        Some((duration, next_fire_utc, timezone)) => {
+                            tracing::debug!(
+                                cron_id = %job_id,
+                                cron_expr,
+                                cron_timezone = %timezone,
+                                next_fire_utc = %next_fire_utc.to_rfc3339(),
+                                sleep_secs = duration.as_secs(),
+                                "wall-clock cron next fire computed"
+                            );
+                            duration
+                        }
+                        None => {
+                            tracing::warn!(
+                                cron_id = %job_id,
+                                cron_expr,
+                                "failed to compute next wall-clock fire; retrying in 60s"
+                            );
+                            Duration::from_secs(60)
+                        }
+                    }
+                } else {
+                    let interval_secs = job.interval_secs;
+                    let delay = if interval_first_tick {
+                        interval_first_tick = false;
+                        interval_initial_delay(interval_secs)
+                    } else {
+                        Duration::from_secs(interval_secs)
+                    };
+                    tracing::debug!(
+                        cron_id = %job_id,
+                        interval_secs,
+                        sleep_secs = delay.as_secs(),
+                        "interval cron next fire computed"
+                    );
+                    delay
+                };
 
-            loop {
-                ticker.tick().await;
+                tokio::time::sleep(sleep_duration).await;
 
                 let job = {
                     let j = jobs.read().await;
@@ -232,72 +286,84 @@ impl Scheduler {
                     }
                 }
 
-                tracing::info!(cron_id = %job_id, "cron job firing");
-
-                match run_cron_job(&job, &context).await {
-                    Ok(()) => {
-                        // Reset failure count on success
-                        let mut j = jobs.write().await;
-                        if let Some(j) = j.get_mut(&job_id) {
-                            j.consecutive_failures = 0;
-                        }
-                    }
-                    Err(error) => {
-                        tracing::error!(
-                            cron_id = %job_id,
-                            %error,
-                            "cron job execution failed"
-                        );
+                if execution_lock.load(std::sync::atomic::Ordering::Acquire) {
+                    tracing::debug!(cron_id = %job_id, "previous execution still running, skipping tick");
+                    continue;
+                }
 
-                        let should_disable = {
-                            let mut j = jobs.write().await;
-                            if let Some(j) = j.get_mut(&job_id) {
-                                j.consecutive_failures += 1;
-                                j.consecutive_failures >= MAX_CONSECUTIVE_FAILURES
-                            } else {
-                                false
+                tracing::info!(cron_id = %job_id, "cron job firing");
+                execution_lock.store(true, std::sync::atomic::Ordering::Release);
+
+                let exec_jobs = jobs.clone();
+                let exec_context = context.clone();
+                let exec_job_id = job_id.clone();
+                let guard = ExecutionGuard(execution_lock.clone());
+
+                tokio::spawn(async move {
+                    let _guard = guard;
+                    match run_cron_job(&job, &exec_context).await {
+                        Ok(()) => {
+                            let mut j = exec_jobs.write().await;
+                            if let Some(j) = j.get_mut(&exec_job_id) {
+                                j.consecutive_failures = 0;
                             }
-                        };
-
-                        if should_disable {
-                            tracing::warn!(
-                                cron_id = %job_id,
-                                "circuit breaker tripped after {MAX_CONSECUTIVE_FAILURES} consecutive failures, disabling"
+                        }
+                        Err(error) => {
+                            tracing::error!(
+                                cron_id = %exec_job_id,
+                                %error,
+                                "cron job execution failed"
                             );
 
-                            {
-                                let mut j = jobs.write().await;
-                                if let Some(j) = j.get_mut(&job_id) {
-                                    j.enabled = false;
+                            let should_disable = {
+                                let mut j = exec_jobs.write().await;
+                                if let Some(j) = j.get_mut(&exec_job_id) {
+                                    j.consecutive_failures += 1;
+                                    j.consecutive_failures >= MAX_CONSECUTIVE_FAILURES
+                                } else {
+                                    false
+                                }
+                            };
+
+                            if should_disable {
+                                tracing::warn!(
+                                    cron_id = %exec_job_id,
+                                    "circuit breaker tripped after {MAX_CONSECUTIVE_FAILURES} consecutive failures, disabling"
+                                );
+
+                                {
+                                    let mut j = exec_jobs.write().await;
+                                    if let Some(j) = j.get_mut(&exec_job_id) {
+                                        j.enabled = false;
+                                    }
                                 }
-                            }
 
-                            // Persist the disabled state
-                            if let Err(error) = context.store.update_enabled(&job_id, false).await {
-                                tracing::error!(%error, "failed to persist cron job disabled state");
+                                if let Err(error) =
+                                    exec_context.store.update_enabled(&exec_job_id, false).await
+                                {
+                                    tracing::error!(%error, "failed to persist cron job disabled state");
+                                }
                             }
-
-                            break;
                         }
                     }
-                }
 
-                if job.run_once {
-                    tracing::info!(cron_id = %job_id, "run-once cron completed, disabling");
+                    if job.run_once {
+                        tracing::info!(cron_id = %exec_job_id, "run-once cron completed, disabling");
 
-                    {
-                        let mut j = jobs.write().await;
-                        if let Some(j) = j.get_mut(&job_id) {
-                            j.enabled = false;
+                        {
+                            let mut j = exec_jobs.write().await;
+                            if let Some(j) = j.get_mut(&exec_job_id) {
+                                j.enabled = false;
+                            }
                         }
-                    }
 
-                    if let Err(error) = context.store.update_enabled(&job_id, false).await {
-                        tracing::error!(%error, "failed to persist run-once cron disabled state");
+                        if let Err(error) =
+                            exec_context.store.update_enabled(&exec_job_id, false).await
+                        {
+                            tracing::error!(%error, "failed to persist run-once cron disabled state");
+                        }
                     }
-
-                    break;
-                }
+                });
             }
         });
 
@@ -422,9 +488,10 @@ impl Scheduler {
                     CronJob {
                         id: config.id.clone(),
                         prompt: config.prompt,
+                        cron_expr: normalize_cron_expr(config.cron_expr)?,
                         interval_secs: config.interval_secs,
                         delivery_target,
-                        active_hours: config.active_hours,
+                        active_hours: normalize_active_hours(config.active_hours),
                         enabled: true,
                         run_once: config.run_once,
                         consecutive_failures: 0,
@@ -512,13 +579,117 @@ fn current_hour_and_timezone(context: &CronContext, cron_id: &str) -> (u8, Strin
 }
 
 fn hour_in_active_window(current_hour: u8, start_hour: u8, end_hour: u8) -> bool {
-    if start_hour <= end_hour {
+    if start_hour == end_hour {
+        return true;
+    }
+    if start_hour < end_hour {
         current_hour >= start_hour && current_hour < end_hour
     } else {
         current_hour >= start_hour || current_hour < end_hour
     }
 }
 
+/// Normalize degenerate active_hours where start == end to None (always active).
+fn normalize_active_hours(active_hours: Option<(u8, u8)>) -> Option<(u8, u8)> {
+    active_hours.filter(|(start, end)| start != end)
+}
+
+fn normalize_cron_expr(cron_expr: Option<String>) -> Result<Option<String>> {
+    let Some(expr) = cron_expr else {
+        return Ok(None);
+    };
+
+    let trimmed = expr.trim();
+    if trimmed.is_empty() {
+        return Ok(None);
+    }
+
+    let field_count = trimmed.split_whitespace().count();
+    if field_count != 5 {
+        return Err(crate::error::Error::Other(anyhow::anyhow!(
+            "cron expression must have exactly 5 fields (got {field_count}): '{trimmed}'"
+        )));
+    }
+
+    Schedule::from_str(trimmed).map_err(|error| {
+        crate::error::Error::Other(anyhow::anyhow!(
+            "invalid cron expression '{trimmed}': {error}"
+        ))
+    })?;
+
+    Ok(Some(trimmed.to_string()))
+}
+
+fn interval_initial_delay(interval_secs: u64) -> Duration {
+    if interval_secs < 86400 && 86400 % interval_secs == 0 {
+        let now_unix = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs();
+        let remainder = now_unix % interval_secs;
+        let secs_until = if remainder == 0 {
+            interval_secs
+        } else {
+            interval_secs - remainder
+        };
+        Duration::from_secs(secs_until)
+    } else {
+        Duration::from_secs(interval_secs)
+    }
+}
+
+fn resolve_cron_timezone(context: &CronContext) -> (Option<chrono_tz::Tz>, String) {
+    let timezone = context.deps.runtime_config.cron_timezone.load();
+    match timezone.as_deref() {
+        Some(name) => match name.parse::<Tz>() {
+            Ok(timezone) => (Some(timezone), name.to_string()),
+            Err(error) => {
+                tracing::warn!(
+                    agent_id = %context.deps.agent_id,
+                    cron_timezone = %name,
+                    %error,
+                    "invalid cron timezone in runtime config, falling back to system timezone"
+                );
+                (None, SYSTEM_TIMEZONE_LABEL.to_string())
+            }
+        },
+        None => (None, SYSTEM_TIMEZONE_LABEL.to_string()),
+    }
+}
+
+fn next_fire_duration(
+    context: &CronContext,
+    cron_id: &str,
+    cron_expr: &str,
+) -> Option<(Duration, chrono::DateTime<chrono::Utc>, String)> {
+    let schedule = match Schedule::from_str(cron_expr) {
+        Ok(schedule) => schedule,
+        Err(error) => {
+            tracing::warn!(cron_id = %cron_id, cron_expr, %error, "invalid cron expression");
+            return None;
+        }
+    };
+
+    let now_utc = chrono::Utc::now();
+    let (timezone, timezone_label) = resolve_cron_timezone(context);
+    let next_utc = if let Some(timezone) = timezone {
+        let now_local = now_utc.with_timezone(&timezone);
+        schedule
+            .after(&now_local)
+            .next()?
+            .with_timezone(&chrono::Utc)
+    } else {
+        let now_local = chrono::Local::now();
+        schedule
+            .after(&now_local)
+            .next()?
+            .with_timezone(&chrono::Utc)
+    };
+    let delay_ms = (next_utc - now_utc).num_milliseconds().max(1) as u64;
+
+    Some((Duration::from_millis(delay_ms), next_utc, timezone_label))
+}
+
 fn ensure_cron_dispatch_readiness(context: &CronContext, cron_id: &str) {
     let readiness = context.deps.runtime_config.work_readiness();
     if readiness.ready {
@@ -589,6 +760,7 @@ async fn run_cron_job(job: &CronJob, context: &CronContext) -> Result<()> {
     let message = InboundMessage {
         id: uuid::Uuid::new_v4().to_string(),
         source: "cron".into(),
+        adapter: None,
         conversation_id: format!("cron:{}", job.id),
         sender_id: "system".into(),
         agent_id: Some(context.deps.agent_id.clone()),
@@ -613,19 +785,23 @@ async fn run_cron_job(job: &CronJob, context: &CronContext) -> Result<()> {
     // when the sender is dropped (message_rx returns None).
     drop(channel_tx);
 
+    let deadline = tokio::time::Instant::now() + timeout;
     loop {
-        match tokio::time::timeout(timeout, response_rx.recv()).await {
+        let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
+        if remaining.is_zero() {
+            tracing::warn!(cron_id = %job.id, "cron job timed out after {timeout:?}");
+            channel_handle.abort();
+            break;
+        }
+        match tokio::time::timeout(remaining, response_rx.recv()).await {
             Ok(Some(OutboundResponse::Text(text))) => {
                 collected_text.push(text);
             }
             Ok(Some(OutboundResponse::RichMessage { text, .. })) => {
                 collected_text.push(text);
             }
-            Ok(Some(_)) => {
-                // Status updates, stream chunks, etc. — ignore for cron jobs
-            }
+            Ok(Some(_)) => {}
             Ok(None) => {
-                // Channel finished (response_tx dropped)
                 break;
             }
             Err(_) => {
@@ -692,7 +868,7 @@ async fn run_cron_job(job: &CronJob, context: &CronContext) -> Result<()> {
 
 #[cfg(test)]
 mod tests {
-    use super::hour_in_active_window;
+    use super::{hour_in_active_window, normalize_active_hours};
 
     #[test]
     fn test_hour_in_active_window_non_wrapping() {
@@ -708,4 +884,21 @@ mod tests {
         assert!(hour_in_active_window(3, 22, 6));
         assert!(!hour_in_active_window(12, 22, 6));
     }
+
+    #[test]
+    fn test_hour_in_active_window_equal_start_end_is_always_active() {
+        assert!(hour_in_active_window(0, 0, 0));
+        assert!(hour_in_active_window(12, 0, 0));
+        assert!(hour_in_active_window(23, 0, 0));
+        assert!(hour_in_active_window(5, 5, 5));
+        assert!(hour_in_active_window(14, 14, 14));
+    }
+
+    #[test]
+    fn test_normalize_active_hours() {
+        assert_eq!(normalize_active_hours(Some((0, 0))), None);
+        assert_eq!(normalize_active_hours(Some((12, 12))), None);
+        assert_eq!(normalize_active_hours(Some((9, 17))), Some((9, 17)));
+        assert_eq!(normalize_active_hours(None), None);
+    }
 }
diff --git a/src/cron/store.rs b/src/cron/store.rs
index 75e76c109..90c5b6d20 100644
--- a/src/cron/store.rs
+++ b/src/cron/store.rs
@@ -24,10 +24,11 @@ impl CronStore {
 
         sqlx::query(
             r#"
-            INSERT INTO cron_jobs (id, prompt, interval_secs, delivery_target, active_start_hour, active_end_hour, enabled, run_once, timeout_secs)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            INSERT INTO cron_jobs (id, prompt, cron_expr, interval_secs, delivery_target, active_start_hour, active_end_hour, enabled, run_once, timeout_secs)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             ON CONFLICT(id) DO UPDATE SET
                 prompt = excluded.prompt,
+                cron_expr = excluded.cron_expr,
                 interval_secs = excluded.interval_secs,
                 delivery_target = excluded.delivery_target,
                 active_start_hour = excluded.active_start_hour,
@@ -39,6 +40,7 @@ impl CronStore {
         )
         .bind(&config.id)
         .bind(&config.prompt)
+        .bind(config.cron_expr.as_deref())
         .bind(config.interval_secs as i64)
         .bind(&config.delivery_target)
         .bind(active_start)
@@ -57,7 +59,7 @@ impl CronStore {
     pub async fn load_all(&self) -> Result<Vec<CronConfig>> {
         let rows = sqlx::query(
             r#"
-            SELECT id, prompt, interval_secs, delivery_target, active_start_hour, active_end_hour, enabled, run_once, timeout_secs
+            SELECT id, prompt, cron_expr, interval_secs, delivery_target, active_start_hour, active_end_hour, enabled, run_once, timeout_secs
             FROM cron_jobs
             WHERE enabled = 1
             ORDER BY created_at ASC
@@ -72,13 +74,14 @@ impl CronStore {
             .map(|row| CronConfig {
                 id: row.try_get("id").unwrap_or_default(),
                 prompt: row.try_get("prompt").unwrap_or_default(),
+                cron_expr: row.try_get::<Option<String>, _>("cron_expr").ok().flatten(),
                 interval_secs: row.try_get::<i64, _>("interval_secs").unwrap_or(3600) as u64,
                 delivery_target: row.try_get("delivery_target").unwrap_or_default(),
                 active_hours: {
                     let start: Option<i64> = row.try_get("active_start_hour").ok();
                     let end: Option<i64> = row.try_get("active_end_hour").ok();
                     match (start, end) {
-                        (Some(s), Some(e)) => Some((s as u8, e as u8)),
+                        (Some(s), Some(e)) if s != e => Some((s as u8, e as u8)),
                         _ => None,
                     }
                 },
@@ -148,7 +151,7 @@ impl CronStore {
     pub async fn load_all_unfiltered(&self) -> Result<Vec<CronConfig>> {
         let rows = sqlx::query(
             r#"
-            SELECT id, prompt, interval_secs, delivery_target, active_start_hour, active_end_hour, enabled, run_once, timeout_secs
+            SELECT id, prompt, cron_expr, interval_secs, delivery_target, active_start_hour, active_end_hour, enabled, run_once, timeout_secs
             FROM cron_jobs
             ORDER BY created_at ASC
             "#,
@@ -162,13 +165,14 @@ impl CronStore {
             .map(|row| CronConfig {
                 id: row.try_get("id").unwrap_or_default(),
                 prompt: row.try_get("prompt").unwrap_or_default(),
+                cron_expr: row.try_get::<Option<String>, _>("cron_expr").ok().flatten(),
                 interval_secs: row.try_get::<i64, _>("interval_secs").unwrap_or(3600) as u64,
                 delivery_target: row.try_get("delivery_target").unwrap_or_default(),
                 active_hours: {
                     let start: Option<i64> = row.try_get("active_start_hour").ok();
                     let end: Option<i64> = row.try_get("active_end_hour").ok();
                     match (start, end) {
-                        (Some(s), Some(e)) => Some((s as u8, e as u8)),
+                        (Some(s), Some(e)) if s != e => Some((s as u8, e as u8)),
                         _ => None,
                     }
                 },
diff --git a/src/error.rs b/src/error.rs
index 84baafcea..952fa34dc 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -212,9 +212,12 @@ pub enum SecretsError {
     #[error("secret not found: {key}")]
     NotFound { key: String },
 
-    #[error("invalid key format")]
+    #[error("invalid master key")]
     InvalidKey,
 
+    #[error("secret store is locked — unlock with master key first")]
+    StoreLocked,
+
     #[error(transparent)]
     Other(#[from] anyhow::Error),
 }
diff --git a/src/hooks.rs b/src/hooks.rs
index b1b02c0fc..6ae37cccb 100644
--- a/src/hooks.rs
+++ b/src/hooks.rs
@@ -4,4 +4,4 @@ pub mod cortex;
 pub mod spacebot;
 
 pub use cortex::CortexHook;
-pub use spacebot::SpacebotHook;
+pub use spacebot::{SpacebotHook, ToolNudgePolicy};
diff --git a/src/hooks/spacebot.rs b/src/hooks/spacebot.rs
index 6f867f9c4..9cc7bace9 100644
--- a/src/hooks/spacebot.rs
+++ b/src/hooks/spacebot.rs
@@ -2,9 +2,30 @@
 
 use crate::{AgentId, ChannelId, ProcessEvent, ProcessId, ProcessType};
 use rig::agent::{HookAction, PromptHook, ToolCallHookAction};
-use rig::completion::{CompletionModel, CompletionResponse, Message};
+use rig::completion::{CompletionModel, CompletionResponse, Message, Prompt, PromptError};
 use tokio::sync::broadcast;
 
+/// Controls whether hook-driven tool nudge retries are enabled.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ToolNudgePolicy {
+    Enabled,
+    Disabled,
+}
+
+impl ToolNudgePolicy {
+    /// Default policy by process type.
+    pub fn for_process(process_type: ProcessType) -> Self {
+        match process_type {
+            ProcessType::Worker => Self::Enabled,
+            _ => Self::Disabled,
+        }
+    }
+
+    fn is_enabled(self) -> bool {
+        matches!(self, Self::Enabled)
+    }
+}
+
 /// Hook for observing agent behavior and sending events.
 #[derive(Clone)]
 pub struct SpacebotHook {
@@ -13,9 +34,25 @@ pub struct SpacebotHook {
     process_type: ProcessType,
     channel_id: Option<ChannelId>,
     event_tx: broadcast::Sender<ProcessEvent>,
+    tool_nudge_policy: ToolNudgePolicy,
+    completion_calls: std::sync::Arc<std::sync::atomic::AtomicUsize>,
+    nudge_request_active: std::sync::Arc<std::sync::atomic::AtomicBool>,
+    /// Set to `true` when the worker calls `set_status` with `kind: "outcome"`.
+    /// Once signaled, the nudge system allows text-only responses to pass
+    /// through as legitimate completions.
+    outcome_signaled: std::sync::Arc<std::sync::atomic::AtomicBool>,
 }
 
 impl SpacebotHook {
+    /// Prompt used to nudge tool-first behavior.
+    pub const TOOL_NUDGE_PROMPT: &str = "You have not completed the task yet. Continue working using the available tools. \
+         When you have reached a final result, call set_status with kind \"outcome\" \
+         before finishing.";
+    /// PromptCancelled reason used internally for tool nudge retries.
+    pub const TOOL_NUDGE_REASON: &str = "spacebot_tool_nudge_retry";
+    /// Maximum nudge retries per prompt request.
+    pub const TOOL_NUDGE_MAX_RETRIES: usize = 2;
+
     /// Create a new hook.
     pub fn new(
         agent_id: AgentId,
@@ -30,9 +67,176 @@ impl SpacebotHook {
             process_type,
             channel_id,
             event_tx,
+            tool_nudge_policy: ToolNudgePolicy::for_process(process_type),
+            completion_calls: std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0)),
+            nudge_request_active: std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)),
+            outcome_signaled: std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)),
+        }
+    }
+
+    /// Override the default process-scoped nudge policy.
+    pub fn with_tool_nudge_policy(mut self, policy: ToolNudgePolicy) -> Self {
+        self.tool_nudge_policy = policy;
+        self
+    }
+
+    /// Return the current tool nudge policy for this hook.
+    pub fn tool_nudge_policy(&self) -> ToolNudgePolicy {
+        self.tool_nudge_policy
+    }
+
+    /// Reset per-prompt state (tool nudging and outcome tracking).
+    pub fn reset_tool_nudge_state(&self) {
+        self.completion_calls
+            .store(0, std::sync::atomic::Ordering::Relaxed);
+        self.outcome_signaled
+            .store(false, std::sync::atomic::Ordering::Relaxed);
+    }
+
+    fn set_tool_nudge_request_active(&self, active: bool) {
+        self.nudge_request_active
+            .store(active, std::sync::atomic::Ordering::Relaxed);
+    }
+
+    /// Return true if a PromptCancelled reason indicates a tool nudge retry.
+    pub fn is_tool_nudge_reason(reason: &str) -> bool {
+        reason == Self::TOOL_NUDGE_REASON
+    }
+
+    /// Prompt an agent with bounded hook-driven tool nudge retries.
+    ///
+    /// This keeps hook usage consistent at call sites while preserving
+    /// PromptCancelled semantics for non-nudge cancellation reasons.
+    pub async fn prompt_with_tool_nudge_retry<M>(
+        &self,
+        agent: &rig::agent::Agent<M>,
+        history: &mut Vec<Message>,
+        prompt: &str,
+    ) -> std::result::Result<String, PromptError>
+    where
+        M: CompletionModel,
+    {
+        self.reset_tool_nudge_state();
+        self.set_tool_nudge_request_active(true);
+
+        let mut nudge_attempts = 0usize;
+        let mut current_prompt = std::borrow::Cow::Borrowed(prompt);
+        let mut using_tool_nudge_prompt = false;
+
+        loop {
+            let history_len_before_attempt = history.len();
+            let result = agent
+                .prompt(current_prompt.as_ref())
+                .with_history(history)
+                .with_hook(self.clone())
+                .await;
+
+            match &result {
+                Err(PromptError::PromptCancelled { reason, .. })
+                    if Self::is_tool_nudge_reason(reason)
+                        && nudge_attempts < Self::TOOL_NUDGE_MAX_RETRIES =>
+                {
+                    Self::prune_tool_nudge_retry_history(
+                        history,
+                        history_len_before_attempt,
+                        using_tool_nudge_prompt,
+                    );
+                    nudge_attempts += 1;
+                    tracing::warn!(
+                        process_id = %self.process_id,
+                        process_type = %self.process_type,
+                        attempt = nudge_attempts,
+                        "text-only response without outcome signal, nudging tool usage"
+                    );
+                    current_prompt = std::borrow::Cow::Borrowed(Self::TOOL_NUDGE_PROMPT);
+                    using_tool_nudge_prompt = true;
+                    continue;
+                }
+                _ => {
+                    if result.is_ok() {
+                        Self::prune_successful_tool_nudge_prompt(
+                            history,
+                            history_len_before_attempt,
+                            using_tool_nudge_prompt,
+                        );
+                    }
+                    self.set_tool_nudge_request_active(false);
+                    return result;
+                }
+            }
         }
     }
 
+    fn prune_tool_nudge_retry_history(
+        history: &mut Vec<Message>,
+        history_len_before_attempt: usize,
+        using_tool_nudge_prompt: bool,
+    ) {
+        if history.len() <= history_len_before_attempt {
+            return;
+        }
+
+        // Synthetic nudge retries should roll back entirely; only the original
+        // task context should persist between attempts.
+        if using_tool_nudge_prompt {
+            history.truncate(history_len_before_attempt);
+            return;
+        }
+
+        // First retry should keep the user task prompt added by the failed
+        // attempt while removing the failed assistant turn.
+        if matches!(
+            history.get(history_len_before_attempt),
+            Some(Message::User { .. })
+        ) {
+            history.truncate(history_len_before_attempt.saturating_add(1));
+        } else {
+            history.truncate(history_len_before_attempt);
+        }
+    }
+
+    fn prune_successful_tool_nudge_prompt(
+        history: &mut Vec<Message>,
+        history_len_before_attempt: usize,
+        using_tool_nudge_prompt: bool,
+    ) {
+        if !using_tool_nudge_prompt || history_len_before_attempt >= history.len() {
+            return;
+        }
+
+        let should_remove_nudge_turn = matches!(
+            history.get(history_len_before_attempt),
+            Some(Message::User { content })
+                if content.iter().any(|item| matches!(
+                    item,
+                    rig::message::UserContent::Text(text)
+                        if text.text.trim() == Self::TOOL_NUDGE_PROMPT
+                ))
+        );
+        if should_remove_nudge_turn {
+            history.remove(history_len_before_attempt);
+        }
+    }
+
+    /// Prompt once with the hook attached and no retry loop.
+    pub async fn prompt_once<M>(
+        &self,
+        agent: &rig::agent::Agent<M>,
+        history: &mut Vec<Message>,
+        prompt: &str,
+    ) -> std::result::Result<String, PromptError>
+    where
+        M: CompletionModel,
+    {
+        self.reset_tool_nudge_state();
+        self.set_tool_nudge_request_active(false);
+        agent
+            .prompt(prompt)
+            .with_history(history)
+            .with_hook(self.clone())
+            .await
+    }
+
     /// Send a status update event.
     pub fn send_status(&self, status: impl Into<String>) {
         let event = ProcessEvent::StatusUpdate {
@@ -40,98 +244,172 @@ impl SpacebotHook {
             process_id: self.process_id.clone(),
             status: status.into(),
         };
-        let _ = self.event_tx.send(event);
-    }
-
-    /// Check a string against the leak pattern set.
-    fn match_patterns(content: &str) -> Option<String> {
-        use regex::Regex;
-        use std::sync::LazyLock;
-
-        static LEAK_PATTERNS: LazyLock<Vec<Regex>> = LazyLock::new(|| {
-            vec![
-                Regex::new(r"sk-[a-zA-Z0-9]{20,}").expect("hardcoded regex"),
-                Regex::new(r"sk-ant-[a-zA-Z0-9_-]{20,}").expect("hardcoded regex"),
-                Regex::new(r"sk-or-[a-zA-Z0-9_-]{20,}").expect("hardcoded regex"),
-                Regex::new(r"-----BEGIN.*PRIVATE KEY-----").expect("hardcoded regex"),
-                Regex::new(r"ghp_[a-zA-Z0-9]{36}").expect("hardcoded regex"),
-                Regex::new(r"AIza[0-9A-Za-z_-]{35}").expect("hardcoded regex"),
-                Regex::new(r"[MN][A-Za-z0-9]{23,}\.[A-Za-z0-9_-]{6}\.[A-Za-z0-9_-]{27,}")
-                    .expect("hardcoded regex"),
-                Regex::new(r"xoxb-[0-9]{10,}-[0-9A-Za-z-]+").expect("hardcoded regex"),
-                Regex::new(r"xapp-[0-9]-[A-Z0-9]+-[0-9]+-[a-f0-9]+").expect("hardcoded regex"),
-                Regex::new(r"\d{8,}:[A-Za-z0-9_-]{35}").expect("hardcoded regex"),
-                Regex::new(r"BSA[a-zA-Z0-9]{20,}").expect("hardcoded regex"),
-            ]
-        });
-
-        for pattern in LEAK_PATTERNS.iter() {
-            if let Some(matched) = pattern.find(content) {
-                return Some(matched.as_str().to_string());
-            }
-        }
+        self.event_tx.send(event).ok();
+    }
 
-        None
+    /// Send a worker idle event. Only valid for worker processes.
+    pub fn send_worker_idle(&self) {
+        if let ProcessId::Worker(worker_id) = &self.process_id {
+            let event = ProcessEvent::WorkerIdle {
+                agent_id: self.agent_id.clone(),
+                worker_id: *worker_id,
+                channel_id: self.channel_id.clone(),
+            };
+            self.event_tx.send(event).ok();
+        }
     }
 
     /// Scan content for potential secret leaks, including encoded forms.
     ///
-    /// Checks raw content first, then attempts URL-decoding, base64-decoding,
-    /// and hex-decoding to catch secrets that an LLM might encode to evade
-    /// plaintext pattern matching.
+    /// Delegates to the shared implementation in `secrets::scrub`.
     fn scan_for_leaks(&self, content: &str) -> Option<String> {
-        use base64::Engine;
-        use regex::Regex;
-        use std::sync::LazyLock;
+        crate::secrets::scrub::scan_for_leaks(content)
+    }
 
-        if let Some(matched) = Self::match_patterns(content) {
-            return Some(matched);
+    /// Apply shared safety checks for tool output before any downstream handling.
+    ///
+    /// For channels, a detected secret terminates the agent immediately to prevent
+    /// exfiltration via the `reply` tool. For workers and branches, secrets are
+    /// logged but execution continues — these processes cannot communicate with
+    /// users directly, and their egress paths (worker results, branch conclusions,
+    /// status updates) apply scrubbing before content reaches the channel.
+    pub(crate) fn guard_tool_result(&self, tool_name: &str, result: &str) -> HookAction {
+        if let Some(leak) = self.scan_for_leaks(result) {
+            match self.process_type {
+                ProcessType::Worker | ProcessType::Branch => {
+                    // Workers and branches cannot communicate with users directly.
+                    // Their egress paths (worker results, branch conclusions,
+                    // status updates) scrub secrets before content reaches the
+                    // channel. Log and continue rather than killing the process.
+                    //
+                    // Avoid logging any fragment of the matched secret. Only log
+                    // the encoding kind (plaintext/url/base64/hex) and length.
+                    let kind = if leak.starts_with("url-encoded:") {
+                        "url-encoded"
+                    } else if leak.starts_with("base64-encoded:") {
+                        "base64-encoded"
+                    } else if leak.starts_with("hex-encoded:") {
+                        "hex-encoded"
+                    } else {
+                        "plaintext"
+                    };
+                    tracing::warn!(
+                        process_id = %self.process_id,
+                        tool_name = %tool_name,
+                        leak_kind = kind,
+                        leak_len = leak.len(),
+                        "secret detected in tool output (non-channel process, continuing)"
+                    );
+                }
+                ProcessType::Channel | ProcessType::Compactor | ProcessType::Cortex => {
+                    tracing::error!(
+                        process_id = %self.process_id,
+                        tool_name = %tool_name,
+                        leak_prefix = %&leak[..leak.len().min(8)],
+                        "secret leak detected in tool output, terminating agent"
+                    );
+                    return HookAction::Terminate {
+                        reason:
+                            "Tool output contained a secret. Agent terminated to prevent exfiltration."
+                                .into(),
+                    };
+                }
+            }
         }
 
-        // Percent-encoded secrets (e.g. sk%2Dant%2D...)
-        let url_decoded = urlencoding::decode(content).unwrap_or(std::borrow::Cow::Borrowed(""));
-        if url_decoded != content
-            && let Some(matched) = Self::match_patterns(&url_decoded)
-        {
-            return Some(format!("url-encoded: {matched}"));
-        }
+        HookAction::Continue
+    }
 
-        // Base64-wrapped secrets. Minimum 24 chars avoids false positives on
-        // short alphanumeric strings while catching any encoded API key.
-        static BASE64_SEGMENT: LazyLock<Regex> =
-            LazyLock::new(|| Regex::new(r"[A-Za-z0-9+/]{24,}={0,2}").expect("hardcoded regex"));
-        for segment in BASE64_SEGMENT.find_iter(content) {
-            if let Ok(decoded_bytes) =
-                base64::engine::general_purpose::STANDARD.decode(segment.as_str())
-                && let Ok(decoded) = std::str::from_utf8(&decoded_bytes)
-                && let Some(matched) = Self::match_patterns(decoded)
-            {
-                return Some(format!("base64-encoded: {matched}"));
-            }
-            if let Ok(decoded_bytes) =
-                base64::engine::general_purpose::URL_SAFE.decode(segment.as_str())
-                && let Ok(decoded) = std::str::from_utf8(&decoded_bytes)
-                && let Some(matched) = Self::match_patterns(decoded)
+    /// Record metrics for a completed tool call.
+    pub(crate) fn record_tool_result_metrics(&self, tool_name: &str, internal_call_id: &str) {
+        #[cfg(feature = "metrics")]
+        {
+            let metrics = crate::telemetry::Metrics::global();
+            metrics
+                .tool_calls_total
+                .with_label_values(&[&*self.agent_id, tool_name])
+                .inc();
+            if let Some(start) = TOOL_CALL_TIMERS
+                .lock()
+                .ok()
+                .and_then(|mut timers| timers.remove(internal_call_id))
             {
-                return Some(format!("base64-encoded: {matched}"));
+                metrics
+                    .tool_call_duration_seconds
+                    .observe(start.elapsed().as_secs_f64());
             }
         }
+        #[cfg(not(feature = "metrics"))]
+        let _ = (tool_name, internal_call_id);
+    }
 
-        // Hex-encoded secrets. Minimum 40 hex chars (20 bytes) to reduce
-        // false positives while catching any hex-wrapped API key.
-        static HEX_SEGMENT: LazyLock<Regex> =
-            LazyLock::new(|| Regex::new(r"(?i)(?:0x)?([0-9a-f]{40,})").expect("hardcoded regex"));
-        for caps in HEX_SEGMENT.captures_iter(content) {
-            let hex_str = caps.get(1).map_or("", |m| m.as_str());
-            if let Ok(decoded_bytes) = hex::decode(hex_str)
-                && let Ok(decoded) = std::str::from_utf8(&decoded_bytes)
-                && let Some(matched) = Self::match_patterns(decoded)
-            {
-                return Some(format!("hex-encoded: {matched}"));
-            }
+    pub(crate) fn emit_tool_completed_event(&self, tool_name: &str, result: &str) {
+        let capped_result =
+            crate::tools::truncate_output(result, crate::tools::MAX_TOOL_OUTPUT_BYTES);
+        self.emit_tool_completed_event_from_capped(tool_name, capped_result);
+    }
+
+    pub(crate) fn emit_tool_completed_event_from_capped(
+        &self,
+        tool_name: &str,
+        capped_result: String,
+    ) {
+        let event = ProcessEvent::ToolCompleted {
+            agent_id: self.agent_id.clone(),
+            process_id: self.process_id.clone(),
+            channel_id: self.channel_id.clone(),
+            tool_name: tool_name.to_string(),
+            result: capped_result,
+        };
+        self.event_tx.send(event).ok();
+    }
+
+    /// Decide whether a text-only response should be rejected and nudged back
+    /// into tool usage.
+    ///
+    /// Workers are not allowed to exit with a text-only response unless they
+    /// have first signaled a terminal outcome via `set_status(kind: "outcome")`.
+    /// This prevents workers from silently completing with narration instead of
+    /// actually doing the work.
+    fn should_nudge_tool_usage<M>(&self, response: &CompletionResponse<M::Response>) -> bool
+    where
+        M: CompletionModel,
+    {
+        if !self.tool_nudge_policy.is_enabled() {
+            return false;
+        }
+        if !self
+            .nudge_request_active
+            .load(std::sync::atomic::Ordering::Relaxed)
+        {
+            return false;
+        }
+
+        // If the worker already signaled a terminal outcome, allow text-only
+        // responses — the worker is legitimately finishing up.
+        if self
+            .outcome_signaled
+            .load(std::sync::atomic::Ordering::Relaxed)
+        {
+            return false;
         }
 
-        None
+        let has_tool_calls = response
+            .choice
+            .iter()
+            .any(|content| matches!(content, rig::message::AssistantContent::ToolCall(_)));
+        if has_tool_calls {
+            return false;
+        }
+
+        // Text-only response without a prior outcome signal — nudge.
+        response.choice.iter().any(|content| {
+            if let rig::message::AssistantContent::Text(text) = content {
+                !text.text.trim().is_empty()
+            } else {
+                false
+            }
+        })
     }
 }
 
@@ -149,6 +427,11 @@ where
     M: CompletionModel,
 {
     async fn on_completion_call(&self, _prompt: &Message, _history: &[Message]) -> HookAction {
+        if self.tool_nudge_policy.is_enabled() {
+            self.completion_calls
+                .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        }
+
         // Log the completion call but don't block it
         tracing::debug!(
             process_id = %self.process_id,
@@ -162,13 +445,36 @@ where
     async fn on_completion_response(
         &self,
         _prompt: &Message,
-        _response: &CompletionResponse<M::Response>,
+        response: &CompletionResponse<M::Response>,
     ) -> HookAction {
         tracing::debug!(
             process_id = %self.process_id,
             "completion response received"
         );
 
+        if self.should_nudge_tool_usage::<M>(response) {
+            return HookAction::Terminate {
+                reason: Self::TOOL_NUDGE_REASON.into(),
+            };
+        }
+
+        HookAction::Continue
+    }
+
+    async fn on_text_delta(&self, text_delta: &str, aggregated_text: &str) -> HookAction {
+        if self.process_type == ProcessType::Channel
+            && let Some(channel_id) = self.channel_id.clone()
+        {
+            let event = ProcessEvent::TextDelta {
+                agent_id: self.agent_id.clone(),
+                process_id: self.process_id.clone(),
+                channel_id: Some(channel_id),
+                text_delta: text_delta.to_string(),
+                aggregated_text: aggregated_text.to_string(),
+            };
+            self.event_tx.send(event).ok();
+        }
+
         HookAction::Continue
     }
 
@@ -179,27 +485,33 @@ where
         _internal_call_id: &str,
         args: &str,
     ) -> ToolCallHookAction {
-        // Scan tool arguments for secrets before execution
-        if let Some(leak) = self.scan_for_leaks(args) {
+        // Leak blocking is enforced at channel egress (`reply`). Worker and
+        // branch tool calls may legitimately handle secrets internally.
+        if self.process_type == ProcessType::Channel
+            && tool_name == "reply"
+            && let Some(leak) = self.scan_for_leaks(args)
+        {
             tracing::error!(
                 process_id = %self.process_id,
                 tool_name = %tool_name,
                 leak_prefix = %&leak[..leak.len().min(8)],
-                "secret leak detected in tool arguments, blocking call"
+                "secret leak detected in reply arguments, blocking call"
             );
             return ToolCallHookAction::Skip {
-                reason: "Tool call blocked: arguments contained a secret.".into(),
+                reason: "Reply blocked: content contained a secret.".into(),
             };
         }
 
-        // Send event without blocking
+        // Send event without blocking. Truncate args to keep broadcast payloads bounded.
+        let capped_args = crate::tools::truncate_output(args, 2_000);
         let event = ProcessEvent::ToolStarted {
             agent_id: self.agent_id.clone(),
             process_id: self.process_id.clone(),
             channel_id: self.channel_id.clone(),
             tool_name: tool_name.to_string(),
+            args: capped_args,
         };
-        let _ = self.event_tx.send(event);
+        self.event_tx.send(event).ok();
 
         tracing::debug!(
             process_id = %self.process_id,
@@ -219,39 +531,48 @@ where
         &self,
         tool_name: &str,
         _tool_call_id: Option<String>,
-        _internal_call_id: &str,
+        internal_call_id: &str,
         _args: &str,
         result: &str,
     ) -> HookAction {
-        // Scan for potential leaks in tool output and terminate if found.
-        // The result is already in Rig's history at this point, but terminating
-        // prevents the agent from forwarding the leaked content to external
-        // services via subsequent tool calls.
-        if let Some(leak) = self.scan_for_leaks(result) {
+        let guard_action = self.guard_tool_result(tool_name, result);
+        if !matches!(guard_action, HookAction::Continue) {
+            self.record_tool_result_metrics(tool_name, internal_call_id);
+            return guard_action;
+        }
+
+        // Belt-and-suspenders check specifically for `reply` tool results on
+        // channels. `guard_tool_result` already terminates channels on any tool
+        // leak, but this catches any edge case where the reply content itself
+        // has a different leak than the raw tool output.
+        if self.process_type == ProcessType::Channel
+            && tool_name == "reply"
+            && let Some(leak) = self.scan_for_leaks(result)
+        {
             tracing::error!(
                 process_id = %self.process_id,
                 tool_name = %tool_name,
                 leak_prefix = %&leak[..leak.len().min(8)],
-                "secret leak detected in tool output, terminating agent"
+                "secret leak detected in reply result, terminating channel turn"
             );
+            self.record_tool_result_metrics(tool_name, internal_call_id);
             return HookAction::Terminate {
-                reason: "Tool output contained a secret. Agent terminated to prevent exfiltration."
-                    .into(),
+                reason: "Reply contained a secret. Channel turn terminated.".into(),
             };
         }
 
         // Cap the result stored in the broadcast event to avoid blowing up
-        // event subscribers with multi-MB tool results.
-        let capped_result =
-            crate::tools::truncate_output(result, crate::tools::MAX_TOOL_OUTPUT_BYTES);
-        let event = ProcessEvent::ToolCompleted {
-            agent_id: self.agent_id.clone(),
-            process_id: self.process_id.clone(),
-            channel_id: self.channel_id.clone(),
-            tool_name: tool_name.to_string(),
-            result: capped_result,
-        };
-        let _ = self.event_tx.send(event);
+        // event subscribers with multi-MB tool results. For worker/branch
+        // processes, scrub leak patterns from the event payload so secrets
+        // don't reach the SSE dashboard.
+        if matches!(self.process_type, ProcessType::Worker | ProcessType::Branch) {
+            let scrubbed = crate::secrets::scrub::scrub_leaks(result);
+            let capped =
+                crate::tools::truncate_output(&scrubbed, crate::tools::MAX_TOOL_OUTPUT_BYTES);
+            self.emit_tool_completed_event_from_capped(tool_name, capped);
+        } else {
+            self.emit_tool_completed_event(tool_name, result);
+        }
 
         tracing::debug!(
             process_id = %self.process_id,
@@ -260,22 +581,20 @@ where
             "tool call completed"
         );
 
-        #[cfg(feature = "metrics")]
+        self.record_tool_result_metrics(tool_name, internal_call_id);
+
+        // Detect terminal outcome signal from successful set_status results.
+        // We check the *result* (not the args) so the flag is only set after the
+        // tool actually executed successfully. A failed set_status call won't
+        // parse as a valid output with `success: true`.
+        if self.tool_nudge_policy.is_enabled()
+            && tool_name == "set_status"
+            && let Ok(parsed) = serde_json::from_str::<serde_json::Value>(result)
+            && parsed.get("success").and_then(|v| v.as_bool()) == Some(true)
+            && parsed.get("kind").and_then(|v| v.as_str()) == Some("outcome")
         {
-            let metrics = crate::telemetry::Metrics::global();
-            metrics
-                .tool_calls_total
-                .with_label_values(&[&*self.agent_id, tool_name])
-                .inc();
-            if let Some(start) = TOOL_CALL_TIMERS
-                .lock()
-                .ok()
-                .and_then(|mut timers| timers.remove(_internal_call_id))
-            {
-                metrics
-                    .tool_call_duration_seconds
-                    .observe(start.elapsed().as_secs_f64());
-            }
+            self.outcome_signaled
+                .store(true, std::sync::atomic::Ordering::Relaxed);
         }
 
         // Channel turns should end immediately after a successful reply tool call.
@@ -290,3 +609,529 @@ where
         HookAction::Continue
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{SpacebotHook, ToolNudgePolicy};
+    use crate::ProcessEvent;
+    use crate::llm::SpacebotModel;
+    use crate::llm::model::RawResponse;
+    use crate::{ProcessId, ProcessType};
+    use rig::OneOrMany;
+    use rig::agent::{HookAction, PromptHook};
+    use rig::completion::{CompletionResponse, Message, Usage};
+    use rig::message::AssistantContent;
+
+    fn make_hook() -> SpacebotHook {
+        let (event_tx, _event_rx) = tokio::sync::broadcast::channel(8);
+        SpacebotHook::new(
+            std::sync::Arc::<str>::from("agent"),
+            ProcessId::Worker(uuid::Uuid::new_v4()),
+            ProcessType::Worker,
+            None,
+            event_tx,
+        )
+    }
+
+    fn prompt_message() -> Message {
+        Message::from("test prompt")
+    }
+
+    fn text_response(text: &str) -> CompletionResponse<RawResponse> {
+        CompletionResponse {
+            choice: OneOrMany::one(AssistantContent::text(text)),
+            message_id: None,
+            usage: Usage::default(),
+            raw_response: RawResponse {
+                body: serde_json::json!({}),
+            },
+        }
+    }
+
+    fn tool_call_response() -> CompletionResponse<RawResponse> {
+        CompletionResponse {
+            choice: OneOrMany::one(AssistantContent::tool_call(
+                "call_1",
+                "reply",
+                serde_json::json!({ "content": "hello" }),
+            )),
+            message_id: None,
+            usage: Usage::default(),
+            raw_response: RawResponse {
+                body: serde_json::json!({}),
+            },
+        }
+    }
+
+    #[tokio::test]
+    async fn nudges_on_every_text_only_response_without_outcome() {
+        let hook = make_hook().with_tool_nudge_policy(ToolNudgePolicy::Enabled);
+        let prompt = prompt_message();
+        hook.reset_tool_nudge_state();
+        hook.set_tool_nudge_request_active(true);
+
+        // Every text-only response should trigger a nudge when no outcome has
+        // been signaled, regardless of how many completions have occurred.
+        for i in 1..=5 {
+            let _ = <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_call(
+                &hook,
+                &prompt,
+                &[],
+            )
+            .await;
+
+            let response = <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_response(
+                &hook,
+                &prompt,
+                &text_response(&format!("text-only attempt {i}")),
+            )
+            .await;
+            assert!(
+                matches!(
+                    response,
+                    HookAction::Terminate { ref reason }
+                    if reason == SpacebotHook::TOOL_NUDGE_REASON
+                ),
+                "Expected nudge on text-only response #{i}"
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn does_not_nudge_when_completion_contains_tool_call() {
+        let hook = make_hook().with_tool_nudge_policy(ToolNudgePolicy::Enabled);
+        let prompt = prompt_message();
+        hook.reset_tool_nudge_state();
+        hook.set_tool_nudge_request_active(true);
+
+        let _ =
+            <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_call(&hook, &prompt, &[])
+                .await;
+
+        let response = <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_response(
+            &hook,
+            &prompt,
+            &tool_call_response(),
+        )
+        .await;
+        assert!(matches!(response, HookAction::Continue));
+    }
+
+    #[tokio::test]
+    async fn nudges_after_tool_calls_without_outcome() {
+        // This is the exact bug case: worker calls read_skill + set_status(progress),
+        // then returns text-only. The nudge must still fire.
+        let hook = make_hook().with_tool_nudge_policy(ToolNudgePolicy::Enabled);
+        let prompt = prompt_message();
+        hook.reset_tool_nudge_state();
+        hook.set_tool_nudge_request_active(true);
+
+        // Simulate read_skill tool call
+        let _ = <SpacebotHook as PromptHook<SpacebotModel>>::on_tool_call(
+            &hook,
+            "read_skill",
+            None,
+            "internal_1",
+            "{\"name\":\"proton-email\"}",
+        )
+        .await;
+
+        // Simulate set_status(progress) tool call
+        let _ = <SpacebotHook as PromptHook<SpacebotModel>>::on_tool_call(
+            &hook,
+            "set_status",
+            None,
+            "internal_2",
+            "{\"status\":\"Researching...\"}",
+        )
+        .await;
+
+        // Now the model returns text-only — must still nudge
+        let _ =
+            <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_call(&hook, &prompt, &[])
+                .await;
+        let response = <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_response(
+            &hook,
+            &prompt,
+            &text_response("Let me create the email now..."),
+        )
+        .await;
+        assert!(
+            matches!(
+                response,
+                HookAction::Terminate { ref reason }
+                if reason == SpacebotHook::TOOL_NUDGE_REASON
+            ),
+            "Expected nudge after tool calls without outcome signal"
+        );
+    }
+
+    #[tokio::test]
+    async fn outcome_signal_allows_text_only_completion() {
+        let hook = make_hook().with_tool_nudge_policy(ToolNudgePolicy::Enabled);
+        let prompt = prompt_message();
+        hook.reset_tool_nudge_state();
+        hook.set_tool_nudge_request_active(true);
+
+        // Simulate some work
+        let _ = <SpacebotHook as PromptHook<SpacebotModel>>::on_tool_call(
+            &hook,
+            "shell",
+            None,
+            "internal_1",
+            "{\"command\":\"echo hello\"}",
+        )
+        .await;
+
+        // Signal outcome via set_status tool call + successful result
+        let _ = <SpacebotHook as PromptHook<SpacebotModel>>::on_tool_call(
+            &hook,
+            "set_status",
+            None,
+            "internal_2",
+            "{\"status\":\"Email sent successfully\",\"kind\":\"outcome\"}",
+        )
+        .await;
+        let _ = <SpacebotHook as PromptHook<SpacebotModel>>::on_tool_result(
+            &hook,
+            "set_status",
+            None,
+            "internal_2",
+            "{\"status\":\"Email sent successfully\",\"kind\":\"outcome\"}",
+            "{\"success\":true,\"worker_id\":1,\"status\":\"Email sent successfully\",\"kind\":\"outcome\"}",
+        )
+        .await;
+
+        // Now text-only response should be allowed
+        let _ =
+            <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_call(&hook, &prompt, &[])
+                .await;
+        let response = <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_response(
+            &hook,
+            &prompt,
+            &text_response("Email sent to jamie@spacedrive.com"),
+        )
+        .await;
+        assert!(
+            matches!(response, HookAction::Continue),
+            "Expected text-only to pass through after outcome signal"
+        );
+    }
+
+    #[tokio::test]
+    async fn progress_status_does_not_signal_outcome() {
+        let hook = make_hook().with_tool_nudge_policy(ToolNudgePolicy::Enabled);
+        let prompt = prompt_message();
+        hook.reset_tool_nudge_state();
+        hook.set_tool_nudge_request_active(true);
+
+        // set_status with kind "progress" should NOT signal outcome, even after
+        // successful execution.
+        let _ = <SpacebotHook as PromptHook<SpacebotModel>>::on_tool_call(
+            &hook,
+            "set_status",
+            None,
+            "internal_1",
+            "{\"status\":\"Working on it...\",\"kind\":\"progress\"}",
+        )
+        .await;
+        let _ = <SpacebotHook as PromptHook<SpacebotModel>>::on_tool_result(
+            &hook,
+            "set_status",
+            None,
+            "internal_1",
+            "{\"status\":\"Working on it...\",\"kind\":\"progress\"}",
+            "{\"success\":true,\"worker_id\":1,\"status\":\"Working on it...\",\"kind\":\"progress\"}",
+        )
+        .await;
+
+        let _ =
+            <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_call(&hook, &prompt, &[])
+                .await;
+        let response = <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_response(
+            &hook,
+            &prompt,
+            &text_response("I'll help with that"),
+        )
+        .await;
+        assert!(
+            matches!(
+                response,
+                HookAction::Terminate { ref reason }
+                if reason == SpacebotHook::TOOL_NUDGE_REASON
+            ),
+            "Expected nudge — progress status is not an outcome signal"
+        );
+    }
+
+    #[tokio::test]
+    async fn default_status_kind_does_not_signal_outcome() {
+        let hook = make_hook().with_tool_nudge_policy(ToolNudgePolicy::Enabled);
+        let prompt = prompt_message();
+        hook.reset_tool_nudge_state();
+        hook.set_tool_nudge_request_active(true);
+
+        // set_status without kind field — defaults to progress. Even after
+        // successful execution, this should NOT signal outcome.
+        let _ = <SpacebotHook as PromptHook<SpacebotModel>>::on_tool_call(
+            &hook,
+            "set_status",
+            None,
+            "internal_1",
+            "{\"status\":\"Working on it...\"}",
+        )
+        .await;
+        let _ = <SpacebotHook as PromptHook<SpacebotModel>>::on_tool_result(
+            &hook,
+            "set_status",
+            None,
+            "internal_1",
+            "{\"status\":\"Working on it...\"}",
+            "{\"success\":true,\"worker_id\":1,\"status\":\"Working on it...\",\"kind\":\"progress\"}",
+        )
+        .await;
+
+        let _ =
+            <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_call(&hook, &prompt, &[])
+                .await;
+        let response = <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_response(
+            &hook,
+            &prompt,
+            &text_response("done"),
+        )
+        .await;
+        assert!(
+            matches!(
+                response,
+                HookAction::Terminate { ref reason }
+                if reason == SpacebotHook::TOOL_NUDGE_REASON
+            ),
+            "Expected nudge — status without kind is not an outcome signal"
+        );
+    }
+
+    #[tokio::test]
+    async fn failed_set_status_does_not_signal_outcome() {
+        let hook = make_hook().with_tool_nudge_policy(ToolNudgePolicy::Enabled);
+        let prompt = prompt_message();
+        hook.reset_tool_nudge_state();
+        hook.set_tool_nudge_request_active(true);
+
+        // Simulate a set_status call with outcome kind that fails. Rig passes
+        // the error string as the result, which won't parse as valid JSON with
+        // success: true.
+        let _ = <SpacebotHook as PromptHook<SpacebotModel>>::on_tool_call(
+            &hook,
+            "set_status",
+            None,
+            "internal_1",
+            "{\"status\":\"Task complete\",\"kind\":\"outcome\"}",
+        )
+        .await;
+        let _ = <SpacebotHook as PromptHook<SpacebotModel>>::on_tool_result(
+            &hook,
+            "set_status",
+            None,
+            "internal_1",
+            "{\"status\":\"Task complete\",\"kind\":\"outcome\"}",
+            "Failed to set status: worker not found",
+        )
+        .await;
+
+        // Text-only response should still be nudged because the outcome tool
+        // call failed.
+        let _ =
+            <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_call(&hook, &prompt, &[])
+                .await;
+        let response = <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_response(
+            &hook,
+            &prompt,
+            &text_response("All done!"),
+        )
+        .await;
+        assert!(
+            matches!(
+                response,
+                HookAction::Terminate { ref reason }
+                if reason == SpacebotHook::TOOL_NUDGE_REASON
+            ),
+            "Expected nudge — failed set_status should not signal outcome"
+        );
+    }
+
+    #[tokio::test]
+    async fn process_scoped_policy_disables_nudge_for_branch() {
+        let (event_tx, _event_rx) = tokio::sync::broadcast::channel(8);
+        let hook = SpacebotHook::new(
+            std::sync::Arc::<str>::from("agent"),
+            ProcessId::Branch(uuid::Uuid::new_v4()),
+            ProcessType::Branch,
+            None,
+            event_tx,
+        );
+        let prompt = prompt_message();
+        hook.reset_tool_nudge_state();
+        hook.set_tool_nudge_request_active(true);
+
+        let _ =
+            <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_call(&hook, &prompt, &[])
+                .await;
+        let response = <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_response(
+            &hook,
+            &prompt,
+            &text_response("text-only branch response"),
+        )
+        .await;
+
+        assert!(matches!(response, HookAction::Continue));
+    }
+
+    #[tokio::test]
+    async fn process_scoped_policy_disables_nudge_for_channel() {
+        let (event_tx, _event_rx) = tokio::sync::broadcast::channel(8);
+        let hook = SpacebotHook::new(
+            std::sync::Arc::<str>::from("agent"),
+            ProcessId::Channel(std::sync::Arc::<str>::from("channel")),
+            ProcessType::Channel,
+            Some(std::sync::Arc::<str>::from("channel")),
+            event_tx,
+        );
+        let prompt = prompt_message();
+        hook.reset_tool_nudge_state();
+        hook.set_tool_nudge_request_active(true);
+
+        let _ =
+            <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_call(&hook, &prompt, &[])
+                .await;
+        let response = <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_response(
+            &hook,
+            &prompt,
+            &text_response("text-only channel response"),
+        )
+        .await;
+
+        assert!(matches!(response, HookAction::Continue));
+    }
+
+    #[tokio::test]
+    async fn explicit_policy_override_disables_nudge() {
+        let hook = make_hook().with_tool_nudge_policy(ToolNudgePolicy::Disabled);
+        let prompt = prompt_message();
+        hook.reset_tool_nudge_state();
+        hook.set_tool_nudge_request_active(true);
+
+        let _ =
+            <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_call(&hook, &prompt, &[])
+                .await;
+        let response = <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_response(
+            &hook,
+            &prompt,
+            &text_response("text-only worker response"),
+        )
+        .await;
+
+        assert!(matches!(response, HookAction::Continue));
+    }
+
+    #[tokio::test]
+    async fn process_scoped_policy_enables_nudge_for_worker_by_default() {
+        let hook = make_hook();
+        let prompt = prompt_message();
+        hook.reset_tool_nudge_state();
+        hook.set_tool_nudge_request_active(true);
+
+        let _ =
+            <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_call(&hook, &prompt, &[])
+                .await;
+        let response = <SpacebotHook as PromptHook<SpacebotModel>>::on_completion_response(
+            &hook,
+            &prompt,
+            &text_response("text-only worker response"),
+        )
+        .await;
+
+        assert!(matches!(
+            response,
+            HookAction::Terminate { ref reason } if reason == SpacebotHook::TOOL_NUDGE_REASON
+        ));
+    }
+
+    #[test]
+    fn tool_nudge_retry_history_hygiene_prevents_stacked_retry_turns() {
+        let mut history = vec![Message::from("original task")];
+        let base_len = history.len();
+
+        history.push(Message::from(SpacebotHook::TOOL_NUDGE_PROMPT));
+        history.push(Message::from(rig::message::AssistantContent::text(
+            "text-only response",
+        )));
+        SpacebotHook::prune_tool_nudge_retry_history(&mut history, base_len, true);
+        assert_eq!(history.len(), base_len);
+
+        history.push(Message::from(SpacebotHook::TOOL_NUDGE_PROMPT));
+        history.push(Message::from(rig::message::AssistantContent::text(
+            "second text-only response",
+        )));
+        SpacebotHook::prune_tool_nudge_retry_history(&mut history, base_len, true);
+        assert_eq!(history.len(), base_len);
+        assert!(matches!(history[0], Message::User { .. }));
+    }
+
+    #[test]
+    fn first_nudge_retry_prunes_failed_assistant_turn_but_keeps_task_prompt() {
+        let mut history = vec![Message::from("prior context")];
+        let base_len = history.len();
+
+        history.push(Message::from("current task"));
+        history.push(Message::from(rig::message::AssistantContent::text(
+            "text-only response",
+        )));
+
+        SpacebotHook::prune_tool_nudge_retry_history(&mut history, base_len, false);
+
+        assert_eq!(history.len(), base_len + 1);
+        assert!(matches!(history[base_len], Message::User { .. }));
+    }
+
+    #[test]
+    fn prompt_with_tool_nudge_retry_prunes_nudge_prompt_on_success() {
+        let mut history = vec![Message::from("original task")];
+        let base_len = history.len();
+
+        history.push(Message::from(SpacebotHook::TOOL_NUDGE_PROMPT));
+        history.push(Message::from(rig::message::AssistantContent::text(
+            "tool execution completed",
+        )));
+
+        SpacebotHook::prune_successful_tool_nudge_prompt(&mut history, base_len, true);
+
+        assert_eq!(history.len(), base_len + 1);
+        assert!(matches!(history[base_len], Message::Assistant { .. }));
+    }
+
+    #[tokio::test]
+    async fn channel_text_delta_emits_process_event() {
+        let (event_tx, mut event_rx) = tokio::sync::broadcast::channel(8);
+        let hook = SpacebotHook::new(
+            std::sync::Arc::<str>::from("agent"),
+            ProcessId::Channel(std::sync::Arc::<str>::from("channel")),
+            ProcessType::Channel,
+            Some(std::sync::Arc::<str>::from("channel")),
+            event_tx,
+        );
+
+        let action =
+            <SpacebotHook as PromptHook<SpacebotModel>>::on_text_delta(&hook, "hi", "hi").await;
+        assert!(matches!(action, HookAction::Continue));
+
+        let event = event_rx.recv().await.expect("text delta event");
+        assert!(matches!(
+            event,
+            ProcessEvent::TextDelta {
+                ref text_delta,
+                ref aggregated_text,
+                ..
+            } if text_delta == "hi" && aggregated_text == "hi"
+        ));
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 572b84415..7e3f03c1a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -21,8 +21,10 @@ pub mod opencode;
 pub mod prompts;
 pub mod sandbox;
 pub mod secrets;
+pub mod self_awareness;
 pub mod settings;
 pub mod skills;
+pub mod tasks;
 #[cfg(feature = "metrics")]
 pub mod telemetry;
 pub mod tools;
@@ -94,6 +96,51 @@ impl std::fmt::Display for ProcessType {
     }
 }
 
+/// Return a short summary from the first non-empty line, truncated to a
+/// character limit.
+pub const EVENT_SUMMARY_MAX_CHARS: usize = 160;
+
+pub fn summarize_first_non_empty_line(value: &str, max_chars: usize) -> String {
+    let first_line = value
+        .lines()
+        .map(str::trim)
+        .find(|line| !line.is_empty())
+        .unwrap_or_else(|| value.trim());
+
+    truncate_to_chars(first_line, max_chars).to_string()
+}
+
+fn truncate_to_chars(value: &str, max_chars: usize) -> &str {
+    if max_chars == 0 {
+        return "";
+    }
+
+    if let Some((index, _)) = value.char_indices().nth(max_chars) {
+        &value[..index]
+    } else {
+        value
+    }
+}
+
+#[derive(Debug)]
+pub enum BroadcastRecvResult<T> {
+    Event(T),
+    Lagged(u64),
+    Closed,
+}
+
+pub fn classify_broadcast_recv_result<T>(
+    result: std::result::Result<T, tokio::sync::broadcast::error::RecvError>,
+) -> BroadcastRecvResult<T> {
+    match result {
+        Ok(event) => BroadcastRecvResult::Event(event),
+        Err(tokio::sync::broadcast::error::RecvError::Lagged(count)) => {
+            BroadcastRecvResult::Lagged(count)
+        }
+        Err(tokio::sync::broadcast::error::RecvError::Closed) => BroadcastRecvResult::Closed,
+    }
+}
+
 /// Events sent between processes.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "snake_case")]
@@ -103,7 +150,7 @@ pub enum ProcessEvent {
         branch_id: BranchId,
         channel_id: ChannelId,
         description: String,
-        reply_to_message_id: Option<u64>,
+        reply_to_message_id: Option<String>,
     },
     BranchResult {
         agent_id: AgentId,
@@ -116,6 +163,8 @@ pub enum ProcessEvent {
         worker_id: WorkerId,
         channel_id: Option<ChannelId>,
         task: String,
+        worker_type: String,
+        interactive: bool,
     },
     WorkerStatus {
         agent_id: AgentId,
@@ -123,18 +172,28 @@ pub enum ProcessEvent {
         channel_id: Option<ChannelId>,
         status: String,
     },
+    /// An interactive worker has entered the idle state (waiting for follow-up
+    /// input). Persisted to the DB so the frontend can show an "idle" badge
+    /// instead of "running". The worker remains in the active set.
+    WorkerIdle {
+        agent_id: AgentId,
+        worker_id: WorkerId,
+        channel_id: Option<ChannelId>,
+    },
     WorkerComplete {
         agent_id: AgentId,
         worker_id: WorkerId,
         channel_id: Option<ChannelId>,
         result: String,
         notify: bool,
+        success: bool,
     },
     ToolStarted {
         agent_id: AgentId,
         process_id: ProcessId,
         channel_id: Option<ChannelId>,
         tool_name: String,
+        args: String,
     },
     ToolCompleted {
         agent_id: AgentId,
@@ -147,6 +206,9 @@ pub enum ProcessEvent {
         agent_id: AgentId,
         memory_id: String,
         channel_id: Option<ChannelId>,
+        memory_type: crate::memory::MemoryType,
+        importance: f32,
+        content_summary: String,
     },
     CompactionTriggered {
         agent_id: AgentId,
@@ -185,6 +247,110 @@ pub enum ProcessEvent {
         link_id: String,
         channel_id: ChannelId,
     },
+    TaskUpdated {
+        agent_id: AgentId,
+        task_number: i64,
+        status: String,
+        /// "created", "updated", or "deleted".
+        action: String,
+    },
+    /// An OpenCode worker created a session, recording metadata for the web UI embed.
+    OpenCodeSessionCreated {
+        agent_id: AgentId,
+        worker_id: WorkerId,
+        session_id: String,
+        port: u16,
+    },
+    /// A finalized content part from an OpenCode worker session. Emitted on every
+    /// `message.part.updated` SSE event so the frontend can build a live transcript.
+    OpenCodePartUpdated {
+        agent_id: AgentId,
+        worker_id: WorkerId,
+        part: crate::opencode::types::OpenCodePart,
+    },
+    /// An interactive worker's initial task completed. The worker remains alive
+    /// for follow-ups, but the channel should retrigger to deliver this result.
+    /// Unlike `WorkerComplete`, the worker is NOT removed from the active set.
+    WorkerInitialResult {
+        agent_id: AgentId,
+        worker_id: WorkerId,
+        channel_id: Option<ChannelId>,
+        result: String,
+    },
+    TextDelta {
+        agent_id: AgentId,
+        process_id: ProcessId,
+        channel_id: Option<ChannelId>,
+        text_delta: String,
+        aggregated_text: String,
+    },
+}
+
+/// Default broadcast capacity for the per-agent control event bus.
+pub const CONTROL_EVENT_BUS_CAPACITY: usize = 256;
+
+/// Default broadcast capacity for the per-agent memory event bus.
+pub const MEMORY_EVENT_BUS_CAPACITY: usize = 1024;
+
+/// Create the default pair of per-agent process event buses.
+///
+/// - `event_tx` carries control/lifecycle events consumed by channels and UI.
+/// - `memory_event_tx` carries memory-save telemetry consumed by the cortex.
+pub fn create_process_event_buses() -> (
+    tokio::sync::broadcast::Sender<ProcessEvent>,
+    tokio::sync::broadcast::Sender<ProcessEvent>,
+) {
+    create_process_event_buses_with_capacity(CONTROL_EVENT_BUS_CAPACITY, MEMORY_EVENT_BUS_CAPACITY)
+}
+
+/// Create per-agent process event buses with explicit capacities.
+pub fn create_process_event_buses_with_capacity(
+    control_event_capacity: usize,
+    memory_event_capacity: usize,
+) -> (
+    tokio::sync::broadcast::Sender<ProcessEvent>,
+    tokio::sync::broadcast::Sender<ProcessEvent>,
+) {
+    let control_event_capacity = control_event_capacity.max(1);
+    let memory_event_capacity = memory_event_capacity.max(1);
+    let (event_tx, _event_rx) = tokio::sync::broadcast::channel(control_event_capacity);
+    let (memory_event_tx, _memory_event_rx) =
+        tokio::sync::broadcast::channel(memory_event_capacity);
+    (event_tx, memory_event_tx)
+}
+
+/// Track lagged broadcast events and return the dropped count when a warning
+/// should be emitted. Returns `None` when still inside the throttle window.
+pub fn drain_lag_warning_count(
+    lagged_since_last_warning: &mut u64,
+    last_lag_warning: &mut Option<std::time::Instant>,
+    newly_lagged_count: u64,
+    warning_interval: std::time::Duration,
+) -> Option<u64> {
+    *lagged_since_last_warning = lagged_since_last_warning.saturating_add(newly_lagged_count);
+
+    let now = std::time::Instant::now();
+    let should_warn =
+        last_lag_warning.is_none_or(|last| now.saturating_duration_since(last) >= warning_interval);
+
+    if !should_warn {
+        return None;
+    }
+
+    *last_lag_warning = Some(now);
+    Some(std::mem::take(lagged_since_last_warning))
+}
+
+/// A message to be injected into a specific channel from outside the normal
+/// inbound message flow. Used for cross-agent task completion notifications.
+#[derive(Debug, Clone)]
+pub struct ChannelInjection {
+    /// The conversation_id of the target channel.
+    pub conversation_id: String,
+    /// The agent that owns the target channel.
+    pub agent_id: String,
+    /// The message to inject.
+    pub message: InboundMessage,
 }
 
 /// Shared dependency bundle for agent processes.
@@ -194,15 +360,27 @@ pub struct AgentDeps {
     pub memory_search: Arc<memory::MemorySearch>,
     pub llm_manager: Arc<llm::LlmManager>,
     pub mcp_manager: Arc<mcp::McpManager>,
+    pub task_store: Arc<tasks::TaskStore>,
     pub cron_tool: Option<tools::CronTool>,
     pub runtime_config: Arc<config::RuntimeConfig>,
     pub event_tx: tokio::sync::broadcast::Sender<ProcessEvent>,
+    pub memory_event_tx: tokio::sync::broadcast::Sender<ProcessEvent>,
     pub sqlite_pool: sqlx::SqlitePool,
     pub messaging_manager: Option<Arc<messaging::MessagingManager>>,
     pub sandbox: Arc<sandbox::Sandbox>,
     pub links: Arc<arc_swap::ArcSwap<Vec<links::AgentLink>>>,
     /// Map of all agent IDs to display names, for inter-agent message routing.
     pub agent_names: Arc<std::collections::HashMap<String, String>>,
+    /// Cross-agent task store registry. Maps agent_id → TaskStore for agents
+    /// reachable via links. Used by `send_agent_message` to create tasks on
+    /// target agents and by the cortex to look up delegation metadata.
+    /// Populated after all agents are initialized.
+    pub task_store_registry:
+        Arc<arc_swap::ArcSwap<std::collections::HashMap<String, Arc<tasks::TaskStore>>>>,
+    pub process_control_registry: Arc<agent::process_control::ProcessControlRegistry>,
+    /// Sender for injecting messages into channels from outside the normal
+    /// inbound message flow (e.g. cross-agent task completion notifications).
+    pub injection_tx: tokio::sync::mpsc::Sender<ChannelInjection>,
 }
 
 impl AgentDeps {
@@ -227,11 +405,35 @@ pub struct Agent {
     pub deps: AgentDeps,
 }
 
+/// Standard metadata keys set by all adapters.
+///
+/// Adapters set these alongside their platform-specific keys so consumers
+/// can read them without knowing which platform originated the message.
+pub mod metadata_keys {
+    /// Server / workspace / chat group name (e.g. Discord guild, Slack workspace).
+    pub const SERVER_NAME: &str = "server_name";
+    /// Channel / conversation name within the server.
+    pub const CHANNEL_NAME: &str = "channel_name";
+    /// Platform message ID (stringified). Used for reply threading.
+    pub const MESSAGE_ID: &str = "message_id";
+    /// Reply target message ID for outbound reply threading.
+    /// Set on retrigger metadata when a branch/worker completes.
+    pub const REPLY_TO_MESSAGE_ID: &str = "reply_to_message_id";
+    /// Quoted reply text preview from the message being replied to.
+    pub const REPLY_TO_TEXT: &str = "reply_to_text";
+}
+
 /// Inbound message from any messaging platform.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct InboundMessage {
     pub id: String,
     pub source: String,
+    /// Runtime adapter key that received this message.
+    ///
+    /// Defaults to the platform source (`source`) when omitted so older payloads
+    /// and synthetic messages remain compatible.
+    #[serde(default)]
+    pub adapter: Option<String>,
     pub conversation_id: String,
     pub sender_id: String,
     /// Set by the router after binding resolution. None until routed.
@@ -244,6 +446,35 @@ pub struct InboundMessage {
     pub formatted_author: Option<String>,
 }
 
+impl InboundMessage {
+    /// Runtime adapter key for routing outbound operations.
+    ///
+    /// Falls back to the platform source for backward compatibility.
+    pub fn adapter_key(&self) -> &str {
+        self.adapter
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .unwrap_or(&self.source)
+    }
+
+    /// Platform-scoped adapter selector used by bindings.
+    ///
+    /// Returns `None` for the default adapter and `Some(name)` for named
+    /// adapters (e.g. `telegram:support` -> `Some("support")`).
+    pub fn adapter_selector(&self) -> Option<&str> {
+        let adapter_key = self.adapter_key();
+        if adapter_key == self.source {
+            return None;
+        }
+
+        adapter_key
+            .strip_prefix(&self.source)
+            .and_then(|suffix| suffix.strip_prefix(':'))
+            .filter(|name| !name.is_empty())
+    }
+}
+
 /// Message content variants.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -308,6 +539,10 @@ pub struct Attachment {
     pub mime_type: String,
     pub url: String,
     pub size_bytes: Option<u64>,
+    /// Optional auth header value for private URLs (e.g. Slack's `url_private`).
+    /// Excluded from serialization to prevent credential leakage.
+    #[serde(skip)]
+    pub auth_header: Option<String>,
 }
 
 /// Outbound response to messaging platforms.
@@ -377,6 +612,62 @@ pub enum OutboundResponse {
     Status(StatusUpdate),
 }
 
+impl OutboundResponse {
+    /// Ensure `RichMessage` variants have a non-empty `text` fallback.
+    ///
+    /// Some LLMs emit card-only payloads with empty content. This derives a
+    /// readable plaintext fallback from cards so adapters that don't support
+    /// rich formatting (or use `text` for notifications) always have content.
+    pub fn ensure_text_fallback(&mut self) {
+        if let OutboundResponse::RichMessage { text, cards, .. } = self
+            && text.trim().is_empty()
+        {
+            let derived = Self::text_from_cards(cards);
+            if !derived.trim().is_empty() {
+                *text = derived;
+            }
+        }
+    }
+
+    /// Derive a plaintext representation from a slice of [`Card`]s.
+    ///
+    /// Used as a fallback when the LLM provides cards but no text content.
+    /// Adapters can call this directly when they destructure `RichMessage`
+    /// and need a text fallback without reconstructing the enum.
+    pub fn text_from_cards(cards: &[Card]) -> String {
+        let mut sections = Vec::new();
+        for card in cards {
+            let mut lines = Vec::new();
+            if let Some(title) = &card.title
+                && !title.trim().is_empty()
+            {
+                lines.push(title.trim().to_string());
+            }
+            if let Some(description) = &card.description
+                && !description.trim().is_empty()
+            {
+                lines.push(description.trim().to_string());
+            }
+            for field in &card.fields {
+                let name = field.name.trim();
+                let value = field.value.trim();
+                if !name.is_empty() || !value.is_empty() {
+                    lines.push(format!("{name}\n{value}").trim().to_string());
+                }
+            }
+            if let Some(footer) = &card.footer
+                && !footer.trim().is_empty()
+            {
+                lines.push(footer.trim().to_string());
+            }
+            if !lines.is_empty() {
+                sections.push(lines.join("\n\n"));
+            }
+        }
+        sections.join("\n\n")
+    }
+}
+
 /// A generic rich-formatted card (maps to Embeds in Discord).
 #[derive(Debug, Clone, Serialize, Deserialize, Default, schemars::JsonSchema)]
 pub struct Card {
diff --git a/src/llm/anthropic/auth.rs b/src/llm/anthropic/auth.rs
index 87ae7c5cb..ec6efcf13 100644
--- a/src/llm/anthropic/auth.rs
+++ b/src/llm/anthropic/auth.rs
@@ -88,11 +88,19 @@ pub enum AnthropicAuthPath {
     ApiKey,
     /// OAuth token (sk-ant-oat*) — uses Bearer auth with Claude Code identity.
     OAuthToken,
+    /// Proxy bearer token — uses `Authorization: Bearer` without Claude Code
+    /// identity headers. Used when key originates from `ANTHROPIC_AUTH_TOKEN`.
+    ProxyBearer,
 }
 
 /// Detect the auth path from a token's prefix.
-pub fn detect_auth_path(token: &str) -> AnthropicAuthPath {
-    if token.starts_with("sk-ant-oat") {
+///
+/// If `force_bearer` is true (key came from `ANTHROPIC_AUTH_TOKEN`),
+/// returns `ProxyBearer` regardless of prefix.
+pub fn detect_auth_path(token: &str, force_bearer: bool) -> AnthropicAuthPath {
+    if force_bearer {
+        AnthropicAuthPath::ProxyBearer
+    } else if token.starts_with("sk-ant-oat") {
         AnthropicAuthPath::OAuthToken
     } else {
         AnthropicAuthPath::ApiKey
@@ -107,8 +115,9 @@ pub fn apply_auth_headers(
     builder: RequestBuilder,
     token: &str,
     interleaved_thinking: bool,
+    force_bearer: bool,
 ) -> (RequestBuilder, AnthropicAuthPath) {
-    let auth_path = detect_auth_path(token);
+    let auth_path = detect_auth_path(token, force_bearer);
 
     let mut beta_parts: Vec<&str> = Vec::new();
     let builder = match auth_path {
@@ -125,6 +134,10 @@ pub fn apply_auth_headers(
                 .header("user-agent", CLAUDE_CODE_USER_AGENT)
                 .header("x-app", "cli")
         }
+        AnthropicAuthPath::ProxyBearer => {
+            beta_parts.push(BETA_FINE_GRAINED_STREAMING);
+            builder.header("Authorization", format!("Bearer {token}"))
+        }
     };
 
     if interleaved_thinking {
@@ -142,16 +155,24 @@ mod tests {
     use super::*;
 
     fn build_request(token: &str, thinking: bool) -> (reqwest::Request, AnthropicAuthPath) {
+        build_request_with_bearer(token, thinking, false)
+    }
+
+    fn build_request_with_bearer(
+        token: &str,
+        thinking: bool,
+        force_bearer: bool,
+    ) -> (reqwest::Request, AnthropicAuthPath) {
         let client = reqwest::Client::new();
         let builder = client.post("https://api.anthropic.com/v1/messages");
-        let (builder, auth_path) = apply_auth_headers(builder, token, thinking);
+        let (builder, auth_path) = apply_auth_headers(builder, token, thinking, force_bearer);
         (builder.build().unwrap(), auth_path)
     }
 
     #[test]
     fn oauth_token_detected_correctly() {
         assert_eq!(
-            detect_auth_path("sk-ant-oat01-abc123"),
+            detect_auth_path("sk-ant-oat01-abc123", false),
             AnthropicAuthPath::OAuthToken
         );
     }
@@ -159,7 +180,7 @@ mod tests {
     #[test]
     fn api_key_detected_correctly() {
         assert_eq!(
-            detect_auth_path("sk-ant-api03-xyz789"),
+            detect_auth_path("sk-ant-api03-xyz789", false),
             AnthropicAuthPath::ApiKey
         );
     }
@@ -167,11 +188,23 @@ mod tests {
     #[test]
     fn unknown_prefix_defaults_to_api_key() {
         assert_eq!(
-            detect_auth_path("some-random-key"),
+            detect_auth_path("some-random-key", false),
             AnthropicAuthPath::ApiKey
         );
     }
 
+    #[test]
+    fn force_bearer_overrides_prefix() {
+        assert_eq!(
+            detect_auth_path("sk-ant-api03-xyz789", true),
+            AnthropicAuthPath::ProxyBearer
+        );
+        assert_eq!(
+            detect_auth_path("some-proxy-token", true),
+            AnthropicAuthPath::ProxyBearer
+        );
+    }
+
     #[test]
     fn oauth_token_uses_bearer_header() {
         let (request, auth_path) = build_request("sk-ant-oat01-abc123", false);
@@ -247,4 +280,41 @@ mod tests {
             .unwrap();
         assert!(!beta.contains(BETA_INTERLEAVED_THINKING));
     }
+
+    #[test]
+    fn proxy_bearer_uses_bearer_header() {
+        let (request, auth_path) = build_request_with_bearer("my-proxy-token", false, true);
+        assert_eq!(auth_path, AnthropicAuthPath::ProxyBearer);
+        assert_eq!(
+            request.headers().get("Authorization").unwrap(),
+            "Bearer my-proxy-token"
+        );
+        assert!(request.headers().get("x-api-key").is_none());
+    }
+
+    #[test]
+    fn proxy_bearer_has_no_identity_headers() {
+        let (request, _) = build_request_with_bearer("my-proxy-token", false, true);
+        assert!(request.headers().get("x-app").is_none());
+        // Should not have Claude Code user-agent
+        let ua = request
+            .headers()
+            .get("user-agent")
+            .map(|v| v.to_str().unwrap().to_string());
+        assert!(ua.is_none() || !ua.unwrap().contains("claude-code"));
+    }
+
+    #[test]
+    fn proxy_bearer_has_streaming_beta_but_not_oauth() {
+        let (request, _) = build_request_with_bearer("my-proxy-token", false, true);
+        let beta = request
+            .headers()
+            .get("anthropic-beta")
+            .unwrap()
+            .to_str()
+            .unwrap();
+        assert!(beta.contains(BETA_FINE_GRAINED_STREAMING));
+        assert!(!beta.contains(BETA_OAUTH));
+        assert!(!beta.contains(BETA_CLAUDE_CODE));
+    }
 }
diff --git a/src/llm/anthropic/params.rs b/src/llm/anthropic/params.rs
index 2f45462af..11dcda8ef 100644
--- a/src/llm/anthropic/params.rs
+++ b/src/llm/anthropic/params.rs
@@ -58,8 +58,9 @@ pub fn build_anthropic_request(
     model_name: &str,
     request: &CompletionRequest,
     thinking_effort: &str,
+    force_bearer: bool,
 ) -> AnthropicRequest {
-    let is_oauth = auth::detect_auth_path(api_key) == AnthropicAuthPath::OAuthToken;
+    let is_oauth = auth::detect_auth_path(api_key, force_bearer) == AnthropicAuthPath::OAuthToken;
     let adaptive_thinking = supports_adaptive_thinking(model_name);
     let retention = cache::resolve_cache_retention(None);
     let url = messages_url(base_url);
@@ -101,7 +102,7 @@ pub fn build_anthropic_request(
         .header("anthropic-version", "2023-06-01")
         .header("content-type", "application/json");
 
-    let (builder, auth_path) = auth::apply_auth_headers(builder, api_key, false);
+    let (builder, auth_path) = auth::apply_auth_headers(builder, api_key, false, force_bearer);
     let builder = builder.json(&body);
 
     AnthropicRequest {
diff --git a/src/llm/manager.rs b/src/llm/manager.rs
index 4febe761d..1f1edb14f 100644
--- a/src/llm/manager.rs
+++ b/src/llm/manager.rs
@@ -185,6 +185,8 @@ impl LlmManager {
                 base_url: "https://api.anthropic.com".to_string(),
                 api_key: token,
                 name: None,
+                use_bearer_auth: false,
+                extra_headers: vec![],
             }),
             (None, None) => Err(LlmError::UnknownProvider("anthropic".to_string()).into()),
         }
@@ -253,6 +255,8 @@ impl LlmManager {
                 base_url: "https://chatgpt.com/backend-api/codex".to_string(),
                 api_key: token,
                 name: None,
+                use_bearer_auth: false,
+                extra_headers: vec![],
             }),
             None => Err(LlmError::UnknownProvider("openai-chatgpt".to_string()).into()),
         }
@@ -289,12 +293,20 @@ impl LlmManager {
     }
 
     /// Resolve a model name to provider and model components.
-    /// Format: "provider/model-name" or just "model-name" (defaults to anthropic).
+    /// Format: "provider/model-name" or just "model-name" (defaults to openai for voice models).
     pub fn resolve_model(&self, model_name: &str) -> Result<(String, String)> {
         if let Some((provider, model)) = model_name.split_once('/') {
+            tracing::debug!(provider = %provider, model = %model, "resolved model with explicit provider");
             Ok((provider.to_string(), model.to_string()))
         } else {
-            Ok(("anthropic".into(), model_name.into()))
+            // Default to openai for voice models (most common for Whisper/vision)
+            // rather than anthropic, since anthropic doesn't support input_audio
+            tracing::debug!(
+                model = %model_name,
+                "no provider prefix specified in model name, defaulting to 'openai'. \
+                 Specify as 'provider/model' (e.g., 'openai/whisper-1') to use a different provider."
+            );
+            Ok(("openai".into(), model_name.into()))
         }
     }
 
diff --git a/src/llm/model.rs b/src/llm/model.rs
index c2a166dd0..c74a76c4d 100644
--- a/src/llm/model.rs
+++ b/src/llm/model.rs
@@ -6,32 +6,36 @@ use crate::llm::routing::{
     self, MAX_FALLBACK_ATTEMPTS, MAX_RETRIES_PER_MODEL, RETRY_BASE_DELAY_MS, RoutingConfig,
 };
 
+use futures::StreamExt as _;
 use rig::completion::{self, CompletionError, CompletionModel, CompletionRequest, GetTokenUsage};
 use rig::message::{
     AssistantContent, DocumentSourceKind, Image, Message, MimeType, Text, ToolCall, ToolFunction,
     UserContent,
 };
 use rig::one_or_many::OneOrMany;
-use rig::streaming::StreamingCompletionResponse;
+use rig::streaming::{RawStreamingChoice, RawStreamingToolCall, StreamingCompletionResponse};
 use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
 use std::sync::Arc;
 
+const STREAM_REQUEST_TIMEOUT_SECS: u64 = 30 * 60;
+
 /// Raw provider response. Wraps the JSON so Rig can carry it through.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct RawResponse {
     pub body: serde_json::Value,
 }
 
-/// Streaming response placeholder. Streaming will be implemented per-provider
-/// when we wire up SSE parsing.
+/// Streaming response wrapper for token usage and raw provider payload.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct RawStreamingResponse {
     pub body: serde_json::Value,
+    pub usage: Option<completion::Usage>,
 }
 
 impl GetTokenUsage for RawStreamingResponse {
     fn token_usage(&self) -> Option<completion::Usage> {
-        None
+        self.usage
     }
 }
 
@@ -78,62 +82,86 @@ impl SpacebotModel {
         self
     }
 
-    /// Direct call to the provider (no fallback logic).
-    async fn attempt_completion(
-        &self,
-        request: CompletionRequest,
-    ) -> Result<completion::CompletionResponse<RawResponse>, CompletionError> {
+    async fn provider_config_for_current_model(&self) -> Result<ProviderConfig, CompletionError> {
         let provider_id = self
             .full_model_name
             .split_once('/')
             .map(|(provider, _)| provider)
             .unwrap_or("anthropic");
 
-        let provider_config = match provider_id {
+        match provider_id {
             "anthropic" => self
                 .llm_manager
                 .get_anthropic_provider()
                 .await
-                .map_err(|e| CompletionError::ProviderError(e.to_string()))?,
+                .map_err(|error| CompletionError::ProviderError(error.to_string())),
             "openai" => self
                 .llm_manager
                 .get_openai_provider()
                 .await
-                .map_err(|e| CompletionError::ProviderError(e.to_string()))?,
+                .map_err(|error| CompletionError::ProviderError(error.to_string())),
             "openai-chatgpt" => self
                 .llm_manager
                 .get_openai_chatgpt_provider()
                 .await
-                .map_err(|e| CompletionError::ProviderError(e.to_string()))?,
+                .map_err(|error| CompletionError::ProviderError(error.to_string())),
             _ => self
                 .llm_manager
                 .get_provider(provider_id)
-                .map_err(|e| CompletionError::ProviderError(e.to_string()))?,
-        };
+                .map_err(|error| CompletionError::ProviderError(error.to_string())),
+        }
+    }
 
-        if provider_id == "zai-coding-plan" || provider_id == "zhipu" {
-            let display_name = if provider_id == "zhipu" {
-                "Z.AI (GLM)"
-            } else {
-                "Z.AI Coding Plan"
-            };
-            let endpoint = format!(
-                "{}/chat/completions",
-                provider_config.base_url.trim_end_matches('/')
-            );
-            return self
-                .call_openai_compatible_with_optional_auth(
+    /// Direct call to the provider (no fallback logic).
+    async fn attempt_completion(
+        &self,
+        request: CompletionRequest,
+    ) -> Result<completion::CompletionResponse<RawResponse>, CompletionError> {
+        let provider_config = self.provider_config_for_current_model().await?;
+
+        match provider_config.api_type {
+            ApiType::Anthropic => self.call_anthropic(request, &provider_config).await,
+            ApiType::OpenAiCompletions => self.call_openai(request, &provider_config).await,
+            ApiType::OpenAiChatCompletions => {
+                let endpoint = format!(
+                    "{}/chat/completions",
+                    provider_config.base_url.trim_end_matches('/')
+                );
+                let display_name = provider_config
+                    .name
+                    .as_deref()
+                    .unwrap_or("OpenAI-compatible provider");
+                let headers: Vec<(&str, &str)> = provider_config
+                    .extra_headers
+                    .iter()
+                    .map(|(k, v)| (k.as_str(), v.as_str()))
+                    .collect();
+                self.call_openai_compatible_with_optional_auth(
                     request,
                     display_name,
                     &endpoint,
                     Some(provider_config.api_key.clone()),
+                    &headers,
                 )
-                .await;
-        }
-
-        match provider_config.api_type {
-            ApiType::Anthropic => self.call_anthropic(request, &provider_config).await,
-            ApiType::OpenAiCompletions => self.call_openai(request, &provider_config).await,
+                .await
+            }
+            ApiType::KiloGateway => {
+                let endpoint = format!(
+                    "{}/chat/completions",
+                    provider_config.base_url.trim_end_matches('/')
+                );
+                self.call_openai_compatible_with_optional_auth(
+                    request,
+                    "Kilo Gateway",
+                    &endpoint,
+                    Some(provider_config.api_key.clone()),
+                    &[
+                        ("HTTP-Referer", "https://github.com/spacedriveapp/spacebot"),
+                        ("X-Title", "spacebot"),
+                    ],
+                )
+                .await
+            }
             ApiType::OpenAiResponses => self.call_openai_responses(request, &provider_config).await,
             ApiType::Gemini => {
                 self.call_openai_compatible(request, "Google Gemini", &provider_config)
@@ -422,11 +450,61 @@ impl CompletionModel for SpacebotModel {
 
     async fn stream(
         &self,
-        _request: CompletionRequest,
+        request: CompletionRequest,
     ) -> Result<StreamingCompletionResponse<RawStreamingResponse>, CompletionError> {
-        Err(CompletionError::ProviderError(
-            "streaming not yet implemented".into(),
-        ))
+        let provider_config = self.provider_config_for_current_model().await?;
+
+        match provider_config.api_type {
+            ApiType::OpenAiCompletions => self.stream_openai(request, &provider_config).await,
+            ApiType::OpenAiChatCompletions => {
+                let endpoint = format!(
+                    "{}/chat/completions",
+                    provider_config.base_url.trim_end_matches('/')
+                );
+                let display_name = provider_config
+                    .name
+                    .as_deref()
+                    .unwrap_or("OpenAI-compatible provider");
+                let headers: Vec<(&str, &str)> = provider_config
+                    .extra_headers
+                    .iter()
+                    .map(|(key, value)| (key.as_str(), value.as_str()))
+                    .collect();
+                self.stream_openai_compatible_with_optional_auth(
+                    request,
+                    display_name,
+                    &endpoint,
+                    Some(provider_config.api_key.clone()),
+                    &headers,
+                )
+                .await
+            }
+            ApiType::KiloGateway => {
+                let endpoint = format!(
+                    "{}/chat/completions",
+                    provider_config.base_url.trim_end_matches('/')
+                );
+                self.stream_openai_compatible_with_optional_auth(
+                    request,
+                    "Kilo Gateway",
+                    &endpoint,
+                    Some(provider_config.api_key.clone()),
+                    &[
+                        ("HTTP-Referer", "https://github.com/spacedriveapp/spacebot"),
+                        ("X-Title", "spacebot"),
+                    ],
+                )
+                .await
+            }
+            ApiType::Gemini => {
+                self.stream_openai_compatible(request, "Google Gemini", &provider_config)
+                    .await
+            }
+            ApiType::Anthropic | ApiType::OpenAiResponses => {
+                let response = self.attempt_completion(request).await?;
+                Ok(stream_from_completion_response(response))
+            }
+        }
     }
 }
 
@@ -450,6 +528,7 @@ impl SpacebotModel {
             &self.model_name,
             &request,
             effort,
+            provider_config.use_bearer_auth,
         );
 
         let is_oauth =
@@ -499,7 +578,22 @@ impl SpacebotModel {
         request: CompletionRequest,
         provider_config: &ProviderConfig,
     ) -> Result<completion::CompletionResponse<RawResponse>, CompletionError> {
+        let stream = self.stream_openai(request, provider_config).await?;
+        collect_streaming_completion_response(stream).await
+    }
+
+    async fn stream_openai(
+        &self,
+        request: CompletionRequest,
+        provider_config: &ProviderConfig,
+    ) -> Result<StreamingCompletionResponse<RawStreamingResponse>, CompletionError> {
         let api_key = provider_config.api_key.as_str();
+        let provider_label = provider_config
+            .name
+            .as_deref()
+            .filter(|name| !name.trim().is_empty())
+            .map(ToOwned::to_owned)
+            .unwrap_or_else(|| provider_display_name(&self.provider));
 
         let mut messages = Vec::new();
 
@@ -512,8 +606,9 @@ impl SpacebotModel {
 
         messages.extend(convert_messages_to_openai(&request.chat_history));
 
+        let api_model_name = self.remap_model_name_for_api();
         let mut body = serde_json::json!({
-            "model": self.model_name,
+            "model": api_model_name,
             "messages": messages,
         });
 
@@ -553,51 +648,37 @@ impl SpacebotModel {
             None
         };
 
-        let mut request_builder = self
-            .llm_manager
-            .http_client()
-            .post(&chat_completions_url)
-            .header("authorization", format!("Bearer {api_key}"))
-            .header("content-type", "application/json");
-        if let Some(account_id) = openai_account_id {
-            request_builder = request_builder.header("chatgpt-account-id", account_id);
-        }
-
-        // Kimi endpoints require a specific user-agent header.
-        if chat_completions_url.contains("kimi.com") || chat_completions_url.contains("moonshot.ai")
-        {
-            request_builder = request_builder.header("user-agent", "KimiCLI/1.3");
-        }
-
-        let response = request_builder
-            .json(&body)
-            .send()
-            .await
-            .map_err(|e| CompletionError::ProviderError(e.to_string()))?;
-
-        let status = response.status();
-        let response_text = response.text().await.map_err(|e| {
-            CompletionError::ProviderError(format!("failed to read response body: {e}"))
-        })?;
+        let http_client = self.llm_manager.http_client().clone();
+        let auth_header = format!("Bearer {api_key}");
+        let extra_headers = provider_config.extra_headers.clone();
+        let is_kimi_endpoint = chat_completions_url.contains("kimi.com")
+            || chat_completions_url.contains("moonshot.ai");
+
+        self.stream_openai_chat_request(
+            move |request_body| {
+                let mut request_builder = http_client
+                    .post(&chat_completions_url)
+                    .header("authorization", auth_header.clone())
+                    .header("content-type", "application/json");
+
+                if let Some(account_id) = openai_account_id.as_deref() {
+                    request_builder = request_builder.header("chatgpt-account-id", account_id);
+                }
 
-        let response_body: serde_json::Value =
-            serde_json::from_str(&response_text).map_err(|e| {
-                CompletionError::ProviderError(format!(
-                    "OpenAI response ({status}) is not valid JSON: {e}\nBody: {}",
-                    truncate_body(&response_text)
-                ))
-            })?;
+                if is_kimi_endpoint {
+                    request_builder = request_builder.header("user-agent", "KimiCLI/1.3");
+                }
 
-        if !status.is_success() {
-            let message = response_body["error"]["message"]
-                .as_str()
-                .unwrap_or("unknown error");
-            return Err(CompletionError::ProviderError(format!(
-                "OpenAI API error ({status}): {message}"
-            )));
-        }
+                for (key, value) in &extra_headers {
+                    request_builder = request_builder.header(key, value);
+                }
 
-        parse_openai_response(response_body, "OpenAI")
+                request_builder.json(request_body)
+            },
+            body,
+            &provider_label,
+        )
+        .await
     }
 
     async fn call_openai_responses(
@@ -613,11 +694,18 @@ impl SpacebotModel {
             format!("{base_url}/v1/responses")
         };
         let api_key = provider_config.api_key.as_str();
+        let provider_label = provider_config
+            .name
+            .as_deref()
+            .filter(|name| !name.trim().is_empty())
+            .map(ToOwned::to_owned)
+            .unwrap_or_else(|| provider_display_name(&self.provider));
 
         let input = convert_messages_to_openai_responses(&request.chat_history);
 
+        let api_model_name = self.remap_model_name_for_api();
         let mut body = serde_json::json!({
-            "model": self.model_name,
+            "model": api_model_name,
             "input": input,
         });
 
@@ -701,22 +789,22 @@ impl SpacebotModel {
             let message = parse_openai_error_message(&response_text)
                 .unwrap_or_else(|| "unknown error".to_string());
             return Err(CompletionError::ProviderError(format!(
-                "OpenAI Responses API error ({status}): {message}"
+                "{provider_label} Responses API error ({status}): {message}"
             )));
         }
 
         let response_body: serde_json::Value = if is_chatgpt_codex {
-            parse_openai_responses_sse_response(&response_text)?
+            parse_openai_responses_sse_response(&response_text, &provider_label)?
         } else {
             serde_json::from_str(&response_text).map_err(|e| {
                 CompletionError::ProviderError(format!(
-                    "OpenAI Responses API response ({status}) is not valid JSON: {e}\nBody: {}",
+                    "{provider_label} Responses API response ({status}) is not valid JSON: {e}\nBody: {}",
                     truncate_body(&response_text)
                 ))
             })?
         };
 
-        parse_openai_responses_response(response_body)
+        parse_openai_responses_response(response_body, &provider_label)
     }
 
     /// Generic OpenAI-compatible API call.
@@ -728,15 +816,33 @@ impl SpacebotModel {
         provider_display_name: &str,
         provider_config: &ProviderConfig,
     ) -> Result<completion::CompletionResponse<RawResponse>, CompletionError> {
+        let stream = self
+            .stream_openai_compatible(request, provider_display_name, provider_config)
+            .await?;
+        collect_streaming_completion_response(stream).await
+    }
+
+    async fn stream_openai_compatible(
+        &self,
+        request: CompletionRequest,
+        provider_display_name: &str,
+        provider_config: &ProviderConfig,
+    ) -> Result<StreamingCompletionResponse<RawStreamingResponse>, CompletionError> {
         let base_url = provider_config.base_url.trim_end_matches('/');
         let endpoint_path = match provider_config.api_type {
             ApiType::OpenAiCompletions | ApiType::OpenAiResponses => "/v1/chat/completions",
-            ApiType::Gemini => "/chat/completions",
+            ApiType::OpenAiChatCompletions | ApiType::Gemini => "/chat/completions",
             ApiType::Anthropic => {
                 return Err(CompletionError::ProviderError(format!(
                     "{provider_display_name} is configured with anthropic API type, but this call expects an OpenAI-compatible API"
                 )));
             }
+            _ => {
+                return Err(CompletionError::ProviderError(format!(
+                    "{provider_display_name} uses API type {:?} which does not support OpenAI-compatible calls",
+                    provider_config.api_type
+                )));
+            }
         };
         let endpoint = format!("{base_url}{endpoint_path}");
         let api_key = provider_config.api_key.as_str();
@@ -783,40 +889,25 @@ impl SpacebotModel {
             body["tools"] = serde_json::json!(tools);
         }
 
-        let response = self
-            .llm_manager
-            .http_client()
-            .post(&endpoint)
-            .header("authorization", format!("Bearer {api_key}"))
-            .header("content-type", "application/json")
-            .json(&body)
-            .send()
-            .await
-            .map_err(|e| CompletionError::ProviderError(e.to_string()))?;
-
-        let status = response.status();
-        let response_text = response.text().await.map_err(|e| {
-            CompletionError::ProviderError(format!("failed to read response body: {e}"))
-        })?;
-
-        let response_body: serde_json::Value =
-            serde_json::from_str(&response_text).map_err(|e| {
-                CompletionError::ProviderError(format!(
-                    "{provider_display_name} response ({status}) is not valid JSON: {e}\nBody: {}",
-                    truncate_body(&response_text)
-                ))
-            })?;
-
-        if !status.is_success() {
-            let message = response_body["error"]["message"]
-                .as_str()
-                .unwrap_or("unknown error");
-            return Err(CompletionError::ProviderError(format!(
-                "{provider_display_name} API error ({status}): {message}"
-            )));
-        }
+        let http_client = self.llm_manager.http_client().clone();
+        let auth_header = format!("Bearer {api_key}");
+        self.stream_openai_chat_request(
+            move |request_body| {
+                http_client
+                    .post(&endpoint)
+                    .header("authorization", auth_header.clone())
+                    .header("content-type", "application/json")
+                    .json(request_body)
+            },
+            body,
+            provider_display_name,
+        )
+        .await
+    }
 
-        parse_openai_response(response_body, provider_display_name)
+    /// Remap model name for providers that require a different format in API calls.
+    fn remap_model_name_for_api(&self) -> String {
+        remap_model_name_for_api(&self.provider, &self.model_name)
     }
 
     /// Generic OpenAI-compatible API call with optional bearer auth.
@@ -826,7 +917,28 @@ impl SpacebotModel {
         provider_display_name: &str,
         endpoint: &str,
         api_key: Option<String>,
+        extra_headers: &[(&str, &str)],
     ) -> Result<completion::CompletionResponse<RawResponse>, CompletionError> {
+        let stream = self
+            .stream_openai_compatible_with_optional_auth(
+                request,
+                provider_display_name,
+                endpoint,
+                api_key,
+                extra_headers,
+            )
+            .await?;
+        collect_streaming_completion_response(stream).await
+    }
+
+    async fn stream_openai_compatible_with_optional_auth(
+        &self,
+        request: CompletionRequest,
+        provider_display_name: &str,
+        endpoint: &str,
+        api_key: Option<String>,
+        extra_headers: &[(&str, &str)],
+    ) -> Result<StreamingCompletionResponse<RawStreamingResponse>, CompletionError> {
         let mut messages = Vec::new();
 
         if let Some(preamble) = &request.preamble {
@@ -838,8 +950,9 @@ impl SpacebotModel {
 
         messages.extend(convert_messages_to_openai(&request.chat_history));
 
+        let api_model_name = self.remap_model_name_for_api();
         let mut body = serde_json::json!({
-            "model": self.model_name,
+            "model": api_model_name,
             "messages": messages,
         });
 
@@ -869,44 +982,219 @@ impl SpacebotModel {
             body["tools"] = serde_json::json!(tools);
         }
 
-        let response = self.llm_manager.http_client().post(endpoint);
+        let http_client = self.llm_manager.http_client().clone();
+        let endpoint = endpoint.to_string();
+        let auth_header = api_key.map(|key| format!("Bearer {key}"));
+        let extra_headers: Vec<(String, String)> = extra_headers
+            .iter()
+            .map(|(name, value)| ((*name).to_string(), (*value).to_string()))
+            .collect();
 
-        let response = if let Some(api_key) = api_key {
-            response.header("authorization", format!("Bearer {api_key}"))
-        } else {
-            response
-        };
+        self.stream_openai_chat_request(
+            move |request_body| {
+                let mut request_builder = http_client.post(&endpoint);
 
-        let response = response
-            .header("content-type", "application/json")
-            .json(&body)
+                for (header_name, header_value) in &extra_headers {
+                    request_builder = request_builder.header(header_name, header_value);
+                }
+
+                if let Some(auth_header) = auth_header.as_deref() {
+                    request_builder = request_builder.header("authorization", auth_header);
+                }
+
+                request_builder
+                    .header("content-type", "application/json")
+                    .json(request_body)
+            },
+            body,
+            provider_display_name,
+        )
+        .await
+    }
+
+    async fn stream_openai_chat_request<F>(
+        &self,
+        mut build_request: F,
+        request_body: serde_json::Value,
+        provider_label: &str,
+    ) -> Result<StreamingCompletionResponse<RawStreamingResponse>, CompletionError>
+    where
+        F: FnMut(&serde_json::Value) -> reqwest::RequestBuilder,
+    {
+        let stream_request_body = with_streaming_enabled(&request_body);
+        let response = build_request(&stream_request_body)
+            .header("accept-encoding", "identity")
+            .timeout(std::time::Duration::from_secs(STREAM_REQUEST_TIMEOUT_SECS))
             .send()
             .await
-            .map_err(|e| CompletionError::ProviderError(e.to_string()))?;
+            .map_err(|error| CompletionError::ProviderError(error.to_string()))?;
 
         let status = response.status();
-        let response_text = response.text().await.map_err(|e| {
-            CompletionError::ProviderError(format!("failed to read response body: {e}"))
-        })?;
-
-        let response_body: serde_json::Value =
-            serde_json::from_str(&response_text).map_err(|e| {
-                CompletionError::ProviderError(format!(
-                    "{provider_display_name} response ({status}) is not valid JSON: {e}\nBody: {}",
-                    truncate_body(&response_text)
-                ))
-            })?;
-
         if !status.is_success() {
-            let message = response_body["error"]["message"]
-                .as_str()
-                .unwrap_or("unknown error");
+            let response_text = response
+                .text()
+                .await
+                .unwrap_or_else(|error| format!("failed to read error response body: {error}"));
+
             return Err(CompletionError::ProviderError(format!(
-                "{provider_display_name} API error ({status}): {message}"
+                "{provider_label} API error ({})",
+                format_api_error_from_response_text(status, &response_text)
             )));
         }
 
-        parse_openai_response(response_body, provider_display_name)
+        let provider_label = provider_label.to_string();
+        let stream = async_stream::stream! {
+            let mut stream = response.bytes_stream();
+            let mut block_buffer = String::new();
+            let mut raw_text = String::new();
+            let mut sse_text = String::new();
+            let mut saw_data_event = false;
+            let mut pending_tool_calls: BTreeMap<usize, OpenAiStreamingToolCall> = BTreeMap::new();
+
+            while let Some(chunk_result) = stream.next().await {
+                let chunk = match chunk_result {
+                    Ok(bytes) => bytes,
+                    Err(error) => {
+                        yield Err(CompletionError::ProviderError(format!(
+                            "{provider_label} stream read failed: {error}"
+                        )));
+                        return;
+                    }
+                };
+
+                let chunk_text = String::from_utf8_lossy(&chunk).to_string();
+                if !saw_data_event {
+                    raw_text.push_str(&chunk_text);
+                }
+                block_buffer.push_str(&chunk_text);
+
+                while let Some(block) = extract_sse_block(&mut block_buffer) {
+                    sse_text.push_str(&block);
+                    sse_text.push_str("\n\n");
+
+                    let Some(data) = extract_sse_data_payload(&block) else {
+                        continue;
+                    };
+                    let data = data.trim();
+                    if data.is_empty() || data == "[DONE]" {
+                        continue;
+                    }
+
+                    saw_data_event = true;
+
+                    let event_body = match serde_json::from_str::<serde_json::Value>(data) {
+                        Ok(body) => body,
+                        Err(error) => {
+                            tracing::trace!(%error, payload = %data, "failed to parse OpenAI SSE chunk");
+                            continue;
+                        }
+                    };
+
+                    match process_openai_chat_stream_event(&event_body, &mut pending_tool_calls) {
+                        Ok(events) => {
+                            for event in events {
+                                yield Ok(event);
+                            }
+                        }
+                        Err(error) => {
+                            yield Err(error);
+                            return;
+                        }
+                    }
+                }
+            }
+
+            if !block_buffer.trim().is_empty()
+                && let Some(data) = extract_sse_data_payload(&block_buffer)
+            {
+                let data = data.trim();
+                if !data.is_empty() && data != "[DONE]" {
+                    saw_data_event = true;
+                    if let Ok(event_body) = serde_json::from_str::<serde_json::Value>(data) {
+                        match process_openai_chat_stream_event(&event_body, &mut pending_tool_calls) {
+                            Ok(events) => {
+                                for event in events {
+                                    yield Ok(event);
+                                }
+                            }
+                            Err(error) => {
+                                yield Err(error);
+                                return;
+                            }
+                        }
+                    }
+                }
+            }
+
+            match flush_openai_streaming_tool_calls(&mut pending_tool_calls) {
+                Ok(events) => {
+                    for event in events {
+                        yield Ok(event);
+                    }
+                }
+                Err(error) => {
+                    yield Err(error);
+                    return;
+                }
+            }
+
+            if saw_data_event {
+                let response_body = match parse_openai_chat_sse_response(&sse_text, &provider_label) {
+                    Ok(body) => body,
+                    Err(error) => {
+                        yield Err(error);
+                        return;
+                    }
+                };
+
+                let parsed_response = match parse_openai_response(response_body.clone(), &provider_label) {
+                    Ok(response) => response,
+                    Err(error) => {
+                        yield Err(error);
+                        return;
+                    }
+                };
+
+                yield Ok(RawStreamingChoice::FinalResponse(RawStreamingResponse {
+                    body: response_body,
+                    usage: Some(parsed_response.usage),
+                }));
+                return;
+            }
+
+            let response_body = match serde_json::from_str::<serde_json::Value>(&raw_text) {
+                Ok(body) => body,
+                Err(error) => {
+                    yield Err(CompletionError::ProviderError(format!(
+                        "{provider_label} response is neither SSE nor JSON: {error}. Body: {}",
+                        truncate_body(&raw_text)
+                    )));
+                    return;
+                }
+            };
+
+            let parsed_response = match parse_openai_response(response_body.clone(), &provider_label) {
+                Ok(response) => response,
+                Err(error) => {
+                    yield Err(error);
+                    return;
+                }
+            };
+
+            for event in completion_choice_to_streaming_choices(&parsed_response.choice) {
+                yield Ok(event);
+            }
+            if let Some(message_id) = parsed_response.message_id {
+                yield Ok(RawStreamingChoice::MessageId(message_id));
+            }
+
+            yield Ok(RawStreamingChoice::FinalResponse(RawStreamingResponse {
+                body: response_body,
+                usage: Some(parsed_response.usage),
+            }));
+        };
+
+        Ok(StreamingCompletionResponse::stream(Box::pin(stream)))
     }
 }
 // --- Helpers ---
@@ -941,14 +1229,13 @@ fn tool_result_content_to_string(content: &OneOrMany<rig::message::ToolResultCon
 pub fn convert_messages_to_anthropic(messages: &OneOrMany<Message>) -> Vec<serde_json::Value> {
     messages
         .iter()
-        .map(|message| match message {
+        .filter_map(|message| match message {
             Message::User { content } => {
                 let parts: Vec<serde_json::Value> = content
                     .iter()
                     .filter_map(|c| match c {
-                        UserContent::Text(t) => {
-                            Some(serde_json::json!({"type": "text", "text": t.text}))
-                        }
+                        UserContent::Text(t) => (!t.text.trim().is_empty())
+                            .then(|| serde_json::json!({"type": "text", "text": t.text})),
                         UserContent::Image(image) => convert_image_anthropic(image),
                         UserContent::ToolResult(result) => Some(serde_json::json!({
                             "type": "tool_result",
@@ -958,15 +1245,14 @@ pub fn convert_messages_to_anthropic(messages: &OneOrMany<Message>) -> Vec<serde
                         _ => None,
                     })
                     .collect();
-                serde_json::json!({"role": "user", "content": parts})
+                (!parts.is_empty()).then(|| serde_json::json!({"role": "user", "content": parts}))
             }
             Message::Assistant { content, .. } => {
                 let parts: Vec<serde_json::Value> = content
                     .iter()
                     .filter_map(|c| match c {
-                        AssistantContent::Text(t) => {
-                            Some(serde_json::json!({"type": "text", "text": t.text}))
-                        }
+                        AssistantContent::Text(t) => (!t.text.trim().is_empty())
+                            .then(|| serde_json::json!({"type": "text", "text": t.text})),
                         AssistantContent::ToolCall(tc) => Some(serde_json::json!({
                             "type": "tool_use",
                             "id": tc.id,
@@ -976,7 +1262,8 @@ pub fn convert_messages_to_anthropic(messages: &OneOrMany<Message>) -> Vec<serde
                         _ => None,
                     })
                     .collect();
-                serde_json::json!({"role": "assistant", "content": parts})
+                (!parts.is_empty())
+                    .then(|| serde_json::json!({"role": "assistant", "content": parts}))
             }
         })
         .collect()
@@ -1241,16 +1528,714 @@ fn truncate_body(body: &str) -> &str {
     }
 }
 
-// --- Response parsing ---
+fn with_streaming_enabled(request_body: &serde_json::Value) -> serde_json::Value {
+    let mut body = request_body.clone();
+    body["stream"] = serde_json::json!(true);
+    body
+}
 
-fn make_tool_call(id: String, name: String, arguments: serde_json::Value) -> ToolCall {
-    ToolCall {
-        id,
-        call_id: None,
-        function: ToolFunction {
-            name: name.trim().to_string(),
-            arguments,
-        },
+fn format_api_error_from_response_text(status: reqwest::StatusCode, response_text: &str) -> String {
+    if let Ok(body) = serde_json::from_str::<serde_json::Value>(response_text) {
+        format_api_error(status, &body)
+    } else if let Some(message) = parse_openai_error_message(response_text) {
+        format!("{status}: {message}")
+    } else {
+        format!("{status}: {}", truncate_body(response_text))
+    }
+}
+
+struct OpenAiStreamingToolCall {
+    id: String,
+    internal_call_id: String,
+    name: String,
+    arguments: String,
+}
+
+impl Default for OpenAiStreamingToolCall {
+    fn default() -> Self {
+        Self {
+            id: String::new(),
+            internal_call_id: uuid::Uuid::new_v4().to_string(),
+            name: String::new(),
+            arguments: String::new(),
+        }
+    }
+}
+
+fn stream_from_completion_response(
+    response: completion::CompletionResponse<RawResponse>,
+) -> StreamingCompletionResponse<RawStreamingResponse> {
+    let usage = response.usage;
+    let message_id = response.message_id;
+    let raw_body = response.raw_response.body;
+    let choice_items: Vec<AssistantContent> = response.choice.into_iter().collect();
+
+    let stream = async_stream::stream! {
+        if let Some(message_id) = message_id {
+            yield Ok(RawStreamingChoice::MessageId(message_id));
+        }
+
+        for content in choice_items {
+            match content {
+                AssistantContent::Text(text) => {
+                    if !text.text.is_empty() {
+                        yield Ok(RawStreamingChoice::Message(text.text));
+                    }
+                }
+                AssistantContent::ToolCall(tool_call) => {
+                    yield Ok(RawStreamingChoice::ToolCall(RawStreamingToolCall {
+                        id: tool_call.id.clone(),
+                        internal_call_id: if tool_call.id.is_empty() {
+                            uuid::Uuid::new_v4().to_string()
+                        } else {
+                            tool_call.id
+                        },
+                        call_id: tool_call.call_id,
+                        name: tool_call.function.name,
+                        arguments: tool_call.function.arguments,
+                        signature: tool_call.signature,
+                        additional_params: tool_call.additional_params,
+                    }));
+                }
+                AssistantContent::Reasoning(reasoning) => {
+                    let reasoning_id = reasoning.id.clone();
+                    for content in reasoning.content {
+                        yield Ok(RawStreamingChoice::Reasoning {
+                            id: reasoning_id.clone(),
+                            content,
+                        });
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        yield Ok(RawStreamingChoice::FinalResponse(RawStreamingResponse {
+            body: raw_body,
+            usage: Some(usage),
+        }));
+    };
+
+    StreamingCompletionResponse::stream(Box::pin(stream))
+}
+
+async fn collect_streaming_completion_response(
+    mut stream: StreamingCompletionResponse<RawStreamingResponse>,
+) -> Result<completion::CompletionResponse<RawResponse>, CompletionError> {
+    while let Some(chunk) = stream.next().await {
+        chunk?;
+    }
+
+    let raw_response = stream.response.unwrap_or(RawStreamingResponse {
+        body: serde_json::json!({}),
+        usage: None,
+    });
+
+    Ok(completion::CompletionResponse {
+        choice: stream.choice,
+        usage: raw_response.usage.unwrap_or_default(),
+        raw_response: RawResponse {
+            body: raw_response.body,
+        },
+        message_id: stream.message_id,
+    })
+}
+
+fn completion_choice_to_streaming_choices(
+    choice: &OneOrMany<AssistantContent>,
+) -> Vec<RawStreamingChoice<RawStreamingResponse>> {
+    let mut events = Vec::new();
+
+    for content in choice.iter() {
+        match content {
+            AssistantContent::Text(text) => {
+                if !text.text.is_empty() {
+                    events.push(RawStreamingChoice::Message(text.text.clone()));
+                }
+            }
+            AssistantContent::ToolCall(tool_call) => {
+                events.push(RawStreamingChoice::ToolCall(RawStreamingToolCall {
+                    id: tool_call.id.clone(),
+                    internal_call_id: if tool_call.id.is_empty() {
+                        uuid::Uuid::new_v4().to_string()
+                    } else {
+                        tool_call.id.clone()
+                    },
+                    call_id: tool_call.call_id.clone(),
+                    name: tool_call.function.name.clone(),
+                    arguments: tool_call.function.arguments.clone(),
+                    signature: tool_call.signature.clone(),
+                    additional_params: tool_call.additional_params.clone(),
+                }));
+            }
+            AssistantContent::Reasoning(reasoning) => {
+                for content in &reasoning.content {
+                    events.push(RawStreamingChoice::Reasoning {
+                        id: reasoning.id.clone(),
+                        content: content.clone(),
+                    });
+                }
+            }
+            _ => {}
+        }
+    }
+
+    events
+}
+
+fn extract_sse_block(buffer: &mut String) -> Option<String> {
+    let (block_end, separator_len) = if let Some(index) = buffer.find("\n\n") {
+        (index, 2)
+    } else if let Some(index) = buffer.find("\r\n\r\n") {
+        (index, 4)
+    } else {
+        return None;
+    };
+
+    let block = buffer[..block_end].to_string();
+    *buffer = buffer[block_end + separator_len..].to_string();
+    Some(block)
+}
+
+fn extract_sse_data_payload(block: &str) -> Option<String> {
+    let mut data_lines = Vec::new();
+
+    for line in block.lines() {
+        if let Some(data) = line.strip_prefix("data: ") {
+            data_lines.push(data);
+        } else if let Some(data) = line.strip_prefix("data:") {
+            data_lines.push(data.trim_start());
+        }
+    }
+
+    if data_lines.is_empty() {
+        None
+    } else {
+        Some(data_lines.join("\n"))
+    }
+}
+
+fn escape_control_characters_in_json_strings(input: &str) -> String {
+    let mut escaped = String::with_capacity(input.len());
+    let mut in_string = false;
+    let mut escape_next = false;
+
+    for character in input.chars() {
+        if in_string {
+            if escape_next {
+                escaped.push(character);
+                escape_next = false;
+                continue;
+            }
+
+            match character {
+                '\\' => {
+                    escaped.push(character);
+                    escape_next = true;
+                }
+                '"' => {
+                    escaped.push(character);
+                    in_string = false;
+                }
+                '\u{0008}' => escaped.push_str("\\b"),
+                '\t' => escaped.push_str("\\t"),
+                '\n' => escaped.push_str("\\n"),
+                '\u{000c}' => escaped.push_str("\\f"),
+                '\r' => escaped.push_str("\\r"),
+                '\u{0000}'..='\u{001f}' => {
+                    let codepoint = character as u32;
+                    escaped.push_str(&format!("\\u{codepoint:04x}"));
+                }
+                _ => escaped.push(character),
+            }
+            continue;
+        }
+
+        if character == '"' {
+            in_string = true;
+        }
+        escaped.push(character);
+    }
+
+    escaped
+}
+
+fn parse_streamed_tool_arguments(
+    tool_name: &str,
+    raw_arguments: &str,
+) -> Result<serde_json::Value, CompletionError> {
+    if raw_arguments.trim().is_empty() {
+        return Ok(serde_json::json!({}));
+    }
+
+    let direct_parse_error = match serde_json::from_str::<serde_json::Value>(raw_arguments) {
+        Ok(arguments) => return Ok(arguments),
+        Err(error) => error,
+    };
+
+    let sanitized_arguments = escape_control_characters_in_json_strings(raw_arguments);
+    if sanitized_arguments != raw_arguments {
+        match serde_json::from_str::<serde_json::Value>(&sanitized_arguments) {
+            Ok(arguments) => {
+                tracing::warn!(
+                    tool_name,
+                    "normalized control characters in streamed tool arguments"
+                );
+                return Ok(arguments);
+            }
+            Err(sanitized_parse_error) => {
+                return Err(CompletionError::ProviderError(format!(
+                    "invalid streamed tool arguments for '{tool_name}': {direct_parse_error}; after sanitization: {sanitized_parse_error}"
+                )));
+            }
+        }
+    }
+
+    Err(CompletionError::ProviderError(format!(
+        "invalid streamed tool arguments for '{tool_name}': {direct_parse_error}"
+    )))
+}
+
+fn flush_openai_streaming_tool_calls(
+    pending_tool_calls: &mut BTreeMap<usize, OpenAiStreamingToolCall>,
+) -> Result<Vec<RawStreamingChoice<RawStreamingResponse>>, CompletionError> {
+    let mut flushed = Vec::new();
+
+    for (index, tool_call) in std::mem::take(pending_tool_calls) {
+        if tool_call.name.trim().is_empty() {
+            continue;
+        }
+
+        let id = if tool_call.id.is_empty() {
+            format!("tool_call_{index}")
+        } else {
+            tool_call.id
+        };
+
+        let arguments = parse_streamed_tool_arguments(&tool_call.name, &tool_call.arguments)?;
+
+        flushed.push(RawStreamingChoice::ToolCall(RawStreamingToolCall {
+            id,
+            internal_call_id: tool_call.internal_call_id,
+            call_id: None,
+            name: tool_call.name,
+            arguments,
+            signature: None,
+            additional_params: None,
+        }));
+    }
+
+    Ok(flushed)
+}
+
+fn process_openai_chat_stream_event(
+    event_body: &serde_json::Value,
+    pending_tool_calls: &mut BTreeMap<usize, OpenAiStreamingToolCall>,
+) -> Result<Vec<RawStreamingChoice<RawStreamingResponse>>, CompletionError> {
+    if let Some(error_body) = event_body.get("error") {
+        let message = error_body["message"].as_str().unwrap_or("unknown error");
+        return Err(CompletionError::ProviderError(format!(
+            "OpenAI-compatible streaming error: {message}"
+        )));
+    }
+
+    let mut events = Vec::new();
+    let Some(choices) = event_body
+        .get("choices")
+        .and_then(serde_json::Value::as_array)
+    else {
+        return Ok(events);
+    };
+
+    for choice in choices {
+        if let Some(delta) = choice.get("delta") {
+            if let Some(content) = delta.get("content") {
+                let mut text_parts = Vec::new();
+                collect_openai_text_content(content, &mut text_parts);
+                for text in text_parts {
+                    events.push(RawStreamingChoice::Message(text));
+                }
+            }
+
+            if let Some(reasoning) = delta.get("reasoning") {
+                let mut reasoning_parts = Vec::new();
+                collect_openai_text_content(reasoning, &mut reasoning_parts);
+                for reasoning in reasoning_parts {
+                    events.push(RawStreamingChoice::ReasoningDelta {
+                        id: None,
+                        reasoning,
+                    });
+                }
+            }
+
+            if let Some(reasoning_content) = delta.get("reasoning_content") {
+                let mut reasoning_parts = Vec::new();
+                collect_openai_text_content(reasoning_content, &mut reasoning_parts);
+                for reasoning in reasoning_parts {
+                    events.push(RawStreamingChoice::ReasoningDelta {
+                        id: None,
+                        reasoning,
+                    });
+                }
+            }
+
+            if let Some(delta_tool_calls) = delta
+                .get("tool_calls")
+                .and_then(serde_json::Value::as_array)
+            {
+                for tool_call in delta_tool_calls {
+                    let index = tool_call
+                        .get("index")
+                        .and_then(serde_json::Value::as_u64)
+                        .unwrap_or(0) as usize;
+                    let entry = pending_tool_calls.entry(index).or_default();
+
+                    if let Some(id) = tool_call.get("id").and_then(serde_json::Value::as_str)
+                        && !id.is_empty()
+                    {
+                        entry.id = id.to_string();
+                    }
+
+                    let function = tool_call
+                        .get("function")
+                        .unwrap_or(&serde_json::Value::Null);
+                    if let Some(name) = function.get("name").and_then(serde_json::Value::as_str)
+                        && !name.is_empty()
+                    {
+                        entry.name = name.to_string();
+                        events.push(RawStreamingChoice::ToolCallDelta {
+                            id: entry.id.clone(),
+                            internal_call_id: entry.internal_call_id.clone(),
+                            content: rig::streaming::ToolCallDeltaContent::Name(name.to_string()),
+                        });
+                    }
+
+                    if let Some(arguments_chunk) = function
+                        .get("arguments")
+                        .and_then(serde_json::Value::as_str)
+                        && !arguments_chunk.is_empty()
+                    {
+                        entry.arguments.push_str(arguments_chunk);
+                        events.push(RawStreamingChoice::ToolCallDelta {
+                            id: entry.id.clone(),
+                            internal_call_id: entry.internal_call_id.clone(),
+                            content: rig::streaming::ToolCallDeltaContent::Delta(
+                                arguments_chunk.to_string(),
+                            ),
+                        });
+                    }
+                }
+            }
+        }
+
+        if let Some(message) = choice.get("message") {
+            if let Some(content) = message.get("content") {
+                let mut text_parts = Vec::new();
+                collect_openai_text_content(content, &mut text_parts);
+                for text in text_parts {
+                    events.push(RawStreamingChoice::Message(text));
+                }
+            }
+
+            if let Some(message_tool_calls) = message
+                .get("tool_calls")
+                .and_then(serde_json::Value::as_array)
+            {
+                for (index, tool_call) in message_tool_calls.iter().enumerate() {
+                    let pending_tool_call = pending_tool_calls.remove(&index);
+                    let fallback_id = pending_tool_call
+                        .as_ref()
+                        .and_then(|pending| {
+                            if pending.id.is_empty() {
+                                None
+                            } else {
+                                Some(pending.id.clone())
+                            }
+                        })
+                        .unwrap_or_else(|| format!("tool_call_{index}"));
+                    if let Some(tool_call) = parse_openai_tool_call(tool_call, fallback_id) {
+                        let internal_call_id = pending_tool_call
+                            .as_ref()
+                            .map(|pending| pending.internal_call_id.clone())
+                            .unwrap_or_else(|| {
+                                if tool_call.id.is_empty() {
+                                    uuid::Uuid::new_v4().to_string()
+                                } else {
+                                    tool_call.id.clone()
+                                }
+                            });
+
+                        events.push(RawStreamingChoice::ToolCall(RawStreamingToolCall {
+                            id: tool_call.id.clone(),
+                            internal_call_id,
+                            call_id: tool_call.call_id,
+                            name: tool_call.function.name,
+                            arguments: tool_call.function.arguments,
+                            signature: tool_call.signature,
+                            additional_params: tool_call.additional_params,
+                        }));
+                    }
+                }
+            }
+        }
+
+        if let Some(finish_reason) = choice
+            .get("finish_reason")
+            .and_then(serde_json::Value::as_str)
+            && matches!(finish_reason, "tool_calls" | "function_call")
+        {
+            events.extend(flush_openai_streaming_tool_calls(pending_tool_calls)?);
+        }
+    }
+
+    Ok(events)
+}
+
+fn parse_openai_chat_sse_response(
+    response_text: &str,
+    provider_label: &str,
+) -> Result<serde_json::Value, CompletionError> {
+    let mut text_parts = Vec::new();
+    let mut reasoning_parts = Vec::new();
+    let mut tool_calls: BTreeMap<usize, OpenAiStreamingToolCall> = BTreeMap::new();
+    let mut usage = None;
+    let mut finish_reason = None;
+    let mut saw_data_event = false;
+
+    let mut process_payload = |payload: &str| -> Result<(), CompletionError> {
+        let data = payload.trim();
+        if data.is_empty() || data == "[DONE]" {
+            return Ok(());
+        }
+
+        saw_data_event = true;
+
+        let Ok(event_body) = serde_json::from_str::<serde_json::Value>(data) else {
+            return Ok(());
+        };
+
+        if let Some(error_body) = event_body.get("error") {
+            let message = error_body["message"].as_str().unwrap_or("unknown error");
+            return Err(CompletionError::ProviderError(format!(
+                "{provider_label} streaming error: {message}"
+            )));
+        }
+
+        if let Some(chunk_usage) = event_body.get("usage")
+            && !chunk_usage.is_null()
+        {
+            usage = Some(chunk_usage.clone());
+        }
+
+        let Some(choices) = event_body
+            .get("choices")
+            .and_then(serde_json::Value::as_array)
+        else {
+            return Ok(());
+        };
+
+        for choice in choices {
+            if finish_reason.is_none()
+                && let Some(reason) = choice
+                    .get("finish_reason")
+                    .and_then(serde_json::Value::as_str)
+                && !reason.is_empty()
+            {
+                finish_reason = Some(reason.to_string());
+            }
+
+            if let Some(delta) = choice.get("delta") {
+                if let Some(content) = delta.get("content") {
+                    collect_openai_text_content(content, &mut text_parts);
+                }
+                if let Some(reasoning) = delta.get("reasoning") {
+                    collect_openai_text_content(reasoning, &mut reasoning_parts);
+                }
+                if let Some(reasoning_content) = delta.get("reasoning_content") {
+                    collect_openai_text_content(reasoning_content, &mut reasoning_parts);
+                }
+
+                if let Some(delta_tool_calls) = delta
+                    .get("tool_calls")
+                    .and_then(serde_json::Value::as_array)
+                {
+                    for tool_call in delta_tool_calls {
+                        let index = tool_call
+                            .get("index")
+                            .and_then(serde_json::Value::as_u64)
+                            .unwrap_or(0) as usize;
+                        let entry = tool_calls.entry(index).or_default();
+
+                        if let Some(id) = tool_call.get("id").and_then(serde_json::Value::as_str)
+                            && !id.is_empty()
+                        {
+                            entry.id = id.to_string();
+                        }
+
+                        let function = tool_call
+                            .get("function")
+                            .unwrap_or(&serde_json::Value::Null);
+                        if let Some(name) = function.get("name").and_then(serde_json::Value::as_str)
+                            && !name.is_empty()
+                        {
+                            entry.name = name.to_string();
+                        }
+
+                        if let Some(arguments_chunk) = function
+                            .get("arguments")
+                            .and_then(serde_json::Value::as_str)
+                            && !arguments_chunk.is_empty()
+                        {
+                            entry.arguments.push_str(arguments_chunk);
+                        }
+                    }
+                }
+            }
+
+            if let Some(message) = choice.get("message") {
+                if let Some(content) = message.get("content") {
+                    collect_openai_text_content(content, &mut text_parts);
+                }
+                if let Some(reasoning) = message.get("reasoning") {
+                    collect_openai_text_content(reasoning, &mut reasoning_parts);
+                }
+                if let Some(reasoning_content) = message.get("reasoning_content") {
+                    collect_openai_text_content(reasoning_content, &mut reasoning_parts);
+                }
+
+                if let Some(message_tool_calls) = message
+                    .get("tool_calls")
+                    .and_then(serde_json::Value::as_array)
+                {
+                    for (index, tool_call) in message_tool_calls.iter().enumerate() {
+                        let entry = tool_calls.entry(index).or_default();
+
+                        if let Some(id) = tool_call.get("id").and_then(serde_json::Value::as_str)
+                            && !id.is_empty()
+                        {
+                            entry.id = id.to_string();
+                        }
+
+                        let function = tool_call
+                            .get("function")
+                            .unwrap_or(&serde_json::Value::Null);
+                        if let Some(name) = function.get("name").and_then(serde_json::Value::as_str)
+                            && !name.is_empty()
+                        {
+                            entry.name = name.to_string();
+                        }
+
+                        if let Some(arguments) = function.get("arguments") {
+                            if let Some(arguments_str) = arguments.as_str() {
+                                entry.arguments = arguments_str.to_string();
+                            } else {
+                                entry.arguments = arguments.to_string();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    };
+
+    let mut block_buffer = response_text.to_string();
+    while let Some(block) = extract_sse_block(&mut block_buffer) {
+        if let Some(payload) = extract_sse_data_payload(&block) {
+            process_payload(&payload)?;
+        }
+    }
+    if !block_buffer.trim().is_empty()
+        && let Some(payload) = extract_sse_data_payload(&block_buffer)
+    {
+        process_payload(&payload)?;
+    }
+
+    if !saw_data_event {
+        return Err(CompletionError::ProviderError(format!(
+            "{provider_label} streaming response missing SSE data events. Body: {}",
+            truncate_body(response_text)
+        )));
+    }
+
+    let mut message = serde_json::json!({
+        "content": if text_parts.is_empty() {
+            serde_json::Value::Null
+        } else {
+            serde_json::Value::String(text_parts.join(""))
+        }
+    });
+
+    if !reasoning_parts.is_empty() {
+        message["reasoning"] = serde_json::Value::String(reasoning_parts.join(""));
+    }
+
+    let mut tool_call_values = Vec::new();
+    for (index, tool_call) in tool_calls {
+        if tool_call.name.trim().is_empty() {
+            continue;
+        }
+
+        let id = if tool_call.id.is_empty() {
+            format!("tool_call_{index}")
+        } else {
+            tool_call.id
+        };
+        let arguments =
+            parse_openai_tool_arguments(&serde_json::Value::String(tool_call.arguments));
+
+        tool_call_values.push(serde_json::json!({
+            "id": id,
+            "type": "function",
+            "function": {
+                "name": tool_call.name,
+                "arguments": arguments,
+            }
+        }));
+    }
+
+    if !tool_call_values.is_empty() {
+        message["tool_calls"] = serde_json::Value::Array(tool_call_values);
+    }
+
+    if message.get("tool_calls").is_none()
+        && message["content"].is_null()
+        && reasoning_parts.is_empty()
+    {
+        return Err(CompletionError::ProviderError(format!(
+            "{provider_label} streaming response did not contain message content or tool calls. Body: {}",
+            truncate_body(response_text)
+        )));
+    }
+
+    let finish_reason = finish_reason.unwrap_or_else(|| {
+        if message.get("tool_calls").is_some() {
+            "tool_calls".to_string()
+        } else {
+            "stop".to_string()
+        }
+    });
+
+    Ok(serde_json::json!({
+        "choices": [{
+            "message": message,
+            "finish_reason": finish_reason,
+        }],
+        "usage": usage.unwrap_or_else(|| serde_json::json!({})),
+    }))
+}
+
+// --- Response parsing ---
+
+fn make_tool_call(id: String, name: String, arguments: serde_json::Value) -> ToolCall {
+    ToolCall {
+        id,
+        call_id: None,
+        function: ToolFunction {
+            name: name.trim().to_string(),
+            arguments,
+        },
         signature: None,
         additional_params: None,
     }
@@ -1268,8 +2253,14 @@ fn parse_anthropic_response(
     for block in content_blocks {
         match block["type"].as_str() {
             Some("text") => {
-                let text = block["text"].as_str().unwrap_or("").to_string();
-                assistant_content.push(AssistantContent::Text(Text { text }));
+                let text = block["text"].as_str().unwrap_or("");
+                if !text.trim().is_empty() {
+                    assistant_content.push(AssistantContent::Text(Text {
+                        text: text.to_string(),
+                    }));
+                } else {
+                    tracing::debug!("dropping empty text block in Anthropic response");
+                }
             }
             Some("tool_use") => {
                 let id = block["id"].as_str().unwrap_or("").to_string();
@@ -1294,21 +2285,35 @@ fn parse_anthropic_response(
         }
     }
 
-    let choice = OneOrMany::many(assistant_content).unwrap_or_else(|_| {
-        // Anthropic returns an empty content array when stop_reason is end_turn
-        // and the model has nothing further to say (e.g. after a side-effect-only
-        // tool call like react/skip). Treat this as a clean empty response rather
-        // than an error so the agentic loop terminates gracefully.
-        let stop_reason = body["stop_reason"].as_str().unwrap_or("unknown");
-        tracing::debug!(
-            stop_reason,
-            content_blocks = content_blocks.len(),
-            "empty assistant_content from Anthropic — returning synthetic empty text"
-        );
-        OneOrMany::one(AssistantContent::Text(Text {
-            text: String::new(),
-        }))
-    });
+    let choice = match OneOrMany::many(assistant_content) {
+        Ok(choice) => choice,
+        Err(_) => {
+            // Anthropic can return an empty content array when stop_reason is
+            // end_turn and the model has nothing further to say (e.g. after a
+            // side-effect-only tool call like react/skip). Treat this as a clean
+            // no-op so the agentic loop terminates gracefully.
+            let stop_reason = body["stop_reason"].as_str().unwrap_or("unknown");
+            if stop_reason == "end_turn" {
+                tracing::debug!(
+                    stop_reason,
+                    content_blocks = content_blocks.len(),
+                    "empty assistant_content from Anthropic end_turn — returning synthetic whitespace placeholder"
+                );
+                OneOrMany::one(AssistantContent::Text(Text {
+                    text: " ".to_string(),
+                }))
+            } else {
+                tracing::warn!(
+                    stop_reason,
+                    content_blocks = content_blocks.len(),
+                    "unexpected empty assistant_content from Anthropic"
+                );
+                return Err(CompletionError::ResponseError(format!(
+                    "empty response from Anthropic (stop_reason: {stop_reason})"
+                )));
+            }
+        }
+    };
 
     let input_tokens = body["usage"]["input_tokens"].as_u64().unwrap_or(0);
     let output_tokens = body["usage"]["output_tokens"].as_u64().unwrap_or(0);
@@ -1325,6 +2330,7 @@ fn parse_anthropic_response(
             cached_input_tokens: cached,
         },
         raw_response: RawResponse { body },
+        message_id: None,
     })
 }
 
@@ -1332,57 +2338,82 @@ fn parse_openai_response(
     body: serde_json::Value,
     provider_label: &str,
 ) -> Result<completion::CompletionResponse<RawResponse>, CompletionError> {
-    let choice = &body["choices"][0]["message"];
+    let choice = body["choices"]
+        .as_array()
+        .and_then(|choices| choices.first())
+        .ok_or_else(|| CompletionError::ResponseError("missing choices array".into()))?;
+    let message = choice.get("message").unwrap_or(&serde_json::Value::Null);
 
     let mut assistant_content = Vec::new();
 
-    if let Some(text) = choice["content"].as_str()
-        && !text.is_empty()
+    if let Some(content) = message.get("content") {
+        let mut text_parts = Vec::new();
+        collect_openai_text_content(content, &mut text_parts);
+        for text in text_parts {
+            assistant_content.push(AssistantContent::Text(Text { text }));
+        }
+    }
+
+    if let Some(tool_calls) = message
+        .get("tool_calls")
+        .and_then(serde_json::Value::as_array)
     {
-        assistant_content.push(AssistantContent::Text(Text {
-            text: text.to_string(),
-        }));
+        for (index, tool_call_value) in tool_calls.iter().enumerate() {
+            if let Some(tool_call) =
+                parse_openai_tool_call(tool_call_value, format!("tool_call_{index}"))
+            {
+                assistant_content.push(AssistantContent::ToolCall(tool_call));
+            }
+        }
+    }
+
+    if let Some(function_call) = message.get("function_call")
+        && let Some(tool_call) =
+            parse_openai_tool_call(function_call, "function_call_0".to_string())
+    {
+        assistant_content.push(AssistantContent::ToolCall(tool_call));
     }
 
     // Some reasoning models (e.g., NVIDIA kimi-k2.5) return reasoning in a separate field
     if assistant_content.is_empty()
-        && let Some(reasoning) = choice["reasoning_content"].as_str()
-        && !reasoning.is_empty()
+        && let Some(reasoning) = parse_openai_reasoning_fallback(message)
     {
         tracing::debug!(
             provider = %provider_label,
-            "extracted reasoning_content as main content"
+            "extracted reasoning fallback as main content"
         );
-        assistant_content.push(AssistantContent::Text(Text {
-            text: reasoning.to_string(),
-        }));
+        assistant_content.push(AssistantContent::Text(Text { text: reasoning }));
     }
 
-    if let Some(tool_calls) = choice["tool_calls"].as_array() {
-        for tc in tool_calls {
-            let id = tc["id"].as_str().unwrap_or("").to_string();
-            let name = tc["function"]["name"].as_str().unwrap_or("").to_string();
-            // OpenAI-compatible APIs usually return arguments as a JSON string.
-            // Some providers return it as a raw JSON object instead.
-            let arguments_field = &tc["function"]["arguments"];
-            let arguments = arguments_field
-                .as_str()
-                .and_then(|raw| serde_json::from_str(raw).ok())
-                .or_else(|| arguments_field.as_object().map(|_| arguments_field.clone()))
-                .unwrap_or(serde_json::json!({}));
-            assistant_content.push(AssistantContent::ToolCall(make_tool_call(
-                id, name, arguments,
-            )));
-        }
+    if assistant_content.is_empty()
+        && let Some(text) = choice["text"].as_str()
+        && !text.trim().is_empty()
+    {
+        assistant_content.push(AssistantContent::Text(Text {
+            text: text.to_string(),
+        }));
     }
 
-    let result_choice = OneOrMany::many(assistant_content.clone()).map_err(|_| {
+    let result_choice = OneOrMany::many(assistant_content).map_err(|_| {
+        let finish_reason = choice["finish_reason"].as_str().unwrap_or("unknown");
+        let message_keys = message
+            .as_object()
+            .map(|keys| {
+                let mut key_names: Vec<String> = keys.keys().cloned().collect();
+                key_names.sort();
+                key_names.join(",")
+            })
+            .unwrap_or_else(|| "non-object".to_string());
         tracing::warn!(
             provider = %provider_label,
+            finish_reason,
+            message_keys = %message_keys,
             choice = ?choice,
             "empty response from provider"
         );
-        CompletionError::ResponseError(format!("empty response from {provider_label}"))
+        CompletionError::ResponseError(format!(
+            "empty response from {provider_label} (finish_reason: {finish_reason})"
+        ))
     })?;
 
     let input_tokens = body["usage"]["prompt_tokens"].as_u64().unwrap_or(0);
@@ -1400,11 +2431,112 @@ fn parse_openai_response(
             cached_input_tokens: cached,
         },
         raw_response: RawResponse { body },
+        message_id: None,
     })
 }
 
+fn parse_openai_reasoning_fallback(message: &serde_json::Value) -> Option<String> {
+    let mut reasoning_parts = Vec::new();
+
+    if let Some(reasoning_content) = message.get("reasoning_content") {
+        collect_openai_text_content(reasoning_content, &mut reasoning_parts);
+    }
+    if let Some(reasoning) = message.get("reasoning") {
+        collect_openai_text_content(reasoning, &mut reasoning_parts);
+    }
+    if let Some(reasoning_details) = message.get("reasoning_details") {
+        collect_openai_text_content(reasoning_details, &mut reasoning_parts);
+    }
+
+    if reasoning_parts.is_empty() {
+        None
+    } else {
+        Some(reasoning_parts.join("\n"))
+    }
+}
+
+fn collect_openai_text_content(value: &serde_json::Value, text_parts: &mut Vec<String>) {
+    match value {
+        serde_json::Value::String(text) => {
+            if !text.trim().is_empty() {
+                text_parts.push(text.to_string());
+            }
+        }
+        serde_json::Value::Array(items) => {
+            for item in items {
+                collect_openai_text_content(item, text_parts);
+            }
+        }
+        serde_json::Value::Object(map) => {
+            if let Some(text) = map.get("text").and_then(serde_json::Value::as_str)
+                && !text.trim().is_empty()
+            {
+                text_parts.push(text.to_string());
+            }
+            if let Some(summary) = map.get("summary").and_then(serde_json::Value::as_str)
+                && !summary.trim().is_empty()
+            {
+                text_parts.push(summary.to_string());
+            }
+            if let Some(refusal) = map.get("refusal").and_then(serde_json::Value::as_str)
+                && !refusal.trim().is_empty()
+            {
+                text_parts.push(refusal.to_string());
+            }
+
+            if let Some(content) = map.get("content") {
+                collect_openai_text_content(content, text_parts);
+            }
+        }
+        _ => {}
+    }
+}
+
+fn parse_openai_tool_arguments(arguments_field: &serde_json::Value) -> serde_json::Value {
+    if let Some(raw) = arguments_field.as_str() {
+        return serde_json::from_str(raw).unwrap_or_else(|_| serde_json::json!({}));
+    }
+    if arguments_field.is_null() {
+        serde_json::json!({})
+    } else {
+        arguments_field.clone()
+    }
+}
+
+fn parse_openai_tool_call(tool_call: &serde_json::Value, fallback_id: String) -> Option<ToolCall> {
+    let name = tool_call
+        .get("function")
+        .and_then(|function| function.get("name"))
+        .and_then(serde_json::Value::as_str)
+        .or_else(|| tool_call.get("name").and_then(serde_json::Value::as_str))
+        .map(str::trim)
+        .unwrap_or("");
+    if name.is_empty() {
+        return None;
+    }
+
+    let id = tool_call
+        .get("id")
+        .and_then(serde_json::Value::as_str)
+        .or_else(|| tool_call.get("call_id").and_then(serde_json::Value::as_str))
+        .filter(|id| !id.is_empty())
+        .map(ToOwned::to_owned)
+        .unwrap_or(fallback_id);
+
+    let null = serde_json::Value::Null;
+    let arguments_field = tool_call
+        .get("function")
+        .and_then(|function| function.get("arguments"))
+        .or_else(|| tool_call.get("arguments"))
+        .unwrap_or(&null);
+    let arguments = parse_openai_tool_arguments(arguments_field);
+
+    Some(make_tool_call(id, name.to_string(), arguments))
+}
+
 fn parse_openai_responses_response(
     body: serde_json::Value,
+    provider_label: &str,
 ) -> Result<completion::CompletionResponse<RawResponse>, CompletionError> {
     let output_items = body["output"]
         .as_array()
@@ -1412,7 +2544,7 @@ fn parse_openai_responses_response(
 
     let mut assistant_content = Vec::new();
 
-    for output_item in output_items {
+    for (index, output_item) in output_items.iter().enumerate() {
         match output_item["type"].as_str() {
             Some("message") => {
                 if let Some(content_items) = output_item["content"].as_array() {
@@ -1432,13 +2564,11 @@ fn parse_openai_responses_response(
                 let call_id = output_item["call_id"]
                     .as_str()
                     .or_else(|| output_item["id"].as_str())
-                    .unwrap_or("")
-                    .to_string();
+                    .filter(|id| !id.is_empty())
+                    .map(ToOwned::to_owned)
+                    .unwrap_or_else(|| format!("function_call_{index}"));
                 let name = output_item["name"].as_str().unwrap_or("").to_string();
-                let arguments = output_item["arguments"]
-                    .as_str()
-                    .and_then(|arguments| serde_json::from_str(arguments).ok())
-                    .unwrap_or(serde_json::json!({}));
+                let arguments = parse_openai_tool_arguments(&output_item["arguments"]);
 
                 assistant_content.push(AssistantContent::ToolCall(make_tool_call(
                     call_id, name, arguments,
@@ -1449,7 +2579,14 @@ fn parse_openai_responses_response(
     }
 
     let choice = OneOrMany::many(assistant_content).map_err(|_| {
-        CompletionError::ResponseError("empty response from OpenAI Responses API".into())
+        tracing::warn!(
+            provider = %provider_label,
+            output_items = output_items.len(),
+            "empty response from responses API"
+        );
+        CompletionError::ResponseError(format!(
+            "empty response from {provider_label} Responses API"
+        ))
     })?;
 
     let input_tokens = body["usage"]["input_tokens"].as_u64().unwrap_or(0);
@@ -1467,11 +2604,13 @@ fn parse_openai_responses_response(
             cached_input_tokens: cached,
         },
         raw_response: RawResponse { body },
+        message_id: None,
     })
 }
 
 fn parse_openai_responses_sse_response(
     response_text: &str,
+    provider_label: &str,
 ) -> Result<serde_json::Value, CompletionError> {
     for line in response_text.lines() {
         let Some(data) = line.strip_prefix("data: ") else {
@@ -1494,7 +2633,7 @@ fn parse_openai_responses_sse_response(
     }
 
     Err(CompletionError::ProviderError(format!(
-        "OpenAI Responses SSE stream missing response.completed event.\nBody: {}",
+        "{provider_label} Responses SSE stream missing response.completed event.\nBody: {}",
         truncate_body(response_text)
     )))
 }
@@ -1508,9 +2647,83 @@ fn parse_openai_error_message(response_text: &str) -> Option<String> {
         .map(ToOwned::to_owned)
 }
 
+/// Build a detailed error string from an OpenAI-compatible error response.
+///
+/// OpenRouter (and potentially other proxies) return additional context in
+/// `error.metadata` — e.g. `provider_name` and `raw` (the upstream error).
+/// Including this in the error message helps users diagnose issues like
+/// misconfigured presets or model-specific rejections (see issue #262).
+fn format_api_error(status: reqwest::StatusCode, body: &serde_json::Value) -> String {
+    let message = body["error"]["message"].as_str().unwrap_or("unknown error");
+
+    let provider_name = body["error"]["metadata"]["provider_name"]
+        .as_str()
+        .filter(|s| !s.is_empty());
+    let raw = match &body["error"]["metadata"]["raw"] {
+        serde_json::Value::String(s) if !s.is_empty() => Some(s.clone()),
+        serde_json::Value::Null => None,
+        other => {
+            let s = other.to_string();
+            if s == "null" { None } else { Some(s) }
+        }
+    };
+
+    match (provider_name, raw.as_deref()) {
+        (Some(provider), Some(raw_err)) => {
+            format!("{status}: {message} (upstream provider {provider}: {raw_err})")
+        }
+        (Some(provider), None) => {
+            format!("{status}: {message} (upstream provider: {provider})")
+        }
+        (None, Some(raw_err)) => {
+            format!("{status}: {message} ({raw_err})")
+        }
+        (None, None) => {
+            format!("{status}: {message}")
+        }
+    }
+}
+
+fn provider_display_name(provider_id: &str) -> String {
+    match provider_id {
+        "openai" => "OpenAI".to_string(),
+        "openai-chatgpt" => "OpenAI ChatGPT".to_string(),
+        "openrouter" => "OpenRouter".to_string(),
+        "kilo" => "Kilo Gateway".to_string(),
+        "zhipu" => "Z.AI (GLM)".to_string(),
+        "groq" => "Groq".to_string(),
+        "together" => "Together".to_string(),
+        "fireworks" => "Fireworks".to_string(),
+        "deepseek" => "DeepSeek".to_string(),
+        "xai" => "xAI".to_string(),
+        "mistral" => "Mistral".to_string(),
+        "gemini" => "Google Gemini".to_string(),
+        "moonshot" => "Moonshot".to_string(),
+        "nvidia" => "NVIDIA".to_string(),
+        "opencode-zen" => "OpenCode Zen".to_string(),
+        "opencode-go" => "OpenCode Go".to_string(),
+        "zai-coding-plan" => "Z.AI Coding Plan".to_string(),
+        _ => provider_id.to_string(),
+    }
+}
+
+fn remap_model_name_for_api(provider: &str, model_name: &str) -> String {
+    if provider == "zai-coding-plan" {
+        // Coding Plan endpoint expects plain model ids (e.g. "glm-5").
+        model_name
+            .strip_prefix("zai/")
+            .unwrap_or(model_name)
+            .to_string()
+    } else {
+        model_name.to_string()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
+    use rig::message::Message;
+    use std::collections::BTreeMap;
 
     #[test]
     fn reverse_map_restores_original_tool_names() {
@@ -1539,6 +2752,7 @@ mod tests {
             raw_response: RawResponse {
                 body: serde_json::json!({}),
             },
+            message_id: None,
         };
 
         reverse_map_tool_names(&mut completion, &original_tools);
@@ -1550,4 +2764,525 @@ mod tests {
             panic!("expected ToolCall");
         }
     }
+    #[test]
+    fn coding_plan_model_name_uses_plain_glm_id() {
+        assert_eq!(
+            remap_model_name_for_api("zai-coding-plan", "glm-5"),
+            "glm-5"
+        );
+        assert_eq!(
+            remap_model_name_for_api("zai-coding-plan", "zai/glm-5"),
+            "glm-5"
+        );
+        assert_eq!(
+            remap_model_name_for_api("openai", "gpt-4o-mini"),
+            "gpt-4o-mini"
+        );
+        assert_eq!(remap_model_name_for_api("openai", "zai/glm-5"), "zai/glm-5");
+    }
+
+    #[test]
+    fn parse_anthropic_response_drops_empty_text_blocks() {
+        let body = serde_json::json!({
+            "content": [
+                {"type": "text", "text": ""},
+                {"type": "text", "text": "   "},
+                {
+                    "type": "tool_use",
+                    "id": "call_1",
+                    "name": "reply",
+                    "input": {"content": "hi"}
+                }
+            ],
+            "usage": {"input_tokens": 1, "output_tokens": 2}
+        });
+
+        let response = parse_anthropic_response(body).expect("valid response");
+        let contents: Vec<_> = response.choice.iter().collect();
+        assert_eq!(contents.len(), 1);
+        assert!(matches!(contents[0], AssistantContent::ToolCall(_)));
+    }
+
+    #[test]
+    fn convert_messages_to_anthropic_omits_empty_text_messages() {
+        let messages = OneOrMany::many(vec![
+            Message::User {
+                content: OneOrMany::one(UserContent::text("   ")),
+            },
+            Message::Assistant {
+                id: None,
+                content: OneOrMany::one(AssistantContent::text("")),
+            },
+            Message::Assistant {
+                id: None,
+                content: OneOrMany::one(AssistantContent::tool_call(
+                    "call_1",
+                    "reply",
+                    serde_json::json!({"content": "ok"}),
+                )),
+            },
+        ])
+        .expect("non-empty message list");
+
+        let converted = convert_messages_to_anthropic(&messages);
+        assert_eq!(converted.len(), 1);
+        assert_eq!(converted[0]["role"], "assistant");
+        assert_eq!(converted[0]["content"][0]["type"], "tool_use");
+    }
+
+    #[test]
+    fn end_turn_placeholder_is_not_forwarded_back_to_anthropic() {
+        let body = serde_json::json!({
+            "content": [],
+            "stop_reason": "end_turn",
+            "usage": {"input_tokens": 1, "output_tokens": 0}
+        });
+
+        let response = parse_anthropic_response(body).expect("valid response");
+        let history = OneOrMany::one(Message::Assistant {
+            id: None,
+            content: response.choice,
+        });
+
+        let converted = convert_messages_to_anthropic(&history);
+        assert!(converted.is_empty());
+    }
+
+    #[test]
+    fn empty_non_end_turn_response_returns_error() {
+        let body = serde_json::json!({
+            "content": [],
+            "stop_reason": "max_tokens",
+            "usage": {"input_tokens": 1, "output_tokens": 0}
+        });
+
+        let error = parse_anthropic_response(body).expect_err("should fail");
+        assert!(matches!(error, CompletionError::ResponseError(_)));
+        assert!(error.to_string().contains("stop_reason: max_tokens"));
+    }
+
+    #[test]
+    fn parse_openai_response_handles_content_array_parts() {
+        let body = serde_json::json!({
+            "choices": [{
+                "message": {
+                    "content": [
+                        {"type": "text", "text": "First"},
+                        {"type": "output_text", "text": "Second"}
+                    ]
+                },
+                "finish_reason": "stop"
+            }],
+            "usage": {
+                "prompt_tokens": 5,
+                "completion_tokens": 3,
+                "prompt_tokens_details": {"cached_tokens": 0}
+            }
+        });
+
+        let response = parse_openai_response(body, "OpenRouter").expect("valid response");
+        let texts: Vec<_> = response
+            .choice
+            .iter()
+            .filter_map(|content| {
+                if let AssistantContent::Text(text) = content {
+                    Some(text.text.clone())
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        assert_eq!(texts, vec!["First".to_string(), "Second".to_string()]);
+    }
+
+    #[test]
+    fn parse_openai_response_uses_reasoning_when_content_is_empty() {
+        let body = serde_json::json!({
+            "choices": [{
+                "message": {
+                    "content": "",
+                    "reasoning": "Reasoning fallback output"
+                },
+                "finish_reason": "stop"
+            }],
+            "usage": {
+                "prompt_tokens": 5,
+                "completion_tokens": 1,
+                "prompt_tokens_details": {"cached_tokens": 0}
+            }
+        });
+
+        let response = parse_openai_response(body, "OpenRouter").expect("valid response");
+        let first = response.choice.first_ref();
+        match first {
+            AssistantContent::Text(text) => assert_eq!(text.text, "Reasoning fallback output"),
+            _ => panic!("expected text content"),
+        }
+    }
+
+    #[test]
+    fn parse_openai_response_handles_legacy_function_call() {
+        let body = serde_json::json!({
+            "choices": [{
+                "message": {
+                    "content": null,
+                    "function_call": {
+                        "name": "reply",
+                        "arguments": "{\"content\":\"ok\"}"
+                    }
+                },
+                "finish_reason": "function_call"
+            }],
+            "usage": {
+                "prompt_tokens": 5,
+                "completion_tokens": 1,
+                "prompt_tokens_details": {"cached_tokens": 0}
+            }
+        });
+
+        let response = parse_openai_response(body, "OpenRouter").expect("valid response");
+        let first = response.choice.first_ref();
+        match first {
+            AssistantContent::ToolCall(tool_call) => {
+                assert_eq!(tool_call.function.name, "reply");
+                assert_eq!(tool_call.function.arguments["content"], "ok");
+                assert!(!tool_call.id.is_empty());
+            }
+            _ => panic!("expected tool call"),
+        }
+    }
+
+    #[test]
+    fn parse_openai_response_empty_error_includes_provider_and_finish_reason() {
+        let body = serde_json::json!({
+            "choices": [{
+                "message": {
+                    "content": ""
+                },
+                "finish_reason": "stop"
+            }],
+            "usage": {
+                "prompt_tokens": 5,
+                "completion_tokens": 0,
+                "prompt_tokens_details": {"cached_tokens": 0}
+            }
+        });
+
+        let error = parse_openai_response(body, "OpenRouter").expect_err("should fail");
+        assert!(error.to_string().contains("empty response from OpenRouter"));
+        assert!(error.to_string().contains("finish_reason: stop"));
+    }
+
+    #[test]
+    fn parse_openai_chat_sse_response_reconstructs_tool_calls() {
+        let sse = concat!(
+            "data: {\"choices\":[{\"delta\":{\"content\":\"Found \"},\"finish_reason\":null}]}\n\n",
+            "data: {\"choices\":[{\"delta\":{\"content\":\"files\",\"tool_calls\":[{\"index\":0,\"id\":\"call_1\",\"function\":{\"name\":\"file\",\"arguments\":\"{\\\"operation\\\":\\\"list\\\"\"}}]},\"finish_reason\":null}]}\n\n",
+            "data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\",\\\"path\\\":\\\".\\\"}\"}}]},\"finish_reason\":\"tool_calls\"}]}\n\n",
+            "data: {\"choices\":[],\"usage\":{\"prompt_tokens\":12,\"completion_tokens\":8}}\n\n",
+            "data: [DONE]\n\n"
+        );
+
+        let parsed = parse_openai_chat_sse_response(sse, "OpenRouter").expect("valid SSE");
+
+        assert_eq!(parsed["choices"][0]["finish_reason"], "tool_calls");
+        assert_eq!(parsed["choices"][0]["message"]["content"], "Found files");
+        assert_eq!(
+            parsed["choices"][0]["message"]["tool_calls"][0]["function"]["name"],
+            "file"
+        );
+        assert_eq!(
+            parsed["choices"][0]["message"]["tool_calls"][0]["function"]["arguments"]["operation"],
+            "list"
+        );
+        assert_eq!(
+            parsed["choices"][0]["message"]["tool_calls"][0]["function"]["arguments"]["path"],
+            "."
+        );
+        assert_eq!(parsed["usage"]["prompt_tokens"], 12);
+    }
+
+    #[test]
+    fn parse_openai_chat_sse_response_requires_data_lines() {
+        let error = parse_openai_chat_sse_response("{\"choices\":[]}", "OpenRouter")
+            .expect_err("should fail");
+        assert!(error.to_string().contains("missing SSE data events"));
+    }
+
+    #[test]
+    fn process_openai_chat_stream_event_flushes_tool_calls() {
+        let first_event = serde_json::json!({
+            "choices": [{
+                "delta": {
+                    "tool_calls": [{
+                        "index": 0,
+                        "id": "call_1",
+                        "function": {
+                            "name": "file",
+                            "arguments": "{\"operation\":\"list\""
+                        }
+                    }]
+                },
+                "finish_reason": null
+            }]
+        });
+
+        let second_event = serde_json::json!({
+            "choices": [{
+                "delta": {
+                    "tool_calls": [{
+                        "index": 0,
+                        "function": {
+                            "arguments": ",\"path\":\".\"}"
+                        }
+                    }]
+                },
+                "finish_reason": "tool_calls"
+            }]
+        });
+
+        let mut pending = BTreeMap::new();
+
+        let first_events = process_openai_chat_stream_event(&first_event, &mut pending)
+            .expect("first event should parse");
+        assert!(
+            first_events.iter().any(|event| {
+                matches!(
+                    event,
+                    RawStreamingChoice::ToolCallDelta {
+                        content: rig::streaming::ToolCallDeltaContent::Name(name),
+                        ..
+                    } if name == "file"
+                )
+            }),
+            "missing tool-call name delta"
+        );
+        assert_eq!(pending.len(), 1);
+
+        let second_events = process_openai_chat_stream_event(&second_event, &mut pending)
+            .expect("second event should parse");
+        assert!(pending.is_empty(), "pending tool calls should be flushed");
+
+        let tool_calls: Vec<_> = second_events
+            .into_iter()
+            .filter_map(|event| match event {
+                RawStreamingChoice::ToolCall(tool_call) => Some(tool_call),
+                _ => None,
+            })
+            .collect();
+        assert_eq!(tool_calls.len(), 1);
+        assert_eq!(tool_calls[0].name, "file");
+        assert_eq!(tool_calls[0].arguments["operation"], "list");
+        assert_eq!(tool_calls[0].arguments["path"], ".");
+    }
+
+    #[test]
+    fn process_openai_chat_stream_event_does_not_duplicate_message_tool_calls() {
+        let delta_event = serde_json::json!({
+            "choices": [{
+                "delta": {
+                    "tool_calls": [{
+                        "index": 0,
+                        "id": "call_1",
+                        "function": {
+                            "name": "file",
+                            "arguments": "{\"operation\":\"list\",\"path\":\".\"}"
+                        }
+                    }]
+                },
+                "finish_reason": null
+            }]
+        });
+
+        let message_event = serde_json::json!({
+            "choices": [{
+                "message": {
+                    "tool_calls": [{
+                        "id": "call_1",
+                        "function": {
+                            "name": "file",
+                            "arguments": "{\"operation\":\"list\",\"path\":\".\"}"
+                        }
+                    }]
+                },
+                "finish_reason": "tool_calls"
+            }]
+        });
+
+        let mut pending = BTreeMap::new();
+        let delta_events = process_openai_chat_stream_event(&delta_event, &mut pending)
+            .expect("delta event should parse");
+        let delta_internal_call_id = delta_events
+            .iter()
+            .find_map(|event| match event {
+                RawStreamingChoice::ToolCallDelta {
+                    internal_call_id, ..
+                } => Some(internal_call_id.clone()),
+                _ => None,
+            })
+            .expect("missing tool-call delta internal id");
+        assert_eq!(pending.len(), 1);
+
+        let events = process_openai_chat_stream_event(&message_event, &mut pending)
+            .expect("message event should parse");
+        let tool_calls: Vec<_> = events
+            .into_iter()
+            .filter_map(|event| match event {
+                RawStreamingChoice::ToolCall(tool_call) => Some(tool_call),
+                _ => None,
+            })
+            .collect();
+
+        assert_eq!(tool_calls.len(), 1, "tool call should not be duplicated");
+        assert_eq!(tool_calls[0].id, "call_1");
+        assert_eq!(tool_calls[0].name, "file");
+        assert_eq!(tool_calls[0].internal_call_id, delta_internal_call_id);
+    }
+
+    #[test]
+    fn flush_openai_streaming_tool_calls_errors_on_invalid_arguments() {
+        let mut pending = BTreeMap::new();
+        pending.insert(
+            0,
+            OpenAiStreamingToolCall {
+                id: "call_1".to_string(),
+                internal_call_id: "internal_1".to_string(),
+                name: "file".to_string(),
+                arguments: "{\"operation\":\"list\"".to_string(),
+            },
+        );
+
+        let error = flush_openai_streaming_tool_calls(&mut pending)
+            .expect_err("invalid JSON arguments should error");
+        assert!(
+            error
+                .to_string()
+                .contains("invalid streamed tool arguments for 'file'"),
+            "unexpected error: {error}"
+        );
+    }
+
+    #[test]
+    fn flush_openai_streaming_tool_calls_sanitizes_control_chars_in_string_arguments() {
+        let mut pending = BTreeMap::new();
+        pending.insert(
+            0,
+            OpenAiStreamingToolCall {
+                id: "call_1".to_string(),
+                internal_call_id: "internal_1".to_string(),
+                name: "file".to_string(),
+                arguments: "{\"operation\":\"write\",\"content\":\"line1\nline2\"}".to_string(),
+            },
+        );
+
+        let events = flush_openai_streaming_tool_calls(&mut pending)
+            .expect("control-char recovery should parse");
+        let tool_calls: Vec<_> = events
+            .into_iter()
+            .filter_map(|event| match event {
+                RawStreamingChoice::ToolCall(tool_call) => Some(tool_call),
+                _ => None,
+            })
+            .collect();
+
+        assert_eq!(tool_calls.len(), 1);
+        assert_eq!(tool_calls[0].name, "file");
+        assert_eq!(tool_calls[0].arguments["operation"], "write");
+        assert_eq!(tool_calls[0].arguments["content"], "line1\nline2");
+    }
+
+    #[test]
+    fn parse_openai_chat_sse_response_merges_multiline_data_blocks() {
+        let sse = concat!(
+            "data: {\"choices\":[{\"delta\":{\"content\":\"Hello\"},\n",
+            "data: \"finish_reason\":null}]}\n\n",
+            "data: {\"choices\":[],\"usage\":{\"prompt_tokens\":2,\"completion_tokens\":1}}\n\n",
+            "data: [DONE]\n\n"
+        );
+
+        let parsed = parse_openai_chat_sse_response(sse, "OpenRouter").expect("valid SSE");
+        assert_eq!(parsed["choices"][0]["message"]["content"], "Hello");
+        assert_eq!(parsed["usage"]["prompt_tokens"], 2);
+    }
+
+    #[test]
+    fn extract_sse_data_payload_merges_data_lines() {
+        let block = "event: message\nid: abc123\ndata: {\"a\":1}\ndata:{\"b\":2}";
+        let payload = extract_sse_data_payload(block).expect("should parse data lines");
+        assert_eq!(payload, "{\"a\":1}\n{\"b\":2}");
+    }
+
+    #[test]
+    fn raw_streaming_response_reports_usage() {
+        let usage = completion::Usage {
+            input_tokens: 7,
+            output_tokens: 3,
+            total_tokens: 10,
+            cached_input_tokens: 2,
+        };
+
+        let response = RawStreamingResponse {
+            body: serde_json::json!({"ok": true}),
+            usage: Some(usage),
+        };
+
+        assert_eq!(response.token_usage(), Some(usage));
+    }
+
+    #[test]
+    fn format_api_error_includes_openrouter_metadata() {
+        let status = reqwest::StatusCode::BAD_REQUEST;
+
+        // OpenRouter-style error with provider_name and raw upstream error
+        let body = serde_json::json!({
+            "error": {
+                "message": "Provider returned error",
+                "metadata": {
+                    "provider_name": "Moonshot",
+                    "raw": "Invalid request: tool_use not supported"
+                }
+            }
+        });
+        let msg = format_api_error(status, &body);
+        assert!(msg.contains("Provider returned error"));
+        assert!(msg.contains("Moonshot"));
+        assert!(msg.contains("tool_use not supported"));
+
+        // Standard OpenAI error without metadata
+        let body = serde_json::json!({
+            "error": {
+                "message": "Invalid model ID"
+            }
+        });
+        let msg = format_api_error(status, &body);
+        assert_eq!(msg, "400 Bad Request: Invalid model ID");
+
+        // Metadata with provider_name but no raw
+        let body = serde_json::json!({
+            "error": {
+                "message": "Provider returned error",
+                "metadata": {
+                    "provider_name": "Azure"
+                }
+            }
+        });
+        let msg = format_api_error(status, &body);
+        assert!(msg.contains("Azure"));
+        assert!(!msg.contains("raw"));
+
+        // Structured JSON raw error (not a string)
+        let body = serde_json::json!({
+            "error": {
+                "message": "Provider returned error",
+                "metadata": {
+                    "provider_name": "Google",
+                    "raw": {"code": 400, "detail": "invalid schema"}
+                }
+            }
+        });
+        let msg = format_api_error(status, &body);
+        assert!(msg.contains("Google"));
+        assert!(msg.contains("invalid schema"));
+    }
 }
diff --git a/src/llm/providers.rs b/src/llm/providers.rs
index 6153e6682..7ab5e80b4 100644
--- a/src/llm/providers.rs
+++ b/src/llm/providers.rs
@@ -17,6 +17,10 @@ pub async fn init_providers(config: &LlmConfig) -> Result<()> {
         tracing::info!("OpenAI provider configured");
     }
 
+    if config.kilo_key.is_some() {
+        tracing::info!("Kilo Gateway provider configured");
+    }
+
     if config.ollama_base_url.is_some() || config.ollama_key.is_some() {
         tracing::info!("Ollama provider configured");
     }
@@ -25,6 +29,10 @@ pub async fn init_providers(config: &LlmConfig) -> Result<()> {
         tracing::info!("OpenCode Zen provider configured");
     }
 
+    if config.opencode_go_key.is_some() {
+        tracing::info!("OpenCode Go provider configured");
+    }
+
     if config.minimax_key.is_some() {
         tracing::info!("MiniMax provider configured");
     }
diff --git a/src/llm/routing.rs b/src/llm/routing.rs
index 0549692e6..0c3b6744c 100644
--- a/src/llm/routing.rs
+++ b/src/llm/routing.rs
@@ -174,6 +174,22 @@ pub fn defaults_for_provider(provider: &str) -> RoutingConfig {
                 ..RoutingConfig::default()
             }
         }
+        "kilo" => {
+            let channel: String = "kilo/anthropic/claude-sonnet-4.5".into();
+            let worker: String = "kilo/anthropic/claude-haiku-4.5".into();
+            RoutingConfig {
+                channel: channel.clone(),
+                branch: channel.clone(),
+                worker: worker.clone(),
+                compactor: worker.clone(),
+                cortex: worker,
+                voice: String::new(),
+                task_overrides: HashMap::from([("coding".into(), channel)]),
+                fallbacks: HashMap::new(),
+                rate_limit_cooldown_secs: 60,
+                ..RoutingConfig::default()
+            }
+        }
         "openai" => {
             let channel: String = "openai/gpt-4.1".into();
             let worker: String = "openai/gpt-4.1-mini".into();
@@ -353,6 +369,22 @@ pub fn defaults_for_provider(provider: &str) -> RoutingConfig {
                 ..RoutingConfig::default()
             }
         }
+        "opencode-go" => {
+            let channel: String = "opencode-go/kimi-k2.5".into();
+            let worker: String = "opencode-go/kimi-k2".into();
+            RoutingConfig {
+                channel: channel.clone(),
+                branch: channel.clone(),
+                worker: worker.clone(),
+                compactor: worker.clone(),
+                cortex: worker.clone(),
+                voice: String::new(),
+                task_overrides: HashMap::from([("coding".into(), channel.clone())]),
+                fallbacks: HashMap::from([(channel, vec![worker])]),
+                rate_limit_cooldown_secs: 60,
+                ..RoutingConfig::default()
+            }
+        }
         "nvidia" => RoutingConfig::for_model("nvidia/meta/llama-3.1-405b-instruct".into()),
         "minimax" => RoutingConfig::for_model("minimax/MiniMax-M2.5".into()),
         "minimax-cn" => RoutingConfig::for_model("minimax-cn/MiniMax-M2.5".into()),
@@ -367,6 +399,7 @@ pub fn defaults_for_provider(provider: &str) -> RoutingConfig {
 pub fn provider_to_prefix(provider: &str) -> &str {
     match provider {
         "openrouter" => "openrouter/",
+        "kilo" => "kilo/",
         "openai" => "openai/",
         "openai-chatgpt" => "openai-chatgpt/",
         "anthropic" => "anthropic/",
@@ -380,6 +413,7 @@ pub fn provider_to_prefix(provider: &str) -> &str {
         "gemini" => "gemini/",
         "nvidia" => "nvidia/",
         "opencode-zen" => "opencode-zen/",
+        "opencode-go" => "opencode-go/",
         "minimax" => "minimax/",
         "minimax-cn" => "minimax-cn/",
         "moonshot" => "moonshot/",
diff --git a/src/main.rs b/src/main.rs
index 451f89b93..b7890d9a2 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -49,6 +49,9 @@ enum Command {
     /// Manage authentication
     #[command(subcommand)]
     Auth(AuthCommand),
+    /// Manage secrets stored in the running instance
+    #[command(subcommand)]
+    Secrets(SecretsCommand),
 }
 
 #[derive(Subcommand)]
@@ -115,6 +118,64 @@ enum SkillCommand {
     },
 }
 
+#[derive(Subcommand)]
+enum SecretsCommand {
+    /// Show store state and secret counts
+    Status,
+    /// List all secrets (name + category)
+    List,
+    /// Add or update a secret
+    Set {
+        /// Secret name (e.g. GH_TOKEN)
+        name: String,
+        /// Secret category (system or tool)
+        #[arg(short, long)]
+        category: Option<String>,
+        /// Read value from stdin instead of interactive prompt
+        #[arg(long)]
+        stdin: bool,
+    },
+    /// Delete a secret
+    Delete {
+        /// Secret name
+        name: String,
+    },
+    /// Show secret metadata and config references
+    Info {
+        /// Secret name
+        name: String,
+    },
+    /// Auto-migrate plaintext keys from config.toml
+    Migrate,
+    /// Enable encryption (generate master key, encrypt all secrets)
+    Encrypt,
+    /// Unlock encrypted store
+    Unlock {
+        /// Read master key from stdin instead of interactive prompt
+        #[arg(long)]
+        stdin: bool,
+    },
+    /// Lock encrypted store (clear key from memory)
+    Lock,
+    /// Rotate master key (encrypted mode only)
+    Rotate,
+    /// Export all secrets to a backup file
+    Export {
+        /// Output file path
+        #[arg(short, long)]
+        output: std::path::PathBuf,
+    },
+    /// Import secrets from a backup file
+    Import {
+        /// Input file path
+        #[arg(short, long)]
+        input: std::path::PathBuf,
+        /// Overwrite existing secrets with same name
+        #[arg(long)]
+        overwrite: bool,
+    },
+}
+
 /// Tracks an active conversation channel and its message sender.
 struct ActiveChannel {
     message_tx: mpsc::Sender<spacebot::InboundMessage>,
@@ -144,6 +205,7 @@ fn main() -> anyhow::Result<()> {
         Command::Status => cmd_status(),
         Command::Skill(skill_cmd) => cmd_skill(cli.config, skill_cmd),
         Command::Auth(auth_cmd) => cmd_auth(cli.config, auth_cmd),
+        Command::Secrets(secrets_cmd) => cmd_secrets(cli.config, secrets_cmd),
     }
 }
 
@@ -170,6 +232,10 @@ fn cmd_start(
         None
     };
 
+    // Open the instance-level secrets store so `secret:` references in config.toml
+    // resolve during Config::load(). The store is shared with all agents.
+    let bootstrapped_store = bootstrap_secrets_store(&resolved_config_path);
+
     // Validate config loads successfully before forking
     let config = load_config(&resolved_config_path)?;
 
@@ -202,7 +268,7 @@ fn cmd_start(
             spacebot::daemon::init_background_tracing(&paths, debug, &config.telemetry)
         };
 
-        run(config, foreground, otel_provider).await
+        run(config, foreground, otel_provider, bootstrapped_store).await
     })
 }
 
@@ -390,6 +456,475 @@ fn cmd_auth(config_path: Option<std::path::PathBuf>, auth_cmd: AuthCommand) -> a
     })
 }
 
+fn cmd_secrets(
+    config_path: Option<std::path::PathBuf>,
+    secrets_cmd: SecretsCommand,
+) -> anyhow::Result<()> {
+    // Bootstrap the secrets store so `secret:` references in config resolve.
+    bootstrap_secrets_store(&config_path);
+
+    let config = load_config(&config_path)?;
+    let api_base = format!("http://{}:{}/api", config.api.bind, config.api.port);
+    let auth_token = config.api.auth_token.clone();
+
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .context("failed to build tokio runtime")?;
+
+    runtime.block_on(async {
+        let client = reqwest::Client::new();
+
+        match secrets_cmd {
+            SecretsCommand::Status => {
+                let response =
+                    secrets_api_get(&client, &api_base, &auth_token, "secrets/status").await?;
+                let body: serde_json::Value = response.json().await?;
+                eprintln!(
+                    "State:          {}",
+                    body["state"].as_str().unwrap_or("unknown")
+                );
+                eprintln!(
+                    "Encrypted:      {}",
+                    body["encrypted"].as_bool().unwrap_or(false)
+                );
+                eprintln!(
+                    "Total secrets:  {}",
+                    body["secret_count"].as_u64().unwrap_or(0)
+                );
+                eprintln!(
+                    "  System:       {}",
+                    body["system_count"].as_u64().unwrap_or(0)
+                );
+                eprintln!(
+                    "  Tool:         {}",
+                    body["tool_count"].as_u64().unwrap_or(0)
+                );
+                if body["platform_managed"].as_bool().unwrap_or(false) {
+                    eprintln!("  Managed by:   platform");
+                }
+                Ok(())
+            }
+            SecretsCommand::List => {
+                let response = secrets_api_get(&client, &api_base, &auth_token, "secrets").await?;
+                let body: serde_json::Value = response.json().await?;
+                let secrets = body["secrets"].as_array();
+                match secrets {
+                    Some(list) if !list.is_empty() => {
+                        eprintln!("{:<30} {:<10} UPDATED", "NAME", "CATEGORY");
+                        for secret in list {
+                            let name = secret["name"].as_str().unwrap_or("");
+                            let category = secret["category"].as_str().unwrap_or("");
+                            let updated = secret["updated_at"].as_str().unwrap_or("");
+                            // Truncate ISO timestamp to date + time.
+                            let short_date = &updated[..updated.len().min(16)];
+                            eprintln!("{:<30} {:<10} {}", name, category, short_date);
+                        }
+                    }
+                    _ => {
+                        eprintln!("No secrets stored.");
+                    }
+                }
+                Ok(())
+            }
+            SecretsCommand::Set {
+                name,
+                category,
+                stdin,
+            } => {
+                let value = if stdin {
+                    let mut buf = String::new();
+                    std::io::Read::read_to_string(&mut std::io::stdin(), &mut buf)?;
+                    buf.trim_end().to_string()
+                } else {
+                    dialoguer::Password::new()
+                        .with_prompt("Enter value")
+                        .interact()
+                        .context("failed to read secret value")?
+                };
+
+                if value.is_empty() {
+                    anyhow::bail!("secret value cannot be empty");
+                }
+
+                let mut body = serde_json::json!({ "value": value });
+                if let Some(cat) = &category {
+                    body["category"] = serde_json::json!(cat);
+                }
+
+                let response = secrets_api_put(
+                    &client,
+                    &api_base,
+                    &auth_token,
+                    &format!("secrets/{name}"),
+                    &body,
+                )
+                .await?;
+
+                if response.status().is_success() {
+                    let result: serde_json::Value = response.json().await?;
+                    eprintln!(
+                        "Secret {} saved ({}).",
+                        result["name"].as_str().unwrap_or(&name),
+                        result["category"].as_str().unwrap_or("unknown")
+                    );
+                    if result["reload_required"].as_bool().unwrap_or(false) {
+                        eprintln!(
+                            "Note: Reload config or restart for the new value to take effect."
+                        );
+                    }
+                } else {
+                    let error: serde_json::Value = response.json().await?;
+                    anyhow::bail!("{}", error["error"].as_str().unwrap_or("unknown error"));
+                }
+                Ok(())
+            }
+            SecretsCommand::Delete { name } => {
+                let response =
+                    secrets_api_delete(&client, &api_base, &auth_token, &format!("secrets/{name}"))
+                        .await?;
+
+                if response.status().is_success() {
+                    let result: serde_json::Value = response.json().await?;
+                    eprintln!("Deleted {}.", result["deleted"].as_str().unwrap_or(&name));
+                    if let Some(warning) = result["warning"].as_str() {
+                        eprintln!("Warning: {warning}");
+                    }
+                } else {
+                    let error: serde_json::Value = response.json().await?;
+                    anyhow::bail!("{}", error["error"].as_str().unwrap_or("unknown error"));
+                }
+                Ok(())
+            }
+            SecretsCommand::Info { name } => {
+                let response = secrets_api_get(
+                    &client,
+                    &api_base,
+                    &auth_token,
+                    &format!("secrets/{name}/info"),
+                )
+                .await?;
+
+                if response.status().is_success() {
+                    let info: serde_json::Value = response.json().await?;
+                    eprintln!("Name:     {}", info["name"].as_str().unwrap_or(""));
+                    eprintln!("Category: {}", info["category"].as_str().unwrap_or(""));
+                    eprintln!("Created:  {}", info["created_at"].as_str().unwrap_or(""));
+                    eprintln!("Updated:  {}", info["updated_at"].as_str().unwrap_or(""));
+                } else {
+                    let error: serde_json::Value = response.json().await?;
+                    anyhow::bail!("{}", error["error"].as_str().unwrap_or("secret not found"));
+                }
+                Ok(())
+            }
+            SecretsCommand::Migrate => {
+                let response = secrets_api_post(
+                    &client,
+                    &api_base,
+                    &auth_token,
+                    "secrets/migrate",
+                    &serde_json::json!({}),
+                )
+                .await?;
+
+                if response.status().is_success() {
+                    let result: serde_json::Value = response.json().await?;
+                    eprintln!(
+                        "{}",
+                        result["message"].as_str().unwrap_or("Migration complete.")
+                    );
+                    if let Some(migrated) = result["migrated"].as_array() {
+                        for item in migrated {
+                            eprintln!(
+                                "  {} -> {} ({})",
+                                item["config_key"].as_str().unwrap_or(""),
+                                item["secret_name"].as_str().unwrap_or(""),
+                                item["category"].as_str().unwrap_or(""),
+                            );
+                        }
+                    }
+                } else {
+                    let error: serde_json::Value = response.json().await?;
+                    anyhow::bail!("{}", error["error"].as_str().unwrap_or("migration failed"));
+                }
+                Ok(())
+            }
+            SecretsCommand::Encrypt => {
+                let response = secrets_api_post(
+                    &client,
+                    &api_base,
+                    &auth_token,
+                    "secrets/encrypt",
+                    &serde_json::json!({}),
+                )
+                .await?;
+
+                if response.status().is_success() {
+                    let result: serde_json::Value = response.json().await?;
+                    eprintln!();
+                    eprintln!("Encryption enabled.");
+                    eprintln!();
+                    eprintln!(
+                        "Master key: {}",
+                        result["master_key"].as_str().unwrap_or("")
+                    );
+                    eprintln!();
+                    eprintln!("IMPORTANT: Save this master key. You will need it to unlock");
+                    eprintln!("the secret store after a reboot (Linux) or if the Keychain");
+                    eprintln!("is reset (macOS). This is the only time the key will be shown.");
+                } else {
+                    let error: serde_json::Value = response.json().await?;
+                    anyhow::bail!("{}", error["error"].as_str().unwrap_or("encryption failed"));
+                }
+                Ok(())
+            }
+            SecretsCommand::Unlock { stdin } => {
+                let master_key = if stdin {
+                    let mut buf = String::new();
+                    std::io::Read::read_to_string(&mut std::io::stdin(), &mut buf)?;
+                    buf.trim().to_string()
+                } else {
+                    dialoguer::Password::new()
+                        .with_prompt("Enter master key")
+                        .interact()
+                        .context("failed to read master key")?
+                };
+
+                let response = secrets_api_post(
+                    &client,
+                    &api_base,
+                    &auth_token,
+                    "secrets/unlock",
+                    &serde_json::json!({ "master_key": master_key }),
+                )
+                .await?;
+
+                if response.status().is_success() {
+                    let result: serde_json::Value = response.json().await?;
+                    eprintln!("{}", result["message"].as_str().unwrap_or("Unlocked."));
+                } else {
+                    let error: serde_json::Value = response.json().await?;
+                    anyhow::bail!("{}", error["error"].as_str().unwrap_or("unlock failed"));
+                }
+                Ok(())
+            }
+            SecretsCommand::Lock => {
+                let response = secrets_api_post(
+                    &client,
+                    &api_base,
+                    &auth_token,
+                    "secrets/lock",
+                    &serde_json::json!({}),
+                )
+                .await?;
+
+                if response.status().is_success() {
+                    let result: serde_json::Value = response.json().await?;
+                    eprintln!("{}", result["message"].as_str().unwrap_or("Locked."));
+                } else {
+                    let error: serde_json::Value = response.json().await?;
+                    anyhow::bail!("{}", error["error"].as_str().unwrap_or("lock failed"));
+                }
+                Ok(())
+            }
+            SecretsCommand::Rotate => {
+                eprintln!("WARNING: This will invalidate your current master key.");
+                eprintln!("You will need to save the new key for future unlocks.");
+                eprint!("Continue? [y/N]: ");
+                let mut confirm = String::new();
+                std::io::BufRead::read_line(&mut std::io::stdin().lock(), &mut confirm)?;
+                if !confirm.trim().eq_ignore_ascii_case("y") {
+                    eprintln!("Cancelled.");
+                    return Ok(());
+                }
+
+                let response = secrets_api_post(
+                    &client,
+                    &api_base,
+                    &auth_token,
+                    "secrets/rotate",
+                    &serde_json::json!({}),
+                )
+                .await?;
+
+                if response.status().is_success() {
+                    let result: serde_json::Value = response.json().await?;
+                    eprintln!();
+                    eprintln!(
+                        "New master key: {}",
+                        result["master_key"].as_str().unwrap_or("")
+                    );
+                    eprintln!();
+                    eprintln!("IMPORTANT: Save this new key. Your old key no longer works.");
+                } else {
+                    let error: serde_json::Value = response.json().await?;
+                    anyhow::bail!("{}", error["error"].as_str().unwrap_or("rotation failed"));
+                }
+                Ok(())
+            }
+            SecretsCommand::Export { output } => {
+                let response = secrets_api_post(
+                    &client,
+                    &api_base,
+                    &auth_token,
+                    "secrets/export",
+                    &serde_json::json!({}),
+                )
+                .await?;
+
+                if response.status().is_success() {
+                    let body: serde_json::Value = response.json().await?;
+                    let count = body["count"].as_u64().unwrap_or(0);
+                    let content = serde_json::to_string_pretty(&body)
+                        .context("failed to serialize export data")?;
+                    // Write with restrictive permissions — this file contains
+                    // plaintext secrets.
+                    #[cfg(unix)]
+                    {
+                        use std::io::Write as _;
+                        use std::os::unix::fs::OpenOptionsExt as _;
+                        let mut file = std::fs::OpenOptions::new()
+                            .write(true)
+                            .create(true)
+                            .truncate(true)
+                            .mode(0o600)
+                            .open(&output)
+                            .with_context(|| format!("failed to create {}", output.display()))?;
+                        file.write_all(content.as_bytes())
+                            .with_context(|| format!("failed to write {}", output.display()))?;
+                    }
+                    #[cfg(not(unix))]
+                    {
+                        std::fs::write(&output, content)
+                            .with_context(|| format!("failed to write {}", output.display()))?;
+                    }
+                    eprintln!("Exported {count} secrets to {}", output.display());
+
+                    if let Some(warning) = body["warning"].as_str() {
+                        eprintln!();
+                        eprintln!("WARNING: {warning}");
+                    }
+                } else {
+                    let error: serde_json::Value = response.json().await?;
+                    anyhow::bail!("{}", error["error"].as_str().unwrap_or("export failed"));
+                }
+                Ok(())
+            }
+            SecretsCommand::Import { input, overwrite } => {
+                let content = std::fs::read_to_string(&input)
+                    .with_context(|| format!("failed to read {}", input.display()))?;
+                let mut import_data: serde_json::Value = serde_json::from_str(&content)
+                    .context("failed to parse backup file as JSON")?;
+
+                import_data["overwrite"] = serde_json::json!(overwrite);
+
+                let response = secrets_api_post(
+                    &client,
+                    &api_base,
+                    &auth_token,
+                    "secrets/import",
+                    &import_data,
+                )
+                .await?;
+
+                if response.status().is_success() {
+                    let result: serde_json::Value = response.json().await?;
+                    eprintln!(
+                        "{}",
+                        result["message"].as_str().unwrap_or("Import complete.")
+                    );
+                    if let Some(skipped) = result["skipped"].as_array()
+                        && !skipped.is_empty()
+                    {
+                        for name in skipped {
+                            eprintln!(
+                                "  {} -- kept existing (use --overwrite to replace)",
+                                name.as_str().unwrap_or("")
+                            );
+                        }
+                    }
+                } else {
+                    let error: serde_json::Value = response.json().await?;
+                    anyhow::bail!("{}", error["error"].as_str().unwrap_or("import failed"));
+                }
+                Ok(())
+            }
+        }
+    })
+}
+
+/// Build an authenticated HTTP request to the control API.
+fn secrets_api_request(
+    client: &reqwest::Client,
+    method: reqwest::Method,
+    api_base: &str,
+    auth_token: &Option<String>,
+    path: &str,
+) -> reqwest::RequestBuilder {
+    let url = format!("{api_base}/{path}");
+    let mut request = client.request(method, &url);
+    if let Some(token) = auth_token {
+        request = request.bearer_auth(token);
+    }
+    request
+}
+
+async fn secrets_api_get(
+    client: &reqwest::Client,
+    api_base: &str,
+    auth_token: &Option<String>,
+    path: &str,
+) -> anyhow::Result<reqwest::Response> {
+    let response = secrets_api_request(client, reqwest::Method::GET, api_base, auth_token, path)
+        .send()
+        .await
+        .context("failed to connect to spacebot API — is the daemon running?")?;
+    Ok(response)
+}
+
+async fn secrets_api_post(
+    client: &reqwest::Client,
+    api_base: &str,
+    auth_token: &Option<String>,
+    path: &str,
+    body: &serde_json::Value,
+) -> anyhow::Result<reqwest::Response> {
+    let response = secrets_api_request(client, reqwest::Method::POST, api_base, auth_token, path)
+        .json(body)
+        .send()
+        .await
+        .context("failed to connect to spacebot API — is the daemon running?")?;
+    Ok(response)
+}
+
+async fn secrets_api_put(
+    client: &reqwest::Client,
+    api_base: &str,
+    auth_token: &Option<String>,
+    path: &str,
+    body: &serde_json::Value,
+) -> anyhow::Result<reqwest::Response> {
+    let response = secrets_api_request(client, reqwest::Method::PUT, api_base, auth_token, path)
+        .json(body)
+        .send()
+        .await
+        .context("failed to connect to spacebot API — is the daemon running?")?;
+    Ok(response)
+}
+
+async fn secrets_api_delete(
+    client: &reqwest::Client,
+    api_base: &str,
+    auth_token: &Option<String>,
+    path: &str,
+) -> anyhow::Result<reqwest::Response> {
+    let response = secrets_api_request(client, reqwest::Method::DELETE, api_base, auth_token, path)
+        .send()
+        .await
+        .context("failed to connect to spacebot API — is the daemon running?")?;
+    Ok(response)
+}
+
 fn cmd_skill(
     config_path: Option<std::path::PathBuf>,
     skill_cmd: SkillCommand,
@@ -587,6 +1122,188 @@ fn load_config(
     }
 }
 
+/// Pre-open secrets stores before config loading so `secret:` references in
+/// config.toml can resolve.
+///
+/// Config resolution happens in `Config::load()`, which calls `resolve_env_value()`
+/// for every credential field. That function checks the thread-local
+/// `RESOLVE_SECRETS_STORE` for `secret:` prefixed values. Without this bootstrap,
+/// all `secret:` references resolve to `None` and the config fails validation
+/// (e.g., messaging adapters see empty tokens and error out).
+///
+/// Returns the pre-opened stores keyed by agent ID. These are reused later in
+/// `initialize_agents()` to avoid double-opening the redb files.
+/// Keystore identifier for the instance-level master key.
+const KEYSTORE_INSTANCE_ID: &str = "instance";
+
+/// Open the instance-level secrets store at `<instance_dir>/data/secrets.redb`
+/// before config loading so that `secret:` references in config.toml resolve.
+///
+/// If no instance-level store exists but per-agent stores do (from the previous
+/// per-agent model), secrets are migrated from the first non-empty agent store.
+fn bootstrap_secrets_store(
+    config_path: &Option<std::path::PathBuf>,
+) -> Option<Arc<spacebot::secrets::store::SecretsStore>> {
+    // Probe kernel keyring support before any workers spawn. If keyctl is
+    // blocked (restrictive seccomp, gVisor, etc.), worker keyring isolation
+    // is disabled but workers still start normally.
+    spacebot::secrets::keystore::probe_keyring_support();
+
+    let instance_dir = if let Some(path) = config_path {
+        path.parent()
+            .map(|p| p.to_path_buf())
+            .unwrap_or_else(|| std::path::PathBuf::from("."))
+    } else {
+        spacebot::config::Config::default_instance_dir()
+    };
+
+    let data_dir = instance_dir.join("data");
+    if let Err(error) = std::fs::create_dir_all(&data_dir) {
+        eprintln!("warning: failed to create instance data directory: {error}");
+        return None;
+    }
+
+    let secrets_path = data_dir.join("secrets.redb");
+    let is_new_store = !secrets_path.exists();
+
+    let store = match spacebot::secrets::store::SecretsStore::new(&secrets_path) {
+        Ok(store) => Arc::new(store),
+        Err(error) => {
+            eprintln!("warning: failed to open secrets store: {error}");
+            return None;
+        }
+    };
+
+    // Migrate from legacy per-agent stores if the instance store is brand new.
+    if is_new_store {
+        migrate_legacy_agent_stores(&instance_dir, &store);
+    }
+
+    // Try to auto-unlock if encrypted.
+    if store.is_encrypted() {
+        let keystore = spacebot::secrets::keystore::platform_keystore();
+
+        // Hosted: check tmpfs-injected key.
+        let tmpfs_key_path = std::path::Path::new("/run/spacebot/master_key");
+        let master_key = if tmpfs_key_path.exists() {
+            std::fs::read(tmpfs_key_path).ok().inspect(|key| {
+                if let Err(error) = std::fs::remove_file(tmpfs_key_path) {
+                    tracing::warn!(%error, "failed to remove tmpfs master key — key may remain accessible");
+                }
+                if let Err(error) = keystore.store_key(KEYSTORE_INSTANCE_ID, key) {
+                    tracing::warn!(%error, "failed to persist master key to OS credential store");
+                }
+            })
+        } else {
+            // Try instance-level key first, then fall back to legacy agent keys.
+            keystore
+                .load_key(KEYSTORE_INSTANCE_ID)
+                .ok()
+                .flatten()
+                .or_else(|| load_legacy_keystore_key(&instance_dir))
+        };
+
+        if let Some(key) = master_key
+            && let Err(error) = store.unlock(&key)
+        {
+            tracing::warn!(%error, "failed to unlock secret store — secrets will be inaccessible");
+        }
+    }
+
+    // Set the store into the thread-local for config resolution.
+    spacebot::config::set_resolve_secrets_store(store.clone());
+
+    Some(store)
+}
+
+/// Migrate secrets from legacy per-agent redb stores into the new instance-level
+/// store. Only runs once when the instance-level store is first created.
+fn migrate_legacy_agent_stores(
+    instance_dir: &std::path::Path,
+    target_store: &spacebot::secrets::store::SecretsStore,
+) {
+    let agents_dir = instance_dir.join("agents");
+    let entries = match std::fs::read_dir(&agents_dir) {
+        Ok(entries) => entries,
+        Err(_) => return,
+    };
+
+    let mut total_migrated = 0usize;
+
+    for entry in entries.flatten() {
+        if !entry.file_type().is_ok_and(|ft| ft.is_dir()) {
+            continue;
+        }
+        let secrets_path = entry.path().join("data").join("secrets.redb");
+        if !secrets_path.exists() {
+            continue;
+        }
+
+        // Open the legacy agent store (read-only access).
+        let legacy_store = match spacebot::secrets::store::SecretsStore::new(&secrets_path) {
+            Ok(store) => store,
+            Err(_) => continue,
+        };
+
+        // If the legacy store is encrypted, try to unlock it with OS keystore.
+        if legacy_store.is_encrypted() {
+            let agent_id = entry.file_name().to_string_lossy().to_string();
+            let keystore = spacebot::secrets::keystore::platform_keystore();
+            if let Some(key) = keystore.load_key(&agent_id).ok().flatten() {
+                let _ = legacy_store.unlock(&key);
+            } else {
+                continue; // Can't read encrypted store without key.
+            }
+        }
+
+        // Export all secrets from the legacy store.
+        let export = match legacy_store.export_all() {
+            Ok(export) => export,
+            Err(_) => continue,
+        };
+
+        // Import into the target store (don't overwrite — first agent wins for
+        // duplicates, which is fine since all agents had the same secrets).
+        match target_store.import_all(&export, false) {
+            Ok(result) => {
+                total_migrated += result.imported;
+            }
+            Err(error) => {
+                eprintln!(
+                    "warning: failed to migrate secrets from {}: {error}",
+                    secrets_path.display()
+                );
+            }
+        }
+    }
+
+    if total_migrated > 0 {
+        eprintln!(
+            "info: migrated {total_migrated} secrets from legacy per-agent stores to instance store"
+        );
+    }
+}
+
+/// Try to load a master key from legacy per-agent keystore entries.
+fn load_legacy_keystore_key(instance_dir: &std::path::Path) -> Option<Vec<u8>> {
+    let agents_dir = instance_dir.join("agents");
+    let entries = std::fs::read_dir(&agents_dir).ok()?;
+    let keystore = spacebot::secrets::keystore::platform_keystore();
+
+    for entry in entries.flatten() {
+        if !entry.file_type().is_ok_and(|ft| ft.is_dir()) {
+            continue;
+        }
+        let agent_id = entry.file_name().to_string_lossy().to_string();
+        if let Ok(Some(key)) = keystore.load_key(&agent_id) {
+            // Migrate the key to the instance-level keystore entry.
+            let _ = keystore.store_key(KEYSTORE_INSTANCE_ID, &key);
+            return Some(key);
+        }
+    }
+    None
+}
+
 fn has_provider_credentials(
     llm_config: &spacebot::config::LlmConfig,
     instance_dir: &std::path::Path,
@@ -600,6 +1317,7 @@ async fn run(
     config: spacebot::config::Config,
     foreground: bool,
     otel_provider: Option<opentelemetry_sdk::trace::SdkTracerProvider>,
+    bootstrapped_store: Option<Arc<spacebot::secrets::store::SecretsStore>>,
 ) -> anyhow::Result<()> {
     let paths = spacebot::daemon::DaemonPaths::new(&config.instance_dir);
 
@@ -618,9 +1336,24 @@ async fn run(
     // Channel for removing agents from the main event loop
     let (agent_remove_tx, mut agent_remove_rx) = mpsc::channel::<String>(8);
 
+    // Channel for cross-agent message injection (e.g. delegated task completion notifications).
+    // The sender is shared with all agents via AgentDeps; the receiver is polled in the main loop.
+    let (injection_tx, mut injection_rx) =
+        tokio::sync::mpsc::channel::<spacebot::ChannelInjection>(64);
+
+    // Shared cross-agent task store registry. Populated after all agents are initialized.
+    let task_store_registry: Arc<
+        ArcSwap<std::collections::HashMap<String, Arc<spacebot::tasks::TaskStore>>>,
+    > = Arc::new(ArcSwap::from_pointee(std::collections::HashMap::new()));
+
     // Start HTTP API server if enabled
-    let mut api_state =
-        spacebot::api::ApiState::new_with_provider_sender(provider_tx, agent_tx, agent_remove_tx);
+    let mut api_state = spacebot::api::ApiState::new_with_provider_sender(
+        provider_tx,
+        agent_tx,
+        agent_remove_tx,
+        injection_tx.clone(),
+        task_store_registry.clone(),
+    );
     api_state.auth_token = config.api.auth_token.clone();
     let api_state = Arc::new(api_state);
 
@@ -771,6 +1504,9 @@ async fn run(
             &mut telegram_permissions,
             &mut twitch_permissions,
             agent_links.clone(),
+            injection_tx.clone(),
+            task_store_registry.clone(),
+            &bootstrapped_store,
         )
         .await?;
         agents_initialized = true;
@@ -871,6 +1607,11 @@ async fn run(
                         agent.config.screenshot_dir(),
                         agent.config.logs_dir(),
                     );
+                    agent
+                        .deps
+                        .process_control_registry
+                        .register_channel(channel.id.clone(), channel.control_handle().downgrade())
+                        .await;
 
                     // Register the channel's status block with the API for snapshot queries
                     api_state.register_channel_status(
@@ -918,10 +1659,25 @@ async fn run(
                     }
 
                     // Spawn the channel's event loop
+                    let cleanup_channel_id = conversation_id.clone();
+                    let process_control_registry = agent.deps.process_control_registry.clone();
+                    let api_state_for_cleanup = api_state.clone();
                     tokio::spawn(async move {
                         if let Err(error) = channel.run().await {
                             tracing::error!(%error, "channel event loop failed");
                         }
+
+                        let scoped_channel_id: spacebot::ChannelId =
+                            Arc::from(cleanup_channel_id.as_str());
+                        process_control_registry
+                            .unregister_channel(&scoped_channel_id)
+                            .await;
+                        api_state_for_cleanup
+                            .unregister_channel_status(&cleanup_channel_id)
+                            .await;
+                        api_state_for_cleanup
+                            .unregister_channel_state(&cleanup_channel_id)
+                            .await;
                     });
 
                     // Spawn outbound response routing: reads from response_rx,
@@ -933,7 +1689,6 @@ async fn run(
                     let api_event_tx = api_state.event_tx.clone();
                     let sse_agent_id = agent_id.to_string();
                     let sse_channel_id = conversation_id.clone();
-                    let outbound_agent_names = agent.deps.agent_names.clone();
                     let outbound_handle = tokio::spawn(async move {
                         while let Some(response) = response_rx.recv().await {
                             // Forward relevant events to SSE clients
@@ -978,100 +1733,6 @@ async fn run(
 
                             let current_message = outbound_message.read().await.clone();
 
-                            // Internal link channels: route replies back to the sender's link channel
-                            if current_message.source == "internal" {
-                                let reply_text = match &response {
-                                    spacebot::OutboundResponse::Text(t) => Some(t.clone()),
-                                    spacebot::OutboundResponse::RichMessage { text, .. } => Some(text.clone()),
-                                    spacebot::OutboundResponse::ThreadReply { text, .. } => Some(text.clone()),
-                                    spacebot::OutboundResponse::Status(_) => None,
-                                    _ => None,
-                                };
-
-                                if let Some(text) = reply_text {
-                                    let reply_to_agent = current_message.metadata
-                                        .get("reply_to_agent")
-                                        .and_then(|v| v.as_str())
-                                        .map(String::from);
-                                    let reply_to_channel = current_message.metadata
-                                        .get("reply_to_channel")
-                                        .and_then(|v| v.as_str())
-                                        .map(String::from);
-
-                                    if let (Some(target_agent), Some(target_channel)) = (reply_to_agent, reply_to_channel) {
-                                        let agent_display = outbound_agent_names
-                                            .get(&sse_agent_id)
-                                            .cloned()
-                                            .unwrap_or_else(|| sse_agent_id.clone());
-
-                                        // Include the original sent message so the receiving
-                                        // agent's link channel can seed its history with context
-                                        let original_text = match &current_message.content {
-                                            spacebot::MessageContent::Text(t) => Some(t.clone()),
-                                            spacebot::MessageContent::Media { text, .. } => text.clone(),
-                                            _ => None,
-                                        };
-
-                                        let mut metadata = std::collections::HashMap::from([
-                                            ("from_agent_id".into(), serde_json::json!(&sse_agent_id)),
-                                            ("reply_to_agent".into(), serde_json::json!(&sse_agent_id)),
-                                            ("reply_to_channel".into(), serde_json::json!(&outbound_conversation_id)),
-                                        ]);
-                                        if let Some(original) = original_text {
-                                            metadata.insert("original_sent_message".into(), serde_json::json!(original));
-                                        }
-                                        // Propagate originating_channel and originating_source so both sides
-                                        // know where to route conclusions and which adapter to use.
-                                        if let Some(originating) = current_message.metadata.get("originating_channel") {
-                                            metadata.insert("originating_channel".into(), originating.clone());
-                                        }
-                                        if let Some(source) = current_message.metadata.get("originating_source") {
-                                            metadata.insert("originating_source".into(), source.clone());
-                                        }
-
-                                        let reply_message = spacebot::InboundMessage {
-                                            id: uuid::Uuid::new_v4().to_string(),
-                                            source: "internal".into(),
-                                            conversation_id: target_channel.clone(),
-                                            sender_id: sse_agent_id.clone(),
-                                            agent_id: Some(Arc::from(target_agent.as_str())),
-                                            content: spacebot::MessageContent::Text(text),
-                                            timestamp: chrono::Utc::now(),
-                                            metadata,
-                                            formatted_author: Some(format!("[{agent_display}]")),
-                                        };
-
-                                        if let Err(error) = messaging_for_outbound
-                                            .inject_message(reply_message)
-                                            .await
-                                        {
-                                            tracing::error!(
-                                                %error,
-                                                from = %sse_agent_id,
-                                                to = %target_agent,
-                                                "failed to route link channel reply"
-                                            );
-                                        } else {
-                                            // Emit SSE event so the dashboard animates the edge
-                                            api_event_tx.send(spacebot::api::ApiEvent::AgentMessageSent {
-                                                from_agent_id: sse_agent_id.clone(),
-                                                to_agent_id: target_agent.clone(),
-                                                link_id: target_channel.clone(),
-                                                channel_id: target_channel.clone(),
-                                            }).ok();
-
-                                            tracing::info!(
-                                                from = %sse_agent_id,
-                                                to = %target_agent,
-                                                channel = %target_channel,
-                                                "routed link channel reply"
-                                            );
-                                        }
-                                    }
-                                }
-                                continue;
-                            }
-
                             match response {
                                 spacebot::OutboundResponse::Status(status) => {
                                     if let Err(error) = messaging_for_outbound
@@ -1155,6 +1816,32 @@ async fn run(
                     tracing::warn!(agent_id = %agent_id, "agent not found in main loop for removal");
                 }
             }
+            // Cross-agent message injection (e.g. delegated task completion retrigger).
+            // Forwards the injected message to the target channel if it exists.
+            Some(injection) = injection_rx.recv() => {
+                if let Some(active) = active_channels.get(&injection.conversation_id) {
+                    if let Err(error) = active.message_tx.send(injection.message).await {
+                        tracing::warn!(
+                            %error,
+                            conversation_id = %injection.conversation_id,
+                            agent_id = %injection.agent_id,
+                            "failed to forward injected message to channel"
+                        );
+                    } else {
+                        tracing::info!(
+                            conversation_id = %injection.conversation_id,
+                            agent_id = %injection.agent_id,
+                            "forwarded cross-agent injection to active channel"
+                        );
+                    }
+                } else {
+                    tracing::info!(
+                        conversation_id = %injection.conversation_id,
+                        agent_id = %injection.agent_id,
+                        "injection target channel not active, notification will be delivered on next message"
+                    );
+                }
+            }
             Some(_event) = provider_rx.recv(), if !agents_initialized => {
                 tracing::info!("providers configured, initializing agents");
 
@@ -1172,6 +1859,10 @@ async fn run(
                     Ok(new_config)
                         if has_provider_credentials(&new_config.llm, &new_config.instance_dir) =>
                     {
+                        // Refresh in-memory defaults so newly created agents
+                        // inherit the latest routing from the updated config.
+                        api_state.set_defaults_config(new_config.defaults.clone()).await;
+
                         // Rebuild LlmManager with the new keys
                         match spacebot::llm::LlmManager::with_instance_dir(
                             new_config.llm.clone(),
@@ -1204,6 +1895,9 @@ async fn run(
                                     &mut new_telegram_permissions,
                                     &mut new_twitch_permissions,
                                     agent_links.clone(),
+                                    injection_tx.clone(),
+                                    task_store_registry.clone(),
+                                    &bootstrapped_store,
                                 ).await {
                                     Ok(()) => {
                                         agents_initialized = true;
@@ -1287,6 +1981,30 @@ async fn run(
 
 /// Initialize agents, messaging adapters, cron, cortex, and ingestion.
 /// Extracted so it can be called either at startup or after providers are configured.
+async fn wait_for_startup_warmup_tasks(
+    startup_warmup: &mut tokio::task::JoinSet<()>,
+    timeout: std::time::Duration,
+) -> bool {
+    let wait_all = async {
+        while let Some(result) = startup_warmup.join_next().await {
+            if let Err(error) = result {
+                if error.is_cancelled() {
+                    tracing::warn!(%error, "startup warmup task cancelled");
+                } else {
+                    tracing::error!(%error, "startup warmup task panicked");
+                }
+            }
+        }
+    };
+
+    if tokio::time::timeout(timeout, wait_all).await.is_err() {
+        startup_warmup.abort_all();
+        true
+    } else {
+        false
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 async fn initialize_agents(
     config: &spacebot::config::Config,
@@ -1313,6 +2031,11 @@ async fn initialize_agents(
     telegram_permissions: &mut Option<Arc<ArcSwap<spacebot::config::TelegramPermissions>>>,
     twitch_permissions: &mut Option<Arc<ArcSwap<spacebot::config::TwitchPermissions>>>,
     agent_links: Arc<ArcSwap<Vec<spacebot::links::AgentLink>>>,
+    injection_tx: tokio::sync::mpsc::Sender<spacebot::ChannelInjection>,
+    task_store_registry: Arc<
+        ArcSwap<std::collections::HashMap<String, Arc<spacebot::tasks::TaskStore>>>,
+    >,
+    bootstrapped_store: &Option<Arc<spacebot::secrets::store::SecretsStore>>,
 ) -> anyhow::Result<()> {
     let resolved_agents = config.resolve_agents();
 
@@ -1372,6 +2095,27 @@ async fn initialize_agents(
                 )
             })?;
 
+        let run_logger = spacebot::conversation::ProcessRunLogger::new(db.sqlite.clone());
+        let orphaned_workers = run_logger
+            .reconcile_running_workers_for_agent(
+                &agent_config.id,
+                "Worker interrupted: Spacebot restarted before completion.",
+            )
+            .await
+            .with_context(|| {
+                format!(
+                    "failed to reconcile stale running workers for agent '{}'",
+                    agent_config.id
+                )
+            })?;
+        if orphaned_workers > 0 {
+            tracing::warn!(
+                agent_id = %agent_config.id,
+                orphaned_workers,
+                "marked stale running workers as failed during startup"
+            );
+        }
+
         // Per-agent settings store (redb-backed)
         let settings_path = agent_config.data_dir.join("settings.redb");
         let settings_store = Arc::new(
@@ -1386,6 +2130,7 @@ async fn initialize_agents(
         // Per-agent memory system
         let memory_store =
             spacebot::memory::MemoryStore::with_agent_id(db.sqlite.clone(), &agent_config.id);
+        let task_store = Arc::new(spacebot::tasks::TaskStore::new(db.sqlite.clone()));
         let embedding_table = spacebot::memory::EmbeddingTable::open_or_create(&db.lance)
             .await
             .with_context(|| {
@@ -1403,8 +2148,8 @@ async fn initialize_agents(
             embedding_model.clone(),
         ));
 
-        // Per-agent event bus (broadcast for fan-out to multiple channels)
-        let (event_tx, _event_rx) = tokio::sync::broadcast::channel(256);
+        // Per-agent control and memory event buses (broadcast fan-out).
+        let (event_tx, memory_event_tx) = spacebot::create_process_event_buses();
 
         let agent_id: spacebot::AgentId = Arc::from(agent_config.id.as_str());
         let mcp_manager = Arc::new(spacebot::mcp::McpManager::new(agent_config.mcp.clone()));
@@ -1437,11 +2182,22 @@ async fn initialize_agents(
         ));
 
         // Set the settings store in RuntimeConfig and apply config-driven defaults
-        runtime_config.set_settings(settings_store.clone());
+        let explicit_listen_only = config
+            .agents
+            .iter()
+            .find(|agent| agent.id == agent_config.id)
+            .and_then(|agent| agent.channel.map(|channel| channel.listen_only_mode));
+        runtime_config.set_settings(settings_store.clone(), explicit_listen_only);
         if let Err(error) = settings_store.set_worker_log_mode(config.defaults.worker_log_mode) {
             tracing::warn!(%error, agent = %agent_config.id, "failed to set worker_log_mode from config");
         }
 
+        // Share the instance-level secrets store with this agent.
+        if let Some(secrets_store) = bootstrapped_store {
+            runtime_config.set_secrets(secrets_store.clone());
+            spacebot::config::set_resolve_secrets_store(secrets_store.clone());
+        }
+
         watcher_agents.push((
             agent_config.id.clone(),
             agent_config.workspace.clone(),
@@ -1451,7 +2207,7 @@ async fn initialize_agents(
 
         let sandbox = std::sync::Arc::new(
             spacebot::sandbox::Sandbox::new(
-                &agent_config.sandbox,
+                runtime_config.sandbox.clone(),
                 agent_config.workspace.clone(),
                 &config.instance_dir,
                 agent_config.data_dir.clone(),
@@ -1459,19 +2215,31 @@ async fn initialize_agents(
             .await,
         );
 
+        // Wire the instance-level secrets store into the sandbox for tool secret injection.
+        if let Some(secrets_store) = &bootstrapped_store {
+            sandbox.set_secrets_store(secrets_store.clone());
+        }
+
         let deps = spacebot::AgentDeps {
             agent_id: agent_id.clone(),
             memory_search,
             llm_manager: llm_manager.clone(),
             mcp_manager,
+            task_store: task_store.clone(),
             cron_tool: None,
             runtime_config,
             event_tx,
+            memory_event_tx,
             sqlite_pool: db.sqlite.clone(),
             messaging_manager: None,
             sandbox,
             links: agent_links.clone(),
             agent_names: agent_name_map.clone(),
+            task_store_registry: task_store_registry.clone(),
+            process_control_registry: Arc::new(
+                spacebot::agent::process_control::ProcessControlRegistry::new(),
+            ),
+            injection_tx: injection_tx.clone(),
         };
 
         let agent = spacebot::Agent {
@@ -1485,6 +2253,40 @@ async fn initialize_agents(
         agents.insert(agent_id, agent);
     }
 
+    // Populate the cross-agent task store registry now that all agents exist.
+    {
+        let registry: std::collections::HashMap<String, Arc<spacebot::tasks::TaskStore>> = agents
+            .iter()
+            .map(|(agent_id, agent)| (agent_id.to_string(), agent.deps.task_store.clone()))
+            .collect();
+        task_store_registry.store(Arc::new(registry));
+    }
+
+    // Pre-register both sides of every link channel so they appear in each
+    // agent's channel list from boot. The actual Channel instances are spawned
+    // on-demand when the first message arrives; this just creates the DB records
+    // so the UI can display them.
+    {
+        let all_links = agent_links.load();
+        let empty_meta = std::collections::HashMap::new();
+        for link in all_links.iter() {
+            let from_channel = link.channel_id_for(&link.from_agent_id);
+            let to_channel = link.channel_id_for(&link.to_agent_id);
+
+            if let Some(agent) = agents.get(&Arc::from(link.from_agent_id.as_str())) {
+                let store = spacebot::conversation::ChannelStore::new(agent.db.sqlite.clone());
+                store.upsert(&from_channel, &empty_meta);
+            }
+            if let Some(agent) = agents.get(&Arc::from(link.to_agent_id.as_str())) {
+                let store = spacebot::conversation::ChannelStore::new(agent.db.sqlite.clone());
+                store.upsert(&to_channel, &empty_meta);
+            }
+        }
+        if !all_links.is_empty() {
+            tracing::info!(link_count = all_links.len(), "pre-registered link channels");
+        }
+    }
+
     tracing::info!(agent_count = agents.len(), "all agents initialized");
 
     // Wire agent event streams, DB pools, and config summaries into the API server
@@ -1493,6 +2295,7 @@ async fn initialize_agents(
         let mut agent_configs = Vec::new();
         let mut memory_searches = std::collections::HashMap::new();
         let mut mcp_managers = std::collections::HashMap::new();
+        let mut task_stores = std::collections::HashMap::new();
         let mut agent_workspaces = std::collections::HashMap::new();
         let mut runtime_configs = std::collections::HashMap::new();
         let mut sandboxes = std::collections::HashMap::new();
@@ -1502,6 +2305,7 @@ async fn initialize_agents(
             agent_pools.insert(agent_id.to_string(), agent.db.sqlite.clone());
             memory_searches.insert(agent_id.to_string(), agent.deps.memory_search.clone());
             mcp_managers.insert(agent_id.to_string(), agent.deps.mcp_manager.clone());
+            task_stores.insert(agent_id.to_string(), agent.deps.task_store.clone());
             agent_workspaces.insert(agent_id.to_string(), agent.config.workspace.clone());
             runtime_configs.insert(agent_id.to_string(), agent.deps.runtime_config.clone());
             sandboxes.insert(agent_id.to_string(), agent.deps.sandbox.clone());
@@ -1520,12 +2324,61 @@ async fn initialize_agents(
         api_state.set_agent_configs(agent_configs);
         api_state.set_memory_searches(memory_searches);
         api_state.set_mcp_managers(mcp_managers);
+        api_state.set_task_stores(task_stores);
         api_state.set_runtime_configs(runtime_configs);
         api_state.set_agent_workspaces(agent_workspaces);
         api_state.set_sandboxes(sandboxes);
+        // Wire the instance-level secrets store into the API state.
+        if let Some(store) = &bootstrapped_store {
+            api_state.set_secrets_store(store.clone());
+        }
         api_state.set_instance_dir(config.instance_dir.clone());
     }
 
+    // Run a startup warmup pass for every agent before adapters begin receiving
+    // inbound traffic. This reduces first-message cold-start latency.
+    {
+        const STARTUP_WARMUP_WAIT_SECS: u64 = 30;
+        let mut startup_warmup = tokio::task::JoinSet::new();
+
+        for (agent_id, agent) in agents.iter() {
+            let deps = agent.deps.clone();
+            let sqlite_pool = agent.db.sqlite.clone();
+            let agent_id = agent_id.clone();
+            startup_warmup.spawn(async move {
+                let logger = spacebot::agent::cortex::CortexLogger::new(sqlite_pool);
+                spacebot::agent::cortex::run_warmup_once(
+                    &deps,
+                    &logger,
+                    "startup_pre_adapter",
+                    false,
+                )
+                .await;
+                let status = deps.runtime_config.warmup_status.load().as_ref().clone();
+                tracing::info!(
+                    agent_id = %agent_id,
+                    state = ?status.state,
+                    embedding_ready = status.embedding_ready,
+                    bulletin_age_secs = ?status.bulletin_age_secs,
+                    last_error = ?status.last_error,
+                    "startup warmup pass finished"
+                );
+            });
+        }
+
+        if wait_for_startup_warmup_tasks(
+            &mut startup_warmup,
+            std::time::Duration::from_secs(STARTUP_WARMUP_WAIT_SECS),
+        )
+        .await
+        {
+            tracing::warn!(
+                timeout_secs = STARTUP_WARMUP_WAIT_SECS,
+                "startup warmup wait timed out; cancelled unfinished startup warmup tasks and continuing startup"
+            );
+        }
+    }
+
     // Initialize messaging adapters
     let new_messaging_manager = spacebot::messaging::MessagingManager::new();
 
@@ -1542,13 +2395,43 @@ async fn initialize_agents(
     if let Some(discord_config) = &config.messaging.discord
         && discord_config.enabled
     {
-        let adapter = spacebot::messaging::discord::DiscordAdapter::new(
-            &discord_config.token,
-            discord_permissions.clone().ok_or_else(|| {
-                anyhow::anyhow!("discord permissions not initialized when discord is enabled")
-            })?,
-        );
-        new_messaging_manager.register(adapter).await;
+        if !discord_config.token.is_empty() {
+            let adapter = spacebot::messaging::discord::DiscordAdapter::new(
+                "discord",
+                &discord_config.token,
+                discord_permissions.clone().ok_or_else(|| {
+                    anyhow::anyhow!("discord permissions not initialized when discord is enabled")
+                })?,
+            );
+            new_messaging_manager.register(adapter).await;
+        }
+
+        for instance in discord_config
+            .instances
+            .iter()
+            .filter(|instance| instance.enabled)
+        {
+            if instance.token.is_empty() {
+                tracing::warn!(adapter = %instance.name, "skipping enabled discord instance with empty token");
+                continue;
+            }
+            let runtime_key = spacebot::config::binding_runtime_adapter_key(
+                "discord",
+                Some(instance.name.as_str()),
+            );
+            let perms = Arc::new(ArcSwap::from_pointee(
+                spacebot::config::DiscordPermissions::from_instance_config(
+                    instance,
+                    &config.bindings,
+                ),
+            ));
+            let adapter = spacebot::messaging::discord::DiscordAdapter::new(
+                runtime_key,
+                &instance.token,
+                perms,
+            );
+            new_messaging_manager.register(adapter).await;
+        }
     }
 
     // Shared Slack permissions (hot-reloadable via file watcher)
@@ -1563,19 +2446,57 @@ async fn initialize_agents(
     if let Some(slack_config) = &config.messaging.slack
         && slack_config.enabled
     {
-        match spacebot::messaging::slack::SlackAdapter::new(
-            &slack_config.bot_token,
-            &slack_config.app_token,
-            slack_permissions.clone().ok_or_else(|| {
-                anyhow::anyhow!("slack permissions not initialized when slack is enabled")
-            })?,
-            slack_config.commands.clone(),
-        ) {
-            Ok(adapter) => {
-                new_messaging_manager.register(adapter).await;
+        if !slack_config.bot_token.is_empty() && !slack_config.app_token.is_empty() {
+            match spacebot::messaging::slack::SlackAdapter::new(
+                "slack",
+                &slack_config.bot_token,
+                &slack_config.app_token,
+                slack_permissions.clone().ok_or_else(|| {
+                    anyhow::anyhow!("slack permissions not initialized when slack is enabled")
+                })?,
+                slack_config.commands.clone(),
+            ) {
+                Ok(adapter) => {
+                    new_messaging_manager.register(adapter).await;
+                }
+                Err(error) => {
+                    tracing::error!(%error, "failed to build slack adapter");
+                }
             }
-            Err(error) => {
-                tracing::error!(%error, "failed to build slack adapter");
+        }
+
+        for instance in slack_config
+            .instances
+            .iter()
+            .filter(|instance| instance.enabled)
+        {
+            if instance.bot_token.is_empty() || instance.app_token.is_empty() {
+                tracing::warn!(adapter = %instance.name, "skipping enabled slack instance with missing tokens");
+                continue;
+            }
+            let runtime_key = spacebot::config::binding_runtime_adapter_key(
+                "slack",
+                Some(instance.name.as_str()),
+            );
+            let perms = Arc::new(ArcSwap::from_pointee(
+                spacebot::config::SlackPermissions::from_instance_config(
+                    instance,
+                    &config.bindings,
+                ),
+            ));
+            match spacebot::messaging::slack::SlackAdapter::new(
+                runtime_key,
+                &instance.bot_token,
+                &instance.app_token,
+                perms,
+                instance.commands.clone(),
+            ) {
+                Ok(adapter) => {
+                    new_messaging_manager.register(adapter).await;
+                }
+                Err(error) => {
+                    tracing::error!(%error, adapter = %instance.name, "failed to build named slack adapter");
+                }
             }
         }
     }
@@ -1590,13 +2511,84 @@ async fn initialize_agents(
     if let Some(telegram_config) = &config.messaging.telegram
         && telegram_config.enabled
     {
-        let adapter = spacebot::messaging::telegram::TelegramAdapter::new(
-            &telegram_config.token,
-            telegram_permissions.clone().ok_or_else(|| {
-                anyhow::anyhow!("telegram permissions not initialized when telegram is enabled")
-            })?,
-        );
-        new_messaging_manager.register(adapter).await;
+        if !telegram_config.token.is_empty() {
+            let adapter = spacebot::messaging::telegram::TelegramAdapter::new(
+                "telegram",
+                &telegram_config.token,
+                telegram_permissions.clone().ok_or_else(|| {
+                    anyhow::anyhow!("telegram permissions not initialized when telegram is enabled")
+                })?,
+            );
+            new_messaging_manager.register(adapter).await;
+        }
+
+        for instance in telegram_config
+            .instances
+            .iter()
+            .filter(|instance| instance.enabled)
+        {
+            if instance.token.is_empty() {
+                tracing::warn!(adapter = %instance.name, "skipping enabled telegram instance with empty token");
+                continue;
+            }
+            let runtime_key = spacebot::config::binding_runtime_adapter_key(
+                "telegram",
+                Some(instance.name.as_str()),
+            );
+            let perms = Arc::new(ArcSwap::from_pointee(
+                spacebot::config::TelegramPermissions::from_instance_config(
+                    instance,
+                    &config.bindings,
+                ),
+            ));
+            let adapter = spacebot::messaging::telegram::TelegramAdapter::new(
+                runtime_key,
+                &instance.token,
+                perms,
+            );
+            new_messaging_manager.register(adapter).await;
+        }
+    }
+
+    if let Some(email_config) = &config.messaging.email
+        && email_config.enabled
+    {
+        if !email_config.imap_host.is_empty() {
+            match spacebot::messaging::email::EmailAdapter::from_config(email_config) {
+                Ok(adapter) => {
+                    new_messaging_manager.register(adapter).await;
+                }
+                Err(error) => {
+                    tracing::error!(%error, "failed to build email adapter");
+                }
+            }
+        }
+
+        for instance in email_config
+            .instances
+            .iter()
+            .filter(|instance| instance.enabled)
+        {
+            if instance.imap_host.is_empty() {
+                tracing::warn!(adapter = %instance.name, "skipping enabled email instance with empty credentials");
+                continue;
+            }
+            let runtime_key = spacebot::config::binding_runtime_adapter_key(
+                "email",
+                Some(instance.name.as_str()),
+            );
+            match spacebot::messaging::email::EmailAdapter::from_instance_config(
+                runtime_key,
+                instance,
+            ) {
+                Ok(adapter) => {
+                    new_messaging_manager.register(adapter).await;
+                }
+                Err(error) => {
+                    tracing::error!(%error, adapter = %instance.name, "failed to build named email adapter");
+                }
+            }
+        }
     }
 
     if let Some(webhook_config) = &config.messaging.webhook
@@ -1621,23 +2613,81 @@ async fn initialize_agents(
         && twitch_config.enabled
     {
         let twitch_token_path = config.instance_dir.join("twitch_token.json");
-        let adapter = spacebot::messaging::twitch::TwitchAdapter::new(
-            &twitch_config.username,
-            &twitch_config.oauth_token,
-            twitch_config.client_id.clone(),
-            twitch_config.client_secret.clone(),
-            twitch_config.refresh_token.clone(),
-            Some(twitch_token_path),
-            twitch_config.channels.clone(),
-            twitch_config.trigger_prefix.clone(),
-            twitch_permissions.clone().ok_or_else(|| {
-                anyhow::anyhow!("twitch permissions not initialized when twitch is enabled")
-            })?,
-        );
-        new_messaging_manager.register(adapter).await;
+        if !twitch_config.username.is_empty() && !twitch_config.oauth_token.is_empty() {
+            let adapter = spacebot::messaging::twitch::TwitchAdapter::new(
+                "twitch",
+                &twitch_config.username,
+                &twitch_config.oauth_token,
+                twitch_config.client_id.clone(),
+                twitch_config.client_secret.clone(),
+                twitch_config.refresh_token.clone(),
+                Some(twitch_token_path),
+                twitch_config.channels.clone(),
+                twitch_config.trigger_prefix.clone(),
+                twitch_permissions.clone().ok_or_else(|| {
+                    anyhow::anyhow!("twitch permissions not initialized when twitch is enabled")
+                })?,
+            );
+            new_messaging_manager.register(adapter).await;
+        }
+
+        for instance in twitch_config
+            .instances
+            .iter()
+            .filter(|instance| instance.enabled)
+        {
+            if instance.username.is_empty() || instance.oauth_token.is_empty() {
+                tracing::warn!(adapter = %instance.name, "skipping enabled twitch instance with missing credentials");
+                continue;
+            }
+            let runtime_key = spacebot::config::binding_runtime_adapter_key(
+                "twitch",
+                Some(instance.name.as_str()),
+            );
+            let token_file_name = {
+                use std::hash::{Hash, Hasher};
+                let mut hasher = std::collections::hash_map::DefaultHasher::new();
+                instance.name.hash(&mut hasher);
+                let name_hash = hasher.finish();
+                format!(
+                    "twitch_token_{}_{name_hash:016x}.json",
+                    instance
+                        .name
+                        .chars()
+                        .map(|ch| if ch.is_ascii_alphanumeric() { ch } else { '_' })
+                        .collect::<String>()
+                )
+            };
+            let token_path = config.instance_dir.join(token_file_name);
+            let perms = Arc::new(ArcSwap::from_pointee(
+                spacebot::config::TwitchPermissions::from_instance_config(
+                    instance,
+                    &config.bindings,
+                ),
+            ));
+            let adapter = spacebot::messaging::twitch::TwitchAdapter::new(
+                runtime_key,
+                &instance.username,
+                &instance.oauth_token,
+                instance.client_id.clone(),
+                instance.client_secret.clone(),
+                instance.refresh_token.clone(),
+                Some(token_path),
+                instance.channels.clone(),
+                instance.trigger_prefix.clone(),
+                perms,
+            );
+            new_messaging_manager.register(adapter).await;
+        }
     }
 
-    let webchat_adapter = Arc::new(spacebot::messaging::webchat::WebChatAdapter::new());
+    let webchat_agent_pools = agents
+        .iter()
+        .map(|(agent_id, agent)| (agent_id.to_string(), agent.db.sqlite.clone()))
+        .collect();
+    let webchat_adapter = Arc::new(spacebot::messaging::webchat::WebChatAdapter::new(
+        webchat_agent_pools,
+    ));
     new_messaging_manager
         .register_shared(webchat_adapter.clone())
         .await;
@@ -1670,6 +2720,7 @@ async fn initialize_agents(
             let cron_config = spacebot::cron::CronConfig {
                 id: cron_def.id.clone(),
                 prompt: cron_def.prompt.clone(),
+                cron_expr: cron_def.cron_expr.clone(),
                 interval_secs: cron_def.interval_secs,
                 delivery_target: cron_def.delivery_target.clone(),
                 active_hours: cron_def.active_hours,
@@ -1745,7 +2796,7 @@ async fn initialize_agents(
         }
     }
 
-    // Start cortex warmup, bulletin loops, and association loops for each agent
+    // Start cortex warmup, runtime, and association loops for each agent
     for (agent_id, agent) in agents.iter() {
         let cortex_logger = spacebot::agent::cortex::CortexLogger::new(agent.db.sqlite.clone());
         let warmup_handle =
@@ -1753,15 +2804,22 @@ async fn initialize_agents(
         cortex_handles.push(warmup_handle);
         tracing::info!(agent_id = %agent_id, "warmup loop started");
 
-        let bulletin_handle =
-            spacebot::agent::cortex::spawn_bulletin_loop(agent.deps.clone(), cortex_logger.clone());
-        cortex_handles.push(bulletin_handle);
-        tracing::info!(agent_id = %agent_id, "cortex bulletin loop started");
+        let cortex_handle =
+            spacebot::agent::cortex::spawn_cortex_loop(agent.deps.clone(), cortex_logger.clone());
+        cortex_handles.push(cortex_handle);
+        tracing::info!(agent_id = %agent_id, "cortex loop started");
 
         let association_handle =
             spacebot::agent::cortex::spawn_association_loop(agent.deps.clone(), cortex_logger);
         cortex_handles.push(association_handle);
         tracing::info!(agent_id = %agent_id, "cortex association loop started");
+
+        let ready_task_handle = spacebot::agent::cortex::spawn_ready_task_loop(
+            agent.deps.clone(),
+            spacebot::agent::cortex::CortexLogger::new(agent.db.sqlite.clone()),
+        );
+        cortex_handles.push(ready_task_handle);
+        tracing::info!(agent_id = %agent_id, "cortex ready-task loop started");
     }
 
     // Create cortex chat sessions for each agent
@@ -1773,15 +2831,21 @@ async fn initialize_agents(
             let conversation_logger =
                 spacebot::conversation::history::ConversationLogger::new(agent.db.sqlite.clone());
             let channel_store = spacebot::conversation::ChannelStore::new(agent.db.sqlite.clone());
+            let run_logger = spacebot::conversation::ProcessRunLogger::new(agent.db.sqlite.clone());
             let tool_server = spacebot::tools::create_cortex_chat_tool_server(
+                agent.deps.agent_id.clone(),
+                agent.deps.task_store.clone(),
                 agent.deps.memory_search.clone(),
+                agent.deps.memory_event_tx.clone(),
                 conversation_logger,
                 channel_store,
+                run_logger,
                 browser_config,
                 agent.config.screenshot_dir(),
                 brave_search_key,
                 agent.deps.runtime_config.workspace_dir.clone(),
                 agent.deps.sandbox.clone(),
+                agent.deps.runtime_config.clone(),
             );
             let store = spacebot::agent::cortex_chat::CortexChatStore::new(agent.db.sqlite.clone());
             let session = spacebot::agent::cortex_chat::CortexChatSession::new(
@@ -1797,3 +2861,70 @@ async fn initialize_agents(
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::wait_for_startup_warmup_tasks;
+    use std::future::pending;
+    use std::sync::Arc;
+    use std::time::Duration;
+
+    #[tokio::test]
+    async fn startup_warmup_wait_returns_false_when_tasks_finish_in_time() {
+        let mut tasks = tokio::task::JoinSet::new();
+        tasks.spawn(async {});
+        let timed_out = wait_for_startup_warmup_tasks(&mut tasks, Duration::from_millis(50)).await;
+        assert!(!timed_out);
+    }
+
+    #[tokio::test]
+    async fn startup_warmup_wait_returns_true_when_timeout_expires() {
+        let mut tasks = tokio::task::JoinSet::new();
+        tasks.spawn(async {
+            tokio::time::sleep(Duration::from_millis(50)).await;
+        });
+        let timed_out = wait_for_startup_warmup_tasks(&mut tasks, Duration::from_millis(5)).await;
+        assert!(timed_out);
+    }
+
+    #[tokio::test]
+    async fn startup_warmup_wait_aborts_timed_out_task_and_releases_lock() {
+        let warmup_lock = Arc::new(tokio::sync::Mutex::new(()));
+        let mut tasks = tokio::task::JoinSet::new();
+        let warmup_lock_for_task = Arc::clone(&warmup_lock);
+        let (locked_tx, locked_rx) = tokio::sync::oneshot::channel();
+        tasks.spawn(async move {
+            let _guard = warmup_lock_for_task.lock().await;
+            locked_tx.send(()).ok();
+            pending::<()>().await;
+        });
+
+        tokio::time::timeout(Duration::from_millis(50), locked_rx)
+            .await
+            .expect("task should acquire lock")
+            .expect("lock signal should send");
+
+        let timed_out = wait_for_startup_warmup_tasks(&mut tasks, Duration::from_millis(5)).await;
+        assert!(timed_out);
+
+        let _guard = tokio::time::timeout(Duration::from_millis(50), warmup_lock.lock())
+            .await
+            .expect("startup warmup timeout should cancel blocked task and release lock");
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn startup_warmup_wait_timeout_stays_bounded_for_non_cooperative_task() {
+        let mut tasks = tokio::task::JoinSet::new();
+        tasks.spawn(async {
+            std::thread::sleep(Duration::from_millis(100));
+        });
+
+        let started = std::time::Instant::now();
+        let timed_out = wait_for_startup_warmup_tasks(&mut tasks, Duration::from_millis(5)).await;
+        assert!(timed_out);
+        assert!(
+            started.elapsed() < Duration::from_millis(80),
+            "startup warmup timeout should return without waiting for non-cooperative task"
+        );
+    }
+}
diff --git a/src/messaging.rs b/src/messaging.rs
index 87ca5e796..f57d5d68a 100644
--- a/src/messaging.rs
+++ b/src/messaging.rs
@@ -1,6 +1,7 @@
-//! Messaging adapters (Discord, Slack, Telegram, Twitch, Webhook, WebChat).
+//! Messaging adapters (Discord, Slack, Telegram, Twitch, Email, Webhook, WebChat).
 
 pub mod discord;
+pub mod email;
 pub mod manager;
 pub mod slack;
 pub mod target;
@@ -12,3 +13,4 @@ pub mod webhook;
 
 pub use manager::MessagingManager;
 pub use traits::Messaging;
+pub use traits::apply_runtime_adapter_to_conversation_id;
diff --git a/src/messaging/discord.rs b/src/messaging/discord.rs
index ab433dd3a..afd8c1c87 100644
--- a/src/messaging/discord.rs
+++ b/src/messaging/discord.rs
@@ -1,6 +1,7 @@
 //! Discord messaging adapter using serenity.
 
 use crate::config::DiscordPermissions;
+use crate::messaging::apply_runtime_adapter_to_conversation_id;
 use crate::messaging::traits::{HistoryMessage, InboundStream, Messaging};
 use crate::{InboundMessage, MessageContent, OutboundResponse, StatusUpdate};
 
@@ -20,6 +21,7 @@ use tokio::sync::{RwLock, mpsc};
 
 /// Discord adapter state.
 pub struct DiscordAdapter {
+    runtime_key: String,
     token: String,
     permissions: Arc<ArcSwap<DiscordPermissions>>,
     http: Arc<RwLock<Option<Arc<Http>>>>,
@@ -32,8 +34,13 @@ pub struct DiscordAdapter {
 }
 
 impl DiscordAdapter {
-    pub fn new(token: impl Into<String>, permissions: Arc<ArcSwap<DiscordPermissions>>) -> Self {
+    pub fn new(
+        runtime_key: impl Into<String>,
+        token: impl Into<String>,
+        permissions: Arc<ArcSwap<DiscordPermissions>>,
+    ) -> Self {
         Self {
+            runtime_key: runtime_key.into(),
             token: token.into(),
             permissions,
             http: Arc::new(RwLock::new(None)),
@@ -81,15 +88,19 @@ impl DiscordAdapter {
     fn extract_reply_message_id(message: &InboundMessage) -> Option<MessageId> {
         message
             .metadata
-            .get("discord_reply_to_message_id")
-            .and_then(|value| value.as_u64())
+            .get(crate::metadata_keys::REPLY_TO_MESSAGE_ID)
+            .and_then(|value| match value {
+                serde_json::Value::String(s) => s.parse::<u64>().ok(),
+                serde_json::Value::Number(n) => n.as_u64(),
+                _ => None,
+            })
             .map(MessageId::new)
     }
 }
 
 impl Messaging for DiscordAdapter {
     fn name(&self) -> &str {
-        "discord"
+        &self.runtime_key
     }
 
     async fn start(&self) -> crate::Result<InboundStream> {
@@ -97,6 +108,7 @@ impl Messaging for DiscordAdapter {
 
         let handler = Handler {
             inbound_tx,
+            runtime_key: self.runtime_key.clone(),
             permissions: self.permissions.clone(),
             http_slot: self.http.clone(),
             bot_user_id_slot: self.bot_user_id.clone(),
@@ -152,7 +164,7 @@ impl Messaging for DiscordAdapter {
                 }
             }
             OutboundResponse::RichMessage {
-                text,
+                mut text,
                 cards,
                 interactive_elements,
                 poll,
@@ -161,6 +173,35 @@ impl Messaging for DiscordAdapter {
                 self.stop_typing(message).await;
                 let reply_to = Self::extract_reply_message_id(message);
 
+                // Derive a plaintext fallback from cards when text is empty so
+                // the message is never blank (notifications, logging, etc.).
+                if text.trim().is_empty() {
+                    let derived = crate::OutboundResponse::text_from_cards(&cards);
+                    if !derived.trim().is_empty() {
+                        text = derived;
+                    }
+                }
+
+                // Enforce Discord API limits: max 10 embeds, 5 action rows.
+                let cards = if cards.len() > 10 {
+                    tracing::warn!(
+                        count = cards.len(),
+                        "truncating cards to Discord embed limit (10)"
+                    );
+                    &cards[..10]
+                } else {
+                    &cards
+                };
+                let interactive_elements = if interactive_elements.len() > 5 {
+                    tracing::warn!(
+                        count = interactive_elements.len(),
+                        "truncating interactive elements to Discord action row limit (5)"
+                    );
+                    &interactive_elements[..5]
+                } else {
+                    &interactive_elements
+                };
+
                 let chunks = split_message(&text, 2000);
                 for (i, chunk) in chunks.iter().enumerate() {
                     let is_last = i == chunks.len() - 1;
@@ -171,16 +212,13 @@ impl Messaging for DiscordAdapter {
 
                     // Attach rich content only to the final chunk
                     if is_last {
-                        let embeds: Vec<_> = cards.iter().take(10).map(build_embed).collect();
+                        let embeds: Vec<_> = cards.iter().map(build_embed).collect();
                         if !embeds.is_empty() {
                             msg = msg.embeds(embeds);
                         }
 
-                        let components: Vec<_> = interactive_elements
-                            .iter()
-                            .take(5)
-                            .map(build_action_row)
-                            .collect();
+                        let components: Vec<_> =
+                            interactive_elements.iter().map(build_action_row).collect();
                         if !components.is_empty() {
                             msg = msg.components(components);
                         }
@@ -410,13 +448,41 @@ impl Messaging for DiscordAdapter {
                     .context("failed to broadcast discord message")?;
             }
         } else if let OutboundResponse::RichMessage {
-            text,
+            mut text,
             cards,
             interactive_elements,
             poll,
             ..
         } = response
         {
+            // Derive a plaintext fallback from cards when text is empty.
+            if text.trim().is_empty() {
+                let derived = crate::OutboundResponse::text_from_cards(&cards);
+                if !derived.trim().is_empty() {
+                    text = derived;
+                }
+            }
+
+            // Enforce Discord API limits: max 10 embeds, 5 action rows.
+            let cards = if cards.len() > 10 {
+                tracing::warn!(
+                    count = cards.len(),
+                    "truncating cards to Discord embed limit (10)"
+                );
+                &cards[..10]
+            } else {
+                &cards
+            };
+            let interactive_elements = if interactive_elements.len() > 5 {
+                tracing::warn!(
+                    count = interactive_elements.len(),
+                    "truncating interactive elements to Discord action row limit (5)"
+                );
+                &interactive_elements[..5]
+            } else {
+                &interactive_elements
+            };
+
             let chunks = split_message(&text, 2000);
             for (i, chunk) in chunks.iter().enumerate() {
                 let is_last = i == chunks.len() - 1;
@@ -427,16 +493,13 @@ impl Messaging for DiscordAdapter {
 
                 // Attach rich content only to the final chunk
                 if is_last {
-                    let embeds: Vec<_> = cards.iter().take(10).map(build_embed).collect();
+                    let embeds: Vec<_> = cards.iter().map(build_embed).collect();
                     if !embeds.is_empty() {
                         msg = msg.embeds(embeds);
                     }
 
-                    let components: Vec<_> = interactive_elements
-                        .iter()
-                        .take(5)
-                        .map(build_action_row)
-                        .collect();
+                    let components: Vec<_> =
+                        interactive_elements.iter().map(build_action_row).collect();
                     if !components.is_empty() {
                         msg = msg.components(components);
                     }
@@ -556,6 +619,7 @@ impl Messaging for DiscordAdapter {
 
 struct Handler {
     inbound_tx: mpsc::Sender<InboundMessage>,
+    runtime_key: String,
     permissions: Arc<ArcSwap<DiscordPermissions>>,
     http_slot: Arc<RwLock<Option<Arc<Http>>>>,
     bot_user_id_slot: Arc<RwLock<Option<UserId>>>,
@@ -603,7 +667,7 @@ impl EventHandler for Handler {
             return;
         }
 
-        let conversation_id = build_conversation_id(&message);
+        let conversation_id = build_conversation_id(&self.runtime_key, &message);
         let content = extract_content(&message);
         let (metadata, formatted_author) = build_metadata(&ctx, &message, bot_user_id).await;
 
@@ -627,6 +691,7 @@ impl EventHandler for Handler {
         let inbound = InboundMessage {
             id: message.id.to_string(),
             source: "discord".into(),
+            adapter: Some(self.runtime_key.clone()),
             conversation_id,
             sender_id: message.author.id.to_string(),
             agent_id: None,
@@ -679,10 +744,12 @@ impl EventHandler for Handler {
             return;
         }
 
-        let conversation_id = match component.guild_id {
+        let base_conversation_id = match component.guild_id {
             Some(guild_id) => format!("discord:{}:{}", guild_id, component.channel_id),
             None => format!("discord:dm:{}", user.id),
         };
+        let conversation_id =
+            apply_runtime_adapter_to_conversation_id(&self.runtime_key, base_conversation_id);
 
         let values = match &component.data.kind {
             serenity::all::ComponentInteractionDataKind::StringSelect { values } => values.clone(),
@@ -706,9 +773,13 @@ impl EventHandler for Handler {
             "discord_message_id".into(),
             serde_json::Value::Number(component.message.id.get().into()),
         );
+        let discord_mentioned_bot = false;
+        let discord_reply_to_bot = true;
+        metadata.insert("discord_mentioned_bot".into(), discord_mentioned_bot.into());
+        metadata.insert("discord_reply_to_bot".into(), discord_reply_to_bot.into());
         metadata.insert(
             "discord_mentions_or_replies_to_bot".into(),
-            serde_json::Value::Bool(true),
+            (discord_mentioned_bot || discord_reply_to_bot).into(),
         );
         if let Some(guild_id) = component.guild_id {
             metadata.insert(
@@ -730,6 +801,7 @@ impl EventHandler for Handler {
         let inbound = InboundMessage {
             id: component.id.to_string(), // Use interaction ID to ensure uniqueness
             source: "discord".into(),
+            adapter: Some(self.runtime_key.clone()),
             conversation_id,
             sender_id: user.id.to_string(),
             agent_id: None,
@@ -749,14 +821,21 @@ impl EventHandler for Handler {
 }
 
 fn is_mention_or_reply_to_bot(message: &Message, bot_user_id: Option<UserId>) -> bool {
+    is_mention_to_bot(message, bot_user_id) || is_reply_to_bot(message, bot_user_id)
+}
+
+fn is_mention_to_bot(message: &Message, bot_user_id: Option<UserId>) -> bool {
     let Some(bot_id) = bot_user_id else {
         return false;
     };
 
-    let directly_mentioned = message.mentions.iter().any(|user| user.id == bot_id);
-    if directly_mentioned {
-        return true;
-    }
+    message.mentions.iter().any(|user| user.id == bot_id)
+}
+
+fn is_reply_to_bot(message: &Message, bot_user_id: Option<UserId>) -> bool {
+    let Some(bot_id) = bot_user_id else {
+        return false;
+    };
 
     message
         .referenced_message
@@ -766,11 +845,13 @@ fn is_mention_or_reply_to_bot(message: &Message, bot_user_id: Option<UserId>) ->
 
 // -- Helper functions --
 
-fn build_conversation_id(message: &Message) -> String {
-    match message.guild_id {
+fn build_conversation_id(runtime_key: &str, message: &Message) -> String {
+    let base_conversation_id = match message.guild_id {
         Some(guild_id) => format!("discord:{}:{}", guild_id, message.channel_id),
         None => format!("discord:dm:{}", message.author.id),
-    }
+    };
+
+    apply_runtime_adapter_to_conversation_id(runtime_key, base_conversation_id)
 }
 
 fn extract_content(message: &Message) -> MessageContent {
@@ -787,6 +868,7 @@ fn extract_content(message: &Message) -> MessageContent {
                 mime_type: attachment.content_type.clone().unwrap_or_default(),
                 url: attachment.url.clone(),
                 size_bytes: Some(attachment.size as u64),
+                auth_header: None,
             })
             .collect();
 
@@ -826,6 +908,10 @@ async fn build_metadata(
     let mut metadata = HashMap::new();
     metadata.insert("discord_channel_id".into(), message.channel_id.get().into());
     metadata.insert("discord_message_id".into(), message.id.get().into());
+    metadata.insert(
+        crate::metadata_keys::MESSAGE_ID.into(),
+        serde_json::Value::String(message.id.get().to_string()),
+    );
     metadata.insert(
         "discord_author_name".into(),
         message.author.name.clone().into(),
@@ -866,7 +952,8 @@ async fn build_metadata(
 
         // Try to get guild name
         if let Ok(guild) = guild_id.to_partial_guild(&ctx.http).await {
-            metadata.insert("discord_guild_name".into(), guild.name.into());
+            metadata.insert("discord_guild_name".into(), guild.name.clone().into());
+            metadata.insert(crate::metadata_keys::SERVER_NAME.into(), guild.name.into());
         }
     }
 
@@ -878,6 +965,10 @@ async fn build_metadata(
             "discord_channel_name".into(),
             guild_channel.name.clone().into(),
         );
+        metadata.insert(
+            crate::metadata_keys::CHANNEL_NAME.into(),
+            guild_channel.name.clone().into(),
+        );
 
         // Threads have a parent_id pointing to the text channel they were created in
         if guild_channel.thread_metadata.is_some() {
@@ -901,17 +992,29 @@ async fn build_metadata(
         let reply_content = resolve_mentions(&referenced.content, &referenced.mentions);
         // Truncate to avoid bloating context with long quoted messages
         let truncated = if reply_content.len() > 200 {
-            format!("{}...", &reply_content[..200])
+            format!(
+                "{}...",
+                &reply_content[..reply_content.floor_char_boundary(200)]
+            )
         } else {
             reply_content
         };
-        metadata.insert("reply_to_content".into(), truncated.into());
+        metadata.insert("reply_to_content".into(), truncated.clone().into());
+        metadata.insert(crate::metadata_keys::REPLY_TO_TEXT.into(), truncated.into());
     }
 
     metadata.insert(
         "discord_mentions_or_replies_to_bot".into(),
         is_mention_or_reply_to_bot(message, bot_user_id).into(),
     );
+    metadata.insert(
+        "discord_mentioned_bot".into(),
+        is_mention_to_bot(message, bot_user_id).into(),
+    );
+    metadata.insert(
+        "discord_reply_to_bot".into(),
+        is_reply_to_bot(message, bot_user_id).into(),
+    );
 
     (metadata, formatted_author)
 }
diff --git a/src/messaging/email.rs b/src/messaging/email.rs
new file mode 100644
index 000000000..b26316fa1
--- /dev/null
+++ b/src/messaging/email.rs
@@ -0,0 +1,1919 @@
+//! Email messaging adapter using IMAP polling and SMTP delivery.
+
+use crate::config::EmailConfig;
+use crate::messaging::traits::{HistoryMessage, InboundStream, Messaging};
+use crate::{InboundMessage, MessageContent, OutboundResponse};
+
+use anyhow::Context as _;
+use chrono::{Duration as ChronoDuration, TimeZone as _, Utc};
+use lettre::message::header::ContentType;
+use lettre::message::{Attachment as EmailAttachment, Mailbox, MultiPart, SinglePart};
+use lettre::transport::smtp::authentication::Credentials;
+use lettre::{Address, AsyncSmtpTransport, AsyncTransport, Message, Tokio1Executor};
+use mailparse::{DispositionType, MailAddr, MailHeaderMap};
+use regex::Regex;
+use sha2::{Digest, Sha256};
+use std::collections::{HashMap, HashSet};
+use std::net::ToSocketAddrs;
+use std::sync::{Arc, OnceLock};
+use std::time::Duration;
+use tokio::sync::{RwLock, mpsc, watch};
+use tokio::task::JoinHandle;
+
+const EMAIL_MAX_RETRY_BACKOFF_SECS: u64 = 300;
+
+/// Wraps both TLS and plaintext IMAP sessions behind a common interface.
+///
+/// Proton Bridge (and similar local bridges) expose IMAP/SMTP over plain TCP
+/// on localhost. The `imap` crate's `Session<T>` is generic, so we need this
+/// enum to support both paths at runtime.
+enum ImapSession {
+    Tls(imap::Session<native_tls::TlsStream<std::net::TcpStream>>),
+    Plain(imap::Session<std::net::TcpStream>),
+}
+
+impl ImapSession {
+    fn select(&mut self, folder: &str) -> imap::error::Result<imap::types::Mailbox> {
+        match self {
+            Self::Tls(session) => session.select(folder),
+            Self::Plain(session) => session.select(folder),
+        }
+    }
+
+    fn uid_fetch(
+        &mut self,
+        uid_set: impl AsRef<str>,
+        query: &str,
+    ) -> imap::error::Result<imap::types::ZeroCopy<Vec<imap::types::Fetch>>> {
+        match self {
+            Self::Tls(session) => session.uid_fetch(uid_set, query),
+            Self::Plain(session) => session.uid_fetch(uid_set, query),
+        }
+    }
+
+    fn uid_store(
+        &mut self,
+        uid_set: impl AsRef<str>,
+        query: impl AsRef<str>,
+    ) -> imap::error::Result<imap::types::ZeroCopy<Vec<imap::types::Fetch>>> {
+        match self {
+            Self::Tls(session) => session.uid_store(uid_set, query),
+            Self::Plain(session) => session.uid_store(uid_set, query),
+        }
+    }
+
+    fn uid_search(&mut self, query: impl AsRef<str>) -> imap::error::Result<HashSet<u32>> {
+        match self {
+            Self::Tls(session) => session.uid_search(query),
+            Self::Plain(session) => session.uid_search(query),
+        }
+    }
+
+    fn logout(&mut self) -> imap::error::Result<()> {
+        match self {
+            Self::Tls(session) => session.logout(),
+            Self::Plain(session) => session.logout(),
+        }
+    }
+}
+
+#[derive(Clone)]
+struct EmailPollConfig {
+    imap_host: String,
+    imap_port: u16,
+    imap_username: String,
+    imap_password: String,
+    imap_use_tls: bool,
+    from_address: String,
+    smtp_username: String,
+    folders: Vec<String>,
+    poll_interval: Duration,
+    allowed_senders: Vec<String>,
+    max_body_bytes: usize,
+    runtime_key: String,
+}
+
+struct HistoryEntry {
+    timestamp: chrono::DateTime<chrono::Utc>,
+    message: HistoryMessage,
+}
+
+/// Query filters for direct IMAP mailbox search.
+#[derive(Debug, Clone, Default)]
+pub struct EmailSearchQuery {
+    pub text: Option<String>,
+    pub from: Option<String>,
+    pub subject: Option<String>,
+    pub unread_only: bool,
+    pub since_days: Option<u32>,
+    pub folders: Vec<String>,
+    pub limit: usize,
+}
+
+/// A single match returned by `search_mailbox`.
+#[derive(Debug, Clone)]
+pub struct EmailSearchHit {
+    pub folder: String,
+    pub uid: u32,
+    pub from: String,
+    pub subject: String,
+    pub date: Option<String>,
+    pub message_id: Option<String>,
+    pub body: String,
+    pub attachment_names: Vec<String>,
+}
+
+/// Email adapter state.
+pub struct EmailAdapter {
+    runtime_key: String,
+    imap_host: String,
+    imap_port: u16,
+    imap_username: String,
+    imap_password: String,
+    imap_use_tls: bool,
+    smtp_host: String,
+    smtp_port: u16,
+    smtp_username: String,
+    smtp_use_starttls: bool,
+    from_address: String,
+    from_name: Option<String>,
+    folders: Vec<String>,
+    poll_interval: Duration,
+    allowed_senders: Vec<String>,
+    max_body_bytes: usize,
+    max_attachment_bytes: usize,
+    smtp_transport: AsyncSmtpTransport<Tokio1Executor>,
+    shutdown_tx: Arc<RwLock<Option<watch::Sender<bool>>>>,
+    poll_task: Arc<RwLock<Option<JoinHandle<()>>>>,
+}
+
+impl std::fmt::Debug for EmailAdapter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("EmailAdapter")
+            .field("imap_host", &self.imap_host)
+            .field("imap_port", &self.imap_port)
+            .field("imap_username", &"[REDACTED]")
+            .field("imap_password", &"[REDACTED]")
+            .field("imap_use_tls", &self.imap_use_tls)
+            .field("smtp_host", &self.smtp_host)
+            .field("smtp_port", &self.smtp_port)
+            .field("smtp_username", &"[REDACTED]")
+            .field("smtp_use_starttls", &self.smtp_use_starttls)
+            .field("from_address", &"[REDACTED]")
+            .field("from_name", &self.from_name)
+            .field("folders", &self.folders)
+            .field("poll_interval", &self.poll_interval)
+            .field("allowed_senders", &"[REDACTED]")
+            .field("max_body_bytes", &self.max_body_bytes)
+            .field("max_attachment_bytes", &self.max_attachment_bytes)
+            .finish()
+    }
+}
+
+impl EmailAdapter {
+    pub fn from_config(config: &EmailConfig) -> crate::Result<Self> {
+        Self::build("email".to_string(), config)
+    }
+
+    pub fn from_instance_config(
+        runtime_key: impl Into<String>,
+        config: &crate::config::EmailInstanceConfig,
+    ) -> crate::Result<Self> {
+        // Build a temporary EmailConfig to reuse build_smtp_transport and shared logic.
+        let email_config = EmailConfig {
+            enabled: config.enabled,
+            imap_host: config.imap_host.clone(),
+            imap_port: config.imap_port,
+            imap_username: config.imap_username.clone(),
+            imap_password: config.imap_password.clone(),
+            imap_use_tls: config.imap_use_tls,
+            smtp_host: config.smtp_host.clone(),
+            smtp_port: config.smtp_port,
+            smtp_username: config.smtp_username.clone(),
+            smtp_password: config.smtp_password.clone(),
+            smtp_use_starttls: config.smtp_use_starttls,
+            from_address: config.from_address.clone(),
+            from_name: config.from_name.clone(),
+            poll_interval_secs: config.poll_interval_secs,
+            folders: config.folders.clone(),
+            allowed_senders: config.allowed_senders.clone(),
+            max_body_bytes: config.max_body_bytes,
+            max_attachment_bytes: config.max_attachment_bytes,
+            instances: Vec::new(),
+        };
+        Self::build(runtime_key.into(), &email_config)
+    }
+
+    fn build(runtime_key: String, config: &EmailConfig) -> crate::Result<Self> {
+        let folders = config
+            .folders
+            .iter()
+            .map(|folder| folder.trim().to_string())
+            .filter(|folder| !folder.is_empty())
+            .collect::<Vec<_>>();
+
+        let folders = if folders.is_empty() {
+            vec!["INBOX".to_string()]
+        } else {
+            folders
+        };
+
+        let smtp_transport = build_smtp_transport(config)?;
+
+        Ok(Self {
+            runtime_key,
+            imap_host: config.imap_host.clone(),
+            imap_port: config.imap_port,
+            imap_username: config.imap_username.clone(),
+            imap_password: config.imap_password.clone(),
+            imap_use_tls: config.imap_use_tls,
+            smtp_host: config.smtp_host.clone(),
+            smtp_port: config.smtp_port,
+            smtp_username: config.smtp_username.clone(),
+            smtp_use_starttls: config.smtp_use_starttls,
+            from_address: config.from_address.clone(),
+            from_name: config.from_name.clone(),
+            folders,
+            poll_interval: Duration::from_secs(config.poll_interval_secs.max(5)),
+            allowed_senders: config.allowed_senders.clone(),
+            max_body_bytes: config.max_body_bytes.max(1024),
+            max_attachment_bytes: config.max_attachment_bytes.max(1024),
+            smtp_transport,
+            shutdown_tx: Arc::new(RwLock::new(None)),
+            poll_task: Arc::new(RwLock::new(None)),
+        })
+    }
+
+    fn poll_config(&self) -> EmailPollConfig {
+        EmailPollConfig {
+            imap_host: self.imap_host.clone(),
+            imap_port: self.imap_port,
+            imap_username: self.imap_username.clone(),
+            imap_password: self.imap_password.clone(),
+            imap_use_tls: self.imap_use_tls,
+            from_address: self.from_address.clone(),
+            smtp_username: self.smtp_username.clone(),
+            folders: self.folders.clone(),
+            poll_interval: self.poll_interval,
+            allowed_senders: self.allowed_senders.clone(),
+            max_body_bytes: self.max_body_bytes,
+            runtime_key: self.runtime_key.clone(),
+        }
+    }
+
+    fn sender_mailbox(&self) -> crate::Result<Mailbox> {
+        let from_address: Address = self
+            .from_address
+            .parse()
+            .with_context(|| format!("invalid email from_address '{}'", self.from_address))?;
+        Ok(Mailbox::new(self.from_name.clone(), from_address))
+    }
+
+    async fn send_email(
+        &self,
+        recipient: &str,
+        subject: &str,
+        body: String,
+        in_reply_to: Option<String>,
+        references: Vec<String>,
+        attachment: Option<(String, Vec<u8>, String)>,
+    ) -> crate::Result<()> {
+        let recipient_mailbox = parse_mailbox(recipient)
+            .with_context(|| format!("invalid recipient address '{recipient}'"))?;
+
+        let mut builder = Message::builder()
+            .from(self.sender_mailbox()?)
+            .to(recipient_mailbox)
+            .subject(subject.to_string());
+
+        if let Some(in_reply_to) = in_reply_to {
+            let in_reply_to = format_message_id_for_header(&in_reply_to);
+            if !in_reply_to.is_empty() {
+                builder = builder.in_reply_to(in_reply_to);
+            }
+        }
+
+        for reference in references {
+            let reference = format_message_id_for_header(&reference);
+            if !reference.is_empty() {
+                builder = builder.references(reference);
+            }
+        }
+
+        let message = if let Some((filename, data, mime_type)) = attachment {
+            if data.len() > self.max_attachment_bytes {
+                return Err(anyhow::anyhow!(
+                    "attachment '{filename}' exceeds max_attachment_bytes ({} > {})",
+                    data.len(),
+                    self.max_attachment_bytes
+                )
+                .into());
+            }
+
+            let content_type = ContentType::parse(&mime_type).unwrap_or(ContentType::TEXT_PLAIN);
+            let attachment = EmailAttachment::new(filename).body(data, content_type);
+            let multipart = MultiPart::mixed()
+                .singlepart(SinglePart::plain(body))
+                .singlepart(attachment);
+            builder
+                .multipart(multipart)
+                .context("failed to build multipart email")?
+        } else {
+            builder.body(body).context("failed to build email body")?
+        };
+
+        self.smtp_transport
+            .send(message)
+            .await
+            .context("failed to send email")?;
+
+        Ok(())
+    }
+}
+
+impl Messaging for EmailAdapter {
+    fn name(&self) -> &str {
+        &self.runtime_key
+    }
+
+    async fn start(&self) -> crate::Result<InboundStream> {
+        if self.poll_task.read().await.is_some() {
+            return Err(anyhow::anyhow!("email adapter already started").into());
+        }
+
+        let (inbound_tx, inbound_rx) = mpsc::channel(256);
+        let (shutdown_tx, mut shutdown_rx) = watch::channel(false);
+
+        *self.shutdown_tx.write().await = Some(shutdown_tx);
+
+        let poll_config = self.poll_config();
+
+        let poll_task = tokio::spawn(async move {
+            let mut retry_backoff = Duration::from_secs(5);
+
+            loop {
+                if *shutdown_rx.borrow() {
+                    break;
+                }
+
+                let config = poll_config.clone();
+                let poll_result =
+                    tokio::task::spawn_blocking(move || poll_inbox_once(&config)).await;
+
+                let mut had_error = false;
+
+                match poll_result {
+                    Ok(Ok(messages)) => {
+                        retry_backoff = Duration::from_secs(5);
+                        for message in messages {
+                            if inbound_tx.send(message).await.is_err() {
+                                tracing::warn!(
+                                    "email inbound channel closed, stopping adapter loop"
+                                );
+                                return;
+                            }
+                        }
+                    }
+                    Ok(Err(error)) => {
+                        had_error = true;
+                        tracing::warn!(%error, "email poll cycle failed");
+                    }
+                    Err(error) => {
+                        had_error = true;
+                        tracing::warn!(%error, "email poll task panicked");
+                    }
+                }
+
+                let sleep_duration = if had_error {
+                    let current = retry_backoff;
+                    retry_backoff =
+                        (retry_backoff * 2).min(Duration::from_secs(EMAIL_MAX_RETRY_BACKOFF_SECS));
+                    current
+                } else {
+                    poll_config.poll_interval
+                };
+
+                tokio::select! {
+                    _ = shutdown_rx.changed() => {
+                        if *shutdown_rx.borrow() {
+                            break;
+                        }
+                    }
+                    _ = tokio::time::sleep(sleep_duration) => {}
+                }
+            }
+
+            tracing::info!("email adapter loop stopped");
+        });
+
+        *self.poll_task.write().await = Some(poll_task);
+
+        let stream = tokio_stream::wrappers::ReceiverStream::new(inbound_rx);
+        Ok(Box::pin(stream))
+    }
+
+    async fn respond(
+        &self,
+        message: &InboundMessage,
+        response: OutboundResponse,
+    ) -> crate::Result<()> {
+        let mut context = reply_context_from_message(message)?;
+
+        match response {
+            OutboundResponse::Text(text) => {
+                self.send_email(
+                    &context.recipient,
+                    &context.subject,
+                    text,
+                    context.in_reply_to,
+                    context.references,
+                    None,
+                )
+                .await?;
+            }
+            OutboundResponse::RichMessage { text, .. } => {
+                self.send_email(
+                    &context.recipient,
+                    &context.subject,
+                    text,
+                    context.in_reply_to,
+                    context.references,
+                    None,
+                )
+                .await?;
+            }
+            OutboundResponse::ThreadReply { thread_name, text } => {
+                if !thread_name.trim().is_empty() {
+                    context.subject = normalize_reply_subject(&thread_name);
+                }
+                self.send_email(
+                    &context.recipient,
+                    &context.subject,
+                    text,
+                    context.in_reply_to,
+                    context.references,
+                    None,
+                )
+                .await?;
+            }
+            OutboundResponse::File {
+                filename,
+                data,
+                mime_type,
+                caption,
+            } => {
+                let mut body = caption.unwrap_or_else(|| format!("Attached file: {filename}"));
+                if body.trim().is_empty() {
+                    body = format!("Attached file: {filename}");
+                }
+
+                self.send_email(
+                    &context.recipient,
+                    &context.subject,
+                    body,
+                    context.in_reply_to,
+                    context.references,
+                    Some((filename, data, mime_type)),
+                )
+                .await?;
+            }
+            OutboundResponse::Reaction(_)
+            | OutboundResponse::RemoveReaction(_)
+            | OutboundResponse::Status(_) => {}
+            OutboundResponse::Ephemeral { text, .. } => {
+                self.send_email(
+                    &context.recipient,
+                    &context.subject,
+                    text,
+                    context.in_reply_to,
+                    context.references,
+                    None,
+                )
+                .await?;
+            }
+            OutboundResponse::ScheduledMessage { text, post_at } => {
+                tracing::warn!(
+                    post_at,
+                    recipient = %context.recipient,
+                    subject = %context.subject,
+                    "email adapter does not support scheduled delivery; sending immediately"
+                );
+                self.send_email(
+                    &context.recipient,
+                    &context.subject,
+                    text,
+                    context.in_reply_to,
+                    context.references,
+                    None,
+                )
+                .await?;
+            }
+            OutboundResponse::StreamStart
+            | OutboundResponse::StreamChunk(_)
+            | OutboundResponse::StreamEnd => {}
+        }
+
+        Ok(())
+    }
+
+    async fn broadcast(&self, target: &str, response: OutboundResponse) -> crate::Result<()> {
+        let recipient = normalize_email_target(target)
+            .ok_or_else(|| anyhow::anyhow!("invalid email target '{target}'"))?;
+
+        match response {
+            OutboundResponse::Text(text) => {
+                self.send_email(&recipient, "Spacebot message", text, None, Vec::new(), None)
+                    .await?;
+            }
+            OutboundResponse::RichMessage { text, .. } => {
+                self.send_email(&recipient, "Spacebot message", text, None, Vec::new(), None)
+                    .await?;
+            }
+            OutboundResponse::File {
+                filename,
+                data,
+                mime_type,
+                caption,
+            } => {
+                let body = caption.unwrap_or_else(|| format!("Attached file: {filename}"));
+                self.send_email(
+                    &recipient,
+                    "Spacebot message",
+                    body,
+                    None,
+                    Vec::new(),
+                    Some((filename, data, mime_type)),
+                )
+                .await?;
+            }
+            OutboundResponse::ThreadReply { text, .. }
+            | OutboundResponse::Ephemeral { text, .. } => {
+                self.send_email(&recipient, "Spacebot message", text, None, Vec::new(), None)
+                    .await?;
+            }
+            OutboundResponse::ScheduledMessage { text, post_at } => {
+                tracing::warn!(
+                    post_at,
+                    recipient = %recipient,
+                    "email adapter does not support scheduled delivery; sending immediately"
+                );
+                self.send_email(&recipient, "Spacebot message", text, None, Vec::new(), None)
+                    .await?;
+            }
+            OutboundResponse::Reaction(_)
+            | OutboundResponse::RemoveReaction(_)
+            | OutboundResponse::Status(_)
+            | OutboundResponse::StreamStart
+            | OutboundResponse::StreamChunk(_)
+            | OutboundResponse::StreamEnd => {}
+        }
+
+        Ok(())
+    }
+
+    async fn fetch_history(
+        &self,
+        message: &InboundMessage,
+        limit: usize,
+    ) -> crate::Result<Vec<HistoryMessage>> {
+        if limit == 0 {
+            return Ok(Vec::new());
+        }
+
+        let references = message
+            .metadata
+            .get("email_references")
+            .and_then(json_value_to_string)
+            .map(|value| extract_message_ids(&value))
+            .unwrap_or_default();
+
+        let in_reply_to = message
+            .metadata
+            .get("email_in_reply_to")
+            .and_then(json_value_to_string)
+            .and_then(|value| extract_message_ids(&value).into_iter().next());
+
+        let mut message_ids = references;
+        if let Some(in_reply_to) = in_reply_to
+            && !message_ids.contains(&in_reply_to)
+        {
+            message_ids.push(in_reply_to);
+        }
+
+        let current_message_id = message
+            .metadata
+            .get("email_message_id")
+            .and_then(json_value_to_string)
+            .map(|value| normalize_message_id(&value));
+
+        message_ids.retain(|message_id| {
+            current_message_id
+                .as_ref()
+                .is_none_or(|current| current != message_id)
+        });
+
+        if message_ids.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let poll_config = self.poll_config();
+
+        let history = tokio::task::spawn_blocking(move || {
+            fetch_history_from_imap(&poll_config, message_ids, limit)
+        })
+        .await
+        .context("email history task failed")??;
+
+        Ok(history)
+    }
+
+    async fn health_check(&self) -> crate::Result<()> {
+        let poll_config = self.poll_config();
+        tokio::task::spawn_blocking(move || {
+            let mut session = open_imap_session(&poll_config)?;
+            let folder = poll_config
+                .folders
+                .first()
+                .cloned()
+                .unwrap_or_else(|| "INBOX".to_string());
+            session
+                .select(&folder)
+                .with_context(|| format!("failed to select IMAP folder '{folder}'"))?;
+            session.logout().ok();
+            anyhow::Ok(())
+        })
+        .await
+        .context("email IMAP health check task failed")??;
+
+        let smtp_ok = self
+            .smtp_transport
+            .test_connection()
+            .await
+            .context("SMTP health check failed")?;
+        if !smtp_ok {
+            return Err(anyhow::anyhow!("SMTP server rejected test connection").into());
+        }
+
+        Ok(())
+    }
+
+    async fn shutdown(&self) -> crate::Result<()> {
+        if let Some(shutdown_tx) = self.shutdown_tx.write().await.take() {
+            shutdown_tx.send(true).ok();
+        }
+
+        if let Some(poll_task) = self.poll_task.write().await.take()
+            && let Err(error) = poll_task.await
+        {
+            tracing::warn!(%error, "email poll task join failed during shutdown");
+        }
+
+        self.smtp_transport.shutdown().await;
+
+        tracing::info!("email adapter shut down");
+        Ok(())
+    }
+}
+
+fn build_smtp_transport(config: &EmailConfig) -> crate::Result<AsyncSmtpTransport<Tokio1Executor>> {
+    let builder = if config.smtp_use_starttls {
+        AsyncSmtpTransport::<Tokio1Executor>::starttls_relay(&config.smtp_host)
+            .with_context(|| format!("invalid SMTP host '{}'", config.smtp_host))?
+    } else {
+        if !is_local_mail_host(&config.smtp_host) {
+            return Err(anyhow::anyhow!(
+                "refusing plaintext SMTP for non-local host '{}'; enable STARTTLS or use a localhost bridge",
+                config.smtp_host
+            )
+            .into());
+        }
+
+        // Plain TCP (no TLS) — used by local bridges like Proton Bridge.
+        // `builder_dangerous` allows unencrypted SMTP, which is safe for
+        // localhost connections where the bridge itself encrypts upstream.
+        AsyncSmtpTransport::<Tokio1Executor>::builder_dangerous(&config.smtp_host)
+    };
+
+    Ok(builder
+        .port(config.smtp_port)
+        .credentials(Credentials::new(
+            config.smtp_username.clone(),
+            config.smtp_password.clone(),
+        ))
+        .build())
+}
+
+fn poll_inbox_once(config: &EmailPollConfig) -> anyhow::Result<Vec<InboundMessage>> {
+    let mut session = open_imap_session(config)?;
+    let mut inbound_messages = Vec::new();
+
+    for folder in &config.folders {
+        if let Err(error) = session.select(folder) {
+            tracing::warn!(folder, %error, "failed to select IMAP folder");
+            continue;
+        }
+
+        let message_uids = session
+            .uid_search("UNSEEN")
+            .with_context(|| format!("failed to search unseen messages in folder '{folder}'"))?;
+
+        for uid in message_uids {
+            let uid_sequence = uid.to_string();
+
+            let fetches = match session.uid_fetch(&uid_sequence, "(UID RFC822)") {
+                Ok(fetches) => fetches,
+                Err(error) => {
+                    tracing::warn!(folder, uid, %error, "failed to fetch unseen email");
+                    continue;
+                }
+            };
+
+            let mut should_mark_seen = !fetches.is_empty();
+
+            for fetch in &fetches {
+                let current_uid = fetch.uid.unwrap_or(uid);
+                let Some(raw_email) = fetch.body() else {
+                    should_mark_seen = false;
+                    tracing::warn!(
+                        folder,
+                        uid = current_uid,
+                        "email fetch body missing; leaving message unseen for retry"
+                    );
+                    continue;
+                };
+
+                match parse_inbound_email(raw_email, folder, current_uid, config) {
+                    Ok(Some(inbound_message)) => inbound_messages.push(inbound_message),
+                    Ok(None) => {}
+                    Err(error) => {
+                        should_mark_seen = false;
+                        tracing::warn!(folder, uid = current_uid, %error, "failed to parse inbound email");
+                    }
+                }
+            }
+
+            if should_mark_seen {
+                if let Err(error) = session.uid_store(&uid_sequence, "+FLAGS (\\Seen)") {
+                    tracing::warn!(folder, uid, %error, "failed to mark email as seen");
+                }
+            } else {
+                tracing::debug!(folder, uid, "leaving email unseen for retry");
+            }
+        }
+    }
+
+    session.logout().ok();
+
+    Ok(inbound_messages)
+}
+
+fn open_imap_session(config: &EmailPollConfig) -> anyhow::Result<ImapSession> {
+    if config.imap_use_tls {
+        // Implicit TLS (typically port 993)
+        let tls = native_tls::TlsConnector::builder()
+            .build()
+            .context("failed to build TLS connector for IMAP")?;
+
+        let client = imap::connect(
+            (config.imap_host.as_str(), config.imap_port),
+            config.imap_host.as_str(),
+            &tls,
+        )
+        .with_context(|| {
+            format!(
+                "failed to connect to IMAP server '{}:{}'",
+                config.imap_host, config.imap_port
+            )
+        })?;
+
+        let session = client
+            .login(config.imap_username.as_str(), config.imap_password.as_str())
+            .map_err(|error| anyhow::anyhow!(error.0))
+            .context("failed to authenticate to IMAP server")?;
+
+        Ok(ImapSession::Tls(session))
+    } else {
+        if !is_local_mail_host(&config.imap_host) {
+            return Err(anyhow::anyhow!(
+                "refusing plaintext IMAP for non-local host '{}'; enable TLS or use a localhost bridge",
+                config.imap_host
+            ));
+        }
+
+        // Plain TCP (no TLS) — used by local bridges like Proton Bridge.
+        // Iterate all resolved addresses so dual-stack localhost (IPv4 + IPv6) works
+        // even when the bridge only listens on one address family.
+        let addresses: Vec<std::net::SocketAddr> = (config.imap_host.as_str(), config.imap_port)
+            .to_socket_addrs()
+            .with_context(|| {
+                format!(
+                    "failed to resolve IMAP server '{}:{}'",
+                    config.imap_host, config.imap_port
+                )
+            })?
+            .collect();
+        if addresses.is_empty() {
+            return Err(anyhow::anyhow!(
+                "no IMAP socket addresses resolved for '{}:{}'",
+                config.imap_host,
+                config.imap_port
+            ));
+        }
+
+        let mut last_error = None;
+        let mut tcp = None;
+        for address in &addresses {
+            match std::net::TcpStream::connect_timeout(address, Duration::from_secs(10)) {
+                Ok(stream) => {
+                    tcp = Some(stream);
+                    break;
+                }
+                Err(error) => {
+                    last_error = Some((*address, error));
+                }
+            }
+        }
+        let tcp = tcp.ok_or_else(|| {
+            let (address, error) = last_error.expect("addresses is non-empty");
+            anyhow::anyhow!(
+                "failed to connect to IMAP server '{}:{}' (last tried {address}: {error})",
+                config.imap_host,
+                config.imap_port,
+            )
+        })?;
+        tcp.set_read_timeout(Some(Duration::from_secs(30)))
+            .context("failed to set IMAP read timeout")?;
+        tcp.set_write_timeout(Some(Duration::from_secs(30)))
+            .context("failed to set IMAP write timeout")?;
+
+        let client = imap::Client::new(tcp);
+
+        let session = client
+            .login(config.imap_username.as_str(), config.imap_password.as_str())
+            .map_err(|error| anyhow::anyhow!(error.0))
+            .context("failed to authenticate to IMAP server")?;
+
+        Ok(ImapSession::Plain(session))
+    }
+}
+
+fn is_local_mail_host(host: &str) -> bool {
+    let normalized_host = host
+        .trim()
+        .trim_start_matches('[')
+        .trim_end_matches(']')
+        .trim_end_matches('.');
+
+    if normalized_host.eq_ignore_ascii_case("localhost") {
+        return true;
+    }
+
+    normalized_host
+        .parse::<std::net::IpAddr>()
+        .map(|address| address.is_loopback())
+        .unwrap_or(false)
+}
+
+fn parse_inbound_email(
+    raw_email: &[u8],
+    folder: &str,
+    uid: u32,
+    config: &EmailPollConfig,
+) -> anyhow::Result<Option<InboundMessage>> {
+    let parsed = mailparse::parse_mail(raw_email).context("failed to parse MIME email")?;
+    let headers = parsed.headers.as_slice();
+
+    if is_auto_generated_email(headers) {
+        return Ok(None);
+    }
+
+    let from_header = headers.get_first_value("From").unwrap_or_default();
+    let Some((sender_email, sender_name)) = parse_primary_mailbox(&from_header) else {
+        return Ok(None);
+    };
+
+    if is_own_sender(&sender_email, config) {
+        return Ok(None);
+    }
+
+    if !is_allowed_sender(&sender_email, &config.allowed_senders) {
+        return Ok(None);
+    }
+
+    let reply_to_email = headers
+        .get_first_value("Reply-To")
+        .and_then(|value| parse_primary_mailbox(&value).map(|(address, _)| address))
+        .unwrap_or_else(|| sender_email.clone());
+
+    let to_header = headers.get_first_value("To");
+    let subject = headers
+        .get_first_value("Subject")
+        .unwrap_or_else(|| "(no subject)".to_string());
+
+    let message_id = headers
+        .get_first_value("Message-ID")
+        .map(|value| normalize_message_id(&value))
+        .filter(|value| !value.is_empty())
+        .unwrap_or_else(|| format!("generated-{}-{}", uid, uuid::Uuid::new_v4()));
+
+    let in_reply_to = headers
+        .get_first_value("In-Reply-To")
+        .and_then(|value| extract_message_ids(&value).into_iter().next());
+
+    let references = headers
+        .get_first_value("References")
+        .map(|value| extract_message_ids(&value))
+        .unwrap_or_default();
+
+    let thread_key = derive_thread_key(
+        &references,
+        in_reply_to.as_deref(),
+        Some(message_id.as_str()),
+        &subject,
+        &sender_email,
+    );
+
+    let account_key = sanitize_account_key(&config.from_address);
+    let conversation_id = format!("email:{account_key}:{thread_key}");
+
+    let (mut body_text, attachment_names) =
+        extract_text_and_attachments(&parsed, config.max_body_bytes);
+    if !attachment_names.is_empty() {
+        body_text.push_str("\n\nAttachments: ");
+        body_text.push_str(&attachment_names.join(", "));
+    }
+
+    let timestamp = headers
+        .get_first_value("Date")
+        .and_then(|value| mailparse::dateparse(&value).ok())
+        .and_then(|timestamp| Utc.timestamp_opt(timestamp, 0).single())
+        .unwrap_or_else(Utc::now);
+
+    let mut metadata = HashMap::new();
+    metadata.insert(
+        "email_from".into(),
+        serde_json::Value::String(sender_email.clone()),
+    );
+    metadata.insert(
+        "email_reply_to".into(),
+        serde_json::Value::String(reply_to_email),
+    );
+    if let Some(to_header) = to_header {
+        metadata.insert("email_to".into(), serde_json::Value::String(to_header));
+    }
+    metadata.insert(
+        "email_subject".into(),
+        serde_json::Value::String(subject.clone()),
+    );
+    metadata.insert(
+        "email_message_id".into(),
+        serde_json::Value::String(message_id.clone()),
+    );
+    metadata.insert(
+        crate::metadata_keys::MESSAGE_ID.into(),
+        serde_json::Value::String(message_id.clone()),
+    );
+    metadata.insert(
+        crate::metadata_keys::CHANNEL_NAME.into(),
+        serde_json::Value::String(format!("Email: {subject}")),
+    );
+    if let Some(in_reply_to) = in_reply_to {
+        metadata.insert(
+            "email_in_reply_to".into(),
+            serde_json::Value::String(in_reply_to),
+        );
+    }
+    if !references.is_empty() {
+        metadata.insert(
+            "email_references".into(),
+            serde_json::Value::String(references.join(" ")),
+        );
+    }
+    metadata.insert(
+        "email_folder".into(),
+        serde_json::Value::String(folder.to_string()),
+    );
+    metadata.insert(
+        "email_uid".into(),
+        serde_json::Value::Number(serde_json::Number::from(uid)),
+    );
+    metadata.insert(
+        "email_thread_key".into(),
+        serde_json::Value::String(thread_key),
+    );
+    metadata.insert(
+        "sender_display_name".into(),
+        serde_json::Value::String(sender_name.clone().unwrap_or_else(|| sender_email.clone())),
+    );
+
+    let formatted_author = sender_name.map_or_else(
+        || sender_email.clone(),
+        |name| format!("{name} <{sender_email}>"),
+    );
+
+    Ok(Some(InboundMessage {
+        id: message_id,
+        source: "email".into(),
+        adapter: Some(config.runtime_key.clone()),
+        conversation_id,
+        sender_id: sender_email,
+        agent_id: None,
+        content: MessageContent::Text(body_text),
+        timestamp,
+        metadata,
+        formatted_author: Some(formatted_author),
+    }))
+}
+
+fn reply_context_from_message(message: &InboundMessage) -> anyhow::Result<EmailReplyContext> {
+    let recipient = message
+        .metadata
+        .get("email_reply_to")
+        .and_then(json_value_to_string)
+        .or_else(|| {
+            message
+                .metadata
+                .get("email_from")
+                .and_then(json_value_to_string)
+        })
+        .context("missing recipient metadata for email reply")?;
+
+    let subject = message
+        .metadata
+        .get("email_subject")
+        .and_then(json_value_to_string)
+        .map(|value| normalize_reply_subject(&value))
+        .unwrap_or_else(|| "Re: Spacebot reply".to_string());
+
+    let in_reply_to = message
+        .metadata
+        .get("email_message_id")
+        .and_then(json_value_to_string)
+        .map(|value| normalize_message_id(&value))
+        .filter(|value| !value.is_empty());
+
+    let mut references = message
+        .metadata
+        .get("email_references")
+        .and_then(json_value_to_string)
+        .map(|value| extract_message_ids(&value))
+        .unwrap_or_default();
+
+    if let Some(in_reply_to) = &in_reply_to
+        && !references.contains(in_reply_to)
+    {
+        references.push(in_reply_to.clone());
+    }
+
+    Ok(EmailReplyContext {
+        recipient,
+        subject,
+        in_reply_to,
+        references,
+    })
+}
+
+fn fetch_history_from_imap(
+    config: &EmailPollConfig,
+    message_ids: Vec<String>,
+    limit: usize,
+) -> anyhow::Result<Vec<HistoryMessage>> {
+    let mut session = open_imap_session(config)?;
+    let mut seen_message_ids = HashSet::new();
+    let mut entries = Vec::new();
+
+    for folder in &config.folders {
+        if entries.len() >= limit {
+            break;
+        }
+
+        if let Err(error) = session.select(folder) {
+            tracing::warn!(folder, %error, "failed to select IMAP folder for history backfill");
+            continue;
+        }
+
+        for message_id in &message_ids {
+            if entries.len() >= limit {
+                break;
+            }
+
+            let Some(criterion) = build_message_id_search_criterion(message_id) else {
+                tracing::debug!(
+                    message_id,
+                    "skipping unsafe message id for IMAP history search"
+                );
+                continue;
+            };
+
+            let uids = match session.uid_search(&criterion) {
+                Ok(uids) => uids,
+                Err(error) => {
+                    tracing::warn!(folder, message_id, %error, "failed IMAP history search");
+                    continue;
+                }
+            };
+
+            for uid in uids {
+                if entries.len() >= limit {
+                    break;
+                }
+
+                let fetches = match session.uid_fetch(uid.to_string(), "(UID RFC822)") {
+                    Ok(fetches) => fetches,
+                    Err(error) => {
+                        tracing::warn!(folder, uid, %error, "failed IMAP history fetch");
+                        continue;
+                    }
+                };
+
+                for fetch in &fetches {
+                    let Some(raw_email) = fetch.body() else {
+                        continue;
+                    };
+
+                    let parsed = match mailparse::parse_mail(raw_email) {
+                        Ok(parsed) => parsed,
+                        Err(error) => {
+                            tracing::warn!(folder, uid, %error, "failed to parse history email MIME");
+                            continue;
+                        }
+                    };
+
+                    let headers = parsed.headers.as_slice();
+                    let normalized_message_id = headers
+                        .get_first_value("Message-ID")
+                        .map(|value| normalize_message_id(&value))
+                        .filter(|value| !value.is_empty());
+
+                    let Some(normalized_message_id) = normalized_message_id else {
+                        continue;
+                    };
+
+                    if !seen_message_ids.insert(normalized_message_id) {
+                        continue;
+                    }
+
+                    let from_header = headers.get_first_value("From").unwrap_or_default();
+                    let (sender_email, sender_name) = parse_primary_mailbox(&from_header)
+                        .unwrap_or_else(|| (from_header.clone(), None));
+
+                    let is_bot = sender_email.eq_ignore_ascii_case(&config.from_address)
+                        || sender_email.eq_ignore_ascii_case(&config.smtp_username);
+
+                    let author = sender_name.unwrap_or(sender_email);
+                    let (body, _) = extract_text_and_attachments(&parsed, config.max_body_bytes);
+
+                    let timestamp = headers
+                        .get_first_value("Date")
+                        .and_then(|value| mailparse::dateparse(&value).ok())
+                        .and_then(|timestamp| Utc.timestamp_opt(timestamp, 0).single())
+                        .unwrap_or_else(Utc::now);
+
+                    entries.push(HistoryEntry {
+                        timestamp,
+                        message: HistoryMessage {
+                            author,
+                            content: body,
+                            is_bot,
+                        },
+                    });
+                }
+            }
+        }
+    }
+
+    session.logout().ok();
+
+    entries.sort_by_key(|entry| entry.timestamp);
+    entries.truncate(limit);
+
+    Ok(entries.into_iter().map(|entry| entry.message).collect())
+}
+
+/// Search the configured mailbox directly via IMAP.
+///
+/// Results are returned newest-first across searched folders.
+pub fn search_mailbox(
+    config: &EmailConfig,
+    query: EmailSearchQuery,
+) -> crate::Result<Vec<EmailSearchHit>> {
+    let mut session = open_imap_session(&EmailPollConfig {
+        imap_host: config.imap_host.clone(),
+        imap_port: config.imap_port,
+        imap_username: config.imap_username.clone(),
+        imap_password: config.imap_password.clone(),
+        imap_use_tls: config.imap_use_tls,
+        from_address: config.from_address.clone(),
+        smtp_username: config.smtp_username.clone(),
+        folders: config.folders.clone(),
+        poll_interval: Duration::from_secs(config.poll_interval_secs.max(5)),
+        allowed_senders: config.allowed_senders.clone(),
+        max_body_bytes: config.max_body_bytes.max(1024),
+        runtime_key: "email".to_string(),
+    })?;
+
+    let limit = query.limit.clamp(1, 50);
+    let criterion = build_imap_search_criterion(&query);
+    let folders = normalize_search_folders(&query.folders, &config.folders);
+    let max_body_bytes = config.max_body_bytes.max(1024);
+    let mut seen_message_ids = HashSet::new();
+    let mut ranked_results: Vec<(i64, EmailSearchHit)> = Vec::new();
+
+    for folder in folders {
+        if let Err(error) = session.select(folder.as_str()) {
+            tracing::warn!(folder, %error, "failed to select IMAP folder for search");
+            continue;
+        }
+
+        let mut message_uids: Vec<u32> = match session.uid_search(&criterion) {
+            Ok(uids) => uids.into_iter().collect(),
+            Err(error) => {
+                tracing::warn!(
+                    folder,
+                    criterion_len = criterion.len(),
+                    has_text = query.text.is_some(),
+                    has_from = query.from.is_some(),
+                    has_subject = query.subject.is_some(),
+                    unread_only = query.unread_only,
+                    since_days = query.since_days,
+                    %error,
+                    "failed IMAP mailbox search"
+                );
+                continue;
+            }
+        };
+
+        message_uids.sort_unstable_by(|left, right| right.cmp(left));
+
+        for uid in message_uids {
+            let fetches = match session.uid_fetch(uid.to_string(), "(UID RFC822)") {
+                Ok(fetches) => fetches,
+                Err(error) => {
+                    tracing::warn!(folder, uid, %error, "failed IMAP mailbox fetch");
+                    continue;
+                }
+            };
+
+            for fetch in &fetches {
+                let current_uid = fetch.uid.unwrap_or(uid);
+                let Some(raw_email) = fetch.body() else {
+                    continue;
+                };
+
+                let parsed = match mailparse::parse_mail(raw_email) {
+                    Ok(parsed) => parsed,
+                    Err(error) => {
+                        tracing::warn!(folder, uid = current_uid, %error, "failed to parse searched email MIME");
+                        continue;
+                    }
+                };
+
+                let headers = parsed.headers.as_slice();
+                let message_id = headers
+                    .get_first_value("Message-ID")
+                    .map(|value| normalize_message_id(&value))
+                    .filter(|value| !value.is_empty());
+
+                if let Some(message_id) = &message_id
+                    && !seen_message_ids.insert(message_id.clone())
+                {
+                    continue;
+                }
+
+                let from = headers.get_first_value("From").unwrap_or_default();
+                let subject = headers
+                    .get_first_value("Subject")
+                    .unwrap_or_else(|| "(No subject)".to_string());
+                let date = headers.get_first_value("Date");
+                let sort_timestamp = date
+                    .as_deref()
+                    .and_then(|value| mailparse::dateparse(value).ok())
+                    .unwrap_or(i64::MIN);
+                let (body, attachment_names) =
+                    extract_text_and_attachments(&parsed, max_body_bytes);
+
+                ranked_results.push((
+                    sort_timestamp,
+                    EmailSearchHit {
+                        folder: folder.clone(),
+                        uid: current_uid,
+                        from,
+                        subject,
+                        date,
+                        message_id,
+                        body,
+                        attachment_names,
+                    },
+                ));
+            }
+        }
+    }
+
+    let results = sort_and_limit_search_hits(ranked_results, limit);
+
+    if let Err(error) = session.logout() {
+        tracing::debug!(%error, "IMAP logout failed after mailbox search");
+    }
+
+    Ok(results)
+}
+
+fn sort_and_limit_search_hits(
+    mut ranked_results: Vec<(i64, EmailSearchHit)>,
+    limit: usize,
+) -> Vec<EmailSearchHit> {
+    ranked_results.sort_unstable_by(|left, right| {
+        right
+            .0
+            .cmp(&left.0)
+            .then_with(|| right.1.uid.cmp(&left.1.uid))
+    });
+
+    ranked_results
+        .into_iter()
+        .map(|(_, hit)| hit)
+        .take(limit)
+        .collect()
+}
+
+fn normalize_search_folders(requested: &[String], fallback: &[String]) -> Vec<String> {
+    let mut folders = requested
+        .iter()
+        .map(|folder| folder.trim().to_string())
+        .filter(|folder| !folder.is_empty())
+        .collect::<Vec<_>>();
+
+    if folders.is_empty() {
+        folders = fallback
+            .iter()
+            .map(|folder| folder.trim().to_string())
+            .filter(|folder| !folder.is_empty())
+            .collect::<Vec<_>>();
+    }
+
+    if folders.is_empty() {
+        folders.push("INBOX".to_string());
+    }
+
+    folders.sort();
+    folders.dedup();
+    folders
+}
+
+fn build_imap_search_criterion(query: &EmailSearchQuery) -> String {
+    let mut clauses = Vec::new();
+
+    if query.unread_only {
+        clauses.push("UNSEEN".to_string());
+    }
+
+    if let Some(from) = sanitize_imap_search_value(query.from.as_deref()) {
+        clauses.push(format!("FROM {}", quote_imap_search_value(&from)));
+    }
+
+    if let Some(subject) = sanitize_imap_search_value(query.subject.as_deref()) {
+        clauses.push(format!("SUBJECT {}", quote_imap_search_value(&subject)));
+    }
+
+    if let Some(text) = sanitize_imap_search_value(query.text.as_deref()) {
+        clauses.push(format!("TEXT {}", quote_imap_search_value(&text)));
+    }
+
+    if let Some(since_days) = query.since_days.filter(|days| *days > 0) {
+        let since_date = (Utc::now() - ChronoDuration::days(since_days as i64))
+            .format("%d-%b-%Y")
+            .to_string();
+        clauses.push(format!("SINCE {since_date}"));
+    }
+
+    if clauses.is_empty() {
+        "ALL".to_string()
+    } else {
+        clauses.join(" ")
+    }
+}
+
+fn sanitize_imap_search_value(value: Option<&str>) -> Option<String> {
+    let value = value?.trim();
+    if value.is_empty() {
+        return None;
+    }
+
+    let normalized = value.replace(['\r', '\n'], " ").trim().to_string();
+    if normalized.is_empty() {
+        None
+    } else {
+        Some(normalized)
+    }
+}
+
+fn quote_imap_search_value(value: &str) -> String {
+    let escaped = value.replace('\\', "\\\\").replace('"', "\\\"");
+    format!("\"{escaped}\"")
+}
+
+fn is_auto_generated_email(headers: &[mailparse::MailHeader<'_>]) -> bool {
+    let auto_submitted = headers
+        .get_first_value("Auto-Submitted")
+        .map(|value| value.trim().to_ascii_lowercase())
+        .unwrap_or_default();
+    if !auto_submitted.is_empty() && auto_submitted != "no" {
+        return true;
+    }
+
+    let precedence = headers
+        .get_first_value("Precedence")
+        .map(|value| value.trim().to_ascii_lowercase())
+        .unwrap_or_default();
+    if matches!(precedence.as_str(), "bulk" | "junk" | "list" | "auto_reply") {
+        return true;
+    }
+
+    headers.get_first_value("X-Autoreply").is_some()
+        || headers.get_first_value("X-Autorespond").is_some()
+}
+
+fn is_own_sender(sender_email: &str, config: &EmailPollConfig) -> bool {
+    sender_email.eq_ignore_ascii_case(&config.from_address)
+        || sender_email.eq_ignore_ascii_case(&config.imap_username)
+        || sender_email.eq_ignore_ascii_case(&config.smtp_username)
+}
+
+fn is_allowed_sender(sender_email: &str, allowed_senders: &[String]) -> bool {
+    if allowed_senders.is_empty() {
+        return true;
+    }
+
+    let sender_email = sender_email.trim().to_ascii_lowercase();
+
+    allowed_senders.iter().any(|rule| {
+        let rule = rule.trim().to_ascii_lowercase();
+        if rule.is_empty() {
+            return false;
+        }
+
+        if rule.starts_with('@') {
+            return sender_email.ends_with(&rule);
+        }
+
+        if rule.contains('@') {
+            return sender_email == rule;
+        }
+
+        sender_email.ends_with(&format!("@{rule}"))
+    })
+}
+
+fn parse_primary_mailbox(value: &str) -> Option<(String, Option<String>)> {
+    let addresses = mailparse::addrparse(value).ok()?.into_inner();
+    for address in addresses {
+        match address {
+            MailAddr::Single(single) => {
+                return Some((single.addr, single.display_name));
+            }
+            MailAddr::Group(group) => {
+                if let Some(single) = group.addrs.into_iter().next() {
+                    return Some((single.addr, single.display_name));
+                }
+            }
+        }
+    }
+    None
+}
+
+fn parse_mailbox(value: &str) -> anyhow::Result<Mailbox> {
+    if let Ok(mailbox) = value.parse::<Mailbox>() {
+        return Ok(mailbox);
+    }
+
+    let (address, display_name) = parse_primary_mailbox(value)
+        .with_context(|| format!("failed to parse email address '{value}'"))?;
+    let address: Address = address
+        .parse()
+        .with_context(|| format!("invalid email address '{address}'"))?;
+    Ok(Mailbox::new(display_name, address))
+}
+
+fn extract_text_and_attachments(
+    parsed: &mailparse::ParsedMail<'_>,
+    max_body_bytes: usize,
+) -> (String, Vec<String>) {
+    let mut plain_text_parts = Vec::new();
+    let mut html_parts = Vec::new();
+    let mut attachment_names = Vec::new();
+
+    collect_parts(
+        parsed,
+        &mut plain_text_parts,
+        &mut html_parts,
+        &mut attachment_names,
+    );
+
+    let mut body_text = if !plain_text_parts.is_empty() {
+        plain_text_parts.join("\n\n")
+    } else if !html_parts.is_empty() {
+        html_to_text(&html_parts.join("\n\n"))
+    } else {
+        parsed.get_body().unwrap_or_default()
+    };
+
+    body_text = body_text.replace("\r\n", "\n").trim().to_string();
+    if body_text.is_empty() {
+        body_text = "(No message body)".to_string();
+    }
+
+    if body_text.len() > max_body_bytes {
+        body_text = format!(
+            "{}\n\n[Message truncated due to size limit]",
+            truncate_to_bytes(&body_text, max_body_bytes)
+        );
+    }
+
+    attachment_names.sort();
+    attachment_names.dedup();
+
+    (body_text, attachment_names)
+}
+
+fn collect_parts(
+    part: &mailparse::ParsedMail<'_>,
+    plain_text_parts: &mut Vec<String>,
+    html_parts: &mut Vec<String>,
+    attachment_names: &mut Vec<String>,
+) {
+    if part.subparts.is_empty() {
+        let disposition = part.get_content_disposition();
+        let filename = disposition
+            .params
+            .get("filename")
+            .cloned()
+            .or_else(|| part.ctype.params.get("name").cloned());
+        let is_attachment =
+            matches!(disposition.disposition, DispositionType::Attachment) || filename.is_some();
+
+        if let Some(filename) = filename {
+            attachment_names.push(filename);
+        }
+
+        if is_attachment {
+            return;
+        }
+
+        let mime_type = part.ctype.mimetype.to_ascii_lowercase();
+        if mime_type.starts_with("text/plain") {
+            if let Ok(body) = part.get_body()
+                && !body.trim().is_empty()
+            {
+                plain_text_parts.push(body);
+            }
+        } else if mime_type.starts_with("text/html")
+            && let Ok(body) = part.get_body()
+            && !body.trim().is_empty()
+        {
+            html_parts.push(body);
+        }
+        return;
+    }
+
+    for subpart in &part.subparts {
+        collect_parts(subpart, plain_text_parts, html_parts, attachment_names);
+    }
+}
+
+fn html_to_text(html: &str) -> String {
+    let without_tags = html_tag_regex().replace_all(html, " ");
+    let decoded = without_tags
+        .replace("&nbsp;", " ")
+        .replace("&amp;", "&")
+        .replace("&lt;", "<")
+        .replace("&gt;", ">")
+        .replace("&quot;", "\"")
+        .replace("&#39;", "'");
+
+    decoded.split_whitespace().collect::<Vec<_>>().join(" ")
+}
+
+fn html_tag_regex() -> &'static Regex {
+    static REGEX: OnceLock<Regex> = OnceLock::new();
+    REGEX.get_or_init(|| Regex::new(r"(?is)<[^>]+>").expect("valid HTML tag regex"))
+}
+
+fn normalize_reply_subject(subject: &str) -> String {
+    let subject = subject.trim();
+    if subject.is_empty() {
+        return "Re: Spacebot reply".to_string();
+    }
+
+    if subject.to_ascii_lowercase().starts_with("re:") {
+        subject.to_string()
+    } else {
+        format!("Re: {subject}")
+    }
+}
+
+fn extract_message_ids(value: &str) -> Vec<String> {
+    mailparse::msgidparse(value)
+        .map(|ids| {
+            ids.iter()
+                .map(|id| normalize_message_id(id.as_str()))
+                .filter(|id| !id.is_empty())
+                .collect::<Vec<String>>()
+        })
+        .unwrap_or_default()
+}
+
+fn normalize_message_id(value: &str) -> String {
+    value
+        .trim()
+        .trim_start_matches('<')
+        .trim_end_matches('>')
+        .trim()
+        .to_string()
+}
+
+fn format_message_id_for_header(message_id: &str) -> String {
+    let message_id = normalize_message_id(message_id);
+    if message_id.is_empty() {
+        String::new()
+    } else {
+        format!("<{message_id}>")
+    }
+}
+
+fn build_message_id_search_criterion(message_id: &str) -> Option<String> {
+    let search_id = format_message_id_for_header(message_id);
+    if search_id.is_empty()
+        || search_id
+            .chars()
+            .any(|character| character == '\r' || character == '\n')
+    {
+        return None;
+    }
+
+    let escaped = search_id.replace('\\', "\\\\").replace('"', "\\\"");
+    Some(format!("HEADER Message-ID \"{escaped}\""))
+}
+
+fn derive_thread_key(
+    references: &[String],
+    in_reply_to: Option<&str>,
+    message_id: Option<&str>,
+    subject: &str,
+    sender_email: &str,
+) -> String {
+    let seed = references
+        .first()
+        .cloned()
+        .or_else(|| in_reply_to.map(normalize_message_id))
+        .or_else(|| message_id.map(normalize_message_id))
+        .unwrap_or_else(|| {
+            format!(
+                "{}:{}",
+                subject.trim().to_ascii_lowercase(),
+                sender_email.trim().to_ascii_lowercase()
+            )
+        });
+
+    let mut hasher = Sha256::new();
+    hasher.update(seed.as_bytes());
+    let digest = hasher.finalize();
+    hex::encode(digest)[..24].to_string()
+}
+
+fn sanitize_account_key(value: &str) -> String {
+    let mut result = String::new();
+    for character in value.trim().to_ascii_lowercase().chars() {
+        if character.is_ascii_alphanumeric() {
+            result.push(character);
+        } else {
+            result.push('_');
+        }
+    }
+
+    let result = result.trim_matches('_').to_string();
+    if result.is_empty() {
+        "default".to_string()
+    } else {
+        result
+    }
+}
+
+fn normalize_email_target(value: &str) -> Option<String> {
+    let value = value.trim();
+    if value.is_empty() {
+        return None;
+    }
+
+    if let Some((address, _)) = parse_primary_mailbox(value) {
+        return Some(address);
+    }
+
+    let value = value.strip_prefix("email:").unwrap_or(value).trim();
+    if value.contains('@') && !value.contains(char::is_whitespace) {
+        Some(value.to_string())
+    } else {
+        None
+    }
+}
+
+fn truncate_to_bytes(value: &str, max_bytes: usize) -> String {
+    if value.len() <= max_bytes {
+        return value.to_string();
+    }
+
+    let mut cutoff = max_bytes;
+    while cutoff > 0 && !value.is_char_boundary(cutoff) {
+        cutoff -= 1;
+    }
+
+    let mut truncated = value[..cutoff].to_string();
+    truncated.push_str("...");
+    truncated
+}
+
+fn json_value_to_string(value: &serde_json::Value) -> Option<String> {
+    if let Some(text) = value.as_str() {
+        return Some(text.to_string());
+    }
+    if let Some(number) = value.as_i64() {
+        return Some(number.to_string());
+    }
+    if let Some(number) = value.as_u64() {
+        return Some(number.to_string());
+    }
+    None
+}
+
+struct EmailReplyContext {
+    recipient: String,
+    subject: String,
+    in_reply_to: Option<String>,
+    references: Vec<String>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        EmailSearchHit, EmailSearchQuery, build_imap_search_criterion, derive_thread_key,
+        extract_message_ids, is_local_mail_host, normalize_email_target, normalize_reply_subject,
+        normalize_search_folders, parse_primary_mailbox, sort_and_limit_search_hits,
+    };
+
+    #[test]
+    fn parse_primary_mailbox_parses_display_name() {
+        let parsed = parse_primary_mailbox("Alice Example <alice@example.com>");
+        assert_eq!(
+            parsed,
+            Some((
+                "alice@example.com".to_string(),
+                Some("Alice Example".to_string())
+            ))
+        );
+    }
+
+    #[test]
+    fn extract_message_ids_strips_angle_brackets() {
+        let ids = extract_message_ids("<root@example.com> <child@example.com>");
+        assert_eq!(ids, vec!["root@example.com", "child@example.com"]);
+    }
+
+    #[test]
+    fn normalize_email_target_accepts_prefixed_target() {
+        assert_eq!(
+            normalize_email_target("email:alice@example.com"),
+            Some("alice@example.com".to_string())
+        );
+    }
+
+    #[test]
+    fn normalize_reply_subject_preserves_existing_prefix() {
+        assert_eq!(
+            normalize_reply_subject("Re: Existing thread"),
+            "Re: Existing thread"
+        );
+        assert_eq!(
+            normalize_reply_subject("Existing thread"),
+            "Re: Existing thread"
+        );
+    }
+
+    #[test]
+    fn is_local_mail_host_accepts_loopback_hosts() {
+        assert!(is_local_mail_host("localhost"));
+        assert!(is_local_mail_host("LOCALHOST"));
+        assert!(is_local_mail_host("localhost."));
+        assert!(is_local_mail_host(" 127.0.0.1 "));
+        assert!(is_local_mail_host("::1"));
+        assert!(is_local_mail_host("[::1]"));
+    }
+
+    #[test]
+    fn is_local_mail_host_rejects_non_loopback_hosts() {
+        assert!(!is_local_mail_host("mail.example.com"));
+        assert!(!is_local_mail_host("192.168.1.10"));
+        assert!(!is_local_mail_host("8.8.8.8"));
+    }
+
+    #[test]
+    fn derive_thread_key_prefers_root_reference() {
+        let from_references = derive_thread_key(
+            &[
+                "root@example.com".to_string(),
+                "child@example.com".to_string(),
+            ],
+            Some("reply@example.com"),
+            Some("current@example.com"),
+            "Subject",
+            "sender@example.com",
+        );
+        let from_root_only = derive_thread_key(
+            &["root@example.com".to_string()],
+            None,
+            None,
+            "Different subject",
+            "other@example.com",
+        );
+
+        assert_eq!(from_references, from_root_only);
+    }
+
+    #[test]
+    fn build_imap_search_criterion_defaults_to_all() {
+        let criterion = build_imap_search_criterion(&EmailSearchQuery::default());
+        assert_eq!(criterion, "ALL");
+    }
+
+    #[test]
+    fn build_imap_search_criterion_escapes_values() {
+        let criterion = build_imap_search_criterion(&EmailSearchQuery {
+            text: Some("release \\\"candidate\\\"".to_string()),
+            from: Some("Alice <alice@example.com>".to_string()),
+            subject: Some("Q1 update".to_string()),
+            unread_only: true,
+            since_days: None,
+            folders: Vec::new(),
+            limit: 10,
+        });
+
+        assert!(criterion.contains("UNSEEN"));
+        assert!(criterion.contains("FROM \"Alice <alice@example.com>\""));
+        assert!(criterion.contains("SUBJECT \"Q1 update\""));
+        assert!(criterion.contains("TEXT \"release \\\\\\\"candidate\\\\\\\"\""));
+    }
+
+    #[test]
+    fn normalize_search_folders_falls_back_to_inbox() {
+        let folders = normalize_search_folders(&[], &[]);
+        assert_eq!(folders, vec!["INBOX".to_string()]);
+    }
+
+    #[test]
+    fn sort_and_limit_search_hits_orders_globally_newest_first() {
+        let ranked = vec![
+            (
+                100,
+                EmailSearchHit {
+                    folder: "INBOX".to_string(),
+                    uid: 10,
+                    from: "a@example.com".to_string(),
+                    subject: "old".to_string(),
+                    date: None,
+                    message_id: Some("m1".to_string()),
+                    body: "body".to_string(),
+                    attachment_names: Vec::new(),
+                },
+            ),
+            (
+                300,
+                EmailSearchHit {
+                    folder: "Support".to_string(),
+                    uid: 20,
+                    from: "b@example.com".to_string(),
+                    subject: "newest".to_string(),
+                    date: None,
+                    message_id: Some("m2".to_string()),
+                    body: "body".to_string(),
+                    attachment_names: Vec::new(),
+                },
+            ),
+            (
+                200,
+                EmailSearchHit {
+                    folder: "Escalations".to_string(),
+                    uid: 30,
+                    from: "c@example.com".to_string(),
+                    subject: "middle".to_string(),
+                    date: None,
+                    message_id: Some("m3".to_string()),
+                    body: "body".to_string(),
+                    attachment_names: Vec::new(),
+                },
+            ),
+        ];
+
+        let results = sort_and_limit_search_hits(ranked, 2);
+        assert_eq!(results.len(), 2);
+        assert_eq!(results[0].subject, "newest");
+        assert_eq!(results[1].subject, "middle");
+    }
+}
diff --git a/src/messaging/manager.rs b/src/messaging/manager.rs
index c08014676..a55a6e293 100644
--- a/src/messaging/manager.rs
+++ b/src/messaging/manager.rs
@@ -125,6 +125,21 @@ impl MessagingManager {
         self.adapters.read().await.contains_key(name)
     }
 
+    /// Returns true if any adapter exists for the given platform.
+    pub async fn has_platform_adapters(&self, platform: &str) -> bool {
+        let prefix = format!("{platform}:");
+        self.adapters
+            .read()
+            .await
+            .keys()
+            .any(|name| name == platform || name.starts_with(&prefix))
+    }
+
+    /// List registered adapter runtime keys.
+    pub async fn adapter_names(&self) -> Vec<String> {
+        self.adapters.read().await.keys().cloned().collect()
+    }
+
     /// Spawn a background task that retries starting a failed adapter with exponential backoff.
     ///
     /// Once the adapter starts successfully, its stream is forwarded into the
@@ -206,9 +221,10 @@ impl MessagingManager {
         response: OutboundResponse,
     ) -> crate::Result<()> {
         let adapters = self.adapters.read().await;
+        let adapter_key = message.adapter_key();
         let adapter = adapters
-            .get(&message.source)
-            .with_context(|| format!("no messaging adapter named '{}'", message.source))?;
+            .get(adapter_key)
+            .with_context(|| format!("no messaging adapter named '{}'", adapter_key))?;
         adapter.respond(message, response).await
     }
 
@@ -219,9 +235,10 @@ impl MessagingManager {
         status: StatusUpdate,
     ) -> crate::Result<()> {
         let adapters = self.adapters.read().await;
+        let adapter_key = message.adapter_key();
         let adapter = adapters
-            .get(&message.source)
-            .with_context(|| format!("no messaging adapter named '{}'", message.source))?;
+            .get(adapter_key)
+            .with_context(|| format!("no messaging adapter named '{}'", adapter_key))?;
         adapter.send_status(message, status).await
     }
 
@@ -246,9 +263,10 @@ impl MessagingManager {
         limit: usize,
     ) -> crate::Result<Vec<HistoryMessage>> {
         let adapters = self.adapters.read().await;
+        let adapter_key = message.adapter_key();
         let adapter = adapters
-            .get(&message.source)
-            .with_context(|| format!("no messaging adapter named '{}'", message.source))?;
+            .get(adapter_key)
+            .with_context(|| format!("no messaging adapter named '{}'", adapter_key))?;
         adapter.fetch_history(message, limit).await
     }
 
@@ -262,6 +280,26 @@ impl MessagingManager {
         Ok(())
     }
 
+    /// Remove and shut down all adapters for a platform (default + named).
+    pub async fn remove_platform_adapters(&self, platform: &str) -> crate::Result<()> {
+        let mut names = Vec::new();
+        {
+            let adapters = self.adapters.read().await;
+            let prefix = format!("{platform}:");
+            for name in adapters.keys() {
+                if name == platform || name.starts_with(&prefix) {
+                    names.push(name.clone());
+                }
+            }
+        }
+
+        for name in names {
+            self.remove_adapter(&name).await?;
+        }
+
+        Ok(())
+    }
+
     /// Shut down all adapters gracefully.
     pub async fn shutdown(&self) {
         let adapters = self.adapters.read().await;
diff --git a/src/messaging/slack.rs b/src/messaging/slack.rs
index 2aa1e3cbf..44e67997a 100644
--- a/src/messaging/slack.rs
+++ b/src/messaging/slack.rs
@@ -22,6 +22,7 @@
 //! - DM broadcast via `conversations.open`
 
 use crate::config::{SlackCommandConfig, SlackPermissions};
+use crate::messaging::apply_runtime_adapter_to_conversation_id;
 use crate::messaging::traits::{HistoryMessage, InboundStream, Messaging};
 use crate::{InboundMessage, MessageContent, OutboundResponse, StatusUpdate};
 
@@ -31,10 +32,12 @@ use slack_morphism::prelude::*;
 use std::collections::HashMap;
 use std::sync::Arc;
 use tokio::sync::{RwLock, mpsc};
+use tokio::time::{Duration, timeout};
 
 /// State shared with socket mode callbacks via `SlackClientEventsUserState`.
 struct SlackAdapterState {
     inbound_tx: mpsc::Sender<InboundMessage>,
+    runtime_key: String,
     permissions: Arc<ArcSwap<SlackPermissions>>,
     bot_token: String,
     bot_user_id: String,
@@ -55,6 +58,7 @@ struct SlackUserIdentity {
 
 /// Slack adapter.
 pub struct SlackAdapter {
+    runtime_key: String,
     bot_token: String,
     app_token: String,
     permissions: Arc<ArcSwap<SlackPermissions>>,
@@ -73,11 +77,13 @@ pub struct SlackAdapter {
 
 impl SlackAdapter {
     pub fn new(
+        runtime_key: impl Into<String>,
         bot_token: impl Into<String>,
         app_token: impl Into<String>,
         permissions: Arc<ArcSwap<SlackPermissions>>,
         commands: Vec<SlackCommandConfig>,
     ) -> anyhow::Result<Self> {
+        let runtime_key = runtime_key.into();
         let bot_token = bot_token.into();
         let client = Arc::new(SlackClient::new(
             SlackClientHyperConnector::new().context("failed to create slack HTTP connector")?,
@@ -88,6 +94,7 @@ impl SlackAdapter {
             .map(|c| (c.command, c.agent_id))
             .collect();
         Ok(Self {
+            runtime_key,
             bot_token,
             app_token: app_token.into(),
             permissions,
@@ -150,8 +157,14 @@ async fn handle_message_event(
     client: Arc<SlackHyperClient>,
     states: SlackClientEventsUserState,
 ) -> UserCallbackResult<()> {
-    // Skip message edits / deletes / bot_message subtypes
-    if msg_event.subtype.is_some() {
+    // Skip message edits / deletes / bot_message subtypes, but allow file-related
+    // subtypes so user-uploaded images and documents are processed.
+    if let Some(ref subtype) = msg_event.subtype
+        && !matches!(
+            subtype,
+            SlackMessageEventType::FileShare | SlackMessageEventType::FileShared
+        )
+    {
         return Ok(());
     }
 
@@ -225,13 +238,15 @@ async fn handle_message_event(
         }
     }
 
-    let conversation_id = if let Some(ref thread_ts) = msg_event.origin.thread_ts {
+    let base_conversation_id = if let Some(ref thread_ts) = msg_event.origin.thread_ts {
         format!("slack:{}:{}:{}", team_id_str, channel_id, thread_ts.0)
     } else {
         format!("slack:{}:{}", team_id_str, channel_id)
     };
+    let conversation_id =
+        apply_runtime_adapter_to_conversation_id(&adapter_state.runtime_key, base_conversation_id);
 
-    let content = extract_message_content(&msg_event.content);
+    let content = extract_message_content(&msg_event.content, &adapter_state.bot_token);
 
     let (metadata, formatted_author) = build_metadata_and_author(
         &team_id_str,
@@ -246,9 +261,62 @@ async fn handle_message_event(
         &adapter_state.channel_name_cache,
     )
     .await;
+    let mut metadata = metadata;
+    let bot_mention = format!("<@{}>", adapter_state.bot_user_id);
+    let mentioned_bot = msg_event
+        .content
+        .as_ref()
+        .and_then(|content| content.text.as_ref())
+        .map(|text| text.contains(&bot_mention))
+        .unwrap_or(false);
+    let token = SlackApiToken::new(SlackApiTokenValue(adapter_state.bot_token.clone()));
+    let session = client.open_session(&token);
+    let replied_to_bot = if let Some(thread_ts) = msg_event.origin.thread_ts.as_ref() {
+        // For threaded replies, treat as explicit invoke only when the thread
+        // root message belongs to this bot.
+        if thread_ts.0 != ts {
+            let thread_replies_request = SlackApiConversationsRepliesRequest::new(
+                SlackChannelId(channel_id.clone()),
+                thread_ts.clone(),
+            )
+            .with_limit(1);
+            match timeout(
+                Duration::from_secs(2),
+                session.conversations_replies(&thread_replies_request),
+            )
+            .await
+            {
+                Ok(Ok(response)) => response
+                    .messages
+                    .first()
+                    .and_then(|message| message.sender.user.as_ref())
+                    .is_some_and(|user| user.0 == adapter_state.bot_user_id),
+                Ok(Err(error)) => {
+                    tracing::debug!(%error, "failed to resolve slack thread parent for reply invoke");
+                    false
+                }
+                Err(error) => {
+                    tracing::debug!(
+                        %error,
+                        "timed out resolving slack thread parent for reply invoke"
+                    );
+                    false
+                }
+            }
+        } else {
+            false
+        }
+    } else {
+        false
+    };
+    metadata.insert(
+        "slack_mentions_or_replies_to_bot".into(),
+        serde_json::Value::Bool(mentioned_bot || replied_to_bot),
+    );
 
     send_inbound(
         &adapter_state.inbound_tx,
+        &adapter_state.runtime_key,
         ts,
         conversation_id,
         user_id.unwrap_or_default(),
@@ -308,11 +376,13 @@ async fn handle_app_mention_event(
         return Ok(());
     }
 
-    let conversation_id = if let Some(ref thread_ts) = mention.origin.thread_ts {
+    let base_conversation_id = if let Some(ref thread_ts) = mention.origin.thread_ts {
         format!("slack:{}:{}:{}", team_id_str, channel_id, thread_ts.0)
     } else {
         format!("slack:{}:{}", team_id_str, channel_id)
     };
+    let conversation_id =
+        apply_runtime_adapter_to_conversation_id(&adapter_state.runtime_key, base_conversation_id);
 
     // Strip the leading @-mention from the text so the agent sees clean input
     let raw_text = mention.content.text.clone().unwrap_or_default();
@@ -333,9 +403,15 @@ async fn handle_app_mention_event(
         &adapter_state.channel_name_cache,
     )
     .await;
+    let mut metadata = metadata;
+    metadata.insert(
+        "slack_mentions_or_replies_to_bot".into(),
+        serde_json::Value::Bool(true),
+    );
 
     send_inbound(
         &adapter_state.inbound_tx,
+        &adapter_state.runtime_key,
         ts,
         conversation_id,
         user_id,
@@ -444,7 +520,9 @@ async fn handle_command_event(
 
     let agent_id = adapter_state.commands[&command_str].clone();
 
-    let conversation_id = format!("slack:{}:{}", team_id, channel_id);
+    let base_conversation_id = format!("slack:{}:{}", team_id, channel_id);
+    let conversation_id =
+        apply_runtime_adapter_to_conversation_id(&adapter_state.runtime_key, base_conversation_id);
 
     let mut metadata = HashMap::new();
     metadata.insert(
@@ -483,6 +561,7 @@ async fn handle_command_event(
     let inbound = InboundMessage {
         id: msg_id,
         source: "slack".into(),
+        adapter: Some(adapter_state.runtime_key.clone()),
         conversation_id,
         sender_id: user_id.clone(),
         agent_id: None,
@@ -579,11 +658,13 @@ async fn handle_interaction_event(
     // Use trigger_id as the unique message id for this interaction turn.
     let msg_id = block_actions.trigger_id.0.clone();
 
-    let conversation_id = if let Some(ref ts) = message_ts {
+    let base_conversation_id = if let Some(ref ts) = message_ts {
         format!("slack:{}:{}:{}", team_id, channel_id, ts)
     } else {
         format!("slack:{}:{}", team_id, channel_id)
     };
+    let conversation_id =
+        apply_runtime_adapter_to_conversation_id(&adapter_state.runtime_key, base_conversation_id);
 
     // Process each action in the payload as a separate inbound message.
     // In practice Slack sends one action per interaction, but the API allows many.
@@ -663,6 +744,7 @@ async fn handle_interaction_event(
         let inbound = InboundMessage {
             id,
             source: "slack".into(),
+            adapter: Some(adapter_state.runtime_key.clone()),
             conversation_id: conversation_id.clone(),
             sender_id: user_id.clone(),
             agent_id: None,
@@ -686,7 +768,7 @@ async fn handle_interaction_event(
 
 impl Messaging for SlackAdapter {
     fn name(&self) -> &str {
-        "slack"
+        &self.runtime_key
     }
 
     async fn start(&self) -> crate::Result<InboundStream> {
@@ -706,6 +788,7 @@ impl Messaging for SlackAdapter {
 
         let adapter_state = Arc::new(SlackAdapterState {
             inbound_tx,
+            runtime_key: self.runtime_key.clone(),
             permissions: self.permissions.clone(),
             bot_token: self.bot_token.clone(),
             bot_user_id,
@@ -1259,7 +1342,10 @@ fn markdown_content(text: impl Into<String>) -> SlackMessageContent {
 }
 
 /// Extract `MessageContent` from an optional `SlackMessageContent`.
-fn extract_message_content(content: &Option<SlackMessageContent>) -> MessageContent {
+fn extract_message_content(
+    content: &Option<SlackMessageContent>,
+    bot_token: &str,
+) -> MessageContent {
     let Some(msg_content) = content else {
         return MessageContent::Text(String::new());
     };
@@ -1274,6 +1360,7 @@ fn extract_message_content(content: &Option<SlackMessageContent>) -> MessageCont
                     mime_type: f.mimetype.as_ref().map(|m| m.0.clone()).unwrap_or_default(),
                     url: url.to_string(),
                     size_bytes: None,
+                    auth_header: Some(format!("Bearer {}", bot_token)),
                 })
             })
             .collect();
@@ -1313,9 +1400,14 @@ async fn build_metadata_and_author(
         "slack_channel_id".into(),
         serde_json::Value::String(channel_id.into()),
     );
+    let ts_string: String = ts.into();
     metadata.insert(
         "slack_message_ts".into(),
-        serde_json::Value::String(ts.into()),
+        serde_json::Value::String(ts_string.clone()),
+    );
+    metadata.insert(
+        crate::metadata_keys::MESSAGE_ID.into(),
+        serde_json::Value::String(ts_string),
     );
 
     if let Some(tts) = thread_ts {
@@ -1341,8 +1433,17 @@ async fn build_metadata_and_author(
     let session = client.open_session(&token);
 
     // Resolve channel name via cache or conversations.info API.
+    let is_dm = channel_id.starts_with('D');
     if let Some(name) = channel_name_cache.read().await.get(channel_id).cloned() {
-        metadata.insert("slack_channel_name".into(), serde_json::Value::String(name));
+        metadata.insert(
+            "slack_channel_name".into(),
+            serde_json::Value::String(name.clone()),
+        );
+        let display_name = if is_dm { name } else { format!("#{name}") };
+        metadata.insert(
+            crate::metadata_keys::CHANNEL_NAME.into(),
+            serde_json::Value::String(display_name),
+        );
     } else {
         match session
             .conversations_info(&SlackApiConversationsInfoRequest::new(SlackChannelId(
@@ -1356,11 +1457,19 @@ async fn build_metadata_and_author(
                         .write()
                         .await
                         .insert(channel_id.to_string(), name.clone());
-                    metadata.insert("slack_channel_name".into(), serde_json::Value::String(name));
+                    metadata.insert(
+                        "slack_channel_name".into(),
+                        serde_json::Value::String(name.clone()),
+                    );
+                    let display_name = if is_dm { name } else { format!("#{name}") };
+                    metadata.insert(
+                        crate::metadata_keys::CHANNEL_NAME.into(),
+                        serde_json::Value::String(display_name),
+                    );
                 }
             }
             // DM channels (D-prefixed) don't support conversations.info in all cases
-            Err(error) if !channel_id.starts_with('D') => {
+            Err(error) if !is_dm => {
                 tracing::warn!(
                     %error,
                     channel_id = %channel_id,
@@ -1416,9 +1525,14 @@ async fn build_metadata_and_author(
         && !metadata.contains_key("slack_channel_name")
         && let Some(display_name) = metadata.get("sender_display_name").and_then(|v| v.as_str())
     {
+        let dm_channel_name = format!("dm-{display_name}");
         metadata.insert(
             "slack_channel_name".into(),
-            serde_json::Value::String(format!("dm-{display_name}")),
+            serde_json::Value::String(dm_channel_name.clone()),
+        );
+        metadata.insert(
+            crate::metadata_keys::CHANNEL_NAME.into(),
+            serde_json::Value::String(dm_channel_name),
         );
     }
 
@@ -1426,8 +1540,10 @@ async fn build_metadata_and_author(
 }
 
 /// Dispatch a fully-constructed `InboundMessage` to the inbound channel.
+#[allow(clippy::too_many_arguments)]
 async fn send_inbound(
     tx: &mpsc::Sender<InboundMessage>,
+    runtime_key: &str,
     ts: String,
     conversation_id: String,
     sender_id: String,
@@ -1438,6 +1554,7 @@ async fn send_inbound(
     let inbound = InboundMessage {
         id: ts,
         source: "slack".into(),
+        adapter: Some(runtime_key.to_string()),
         conversation_id,
         sender_id,
         agent_id: None,
diff --git a/src/messaging/target.rs b/src/messaging/target.rs
index c60e2d0a4..68aba7831 100644
--- a/src/messaging/target.rs
+++ b/src/messaging/target.rs
@@ -101,6 +101,23 @@ pub fn resolve_broadcast_target(channel: &ChannelInfo) -> Option<BroadcastTarget
                 }
             }
         }
+        "email" => {
+            let reply_to = channel
+                .platform_meta
+                .as_ref()
+                .and_then(|meta| meta.get("email_reply_to"))
+                .and_then(json_value_to_string);
+            let from = channel
+                .platform_meta
+                .as_ref()
+                .and_then(|meta| meta.get("email_from"))
+                .and_then(json_value_to_string);
+
+            reply_to
+                .as_deref()
+                .and_then(normalize_email_target)
+                .or_else(|| from.as_deref().and_then(normalize_email_target))?
+        }
         _ => return None,
     };
 
@@ -123,6 +140,7 @@ fn normalize_target(adapter: &str, raw_target: &str) -> Option<String> {
         "slack" => normalize_slack_target(trimmed),
         "telegram" => normalize_telegram_target(trimmed),
         "twitch" => normalize_twitch_target(trimmed),
+        "email" => normalize_email_target(trimmed),
         _ => Some(trimmed.to_string()),
     }
 }
@@ -195,6 +213,26 @@ fn normalize_twitch_target(raw_target: &str) -> Option<String> {
     }
 }
 
+fn normalize_email_target(raw_target: &str) -> Option<String> {
+    let target = strip_repeated_prefix(raw_target, "email").trim();
+    if target.is_empty() {
+        return None;
+    }
+
+    if let Some((_, address)) = target.rsplit_once('<') {
+        let address = address.trim_end_matches('>').trim();
+        if address.contains('@') && !address.contains(char::is_whitespace) {
+            return Some(address.to_string());
+        }
+    }
+
+    if target.contains('@') && !target.contains(char::is_whitespace) {
+        return Some(target.to_string());
+    }
+
+    None
+}
+
 fn strip_repeated_prefix<'a>(raw_target: &'a str, adapter: &str) -> &'a str {
     let mut target = raw_target;
     let prefix = format!("{adapter}:");
@@ -283,4 +321,47 @@ mod tests {
             })
         );
     }
+
+    #[test]
+    fn parse_email_target_with_prefix() {
+        let parsed = parse_delivery_target("email:alice@example.com");
+        assert_eq!(
+            parsed,
+            Some(super::BroadcastTarget {
+                adapter: "email".to_string(),
+                target: "alice@example.com".to_string(),
+            })
+        );
+    }
+
+    #[test]
+    fn parse_email_target_with_display_name() {
+        let parsed = parse_delivery_target("email:Alice <alice@example.com>");
+        assert_eq!(
+            parsed,
+            Some(super::BroadcastTarget {
+                adapter: "email".to_string(),
+                target: "alice@example.com".to_string(),
+            })
+        );
+    }
+
+    #[test]
+    fn resolve_email_target_falls_back_when_reply_to_invalid() {
+        let mut channel = test_channel_info("email:acct:thread", "email");
+        channel.platform_meta = Some(serde_json::json!({
+            "email_reply_to": "not-an-email",
+            "email_from": "valid@example.com"
+        }));
+
+        let resolved = resolve_broadcast_target(&channel);
+
+        assert_eq!(
+            resolved,
+            Some(super::BroadcastTarget {
+                adapter: "email".to_string(),
+                target: "valid@example.com".to_string(),
+            })
+        );
+    }
 }
diff --git a/src/messaging/telegram.rs b/src/messaging/telegram.rs
index eab7994c2..f806e7537 100644
--- a/src/messaging/telegram.rs
+++ b/src/messaging/telegram.rs
@@ -1,6 +1,7 @@
 //! Telegram messaging adapter using teloxide.
 
 use crate::config::TelegramPermissions;
+use crate::messaging::apply_runtime_adapter_to_conversation_id;
 use crate::messaging::traits::{InboundStream, Messaging};
 use crate::{Attachment, InboundMessage, MessageContent, OutboundResponse, StatusUpdate};
 
@@ -26,6 +27,7 @@ const REJECTED_USERS_CAPACITY: usize = 50;
 
 /// Telegram adapter state.
 pub struct TelegramAdapter {
+    runtime_key: String,
     permissions: Arc<ArcSwap<TelegramPermissions>>,
     bot: Bot,
     bot_user_id: Arc<RwLock<Option<UserId>>>,
@@ -55,10 +57,16 @@ const FORMATTED_SPLIT_LENGTH: usize = MAX_MESSAGE_LENGTH / 2;
 const STREAM_EDIT_INTERVAL: std::time::Duration = std::time::Duration::from_millis(1000);
 
 impl TelegramAdapter {
-    pub fn new(token: impl Into<String>, permissions: Arc<ArcSwap<TelegramPermissions>>) -> Self {
+    pub fn new(
+        runtime_key: impl Into<String>,
+        token: impl Into<String>,
+        permissions: Arc<ArcSwap<TelegramPermissions>>,
+    ) -> Self {
+        let runtime_key = runtime_key.into();
         let token = token.into();
         let bot = Bot::new(&token);
         Self {
+            runtime_key,
             permissions,
             bot,
             bot_user_id: Arc::new(RwLock::new(None)),
@@ -97,7 +105,7 @@ impl TelegramAdapter {
 
 impl Messaging for TelegramAdapter {
     fn name(&self) -> &str {
-        "telegram"
+        &self.runtime_key
     }
 
     async fn start(&self) -> crate::Result<InboundStream> {
@@ -122,6 +130,7 @@ impl Messaging for TelegramAdapter {
         );
 
         let bot = self.bot.clone();
+        let runtime_key = self.runtime_key.clone();
         let permissions = self.permissions.clone();
         let bot_user_id = self.bot_user_id.clone();
         let bot_username = self.bot_username.clone();
@@ -238,7 +247,11 @@ impl Messaging for TelegramAdapter {
                             }
 
                             let content = build_content(&bot, message, &text).await;
-                            let conversation_id = format!("telegram:{chat_id}");
+                            let base_conversation_id = format!("telegram:{chat_id}");
+                            let conversation_id = apply_runtime_adapter_to_conversation_id(
+                                &runtime_key,
+                                base_conversation_id,
+                            );
                             let sender_id = message
                                 .from
                                 .as_ref()
@@ -253,6 +266,7 @@ impl Messaging for TelegramAdapter {
                             let inbound = InboundMessage {
                                 id: message.id.0.to_string(),
                                 source: "telegram".into(),
+                                adapter: Some(runtime_key.clone()),
                                 conversation_id,
                                 sender_id,
                                 agent_id: None,
@@ -665,6 +679,7 @@ fn extract_attachments(message: &teloxide::types::Message) -> Vec<Attachment> {
                     mime_type: "image/jpeg".into(),
                     url: largest.file.id.to_string(),
                     size_bytes: Some(largest.file.size as u64),
+                    auth_header: None,
                 });
             }
         }
@@ -683,6 +698,7 @@ fn extract_attachments(message: &teloxide::types::Message) -> Vec<Attachment> {
                     .unwrap_or_else(|| "application/octet-stream".into()),
                 url: doc.document.file.id.to_string(),
                 size_bytes: Some(doc.document.file.size as u64),
+                auth_header: None,
             });
         }
         MediaKind::Video(video) => {
@@ -700,6 +716,7 @@ fn extract_attachments(message: &teloxide::types::Message) -> Vec<Attachment> {
                     .unwrap_or_else(|| "video/mp4".into()),
                 url: video.video.file.id.to_string(),
                 size_bytes: Some(video.video.file.size as u64),
+                auth_header: None,
             });
         }
         MediaKind::Voice(voice) => {
@@ -713,6 +730,7 @@ fn extract_attachments(message: &teloxide::types::Message) -> Vec<Attachment> {
                     .unwrap_or_else(|| "audio/ogg".into()),
                 url: voice.voice.file.id.to_string(),
                 size_bytes: Some(voice.voice.file.size as u64),
+                auth_header: None,
             });
         }
         MediaKind::Audio(audio) => {
@@ -730,6 +748,7 @@ fn extract_attachments(message: &teloxide::types::Message) -> Vec<Attachment> {
                     .unwrap_or_else(|| "audio/mpeg".into()),
                 url: audio.audio.file.id.to_string(),
                 size_bytes: Some(audio.audio.file.size as u64),
+                auth_header: None,
             });
         }
         _ => {}
@@ -777,6 +796,10 @@ fn build_metadata(
         "telegram_message_id".into(),
         serde_json::Value::Number(message.id.0.into()),
     );
+    metadata.insert(
+        crate::metadata_keys::MESSAGE_ID.into(),
+        serde_json::Value::String(message.id.0.to_string()),
+    );
 
     let chat_type = if message.chat.is_private() {
         "private"
@@ -793,7 +816,18 @@ fn build_metadata(
 
     if let Some(title) = &message.chat.title() {
         metadata.insert("telegram_chat_title".into(), (*title).into());
+        metadata.insert(crate::metadata_keys::SERVER_NAME.into(), (*title).into());
     }
+    let channel_name = message
+        .chat
+        .title()
+        .map(|title| title.to_string())
+        .or_else(|| message.from.as_ref().map(build_display_name))
+        .unwrap_or_else(|| chat_type.to_string());
+    metadata.insert(
+        crate::metadata_keys::CHANNEL_NAME.into(),
+        channel_name.into(),
+    );
 
     let formatted_author = if let Some(from) = &message.from {
         metadata.insert(
@@ -840,6 +874,17 @@ fn build_metadata(
         }
         if let Some(from) = &reply.from {
             metadata.insert("reply_to_author".into(), build_display_name(from).into());
+            metadata.insert(
+                "reply_to_user_id".into(),
+                serde_json::Value::Number(from.id.0.into()),
+            );
+            metadata.insert(
+                "reply_to_is_bot".into(),
+                serde_json::Value::Bool(from.is_bot),
+            );
+            if let Some(username) = &from.username {
+                metadata.insert("reply_to_username".into(), username.clone().into());
+            }
         }
     }
 
diff --git a/src/messaging/traits.rs b/src/messaging/traits.rs
index 1f5e10f00..060c060c4 100644
--- a/src/messaging/traits.rs
+++ b/src/messaging/traits.rs
@@ -168,3 +168,24 @@ impl<T: Messaging> MessagingDyn for T {
         Box::pin(Messaging::shutdown(self))
     }
 }
+
+/// Rewrite a conversation ID's platform prefix to use a named adapter's runtime key.
+///
+/// Given a `runtime_key` like `"discord:ops"` and a `base_conversation_id` like
+/// `"discord:12345"`, returns `"discord:ops:12345"`. If the runtime key matches
+/// the existing platform prefix (i.e. the default adapter), the ID is returned
+/// unchanged.
+pub fn apply_runtime_adapter_to_conversation_id(
+    runtime_key: &str,
+    base_conversation_id: String,
+) -> String {
+    let Some((platform, remainder)) = base_conversation_id.split_once(':') else {
+        return base_conversation_id;
+    };
+
+    if runtime_key == platform {
+        base_conversation_id
+    } else {
+        format!("{runtime_key}:{remainder}")
+    }
+}
diff --git a/src/messaging/twitch.rs b/src/messaging/twitch.rs
index d716bf795..0974a1326 100644
--- a/src/messaging/twitch.rs
+++ b/src/messaging/twitch.rs
@@ -1,6 +1,7 @@
 //! Twitch chat messaging adapter using twitch-irc.
 
 use crate::config::TwitchPermissions;
+use crate::messaging::apply_runtime_adapter_to_conversation_id;
 use crate::messaging::traits::{InboundStream, Messaging};
 use crate::{InboundMessage, MessageContent, OutboundResponse};
 
@@ -40,38 +41,30 @@ impl TokenStorage for TwitchTokenStorage {
 
     async fn load_token(&mut self) -> Result<UserAccessToken, Self::LoadError> {
         let mut created_at = Utc::now();
-        let mut expires_at = None;
 
-        if let Some(path) = &self.token_path {
-            if let Ok(data) = std::fs::read_to_string(path)
-                && let Ok(file) = serde_json::from_str::<TwitchTokenFile>(&data)
-            {
-                self.access_token = file.access_token;
-                self.refresh_token = file.refresh_token;
-                if let Some(stored_created) = file.created_at {
-                    created_at = stored_created;
-                }
-                expires_at = file.expires_at;
-            }
-            if !self.refresh_token.is_empty() && expires_at.is_none() {
-                expires_at = Some(created_at + chrono::Duration::hours(1));
-            }
-            let file = TwitchTokenFile {
-                access_token: self.access_token.clone(),
-                refresh_token: self.refresh_token.clone(),
-                created_at: Some(created_at),
-                expires_at,
-            };
-            if let Ok(data) = serde_json::to_string_pretty(&file) {
-                let _ = std::fs::write(path, data);
+        if let Some(path) = &self.token_path
+            && let Ok(data) = std::fs::read_to_string(path)
+            && let Ok(file) = serde_json::from_str::<TwitchTokenFile>(&data)
+        {
+            self.access_token = file.access_token;
+            self.refresh_token = file.refresh_token;
+            if let Some(stored_created) = file.created_at {
+                created_at = stored_created;
             }
         }
 
+        // Never return expires_at from load_token. The twitch-irc library's
+        // RefreshingLoginCredentials will attempt an OAuth token refresh
+        // whenever it sees an expired/near-expired token, and if the refresh
+        // credentials are invalid it spin-loops with no backoff. By always
+        // returning expires_at = None here, we treat the access token as
+        // non-expiring on load. Real expiry data is only set via
+        // update_token() after a *successful* library-driven refresh.
         Ok(UserAccessToken {
             access_token: self.access_token.clone(),
             refresh_token: self.refresh_token.clone(),
             created_at,
-            expires_at,
+            expires_at: None,
         })
     }
 
@@ -100,6 +93,7 @@ type IrcClient = TwitchIRCClient<SecureTCPTransport, TwitchCredentials>;
 
 /// Twitch chat adapter state.
 pub struct TwitchAdapter {
+    runtime_key: String,
     username: String,
     oauth_token: String,
     client_id: Option<String>,
@@ -119,6 +113,7 @@ const MAX_MESSAGE_LENGTH: usize = 500;
 impl TwitchAdapter {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
+        runtime_key: impl Into<String>,
         username: impl Into<String>,
         oauth_token: impl Into<String>,
         client_id: Option<String>,
@@ -130,6 +125,7 @@ impl TwitchAdapter {
         permissions: Arc<ArcSwap<TwitchPermissions>>,
     ) -> Self {
         Self {
+            runtime_key: runtime_key.into(),
             username: username.into(),
             oauth_token: oauth_token.into(),
             client_id,
@@ -147,7 +143,7 @@ impl TwitchAdapter {
 
 impl Messaging for TwitchAdapter {
     fn name(&self) -> &str {
-        "twitch"
+        &self.runtime_key
     }
 
     async fn start(&self) -> crate::Result<InboundStream> {
@@ -163,15 +159,26 @@ impl Messaging for TwitchAdapter {
             .unwrap_or(&self.oauth_token)
             .to_string();
 
+        let refresh_token = self.refresh_token.clone().unwrap_or_default();
+        let client_id = self.client_id.clone().unwrap_or_default();
+        let client_secret = self.client_secret.clone().unwrap_or_default();
+
+        if refresh_token.is_empty() || client_id.is_empty() || client_secret.is_empty() {
+            tracing::info!(
+                adapter = %self.runtime_key,
+                "twitch token refresh disabled (missing client_id, client_secret, or refresh_token)"
+            );
+        }
+
         let storage = TwitchTokenStorage {
             access_token: token,
-            refresh_token: self.refresh_token.clone().unwrap_or_default(),
+            refresh_token,
             token_path: self.token_path.clone(),
         };
         let credentials = TwitchCredentials::init_with_username(
             Some(self.username.clone()),
-            self.client_id.clone().unwrap_or_default(),
-            self.client_secret.clone().unwrap_or_default(),
+            client_id,
+            client_secret,
             storage,
         );
         let config = ClientConfig::new_simple(credentials);
@@ -198,6 +205,7 @@ impl Messaging for TwitchAdapter {
         let permissions = self.permissions.clone();
         let bot_username = self.username.to_lowercase();
         let trigger_prefix = self.trigger_prefix.clone();
+        let runtime_key = self.runtime_key.clone();
 
         tokio::spawn(async move {
             loop {
@@ -249,17 +257,29 @@ impl Messaging for TwitchAdapter {
                         }
 
                         let channel_login = privmsg.channel_login.clone();
-                        let conversation_id = format!("twitch:{channel_login}");
+                        let base_conversation_id = format!("twitch:{channel_login}");
+                        let conversation_id = apply_runtime_adapter_to_conversation_id(
+                            &runtime_key,
+                            base_conversation_id,
+                        );
 
                         let mut metadata = HashMap::new();
                         metadata.insert(
                             "twitch_channel".into(),
+                            serde_json::Value::String(channel_login.clone()),
+                        );
+                        metadata.insert(
+                            crate::metadata_keys::CHANNEL_NAME.into(),
                             serde_json::Value::String(channel_login),
                         );
                         metadata.insert(
                             "twitch_message_id".into(),
                             serde_json::Value::String(privmsg.message_id.clone()),
                         );
+                        metadata.insert(
+                            crate::metadata_keys::MESSAGE_ID.into(),
+                            serde_json::Value::String(privmsg.message_id.clone()),
+                        );
                         metadata.insert(
                             "twitch_user_id".into(),
                             serde_json::Value::String(privmsg.sender.id.clone()),
@@ -268,10 +288,39 @@ impl Messaging for TwitchAdapter {
                             "twitch_user_login".into(),
                             serde_json::Value::String(privmsg.sender.login.clone()),
                         );
+                        metadata.insert(
+                            "twitch_bot_login".into(),
+                            serde_json::Value::String(bot_username.clone()),
+                        );
                         metadata.insert(
                             "sender_display_name".into(),
                             serde_json::Value::String(privmsg.sender.name.clone()),
                         );
+                        let message_lower = privmsg.message_text.to_lowercase();
+                        let mention = format!("@{bot_username}");
+                        let is_login_char = |character: char| {
+                            character.is_ascii_lowercase()
+                                || character.is_ascii_digit()
+                                || character == '_'
+                        };
+                        let mentions_bot = message_lower.match_indices(&mention).any(|(start, _)| {
+                            let before = message_lower[..start].chars().next_back();
+                            let after = message_lower[start + mention.len()..].chars().next();
+                            let before_ok = before.map(|character| !is_login_char(character)).unwrap_or(true);
+                            let after_ok = after.map(|character| !is_login_char(character)).unwrap_or(true);
+                            before_ok && after_ok
+                        });
+                        let replies_to_bot = privmsg
+                            .source
+                            .tags
+                            .0
+                            .get("reply-parent-user-login")
+                            .and_then(|value| value.as_ref())
+                            .is_some_and(|login| login.eq_ignore_ascii_case(&bot_username));
+                        metadata.insert(
+                            "twitch_mentions_or_replies_to_bot".into(),
+                            serde_json::Value::Bool(mentions_bot || replies_to_bot),
+                        );
 
                         let formatted_author = format!(
                             "{} ({})",
@@ -282,6 +331,7 @@ impl Messaging for TwitchAdapter {
                         let inbound = InboundMessage {
                             id: privmsg.message_id.clone(),
                             source: "twitch".into(),
+                            adapter: Some(runtime_key.clone()),
                             conversation_id,
                             sender_id: privmsg.sender.id.clone(),
                             agent_id: None,
diff --git a/src/messaging/webchat.rs b/src/messaging/webchat.rs
index a016df1f4..595f018a7 100644
--- a/src/messaging/webchat.rs
+++ b/src/messaging/webchat.rs
@@ -2,60 +2,40 @@
 //!
 //! Unlike other adapters, this does not own an HTTP server or inbound stream.
 //! Inbound messages are injected by the API handler via `MessagingManager::inject_message`,
-//! and outbound responses are routed to per-session channels consumed as SSE streams.
+//! and outbound responses are delivered through the global SSE event bus — the same
+//! path used by all other channels. No per-session SSE streams or dedup needed.
 
-use crate::messaging::traits::{InboundStream, Messaging};
-use crate::{InboundMessage, OutboundResponse, StatusUpdate};
+use crate::conversation::ConversationLogger;
+use crate::messaging::traits::{HistoryMessage, InboundStream, Messaging};
+use crate::{InboundMessage, OutboundResponse};
 
+use anyhow::Context as _;
+use sqlx::SqlitePool;
 use std::collections::HashMap;
 use std::sync::Arc;
-use tokio::sync::{RwLock, mpsc};
 
-/// Web chat adapter state.
+/// Web chat adapter. Inbound arrives via `inject_message`, outbound is handled
+/// by the global SSE event bus in `main.rs`.
 pub struct WebChatAdapter {
-    sessions: Arc<RwLock<HashMap<String, mpsc::Sender<WebChatEvent>>>>,
-}
-
-#[derive(Debug, Clone, serde::Serialize)]
-pub enum WebChatEvent {
-    Thinking,
-    Text(String),
-    StreamStart,
-    StreamChunk(String),
-    StreamEnd,
-    ToolStarted { tool_name: String },
-    ToolCompleted { tool_name: String },
-    StopTyping,
-    Done,
+    conversation_loggers: HashMap<String, ConversationLogger>,
 }
 
 impl Default for WebChatAdapter {
     fn default() -> Self {
-        Self::new()
+        Self::new(HashMap::new())
     }
 }
 
 impl WebChatAdapter {
-    pub fn new() -> Self {
+    pub fn new(agent_pools: HashMap<String, SqlitePool>) -> Self {
+        let conversation_loggers = agent_pools
+            .into_iter()
+            .map(|(agent_id, pool)| (agent_id, ConversationLogger::new(pool)))
+            .collect();
         Self {
-            sessions: Arc::new(RwLock::new(HashMap::new())),
+            conversation_loggers,
         }
     }
-
-    pub async fn register_session(&self, conversation_id: &str) -> mpsc::Receiver<WebChatEvent> {
-        let (tx, rx) = mpsc::channel(256);
-        self.sessions
-            .write()
-            .await
-            .insert(conversation_id.to_string(), tx);
-        tracing::debug!(%conversation_id, "webchat session registered");
-        rx
-    }
-
-    pub async fn unregister_session(&self, conversation_id: &str) {
-        self.sessions.write().await.remove(conversation_id);
-        tracing::debug!(%conversation_id, "webchat session unregistered");
-    }
 }
 
 impl Messaging for WebChatAdapter {
@@ -71,57 +51,68 @@ impl Messaging for WebChatAdapter {
 
     async fn respond(
         &self,
-        message: &InboundMessage,
-        response: OutboundResponse,
+        _message: &InboundMessage,
+        _response: OutboundResponse,
     ) -> crate::Result<()> {
-        let sessions = self.sessions.read().await;
-        let Some(tx) = sessions.get(&message.conversation_id) else {
-            tracing::debug!(conversation_id = %message.conversation_id, "no webchat session for response");
-            return Ok(());
-        };
-
-        let (event, signals_done) = match response {
-            OutboundResponse::Text(text) => (WebChatEvent::Text(text), true),
-            OutboundResponse::ThreadReply { text, .. } => (WebChatEvent::Text(text), true),
-            OutboundResponse::StreamStart => (WebChatEvent::StreamStart, false),
-            OutboundResponse::StreamChunk(text) => (WebChatEvent::StreamChunk(text), false),
-            OutboundResponse::StreamEnd => (WebChatEvent::StreamEnd, true),
-            OutboundResponse::File { .. }
-            | OutboundResponse::Reaction(_)
-            | OutboundResponse::RemoveReaction(_)
-            | OutboundResponse::Ephemeral { .. }
-            | OutboundResponse::ScheduledMessage { .. }
-            | OutboundResponse::RichMessage { .. }
-            | OutboundResponse::Status(_) => return Ok(()),
-        };
-
-        let _ = tx.send(event).await;
-        if signals_done {
-            let _ = tx.send(WebChatEvent::Done).await;
-        }
+        // Outbound delivery is handled by the global SSE event bus in main.rs.
+        // The webchat adapter itself doesn't need to do anything — the API events
+        // stream already pushes outbound_message events to all connected clients,
+        // and the portal chat UI consumes the same timeline as regular channels.
         Ok(())
     }
 
-    async fn send_status(
+    async fn fetch_history(
         &self,
         message: &InboundMessage,
-        status: StatusUpdate,
-    ) -> crate::Result<()> {
-        let sessions = self.sessions.read().await;
-        let Some(tx) = sessions.get(&message.conversation_id) else {
-            return Ok(());
-        };
-
-        let event = match status {
-            StatusUpdate::Thinking => WebChatEvent::Thinking,
-            StatusUpdate::StopTyping => WebChatEvent::StopTyping,
-            StatusUpdate::ToolStarted { tool_name } => WebChatEvent::ToolStarted { tool_name },
-            StatusUpdate::ToolCompleted { tool_name } => WebChatEvent::ToolCompleted { tool_name },
-            _ => return Ok(()),
-        };
+        limit: usize,
+    ) -> crate::Result<Vec<HistoryMessage>> {
+        if limit == 0 {
+            return Ok(Vec::new());
+        }
 
-        let _ = tx.send(event).await;
-        Ok(())
+        let agent_id = message
+            .agent_id
+            .as_ref()
+            .context("missing agent_id on webchat history message")?;
+        let logger = self
+            .conversation_loggers
+            .get(agent_id.as_ref())
+            .with_context(|| {
+                format!("no webchat history logger configured for agent '{agent_id}'")
+            })?;
+
+        let channel_id: crate::ChannelId = Arc::from(message.conversation_id.as_str());
+        let messages = logger.load_recent(&channel_id, limit as i64).await?;
+
+        let history = messages
+            .into_iter()
+            .map(|message| {
+                let is_bot = message.role == "assistant";
+                let author = if is_bot {
+                    "assistant".to_string()
+                } else {
+                    message
+                        .sender_name
+                        .or(message.sender_id)
+                        .unwrap_or_else(|| "user".to_string())
+                };
+
+                HistoryMessage {
+                    author,
+                    content: message.content,
+                    is_bot,
+                }
+            })
+            .collect::<Vec<_>>();
+
+        tracing::info!(
+            agent_id = %agent_id,
+            conversation_id = %message.conversation_id,
+            count = history.len(),
+            "fetched webchat message history"
+        );
+
+        Ok(history)
     }
 
     async fn health_check(&self) -> crate::Result<()> {
@@ -129,8 +120,100 @@ impl Messaging for WebChatAdapter {
     }
 
     async fn shutdown(&self) -> crate::Result<()> {
-        self.sessions.write().await.clear();
         tracing::info!("webchat adapter shut down");
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::MessageContent;
+    use chrono::Utc;
+
+    #[tokio::test]
+    async fn fetch_history_reads_webchat_messages_from_db() {
+        let pool = SqlitePool::connect("sqlite::memory:")
+            .await
+            .expect("in-memory sqlite should connect");
+
+        sqlx::query(
+            "CREATE TABLE conversation_messages (
+                id TEXT PRIMARY KEY,
+                channel_id TEXT NOT NULL,
+                role TEXT NOT NULL,
+                sender_name TEXT,
+                sender_id TEXT,
+                content TEXT NOT NULL,
+                metadata TEXT,
+                created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+            )",
+        )
+        .execute(&pool)
+        .await
+        .expect("conversation_messages table should create");
+
+        sqlx::query(
+            "INSERT INTO conversation_messages (
+                id, channel_id, role, sender_name, sender_id, content, metadata, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+        )
+        .bind("m1")
+        .bind("webchat-session")
+        .bind("user")
+        .bind("Alice")
+        .bind("alice-id")
+        .bind("hey there")
+        .bind(Option::<String>::None)
+        .bind("2026-01-01 00:00:00")
+        .execute(&pool)
+        .await
+        .expect("user row should insert");
+
+        sqlx::query(
+            "INSERT INTO conversation_messages (
+                id, channel_id, role, sender_name, sender_id, content, metadata, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+        )
+        .bind("m2")
+        .bind("webchat-session")
+        .bind("assistant")
+        .bind(Option::<String>::None)
+        .bind(Option::<String>::None)
+        .bind("hello Alice")
+        .bind(Option::<String>::None)
+        .bind("2026-01-01 00:00:01")
+        .execute(&pool)
+        .await
+        .expect("assistant row should insert");
+
+        let adapter = WebChatAdapter::new(HashMap::from([("agent-a".to_string(), pool)]));
+
+        let inbound = InboundMessage {
+            id: "trigger".to_string(),
+            source: "webchat".to_string(),
+            adapter: Some("webchat".to_string()),
+            conversation_id: "webchat-session".to_string(),
+            sender_id: "alice-id".to_string(),
+            agent_id: Some(Arc::from("agent-a")),
+            content: MessageContent::Text("new message".to_string()),
+            timestamp: Utc::now(),
+            metadata: HashMap::new(),
+            formatted_author: Some("Alice".to_string()),
+        };
+
+        let history = adapter
+            .fetch_history(&inbound, 50)
+            .await
+            .expect("fetch_history should succeed");
+
+        assert_eq!(history.len(), 2);
+        assert_eq!(history[0].author, "Alice");
+        assert_eq!(history[0].content, "hey there");
+        assert!(!history[0].is_bot);
+
+        assert_eq!(history[1].author, "assistant");
+        assert_eq!(history[1].content, "hello Alice");
+        assert!(history[1].is_bot);
+    }
+}
diff --git a/src/messaging/webhook.rs b/src/messaging/webhook.rs
index e43f742ef..1654bc1d7 100644
--- a/src/messaging/webhook.rs
+++ b/src/messaging/webhook.rs
@@ -37,6 +37,7 @@ struct AppState {
     inbound_tx: Arc<RwLock<Option<mpsc::Sender<InboundMessage>>>>,
     response_buffers: Arc<RwLock<HashMap<String, Vec<WebhookResponse>>>>,
     auth_token: Option<String>,
+    runtime_key: String,
 }
 
 /// Inbound webhook request body.
@@ -103,6 +104,7 @@ impl Messaging for WebhookAdapter {
             inbound_tx: self.inbound_tx.clone(),
             response_buffers: self.response_buffers.clone(),
             auth_token: self.auth_token.clone(),
+            runtime_key: self.name().to_string(),
         };
 
         if self.auth_token.is_none() {
@@ -262,12 +264,21 @@ async fn handle_send(
         "display_name".into(),
         serde_json::Value::String(request.sender_id.clone()),
     );
+    metadata.insert(
+        "sender_display_name".into(),
+        serde_json::Value::String(request.sender_id.clone()),
+    );
+    metadata.insert(
+        crate::metadata_keys::CHANNEL_NAME.into(),
+        serde_json::Value::String(request.conversation_id.clone()),
+    );
 
     let conversation_id = format!("webhook:{}", request.conversation_id);
 
     let inbound = InboundMessage {
         id: uuid::Uuid::new_v4().to_string(),
         source: "webhook".into(),
+        adapter: Some(state.runtime_key.clone()),
         conversation_id,
         sender_id: request.sender_id.clone(),
         agent_id: request.agent_id.map(Into::into),
diff --git a/src/openai_auth.rs b/src/openai_auth.rs
index a2e156e65..4053c947a 100644
--- a/src/openai_auth.rs
+++ b/src/openai_auth.rs
@@ -216,6 +216,12 @@ pub async fn request_device_code() -> Result<DeviceCodeResponse> {
         .await
         .context("failed to read OpenAI device-code usercode response")?;
 
+    if status == reqwest::StatusCode::NOT_FOUND {
+        anyhow::bail!(
+            "Device code login is not enabled. Please enable it in your ChatGPT security settings at https://chatgpt.com/security-settings and try again."
+        );
+    }
+
     if !status.is_success() {
         anyhow::bail!(
             "OpenAI device-code usercode request failed ({}): {}",
diff --git a/src/opencode/types.rs b/src/opencode/types.rs
index 31542dd7e..a41007c5f 100644
--- a/src/opencode/types.rs
+++ b/src/opencode/types.rs
@@ -501,7 +501,7 @@ pub struct OpenCodeEnvConfig {
 }
 
 /// Permission settings for headless OpenCode operation.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct OpenCodePermissions {
     pub edit: String,
     pub bash: String,
@@ -534,3 +534,137 @@ impl OpenCodeEnvConfig {
         }
     }
 }
+
+// -- OpenCode part types for real-time transcript mirroring --
+
+/// A finalized content part from an OpenCode session, sent to the frontend
+/// via SSE for live transcript rendering. Each part has a stable `id` that
+/// the frontend uses to upsert into an ordered map.
+///
+/// This is a typed Rust subset of OpenCode's Part — only the variants the
+/// frontend cares about are included.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum OpenCodePart {
+    /// Assistant text output.
+    Text { id: String, text: String },
+    /// A tool call with its current execution state.
+    Tool {
+        id: String,
+        tool: String,
+        #[serde(flatten)]
+        state: OpenCodeToolState,
+    },
+    /// Marks the beginning of an agentic step (sub-agent delegation).
+    StepStart { id: String },
+    /// Marks the end of an agentic step.
+    StepFinish {
+        id: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        reason: Option<String>,
+    },
+}
+
+impl OpenCodePart {
+    /// Get the stable part ID.
+    pub fn id(&self) -> &str {
+        match self {
+            OpenCodePart::Text { id, .. }
+            | OpenCodePart::Tool { id, .. }
+            | OpenCodePart::StepStart { id }
+            | OpenCodePart::StepFinish { id, .. } => id,
+        }
+    }
+}
+
+/// Tool execution state for the frontend. Flattened into the Tool variant.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "status", rename_all = "snake_case")]
+pub enum OpenCodeToolState {
+    Pending,
+    Running {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        title: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        input: Option<String>,
+    },
+    Completed {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        title: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        input: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        output: Option<String>,
+    },
+    Error {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        error: Option<String>,
+    },
+}
+
+/// Convert an internal SSE `Part` into an `OpenCodePart` for the frontend.
+/// Returns `None` for part types we don't mirror (reasoning, file, snapshot, etc.).
+pub fn part_to_opencode_part(part: &Part) -> Option<OpenCodePart> {
+    match part {
+        Part::Text { id, text, .. } => Some(OpenCodePart::Text {
+            id: id.clone(),
+            text: text.clone(),
+        }),
+        Part::Tool {
+            id,
+            tool,
+            state: tool_state,
+            ..
+        } => {
+            let tool_name = tool.as_deref().unwrap_or("unknown").to_string();
+            let oc_state = match tool_state {
+                Some(ToolState::Pending { .. }) => OpenCodeToolState::Pending,
+                Some(ToolState::Running { title, input, .. }) => OpenCodeToolState::Running {
+                    title: title.clone(),
+                    input: input.as_ref().map(|v| {
+                        let s = v.to_string();
+                        if s.len() > 2_000 {
+                            crate::tools::truncate_output(&s, 2_000)
+                        } else {
+                            s
+                        }
+                    }),
+                },
+                Some(ToolState::Completed {
+                    title,
+                    input,
+                    output,
+                    ..
+                }) => OpenCodeToolState::Completed {
+                    title: title.clone(),
+                    input: input.as_ref().map(|v| {
+                        let s = v.to_string();
+                        if s.len() > 2_000 {
+                            crate::tools::truncate_output(&s, 2_000)
+                        } else {
+                            s
+                        }
+                    }),
+                    output: output.as_ref().map(|o| {
+                        crate::tools::truncate_output(o, crate::tools::MAX_TOOL_OUTPUT_BYTES)
+                    }),
+                },
+                Some(ToolState::Error { error, .. }) => OpenCodeToolState::Error {
+                    error: error.clone(),
+                },
+                None => OpenCodeToolState::Pending,
+            };
+            Some(OpenCodePart::Tool {
+                id: id.clone(),
+                tool: tool_name,
+                state: oc_state,
+            })
+        }
+        Part::StepStart { id, .. } => Some(OpenCodePart::StepStart { id: id.clone() }),
+        Part::StepFinish { id, reason, .. } => Some(OpenCodePart::StepFinish {
+            id: id.clone(),
+            reason: reason.clone(),
+        }),
+        Part::Other => None,
+    }
+}
diff --git a/src/opencode/worker.rs b/src/opencode/worker.rs
index 5ef5bbcdb..2906edba2 100644
--- a/src/opencode/worker.rs
+++ b/src/opencode/worker.rs
@@ -6,6 +6,7 @@
 
 use crate::opencode::server::OpenCodeServerPool;
 use crate::opencode::types::*;
+use crate::secrets::store::SecretsStore;
 use crate::{AgentId, ChannelId, ProcessEvent, WorkerId};
 
 use anyhow::{Context as _, bail};
@@ -30,12 +31,47 @@ pub struct OpenCodeWorker {
     pub system_prompt: Option<String>,
     /// Model override (provider/model format like "anthropic/claude-sonnet-4").
     pub model: Option<String>,
+    /// Secrets store for exact-match scrubbing of tool secret values in SSE output.
+    pub secrets_store: Option<Arc<SecretsStore>>,
+}
+
+/// Accumulated state from SSE event processing.
+struct EventState {
+    /// The most recent text part (used for status/initial result delivery).
+    last_text: String,
+    /// Currently running tool name.
+    current_tool: Option<String>,
+    /// Number of tool calls observed (for status reporting).
+    tool_calls: i64,
+    /// Guards: don't treat session.idle as completion until we've seen real work.
+    has_received_event: bool,
+    has_assistant_message: bool,
+    /// Accumulated OpenCode parts from SSE events, used as a fallback transcript
+    /// source when the post-completion `get_messages()` API call fails.
+    accumulated_parts: Vec<OpenCodePart>,
+}
+
+impl EventState {
+    fn new() -> Self {
+        Self {
+            last_text: String::new(),
+            current_tool: None,
+            tool_calls: 0,
+            has_received_event: false,
+            has_assistant_message: false,
+            accumulated_parts: Vec::new(),
+        }
+    }
 }
 
 /// Result of an OpenCode worker run.
 pub struct OpenCodeWorkerResult {
     pub session_id: String,
     pub result_text: String,
+    /// Transcript steps converted from the OpenCode messages API on completion.
+    pub transcript: Vec<crate::conversation::worker_transcript::TranscriptStep>,
+    /// Number of tool calls observed during the session.
+    pub tool_calls: i64,
 }
 
 impl OpenCodeWorker {
@@ -59,6 +95,7 @@ impl OpenCodeWorker {
             input_rx: None,
             system_prompt: None,
             model: None,
+            secrets_store: None,
         }
     }
 
@@ -89,6 +126,21 @@ impl OpenCodeWorker {
         self
     }
 
+    /// Set the secrets store for exact-match scrubbing of tool secret values.
+    pub fn with_secrets_store(mut self, store: Arc<SecretsStore>) -> Self {
+        self.secrets_store = Some(store);
+        self
+    }
+
+    /// Scrub tool secret values from text, replacing each with `[REDACTED:<name>]`.
+    /// Returns the scrubbed text. If no secrets store is set, returns the input unchanged.
+    fn scrub_text(&self, text: &str) -> String {
+        match &self.secrets_store {
+            Some(store) => crate::secrets::scrub::scrub_with_store(text, store),
+            None => text.to_string(),
+        }
+    }
+
     /// Run the worker: spawn/reuse an OpenCode server, create a session,
     /// send the task, monitor via SSE, and return the result.
     pub async fn run(mut self) -> anyhow::Result<OpenCodeWorkerResult> {
@@ -117,9 +169,24 @@ impl OpenCodeWorker {
         };
         let session_id = session.id.clone();
 
+        // Record metadata so the web UI can embed the OpenCode interface
+        let opencode_port = {
+            let guard = server.lock().await;
+            guard.port()
+        };
+        self.event_tx
+            .send(ProcessEvent::OpenCodeSessionCreated {
+                agent_id: self.agent_id.clone(),
+                worker_id: self.id,
+                session_id: session_id.clone(),
+                port: opencode_port,
+            })
+            .ok();
+
         tracing::info!(
             worker_id = %self.id,
             session_id = %session_id,
+            port = opencode_port,
             directory = %self.directory.display(),
             "OpenCode session created"
         );
@@ -151,14 +218,34 @@ impl OpenCodeWorker {
                 .await?;
         }
 
-        // Process SSE events until session goes idle or errors
-        let result_text = self
-            .process_events(event_response, &session_id, &server)
+        // Process SSE events until session goes idle or errors.
+        // EventState tracks status and last_text for the initial result delivery.
+        // The full transcript is fetched from the OpenCode API on completion.
+        let mut event_state = EventState::new();
+        self.process_events(event_response, &session_id, &server, &mut event_state)
             .await?;
 
+        // last_text is our best signal for the initial result (used for
+        // WorkerInitialResult and the fallback if API fetch fails).
+        let result_text = event_state.last_text.clone();
+
         // Interactive follow-up loop
         if let Some(mut input_rx) = self.input_rx.take() {
+            // Emit the initial result immediately so the channel can retrigger
+            // and tell the user what the worker found. Without this, the channel
+            // would block until the entire follow-up loop exits — which only
+            // happens when the channel drops the input sender, creating a deadlock.
+            let scrubbed_result = self.scrub_text(&result_text);
+            let scrubbed_result = crate::secrets::scrub::scrub_leaks(&scrubbed_result);
+            let _ = self.event_tx.send(ProcessEvent::WorkerInitialResult {
+                agent_id: self.agent_id.clone(),
+                worker_id: self.id,
+                channel_id: self.channel_id.clone(),
+                result: scrubbed_result,
+            });
+
             self.send_status("waiting for follow-up");
+            self.send_idle();
 
             while let Some(follow_up) = input_rx.recv().await {
                 self.send_status("processing follow-up");
@@ -187,11 +274,25 @@ impl OpenCodeWorker {
                 }
 
                 match self
-                    .process_events(event_response, &session_id, &server)
+                    .process_events(event_response, &session_id, &server, &mut event_state)
                     .await
                 {
                     Ok(_) => {
+                        // Emit follow-up result so the channel can retrigger
+                        // and relay this to the user — same as initial result.
+                        let follow_up_text = event_state.last_text.clone();
+                        if !follow_up_text.is_empty() {
+                            let scrubbed = self.scrub_text(&follow_up_text);
+                            let scrubbed = crate::secrets::scrub::scrub_leaks(&scrubbed);
+                            let _ = self.event_tx.send(ProcessEvent::WorkerInitialResult {
+                                agent_id: self.agent_id.clone(),
+                                worker_id: self.id,
+                                channel_id: self.channel_id.clone(),
+                                result: scrubbed,
+                            });
+                        }
                         self.send_status("waiting for follow-up");
+                        self.send_idle();
                     }
                     Err(error) => {
                         tracing::error!(
@@ -208,15 +309,58 @@ impl OpenCodeWorker {
 
         self.send_status("completed");
 
+        // Fetch the full message history from the OpenCode API and convert
+        // to TranscriptStep[] for persistence + extract all assistant text
+        // as the definitive result_text.
+        let (transcript, api_result_text) =
+            match server.lock().await.get_messages(&session_id).await {
+                Ok(messages) => {
+                    let (steps, all_text) =
+                        crate::conversation::worker_transcript::convert_opencode_messages(
+                            &messages,
+                        );
+                    (
+                        steps,
+                        if all_text.is_empty() {
+                            None
+                        } else {
+                            Some(all_text)
+                        },
+                    )
+                }
+                Err(error) => {
+                    // API call failed (server recycled, process exited, etc.).
+                    // Fall back to the OpenCodeParts accumulated from SSE events
+                    // during the session — better than losing the transcript entirely.
+                    let fallback_steps =
+                        crate::conversation::worker_transcript::convert_opencode_parts(
+                            &event_state.accumulated_parts,
+                        );
+                    tracing::warn!(
+                        worker_id = %self.id,
+                        %error,
+                        fallback_steps = fallback_steps.len(),
+                        "failed to fetch OpenCode messages for transcript, using SSE fallback"
+                    );
+                    (fallback_steps, None)
+                }
+            };
+
+        // Prefer API-fetched result text, fall back to SSE last_text
+        let final_result_text = api_result_text.unwrap_or(result_text);
+
         tracing::info!(
             worker_id = %self.id,
             session_id = %session_id,
+            transcript_steps = transcript.len(),
             "OpenCode worker completed"
         );
 
         Ok(OpenCodeWorkerResult {
             session_id,
-            result_text,
+            result_text: final_result_text,
+            transcript,
+            tool_calls: event_state.tool_calls,
         })
     }
 
@@ -227,14 +371,10 @@ impl OpenCodeWorker {
         response: reqwest::Response,
         session_id: &str,
         server: &Arc<Mutex<crate::opencode::server::OpenCodeServer>>,
+        event_state: &mut EventState,
     ) -> anyhow::Result<String> {
         let mut stream = response.bytes_stream();
         let mut buffer = String::new();
-        let mut last_text = String::new();
-        let mut current_tool: Option<String> = None;
-        // Guards: don't treat session.idle as completion until we've seen real work
-        let mut has_received_event = false;
-        let mut has_assistant_message = false;
 
         loop {
             let chunk = tokio::select! {
@@ -246,8 +386,8 @@ impl OpenCodeWorker {
 
             let Some(chunk) = chunk else {
                 // Stream ended -- if we have results, return them
-                if has_assistant_message && !last_text.is_empty() {
-                    return Ok(last_text);
+                if event_state.has_assistant_message && !event_state.last_text.is_empty() {
+                    return Ok(event_state.last_text.clone());
                 }
                 bail!("OpenCode event stream ended before session completed");
             };
@@ -258,19 +398,11 @@ impl OpenCodeWorker {
             // Parse SSE lines from buffer
             while let Some(event) = extract_sse_event(&mut buffer) {
                 match self
-                    .handle_sse_event(
-                        &event,
-                        session_id,
-                        server,
-                        &mut last_text,
-                        &mut current_tool,
-                        &mut has_received_event,
-                        &mut has_assistant_message,
-                    )
+                    .handle_sse_event(&event, session_id, server, event_state)
                     .await
                 {
                     EventAction::Continue => {}
-                    EventAction::Complete => return Ok(last_text.clone()),
+                    EventAction::Complete => return Ok(event_state.last_text.clone()),
                     EventAction::Error(message) => bail!("OpenCode session error: {message}"),
                 }
             }
@@ -278,73 +410,116 @@ impl OpenCodeWorker {
     }
 
     /// Handle a single SSE event. Returns whether to continue, complete, or error.
-    #[allow(clippy::too_many_arguments)]
     async fn handle_sse_event(
         &self,
         event: &SseEvent,
         session_id: &str,
         server: &Arc<Mutex<crate::opencode::server::OpenCodeServer>>,
-        last_text: &mut String,
-        current_tool: &mut Option<String>,
-        has_received_event: &mut bool,
-        has_assistant_message: &mut bool,
+        state: &mut EventState,
     ) -> EventAction {
         match event {
             SseEvent::MessageUpdated { info } => {
-                *has_received_event = true;
+                state.has_received_event = true;
                 // Track assistant messages for idle guard
                 if let Some(msg) = info
                     && msg.role == "assistant"
                     && let Some(sid) = &msg.session_id
                     && sid == session_id
                 {
-                    *has_assistant_message = true;
+                    state.has_assistant_message = true;
                 }
                 EventAction::Continue
             }
 
             SseEvent::MessagePartUpdated { part, .. } => {
-                *has_received_event = true;
+                state.has_received_event = true;
+
+                // Filter out parts from other sessions
+                let part_session_id = match part {
+                    Part::Text { session_id: s, .. } => s.as_deref(),
+                    Part::Tool { session_id: s, .. } => s.as_deref(),
+                    Part::StepStart { session_id: s, .. } => s.as_deref(),
+                    Part::StepFinish { session_id: s, .. } => s.as_deref(),
+                    Part::Other => None,
+                };
+                if let Some(sid) = part_session_id
+                    && sid != session_id
+                {
+                    return EventAction::Continue;
+                }
+
+                // Emit OpenCodePartUpdated for the frontend live transcript
+                // and accumulate for fallback transcript persistence.
+                if let Some(opencode_part) = part_to_opencode_part(part) {
+                    let _ = self.event_tx.send(ProcessEvent::OpenCodePartUpdated {
+                        agent_id: self.agent_id.clone(),
+                        worker_id: self.id,
+                        part: opencode_part.clone(),
+                    });
+                    state.accumulated_parts.push(opencode_part);
+                }
+
+                // Continue processing for status updates and state tracking
                 match part {
-                    Part::Text {
-                        text,
-                        session_id: part_session,
-                        ..
-                    } => {
-                        if let Some(sid) = part_session
-                            && sid != session_id
-                        {
-                            return EventAction::Continue;
+                    Part::Text { text, .. } => {
+                        state.has_assistant_message = true;
+
+                        // Exact-match scrubbing for leak detection
+                        let scrubbed = self.scrub_text(text);
+                        if let Some(leak) = crate::secrets::scrub::scan_for_leaks(&scrubbed) {
+                            tracing::warn!(
+                                worker_id = %self.id,
+                                leak_prefix = %&leak[..leak.len().min(8)],
+                                "potential secret detected in OpenCode worker output"
+                            );
                         }
-                        *has_assistant_message = true;
-                        *last_text = text.clone();
+
+                        state.last_text = scrubbed;
                     }
                     Part::Tool {
                         tool,
-                        state,
-                        session_id: part_session,
+                        state: tool_state,
                         ..
                     } => {
-                        if let Some(sid) = part_session
-                            && sid != session_id
-                        {
-                            return EventAction::Continue;
-                        }
-                        *has_assistant_message = true;
+                        state.has_assistant_message = true;
                         if let Some(tool_name) = tool
-                            && let Some(tool_state) = state
+                            && let Some(tool_state) = tool_state
                         {
                             match tool_state {
-                                ToolState::Running { title, .. } => {
-                                    *current_tool = Some(tool_name.clone());
-                                    let label = title.as_deref().unwrap_or(tool_name.as_str());
+                                ToolState::Running { title, input, .. } => {
+                                    state.current_tool = Some(tool_name.clone());
+                                    state.tool_calls += 1;
+                                    let label = title
+                                        .as_deref()
+                                        .map(String::from)
+                                        .or_else(|| describe_tool_input(tool_name, input.as_ref()))
+                                        .unwrap_or_else(|| tool_name.clone());
                                     self.send_status(&format!("running: {label}"));
                                 }
-                                ToolState::Completed { .. } => {
-                                    if current_tool.as_deref() == Some(tool_name.as_str()) {
-                                        *current_tool = None;
+                                ToolState::Completed { output, title, .. } => {
+                                    // Scrub and log potential secret-pattern hits
+                                    if let Some(output) = output {
+                                        let scrubbed = self.scrub_text(output);
+                                        if let Some(leak) =
+                                            crate::secrets::scrub::scan_for_leaks(&scrubbed)
+                                        {
+                                            tracing::warn!(
+                                                worker_id = %self.id,
+                                                tool = %tool_name,
+                                                leak_prefix = %&leak[..leak.len().min(8)],
+                                                "potential secret detected in OpenCode tool output"
+                                            );
+                                        }
+                                    }
+
+                                    if state.current_tool.as_deref() == Some(tool_name.as_str()) {
+                                        state.current_tool = None;
                                     }
-                                    self.send_status("working");
+                                    let done_label = title
+                                        .as_deref()
+                                        .filter(|t| !t.is_empty())
+                                        .unwrap_or(tool_name.as_str());
+                                    self.send_status(&format!("done: {done_label}"));
                                 }
                                 ToolState::Error { error, .. } => {
                                     let description = error.as_deref().unwrap_or("unknown");
@@ -372,11 +547,11 @@ impl OpenCodeWorker {
 
                 // Guard: don't complete until we've seen actual work.
                 // OpenCode can send an early idle event before the prompt is processed.
-                if !*has_received_event || !*has_assistant_message {
+                if !state.has_received_event || !state.has_assistant_message {
                     tracing::trace!(
                         worker_id = %self.id,
-                        has_received_event,
-                        has_assistant_message,
+                        has_received_event = state.has_received_event,
+                        has_assistant_message = state.has_assistant_message,
                         "ignoring early session.idle"
                     );
                     return EventAction::Continue;
@@ -538,6 +713,84 @@ impl OpenCodeWorker {
             status: status.to_string(),
         });
     }
+
+    /// Send an idle event to mark this worker as waiting for follow-up input.
+    fn send_idle(&self) {
+        let _ = self.event_tx.send(ProcessEvent::WorkerIdle {
+            agent_id: self.agent_id.clone(),
+            worker_id: self.id,
+            channel_id: self.channel_id.clone(),
+        });
+    }
+}
+
+/// Extract a human-readable description from a tool's input JSON.
+///
+/// OpenCode tool inputs have well-known shapes (e.g. `read` has `filePath`,
+/// `bash` has `description` and `command`, `grep` has `pattern`). When the
+/// running-state `title` is absent we derive a label from the input fields
+/// so the transcript shows "reading src/main.rs" instead of "running: read".
+fn describe_tool_input(tool_name: &str, input: Option<&serde_json::Value>) -> Option<String> {
+    let input = input?.as_object()?;
+    match tool_name {
+        "read" | "write" | "edit" => {
+            let file_path = input.get("filePath")?.as_str()?;
+            // Show just the last 3 path components to keep it short
+            let short = short_path(file_path);
+            Some(short.to_string())
+        }
+        "bash" => {
+            // Prefer the LLM-provided description, fall back to command
+            if let Some(description) = input.get("description").and_then(|v| v.as_str())
+                && !description.is_empty()
+            {
+                return Some(truncate_status(description, 80));
+            }
+            let command = input.get("command")?.as_str()?;
+            Some(truncate_status(command, 60))
+        }
+        "glob" => {
+            let pattern = input.get("pattern")?.as_str()?;
+            Some(format!("glob {pattern}"))
+        }
+        "grep" => {
+            let pattern = input.get("pattern")?.as_str()?;
+            Some(format!("search \"{pattern}\""))
+        }
+        "task" => {
+            let description = input.get("description")?.as_str()?;
+            Some(truncate_status(description, 80))
+        }
+        _ => None,
+    }
+}
+
+/// Shorten an absolute file path to at most the last 3 components.
+fn short_path(path: &str) -> &str {
+    let mut count = 0;
+    for (idx, byte) in path.bytes().enumerate().rev() {
+        if byte == b'/' {
+            count += 1;
+            if count == 3 {
+                return &path[idx + 1..];
+            }
+        }
+    }
+    path
+}
+
+/// Truncate a status string to `max` characters, appending "…" if trimmed.
+fn truncate_status(text: &str, max: usize) -> String {
+    if text.len() <= max {
+        text.to_string()
+    } else {
+        let boundary = text
+            .char_indices()
+            .nth(max.saturating_sub(1))
+            .map(|(idx, _)| idx)
+            .unwrap_or(max);
+        format!("{}…", &text[..boundary])
+    }
 }
 
 /// Result of processing a single SSE event.
diff --git a/src/prompts/engine.rs b/src/prompts/engine.rs
index 69a69be61..80640271a 100644
--- a/src/prompts/engine.rs
+++ b/src/prompts/engine.rs
@@ -1,9 +1,23 @@
 use crate::error::Result;
 use anyhow::Context;
 use minijinja::{Environment, Value, context};
+use serde::Serialize;
 use std::collections::HashMap;
 use std::sync::Arc;
 
+/// A completed background process result, passed to the retrigger template.
+#[derive(Clone, Debug, Serialize)]
+pub struct RetriggerResult {
+    /// "branch" or "worker"
+    pub process_type: String,
+    /// The branch or worker ID (short UUID).
+    pub process_id: String,
+    /// Whether the process completed successfully.
+    pub success: bool,
+    /// The result/conclusion text from the process.
+    pub result: String,
+}
+
 /// Template engine for rendering system prompts with dynamic variables.
 ///
 /// Prompts are bundled in the binary as `include_str!` embedded templates.
@@ -55,6 +69,12 @@ impl PromptEngine {
             crate::prompts::text::get("cortex_profile"),
         )?;
 
+        // Adapter-specific prompt fragments
+        env.add_template(
+            "adapters/email",
+            crate::prompts::text::get("adapters/email"),
+        )?;
+
         // Fragment templates
         env.add_template(
             "fragments/worker_capabilities",
@@ -80,10 +100,6 @@ impl PromptEngine {
             "fragments/org_context",
             crate::prompts::text::get("fragments/org_context"),
         )?;
-        env.add_template(
-            "fragments/link_context",
-            crate::prompts::text::get("fragments/link_context"),
-        )?;
 
         // System message fragments
         env.add_template(
@@ -126,6 +142,10 @@ impl PromptEngine {
             "fragments/system/tool_syntax_correction",
             crate::prompts::text::get("fragments/system/tool_syntax_correction"),
         )?;
+        env.add_template(
+            "fragments/system/worker_time_context",
+            crate::prompts::text::get("fragments/system/worker_time_context"),
+        )?;
         env.add_template(
             "fragments/coalesce_hint",
             crate::prompts::text::get("fragments/coalesce_hint"),
@@ -221,13 +241,29 @@ impl PromptEngine {
         )
     }
 
-    /// Render the worker system prompt with filesystem context.
-    pub fn render_worker_prompt(&self, instance_dir: &str, workspace_dir: &str) -> Result<String> {
+    /// Render the worker system prompt with filesystem context and optional tool
+    /// secret names.
+    #[allow(clippy::too_many_arguments)]
+    pub fn render_worker_prompt(
+        &self,
+        instance_dir: &str,
+        workspace_dir: &str,
+        sandbox_enabled: bool,
+        sandbox_containment_active: bool,
+        sandbox_read_allowlist: Vec<String>,
+        sandbox_write_allowlist: Vec<String>,
+        tool_secret_names: &[String],
+    ) -> Result<String> {
         self.render(
             "worker",
             context! {
                 instance_dir => instance_dir,
                 workspace_dir => workspace_dir,
+                sandbox_enabled => sandbox_enabled,
+                sandbox_containment_active => sandbox_containment_active,
+                sandbox_read_allowlist => sandbox_read_allowlist,
+                sandbox_write_allowlist => sandbox_write_allowlist,
+                tool_secret_names => tool_secret_names,
             },
         )
     }
@@ -266,9 +302,17 @@ impl PromptEngine {
         )
     }
 
-    /// Convenience method for rendering system retrigger message.
-    pub fn render_system_retrigger(&self) -> Result<String> {
-        self.render_static("fragments/system/retrigger")
+    /// Render the retrigger message with specific process results embedded.
+    ///
+    /// Each result includes the process type, ID, and full result text so the
+    /// LLM knows exactly what completed and what to relay to the user.
+    pub fn render_system_retrigger(&self, results: &[RetriggerResult]) -> Result<String> {
+        self.render(
+            "fragments/system/retrigger",
+            context! {
+                results => results,
+            },
+        )
     }
 
     /// Correction message when the LLM outputs tool call syntax as plain text.
@@ -276,6 +320,21 @@ impl PromptEngine {
         self.render_static("fragments/system/tool_syntax_correction")
     }
 
+    /// Render worker task time-context preamble.
+    pub fn render_system_worker_time_context(
+        &self,
+        current_local_datetime: &str,
+        current_utc_datetime: &str,
+    ) -> Result<String> {
+        self.render(
+            "fragments/system/worker_time_context",
+            context! {
+                current_local_datetime => current_local_datetime,
+                current_utc_datetime => current_utc_datetime,
+            },
+        )
+    }
+
     /// Convenience method for rendering truncation marker.
     pub fn render_system_truncation(&self, remove_count: usize) -> Result<String> {
         self.render(
@@ -395,6 +454,7 @@ impl PromptEngine {
         status_text: Option<String>,
         coalesce_hint: Option<String>,
         available_channels: Option<String>,
+        sandbox_enabled: bool,
     ) -> Result<String> {
         self.render_channel_prompt_with_links(
             identity_context,
@@ -405,17 +465,41 @@ impl PromptEngine {
             status_text,
             coalesce_hint,
             available_channels,
+            sandbox_enabled,
             None,
             None,
         )
     }
 
+    /// Render optional adapter-specific channel guidance.
+    pub fn render_channel_adapter_prompt(&self, adapter: &str) -> Option<String> {
+        let template_name = match adapter {
+            "email" => "adapters/email",
+            _ => return None,
+        };
+
+        match self.render_static(template_name) {
+            Ok(value) => {
+                let value = value.trim().to_string();
+                if value.is_empty() { None } else { Some(value) }
+            }
+            Err(error) => {
+                tracing::error!(template_name, %error, "failed to render adapter prompt template");
+                None
+            }
+        }
+    }
+
     /// Render the cortex chat system prompt with optional channel context.
+    #[allow(clippy::too_many_arguments)]
     pub fn render_cortex_chat_prompt(
         &self,
         identity_context: Option<String>,
         memory_bulletin: Option<String>,
         channel_transcript: Option<String>,
+        agents_manifest: Option<String>,
+        changelog_highlights: Option<String>,
+        runtime_config_snapshot: Option<String>,
         worker_capabilities: String,
     ) -> Result<String> {
         self.render(
@@ -424,6 +508,9 @@ impl PromptEngine {
                 identity_context => identity_context,
                 memory_bulletin => memory_bulletin,
                 channel_transcript => channel_transcript,
+                agents_manifest => agents_manifest,
+                changelog_highlights => changelog_highlights,
+                runtime_config_snapshot => runtime_config_snapshot,
                 worker_capabilities => worker_capabilities,
             },
         )
@@ -439,17 +526,7 @@ impl PromptEngine {
         )
     }
 
-    /// Render the link context fragment for an internal agent-to-agent channel.
-    pub fn render_link_context(&self, link_context: LinkContext) -> Result<String> {
-        self.render(
-            "fragments/link_context",
-            context! {
-                link_context => link_context,
-            },
-        )
-    }
-
-    /// Render the channel system prompt with all dynamic components including org/link context.
+    /// Render the channel system prompt with all dynamic components including org context.
     #[allow(clippy::too_many_arguments)]
     pub fn render_channel_prompt_with_links(
         &self,
@@ -461,8 +538,9 @@ impl PromptEngine {
         status_text: Option<String>,
         coalesce_hint: Option<String>,
         available_channels: Option<String>,
+        sandbox_enabled: bool,
         org_context: Option<String>,
-        link_context: Option<String>,
+        adapter_prompt: Option<String>,
     ) -> Result<String> {
         self.render(
             "channel",
@@ -475,8 +553,9 @@ impl PromptEngine {
                 status_text => status_text,
                 coalesce_hint => coalesce_hint,
                 available_channels => available_channels,
+                sandbox_enabled => sandbox_enabled,
                 org_context => org_context,
-                link_context => link_context,
+                adapter_prompt => adapter_prompt,
             },
         )
     }
@@ -504,13 +583,6 @@ pub struct LinkedAgent {
     pub is_human: bool,
 }
 
-/// Context for the current link channel.
-#[derive(Debug, Clone, serde::Serialize)]
-pub struct LinkContext {
-    pub agent_name: String,
-    pub relationship: String,
-}
-
 /// Information about a skill for template rendering.
 #[derive(Debug, Clone, serde::Serialize)]
 pub struct SkillInfo {
diff --git a/src/prompts/text.rs b/src/prompts/text.rs
index 3e0518b45..1daf00edb 100644
--- a/src/prompts/text.rs
+++ b/src/prompts/text.rs
@@ -65,6 +65,9 @@ fn lookup(lang: &str, key: &str) -> &'static str {
         ("en", "ingestion") => include_str!("../../prompts/en/ingestion.md.j2"),
         ("en", "cortex_chat") => include_str!("../../prompts/en/cortex_chat.md.j2"),
 
+        // Adapter-specific prompt fragments
+        ("en", "adapters/email") => include_str!("../../prompts/en/adapters/email.md.j2"),
+
         // Fragment Templates
         ("en", "fragments/worker_capabilities") => {
             include_str!("../../prompts/en/fragments/worker_capabilities.md.j2")
@@ -113,15 +116,14 @@ fn lookup(lang: &str, key: &str) -> &'static str {
         ("en", "fragments/system/tool_syntax_correction") => {
             include_str!("../../prompts/en/fragments/system/tool_syntax_correction.md.j2")
         }
+        ("en", "fragments/system/worker_time_context") => {
+            include_str!("../../prompts/en/fragments/system/worker_time_context.md.j2")
+        }
 
         // Agent Communication Fragments
         ("en", "fragments/org_context") => {
             include_str!("../../prompts/en/fragments/org_context.md.j2")
         }
-        ("en", "fragments/link_context") => {
-            include_str!("../../prompts/en/fragments/link_context.md.j2")
-        }
-
         // Coalesce Hint
         ("en", "fragments/coalesce_hint") => {
             include_str!("../../prompts/en/fragments/coalesce_hint.md.j2")
@@ -159,6 +161,12 @@ fn lookup(lang: &str, key: &str) -> &'static str {
         ("en", "tools/channel_recall") => {
             include_str!("../../prompts/en/tools/channel_recall_description.md.j2")
         }
+        ("en", "tools/email_search") => {
+            include_str!("../../prompts/en/tools/email_search_description.md.j2")
+        }
+        ("en", "tools/worker_inspect") => {
+            include_str!("../../prompts/en/tools/worker_inspect_description.md.j2")
+        }
         ("en", "tools/send_file") => {
             include_str!("../../prompts/en/tools/send_file_description.md.j2")
         }
@@ -166,11 +174,26 @@ fn lookup(lang: &str, key: &str) -> &'static str {
         ("en", "tools/send_message_to_another_channel") => {
             include_str!("../../prompts/en/tools/send_message_description.md.j2")
         }
+        ("en", "tools/secret_set") => {
+            include_str!("../../prompts/en/tools/secret_set_description.md.j2")
+        }
         ("en", "tools/send_agent_message") => {
             include_str!("../../prompts/en/tools/send_agent_message_description.md.j2")
         }
-        ("en", "tools/conclude_link") => {
-            include_str!("../../prompts/en/tools/conclude_link_description.md.j2")
+        ("en", "tools/task_create") => {
+            include_str!("../../prompts/en/tools/task_create_description.md.j2")
+        }
+        ("en", "tools/task_list") => {
+            include_str!("../../prompts/en/tools/task_list_description.md.j2")
+        }
+        ("en", "tools/task_update") => {
+            include_str!("../../prompts/en/tools/task_update_description.md.j2")
+        }
+        ("en", "tools/spacebot_docs") => {
+            include_str!("../../prompts/en/tools/spacebot_docs_description.md.j2")
+        }
+        ("en", "tools/config_inspect") => {
+            include_str!("../../prompts/en/tools/config_inspect_description.md.j2")
         }
 
         // Fallback: unknown language or key -> try English
diff --git a/src/sandbox.rs b/src/sandbox.rs
index 1a8953325..0a5fb51ae 100644
--- a/src/sandbox.rs
+++ b/src/sandbox.rs
@@ -5,8 +5,11 @@
 //! On macOS, uses sandbox-exec with a generated SBPL profile.
 //! Falls back to no sandboxing when neither backend is available.
 
+use arc_swap::ArcSwap;
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 use tokio::process::Command;
 
 /// Sandbox configuration from the agent config file.
@@ -16,6 +19,13 @@ pub struct SandboxConfig {
     pub mode: SandboxMode,
     #[serde(default)]
     pub writable_paths: Vec<PathBuf>,
+    /// Environment variable names to forward from the parent process into worker
+    /// subprocesses. This is the escape hatch for self-hosted users who set env
+    /// vars in Docker/systemd but don't configure a secret store. When the secret
+    /// store is available, `passthrough_env` is redundant — everything should be
+    /// in the store. The field is additive either way.
+    #[serde(default)]
+    pub passthrough_env: Vec<String>,
 }
 
 impl Default for SandboxConfig {
@@ -23,6 +33,7 @@ impl Default for SandboxConfig {
         Self {
             mode: SandboxMode::Enabled,
             writable_paths: Vec::new(),
+            passthrough_env: Vec::new(),
         }
     }
 }
@@ -52,89 +63,271 @@ enum SandboxBackend {
     None,
 }
 
+/// Environment variables always passed through to worker subprocesses.
+/// These are required for basic process operation.
+const SAFE_ENV_VARS: &[&str] = &["USER", "LANG", "TERM"];
+
+/// Environment variable names that are set by the hardened sandbox defaults and
+/// must not be overridden via `passthrough_env`. Allowing user config to replace
+/// PATH would drop `tools/bin` precedence; replacing HOME/TMPDIR would break the
+/// deterministic sandbox-local paths.
+const RESERVED_ENV_VARS: &[&str] = &["PATH", "HOME", "TMPDIR"];
+
+/// Returns true if the variable name is reserved (set by hardened defaults) or
+/// is in the safe-vars list, and therefore must not be overridden by
+/// `passthrough_env`.
+fn is_reserved_env_var(name: &str) -> bool {
+    RESERVED_ENV_VARS.contains(&name) || SAFE_ENV_VARS.contains(&name)
+}
+
+/// Linux host paths exposed read-only inside bubblewrap sandboxes.
+/// This is a minimal runtime allowlist: worker/user data directories are not
+/// mounted unless they are explicitly configured as writable paths.
+const LINUX_READ_ONLY_SYSTEM_PATHS: &[&str] = &[
+    "/bin", "/sbin", "/usr", "/lib", "/lib64", "/etc", "/opt", "/run", "/nix",
+];
+
+/// macOS host paths exposed read-only in sandbox-exec profiles.
+/// User data directories are intentionally excluded; worker access is limited
+/// to workspace paths plus core system roots.
+const MACOS_READ_ONLY_SYSTEM_PATHS: &[&str] = &[
+    "/System",
+    "/usr",
+    "/bin",
+    "/sbin",
+    "/opt",
+    "/Library",
+    "/Applications",
+    "/private/etc",
+    "/private/var/run",
+    "/private/tmp",
+    "/etc",
+    "/dev",
+];
+
 /// Filesystem sandbox for subprocess execution.
 ///
 /// Created once per agent at startup, shared via `Arc` across all workers.
 /// Wraps `tokio::process::Command` to apply OS-level containment before spawning.
-#[derive(Debug, Clone)]
+///
+/// Reads `SandboxMode` dynamically from the shared `ArcSwap<SandboxConfig>` on
+/// every `wrap()` call, so toggling sandbox mode via the API takes effect
+/// immediately without restarting the agent.
 pub struct Sandbox {
-    #[allow(dead_code)]
-    mode: SandboxMode,
+    config: Arc<ArcSwap<SandboxConfig>>,
     workspace: PathBuf,
     data_dir: PathBuf,
     tools_bin: PathBuf,
-    writable_paths: Vec<PathBuf>,
     backend: SandboxBackend,
+    /// Reference to the secrets store for injecting tool secrets into worker
+    /// subprocesses. When set, `wrap()` reads tool secrets from the store and
+    /// injects them as env vars via `--setenv` (bubblewrap) or `Command::env()`
+    /// (passthrough/sandbox-exec).
+    secrets_store: ArcSwap<Option<Arc<crate::secrets::store::SecretsStore>>>,
+}
+
+impl std::fmt::Debug for Sandbox {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let config = self.config.load();
+        f.debug_struct("Sandbox")
+            .field("mode", &config.mode)
+            .field("workspace", &self.workspace)
+            .field("data_dir", &self.data_dir)
+            .field("tools_bin", &self.tools_bin)
+            .field("backend", &self.backend)
+            .finish()
+    }
 }
 
 impl Sandbox {
     /// Create a sandbox with the given configuration. Probes for backend support.
+    ///
+    /// Always detects the best available backend regardless of the initial mode,
+    /// so switching from Disabled to Enabled via the API works without restart.
     pub async fn new(
-        config: &SandboxConfig,
+        config: Arc<ArcSwap<SandboxConfig>>,
         workspace: PathBuf,
         instance_dir: &Path,
         data_dir: PathBuf,
     ) -> Self {
         let tools_bin = instance_dir.join("tools/bin");
-        let backend = if config.mode == SandboxMode::Disabled {
-            SandboxBackend::None
-        } else {
-            detect_backend().await
-        };
+
+        // Always detect the backend so we know what's available if the user
+        // later enables sandboxing via the API.
+        let backend = detect_backend().await;
+        let current_mode = config.load().mode;
 
         match backend {
             SandboxBackend::Bubblewrap { proc_supported } => {
-                tracing::info!(proc_supported, "sandbox enabled: bubblewrap backend");
+                if current_mode == SandboxMode::Enabled {
+                    tracing::info!(proc_supported, "sandbox enabled: bubblewrap backend");
+                } else {
+                    tracing::info!(
+                        proc_supported,
+                        "sandbox disabled by config (bubblewrap available)"
+                    );
+                }
             }
             SandboxBackend::SandboxExec => {
-                tracing::info!("sandbox enabled: macOS sandbox-exec backend");
+                if current_mode == SandboxMode::Enabled {
+                    tracing::info!("sandbox enabled: macOS sandbox-exec backend");
+                } else {
+                    tracing::info!("sandbox disabled by config (sandbox-exec available)");
+                }
             }
-            SandboxBackend::None if config.mode == SandboxMode::Enabled => {
+            SandboxBackend::None if current_mode == SandboxMode::Enabled => {
                 tracing::warn!(
                     "sandbox mode is enabled but no backend available — \
                      processes will run unsandboxed"
                 );
             }
             SandboxBackend::None => {
-                tracing::info!("sandbox disabled by config");
+                tracing::info!("sandbox disabled by config (no backend available)");
             }
         }
 
         // Canonicalize paths at construction to resolve symlinks and validate existence.
         let workspace = canonicalize_or_self(&workspace);
         let data_dir = canonicalize_or_self(&data_dir);
-        let writable_paths: Vec<PathBuf> = config
-            .writable_paths
-            .iter()
-            .filter_map(|path| match path.canonicalize() {
-                Ok(canonical) => Some(canonical),
-                Err(error) => {
-                    tracing::warn!(
-                        path = %path.display(),
-                        %error,
-                        "dropping writable_path entry (does not exist or is unresolvable)"
-                    );
-                    None
-                }
-            })
-            .collect();
 
         Self {
-            mode: config.mode,
+            config,
             workspace,
             data_dir,
             tools_bin,
-            writable_paths,
             backend,
+            secrets_store: ArcSwap::from_pointee(None),
         }
     }
 
+    /// Set the secrets store for tool secret injection into worker subprocesses.
+    ///
+    /// Called after the secrets store is initialized (may happen after sandbox
+    /// construction during agent startup).
+    pub fn set_secrets_store(&self, store: Arc<crate::secrets::store::SecretsStore>) {
+        self.secrets_store.store(Arc::new(Some(store)));
+    }
+
+    /// Read tool secrets from the store for injection into subprocess environment.
+    fn tool_secrets(&self) -> HashMap<String, String> {
+        let guard = self.secrets_store.load();
+        match guard.as_ref() {
+            Some(store) => store.tool_env_vars(),
+            None => HashMap::new(),
+        }
+    }
+
+    /// True when sandbox mode is enabled in config.
+    pub fn mode_enabled(&self) -> bool {
+        self.config.load().mode == SandboxMode::Enabled
+    }
+
+    /// True when OS-level containment is currently active.
+    ///
+    /// If mode is enabled but no backend is available, this returns false
+    /// because subprocesses fall back to passthrough execution.
+    pub fn containment_active(&self) -> bool {
+        self.mode_enabled() && !matches!(self.backend, SandboxBackend::None)
+    }
+
+    /// Read-allowlisted filesystem paths exposed to shell/exec subprocesses when
+    /// containment is active.
+    pub fn prompt_read_allowlist(&self) -> Vec<String> {
+        if !self.containment_active() {
+            return Vec::new();
+        }
+
+        let config = self.config.load();
+        let mut paths = Vec::new();
+
+        match self.backend {
+            SandboxBackend::Bubblewrap { .. } => {
+                for system_path in LINUX_READ_ONLY_SYSTEM_PATHS {
+                    let path = Path::new(system_path);
+                    if path.exists() {
+                        push_unique_path(&mut paths, canonicalize_or_self(path));
+                    }
+                }
+
+                if self.tools_bin.exists() {
+                    push_unique_path(&mut paths, canonicalize_or_self(&self.tools_bin));
+                }
+
+                push_unique_path(&mut paths, canonicalize_or_self(&self.workspace));
+
+                for path in &config.writable_paths {
+                    if let Ok(canonical) = path.canonicalize() {
+                        push_unique_path(&mut paths, canonical);
+                    }
+                }
+            }
+            SandboxBackend::SandboxExec => {
+                for system_path in MACOS_READ_ONLY_SYSTEM_PATHS {
+                    let path = Path::new(system_path);
+                    if path.exists() {
+                        push_unique_path(&mut paths, canonicalize_or_self(path));
+                    }
+                }
+
+                if self.tools_bin.exists() {
+                    push_unique_path(&mut paths, canonicalize_or_self(&self.tools_bin));
+                }
+
+                push_unique_path(&mut paths, canonicalize_or_self(&self.workspace));
+
+                for path in &config.writable_paths {
+                    push_unique_path(&mut paths, canonicalize_or_self(path));
+                }
+            }
+            SandboxBackend::None => {}
+        }
+
+        paths
+    }
+
+    /// Write-allowlisted filesystem paths exposed to shell/exec subprocesses when
+    /// containment is active.
+    pub fn prompt_write_allowlist(&self) -> Vec<String> {
+        if !self.containment_active() {
+            return Vec::new();
+        }
+
+        let config = self.config.load();
+        let mut paths = Vec::new();
+
+        push_unique_path(&mut paths, canonicalize_or_self(&self.workspace));
+        push_unique_path(&mut paths, canonicalize_or_self(Path::new("/tmp")));
+
+        match self.backend {
+            SandboxBackend::Bubblewrap { .. } => {
+                for path in &config.writable_paths {
+                    if let Ok(canonical) = path.canonicalize() {
+                        push_unique_path(&mut paths, canonical);
+                    }
+                }
+            }
+            SandboxBackend::SandboxExec => {
+                for path in &config.writable_paths {
+                    push_unique_path(&mut paths, canonicalize_or_self(path));
+                }
+            }
+            SandboxBackend::None => {}
+        }
+
+        paths
+    }
+
     /// Wrap a command for sandboxed execution.
     ///
     /// Returns a `Command` ready to spawn, potentially prefixed with bwrap or
     /// sandbox-exec depending on the detected backend. The caller still needs
     /// to set stdout/stderr/timeout after this call.
+    ///
+    /// Reads the current `SandboxMode` from the shared `ArcSwap<SandboxConfig>`
+    /// on every call, so changes via the API take effect immediately.
     pub fn wrap(&self, program: &str, args: &[&str], working_dir: &Path) -> Command {
+        let config = self.config.load();
+
         // Prepend tools/bin to PATH for all commands
         let path_env = match std::env::var_os("PATH") {
             Some(current) => {
@@ -148,18 +341,51 @@ impl Sandbox {
             None => self.tools_bin.to_string_lossy().into_owned(),
         };
 
+        // Read tool secrets once for injection into the subprocess.
+        let tool_secrets = self.tool_secrets();
+
+        if config.mode == SandboxMode::Disabled {
+            return self.wrap_passthrough(
+                program,
+                args,
+                working_dir,
+                &path_env,
+                &config,
+                &tool_secrets,
+            );
+        }
+
         match self.backend {
-            SandboxBackend::Bubblewrap { proc_supported } => {
-                self.wrap_bubblewrap(program, args, working_dir, proc_supported, &path_env)
-            }
-            SandboxBackend::SandboxExec => {
-                self.wrap_sandbox_exec(program, args, working_dir, &path_env)
-            }
-            SandboxBackend::None => self.wrap_passthrough(program, args, working_dir, &path_env),
+            SandboxBackend::Bubblewrap { proc_supported } => self.wrap_bubblewrap(
+                program,
+                args,
+                working_dir,
+                proc_supported,
+                &path_env,
+                &config,
+                &tool_secrets,
+            ),
+            SandboxBackend::SandboxExec => self.wrap_sandbox_exec(
+                program,
+                args,
+                working_dir,
+                &path_env,
+                &config,
+                &tool_secrets,
+            ),
+            SandboxBackend::None => self.wrap_passthrough(
+                program,
+                args,
+                working_dir,
+                &path_env,
+                &config,
+                &tool_secrets,
+            ),
         }
     }
 
     /// Linux: wrap with bubblewrap mount namespace.
+    #[allow(clippy::too_many_arguments)]
     fn wrap_bubblewrap(
         &self,
         program: &str,
@@ -167,12 +393,26 @@ impl Sandbox {
         working_dir: &Path,
         proc_supported: bool,
         path_env: &str,
+        config: &SandboxConfig,
+        tool_secrets: &HashMap<String, String>,
     ) -> Command {
         let mut cmd = Command::new("bwrap");
 
         // Mount order matters — later mounts override earlier ones.
-        // 1. Entire filesystem read-only
-        cmd.arg("--ro-bind").arg("/").arg("/");
+        // 1. Mount a minimal read-only runtime allowlist.
+        for system_path in LINUX_READ_ONLY_SYSTEM_PATHS {
+            let path = Path::new(system_path);
+            if path.exists() {
+                cmd.arg("--ro-bind").arg(path).arg(path);
+            }
+        }
+
+        // Keep persistent tools visible on PATH if present.
+        if self.tools_bin.exists() {
+            cmd.arg("--ro-bind")
+                .arg(&self.tools_bin)
+                .arg(&self.tools_bin);
+        }
 
         // 2. Writable /dev with standard nodes
         cmd.arg("--dev").arg("/dev");
@@ -188,26 +428,91 @@ impl Sandbox {
         // 5. Workspace writable
         cmd.arg("--bind").arg(&self.workspace).arg(&self.workspace);
 
-        // 6. Each configured writable path
-        for writable in &self.writable_paths {
-            cmd.arg("--bind").arg(writable).arg(writable);
+        // 6. Each configured writable path (canonicalized dynamically)
+        for path in &config.writable_paths {
+            match path.canonicalize() {
+                Ok(canonical) => {
+                    cmd.arg("--bind").arg(&canonical).arg(&canonical);
+                }
+                Err(error) => {
+                    tracing::debug!(
+                        path = %path.display(),
+                        %error,
+                        "skipping writable_path (does not exist or is unresolvable)"
+                    );
+                }
+            }
         }
 
-        // 7. Re-protect agent data dir (may overlap with workspace parent)
-        cmd.arg("--ro-bind").arg(&self.data_dir).arg(&self.data_dir);
+        // 7. Mask agent data dir with an empty tmpfs to prevent reads/writes,
+        // even when it overlaps with workspace-related paths.
+        cmd.arg("--tmpfs").arg(&self.data_dir);
 
         // 8. Isolation flags
         cmd.arg("--unshare-pid");
         cmd.arg("--new-session");
         cmd.arg("--die-with-parent");
 
-        // 9. Working directory
+        // 9. Clear all inherited environment variables. Workers must not see
+        // system secrets (LLM API keys, messaging tokens) or SPACEBOT_* internals.
+        cmd.arg("--clearenv");
+
+        // 10. Working directory
         cmd.arg("--chdir").arg(working_dir);
 
-        // 10. Set PATH inside the sandbox
+        // 11. Set PATH inside the sandbox
         cmd.arg("--setenv").arg("PATH").arg(path_env);
 
-        // 11. The actual command
+        // 12. Set deterministic sandbox-local home/temp paths.
+        cmd.arg("--setenv")
+            .arg("HOME")
+            .arg(self.workspace.to_string_lossy().into_owned());
+        cmd.arg("--setenv").arg("TMPDIR").arg("/tmp");
+
+        // 13. Re-inject safe environment variables for basic process operation
+        for var_name in SAFE_ENV_VARS {
+            if let Ok(value) = std::env::var(var_name) {
+                cmd.arg("--setenv").arg(var_name).arg(value);
+            }
+        }
+
+        // 13. Re-inject tool secrets from the secret store.
+        // Only tool-category secrets are injected; system secrets (LLM API keys,
+        // messaging tokens) never enter subprocess environments.
+        for (name, value) in tool_secrets {
+            if is_reserved_env_var(name) {
+                tracing::debug!(%name, "skipping reserved tool secret name");
+                continue;
+            }
+            cmd.arg("--setenv").arg(name).arg(value);
+        }
+
+        // 14. Re-inject passthrough env vars (user-configured forwarding),
+        // skipping any that would override hardened defaults.
+        for var_name in &config.passthrough_env {
+            if is_reserved_env_var(var_name) {
+                tracing::debug!(%var_name, "skipping reserved passthrough_env variable");
+                continue;
+            }
+            if let Ok(value) = std::env::var(var_name) {
+                cmd.arg("--setenv").arg(var_name).arg(value);
+            }
+        }
+
+        // 15. Worker keyring isolation (Linux) — give the child a fresh empty
+        // session keyring so it cannot access the parent's keyring (which holds
+        // the master key for secret store encryption).
+        #[cfg(target_os = "linux")]
+        {
+            // pre_exec runs between fork and exec. If it fails, spawn() fails
+            // and the worker is not started (correct — a worker that inherits
+            // the parent's session keyring could access the master key).
+            unsafe {
+                cmd.pre_exec(|| crate::secrets::keystore::pre_exec_new_session_keyring());
+            }
+        }
+
+        // 16. The actual command
         cmd.arg("--").arg(program);
         for arg in args {
             cmd.arg(arg);
@@ -223,8 +528,10 @@ impl Sandbox {
         args: &[&str],
         working_dir: &Path,
         path_env: &str,
+        config: &SandboxConfig,
+        tool_secrets: &HashMap<String, String>,
     ) -> Command {
-        let profile = self.generate_sbpl_profile();
+        let profile = self.generate_sbpl_profile(config);
 
         let mut cmd = Command::new("/usr/bin/sandbox-exec");
         cmd.arg("-p").arg(profile);
@@ -233,25 +540,99 @@ impl Sandbox {
             cmd.arg(arg);
         }
         cmd.current_dir(working_dir);
+
+        // Clear all inherited environment variables, then re-inject only
+        // approved vars. Prevents system secrets from leaking to workers.
+        cmd.env_clear();
         cmd.env("PATH", path_env);
+        cmd.env("HOME", &self.workspace);
+        cmd.env("TMPDIR", "/tmp");
+        for var_name in SAFE_ENV_VARS {
+            if let Ok(value) = std::env::var(var_name) {
+                cmd.env(var_name, value);
+            }
+        }
+        // Inject tool secrets from the secret store.
+        for (name, value) in tool_secrets {
+            if is_reserved_env_var(name) {
+                tracing::debug!(%name, "skipping reserved tool secret name");
+                continue;
+            }
+            cmd.env(name, value);
+        }
+        for var_name in &config.passthrough_env {
+            if is_reserved_env_var(var_name) {
+                tracing::debug!(%var_name, "skipping reserved passthrough_env variable");
+                continue;
+            }
+            if let Ok(value) = std::env::var(var_name) {
+                cmd.env(var_name, value);
+            }
+        }
 
         cmd
     }
 
-    /// No backend: pass through unchanged.
+    /// No backend: pass through without OS-level containment.
+    ///
+    /// Still applies environment sanitization — workers never inherit the full
+    /// parent environment regardless of sandbox state.
     fn wrap_passthrough(
         &self,
         program: &str,
         args: &[&str],
         working_dir: &Path,
         path_env: &str,
+        config: &SandboxConfig,
+        tool_secrets: &HashMap<String, String>,
     ) -> Command {
         let mut cmd = Command::new(program);
         for arg in args {
             cmd.arg(arg);
         }
         cmd.current_dir(working_dir);
+
+        let home_dir = std::env::var_os("HOME")
+            .filter(|value| !value.is_empty())
+            .unwrap_or_else(|| self.workspace.as_os_str().to_os_string());
+
+        // Clear all inherited environment variables, then re-inject only
+        // approved vars. Prevents system secrets from leaking to workers.
+        cmd.env_clear();
         cmd.env("PATH", path_env);
+        cmd.env("HOME", home_dir);
+        cmd.env("TMPDIR", "/tmp");
+        for var_name in SAFE_ENV_VARS {
+            if let Ok(value) = std::env::var(var_name) {
+                cmd.env(var_name, value);
+            }
+        }
+        // Inject tool secrets from the secret store.
+        for (name, value) in tool_secrets {
+            if is_reserved_env_var(name) {
+                tracing::debug!(%name, "skipping reserved tool secret name");
+                continue;
+            }
+            cmd.env(name, value);
+        }
+        for var_name in &config.passthrough_env {
+            if is_reserved_env_var(var_name) {
+                tracing::debug!(%var_name, "skipping reserved passthrough_env variable");
+                continue;
+            }
+            if let Ok(value) = std::env::var(var_name) {
+                cmd.env(var_name, value);
+            }
+        }
+
+        // Worker keyring isolation (Linux) — give the child a fresh empty
+        // session keyring even in passthrough (no sandbox) mode.
+        #[cfg(target_os = "linux")]
+        {
+            unsafe {
+                cmd.pre_exec(|| crate::secrets::keystore::pre_exec_new_session_keyring());
+            }
+        }
 
         cmd
     }
@@ -259,8 +640,9 @@ impl Sandbox {
     /// Generate a macOS SBPL (Sandbox Profile Language) policy.
     ///
     /// Paths are canonicalized because /var on macOS is actually /private/var.
-    fn generate_sbpl_profile(&self) -> String {
+    fn generate_sbpl_profile(&self, config: &SandboxConfig) -> String {
         let workspace = canonicalize_or_self(&self.workspace);
+        let tools_bin = canonicalize_or_self(&self.tools_bin);
 
         let mut profile = String::from(
             r#"(version 1)
@@ -271,40 +653,67 @@ impl Sandbox {
 (allow process-fork)
 (allow signal (target same-sandbox))
 (allow process-info* (target same-sandbox))
-
-; filesystem: read everything
-(allow file-read*)
-
 "#,
         );
 
-        // Workspace writable
+        profile.push_str("\n; filesystem: read allowlist (system roots + workspace)\n");
+        // Allow access to the root directory entry itself so macOS can traverse
+        // into explicitly-allowed subpaths without granting recursive read access.
+        profile.push_str("(allow file-read* (literal \"/\"))\n");
+        for system_path in MACOS_READ_ONLY_SYSTEM_PATHS {
+            let path = Path::new(system_path);
+            if path.exists() {
+                let canonical = canonicalize_or_self(path);
+                profile.push_str(&format!(
+                    "(allow file-read* (subpath \"{}\"))\n",
+                    escape_sbpl_path(&canonical)
+                ));
+            }
+        }
+
         profile.push_str(&format!(
-            "; workspace writable\n(allow file-write* (subpath \"{}\"))\n\n",
-            workspace.display()
+            "(allow file-read* (subpath \"{}\"))\n",
+            escape_sbpl_path(&workspace)
         ));
 
-        // Additional writable paths
-        for (index, writable) in self.writable_paths.iter().enumerate() {
-            let canonical = canonicalize_or_self(writable);
+        if self.tools_bin.exists() {
             profile.push_str(&format!(
-                "; writable path {index}\n(allow file-write* (subpath \"{}\"))\n",
-                canonical.display()
+                "(allow file-read* (subpath \"{}\"))\n",
+                escape_sbpl_path(&tools_bin)
             ));
         }
 
-        // Protect data_dir even if it falls under the workspace subtree
-        let data_dir = canonicalize_or_self(&self.data_dir);
+        profile.push('\n');
+
+        // Workspace writable
         profile.push_str(&format!(
-            "\n; data dir read-only\n(deny file-write* (subpath \"{}\"))\n",
-            data_dir.display()
+            "; workspace writable\n(allow file-write* (subpath \"{}\"))\n\n",
+            escape_sbpl_path(&workspace)
         ));
 
+        // Additional writable paths (canonicalized dynamically) are readable and writable.
+        for (index, path) in config.writable_paths.iter().enumerate() {
+            let canonical = canonicalize_or_self(path);
+            profile.push_str(&format!(
+                "; writable path {index}\n(allow file-read* (subpath \"{}\"))\n(allow file-write* (subpath \"{}\"))\n",
+                escape_sbpl_path(&canonical),
+                escape_sbpl_path(&canonical)
+            ));
+        }
+
         // /tmp writable
         let tmp = canonicalize_or_self(Path::new("/tmp"));
         profile.push_str(&format!(
             "\n; tmp writable\n(allow file-write* (subpath \"{}\"))\n",
-            tmp.display()
+            escape_sbpl_path(&tmp)
+        ));
+
+        // Protect data_dir even if it falls under the workspace subtree
+        let data_dir = canonicalize_or_self(&self.data_dir);
+        profile.push_str(&format!(
+            "\n; data dir blocked\n(deny file-read* (subpath \"{}\"))\n(deny file-write* (subpath \"{}\"))\n",
+            escape_sbpl_path(&data_dir),
+            escape_sbpl_path(&data_dir)
         ));
 
         profile.push_str(
@@ -314,7 +723,8 @@ impl Sandbox {
   (require-all (path "/dev/null") (vnode-type CHARACTER-DEVICE)))
 (allow sysctl-read)
 (allow mach-lookup
-  (global-name "com.apple.system.opendirectoryd.libinfo"))
+  (global-name "com.apple.system.opendirectoryd.libinfo")
+  (global-name "com.apple.trustd"))
 (allow ipc-posix-sem)
 (allow pseudo-tty)
 (allow network*)
@@ -323,6 +733,34 @@ impl Sandbox {
 
         profile
     }
+
+    /// Create a minimal sandbox for unit tests without probing for backends.
+    #[cfg(test)]
+    pub fn new_for_test(config: Arc<ArcSwap<SandboxConfig>>, workspace: PathBuf) -> Self {
+        Self {
+            config,
+            workspace,
+            data_dir: PathBuf::new(),
+            tools_bin: PathBuf::new(),
+            backend: SandboxBackend::None,
+            secrets_store: ArcSwap::from_pointee(None),
+        }
+    }
+}
+
+/// Push a path into a list while preserving order and removing duplicates.
+fn push_unique_path(paths: &mut Vec<String>, path: PathBuf) {
+    let value = path.display().to_string();
+    if !paths.contains(&value) {
+        paths.push(value);
+    }
+}
+
+/// Escape a path for embedding in an SBPL string literal.
+fn escape_sbpl_path(path: &Path) -> String {
+    path.to_string_lossy()
+        .replace('\\', "\\\\")
+        .replace('"', "\\\"")
 }
 
 /// Canonicalize a path, falling back to the original if canonicalization fails.
diff --git a/src/secrets.rs b/src/secrets.rs
index 0d671701d..c24bb26be 100644
--- a/src/secrets.rs
+++ b/src/secrets.rs
@@ -1,3 +1,5 @@
-//! Encrypted secrets storage.
+//! Credential storage, output protection, and OS keystore integration.
 
+pub mod keystore;
+pub mod scrub;
 pub mod store;
diff --git a/src/secrets/keystore.rs b/src/secrets/keystore.rs
new file mode 100644
index 000000000..66f5d0867
--- /dev/null
+++ b/src/secrets/keystore.rs
@@ -0,0 +1,382 @@
+//! OS credential store abstraction for master key storage.
+//!
+//! The master key never exists as an environment variable or a file on disk.
+//! It lives in kernel-level credential storage that is inaccessible to worker
+//! subprocesses regardless of sandbox state.
+//!
+//! - **macOS:** Keychain via the Security framework. Access controlled by code
+//!   signature — worker subprocesses (bash, python, etc.) are different binaries
+//!   and cannot retrieve the key.
+//! - **Linux:** Kernel keyring via `keyctl`. The key lives in kernel memory,
+//!   scoped to a session keyring. Workers are spawned with a fresh empty session
+//!   keyring via `pre_exec`.
+
+use crate::error::SecretsError;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+/// Service name used for Keychain/keyring identification.
+const SERVICE_NAME: &str = "sh.spacebot.master-key";
+
+/// Whether the kernel keyring `keyctl` syscall is available on this system.
+/// Set once at startup by `probe_keyring_support()`. When `false`, the
+/// `pre_exec_new_session_keyring` hook is a no-op so workers always start.
+static KEYRING_ISOLATION_AVAILABLE: AtomicBool = AtomicBool::new(false);
+
+/// Trait for OS-level credential storage.
+///
+/// Implementations must be Send + Sync for use in async contexts.
+pub trait KeyStore: Send + Sync {
+    /// Store the master key for the given instance.
+    fn store_key(&self, instance_id: &str, key: &[u8]) -> Result<(), SecretsError>;
+
+    /// Retrieve the master key for the given instance.
+    fn load_key(&self, instance_id: &str) -> Result<Option<Vec<u8>>, SecretsError>;
+
+    /// Remove the master key from the credential store.
+    fn delete_key(&self, instance_id: &str) -> Result<(), SecretsError>;
+}
+
+/// Create the platform-appropriate keystore.
+pub fn platform_keystore() -> Box<dyn KeyStore> {
+    #[cfg(target_os = "macos")]
+    {
+        Box::new(MacOSKeyStore)
+    }
+    #[cfg(target_os = "linux")]
+    {
+        Box::new(LinuxKeyStore)
+    }
+    #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+    {
+        tracing::warn!("no OS keystore available on this platform — master key storage disabled");
+        Box::new(NoopKeyStore)
+    }
+}
+
+#[cfg(target_os = "macos")]
+pub struct MacOSKeyStore;
+
+#[cfg(target_os = "macos")]
+impl KeyStore for MacOSKeyStore {
+    fn store_key(&self, instance_id: &str, key: &[u8]) -> Result<(), SecretsError> {
+        use security_framework::passwords::{delete_generic_password, set_generic_password};
+
+        // Delete any existing entry first (set_generic_password fails on duplicate).
+        let _ = delete_generic_password(SERVICE_NAME, instance_id);
+
+        set_generic_password(SERVICE_NAME, instance_id, key)
+            .map_err(|error| SecretsError::Other(anyhow::anyhow!("keychain store failed: {error}")))
+    }
+
+    fn load_key(&self, instance_id: &str) -> Result<Option<Vec<u8>>, SecretsError> {
+        use security_framework::passwords::get_generic_password;
+
+        match get_generic_password(SERVICE_NAME, instance_id) {
+            Ok(data) => Ok(Some(data.to_vec())),
+            Err(error) => {
+                // errSecItemNotFound means no key stored — not an error.
+                let code = error.code();
+                if code == -25300 {
+                    // errSecItemNotFound
+                    Ok(None)
+                } else {
+                    Err(SecretsError::Other(anyhow::anyhow!(
+                        "keychain load failed: {error}"
+                    )))
+                }
+            }
+        }
+    }
+
+    fn delete_key(&self, instance_id: &str) -> Result<(), SecretsError> {
+        use security_framework::passwords::delete_generic_password;
+
+        match delete_generic_password(SERVICE_NAME, instance_id) {
+            Ok(()) => Ok(()),
+            Err(error) => {
+                let code = error.code();
+                if code == -25300 {
+                    Ok(()) // Already gone
+                } else {
+                    Err(SecretsError::Other(anyhow::anyhow!(
+                        "keychain delete failed: {error}"
+                    )))
+                }
+            }
+        }
+    }
+}
+
+#[cfg(target_os = "linux")]
+use std::ffi::CString;
+
+#[cfg(target_os = "linux")]
+pub struct LinuxKeyStore;
+
+#[cfg(target_os = "linux")]
+impl KeyStore for LinuxKeyStore {
+    fn store_key(&self, instance_id: &str, key: &[u8]) -> Result<(), SecretsError> {
+        let description =
+            CString::new(format!("{SERVICE_NAME}:{instance_id}")).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("invalid key description: {error}"))
+            })?;
+
+        // Get the session keyring.
+        let session_keyring = unsafe {
+            libc::syscall(
+                libc::SYS_keyctl,
+                0x00_i64, // KEYCTL_GET_KEYRING_ID
+                -3_i64,   // KEY_SPEC_SESSION_KEYRING
+                0_i64,    // don't create
+            )
+        };
+        if session_keyring < 0 {
+            return Err(SecretsError::Other(anyhow::anyhow!(
+                "failed to get session keyring: {}",
+                std::io::Error::last_os_error()
+            )));
+        }
+
+        // Add the key. If it already exists with the same description,
+        // this replaces it (add_key with same type+description = update).
+        let result = unsafe {
+            libc::syscall(
+                libc::SYS_add_key,
+                c"user".as_ptr(),
+                description.as_ptr(),
+                key.as_ptr(),
+                key.len(),
+                session_keyring,
+            )
+        };
+        if result < 0 {
+            return Err(SecretsError::Other(anyhow::anyhow!(
+                "keyctl add_key failed: {}",
+                std::io::Error::last_os_error()
+            )));
+        }
+
+        Ok(())
+    }
+
+    fn load_key(&self, instance_id: &str) -> Result<Option<Vec<u8>>, SecretsError> {
+        let description =
+            CString::new(format!("{SERVICE_NAME}:{instance_id}")).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("invalid key description: {error}"))
+            })?;
+
+        // Search the session keyring for a "user" type key with our description.
+        let key_id = unsafe {
+            libc::syscall(
+                libc::SYS_keyctl,
+                0x0a_i64, // KEYCTL_SEARCH
+                -3_i64,   // KEY_SPEC_SESSION_KEYRING
+                c"user".as_ptr(),
+                description.as_ptr(),
+                0_i64, // don't link to a destination keyring
+            )
+        };
+        if key_id < 0 {
+            let error = std::io::Error::last_os_error();
+            if error.raw_os_error() == Some(libc::ENOKEY) {
+                return Ok(None);
+            }
+            return Err(SecretsError::Other(anyhow::anyhow!(
+                "keyctl search failed: {error}"
+            )));
+        }
+
+        // Read the key payload.
+        // First call with null buffer to get the size.
+        let size = unsafe {
+            libc::syscall(
+                libc::SYS_keyctl,
+                0x0b_i64, // KEYCTL_READ
+                key_id,
+                std::ptr::null::<u8>(),
+                0_usize,
+            )
+        };
+        if size < 0 {
+            return Err(SecretsError::Other(anyhow::anyhow!(
+                "keyctl read (size) failed: {}",
+                std::io::Error::last_os_error()
+            )));
+        }
+
+        let mut buffer = vec![0u8; size as usize];
+        let read = unsafe {
+            libc::syscall(
+                libc::SYS_keyctl,
+                0x0b_i64, // KEYCTL_READ
+                key_id,
+                buffer.as_mut_ptr(),
+                buffer.len(),
+            )
+        };
+        if read < 0 {
+            return Err(SecretsError::Other(anyhow::anyhow!(
+                "keyctl read failed: {}",
+                std::io::Error::last_os_error()
+            )));
+        }
+
+        buffer.truncate(read as usize);
+        Ok(Some(buffer))
+    }
+
+    fn delete_key(&self, instance_id: &str) -> Result<(), SecretsError> {
+        let description =
+            CString::new(format!("{SERVICE_NAME}:{instance_id}")).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("invalid key description: {error}"))
+            })?;
+
+        // Find the key first.
+        let key_id = unsafe {
+            libc::syscall(
+                libc::SYS_keyctl,
+                0x0a_i64, // KEYCTL_SEARCH
+                -3_i64,   // KEY_SPEC_SESSION_KEYRING
+                c"user".as_ptr(),
+                description.as_ptr(),
+                0_i64,
+            )
+        };
+        if key_id < 0 {
+            let error = std::io::Error::last_os_error();
+            if error.raw_os_error() == Some(libc::ENOKEY) {
+                // Not found — already deleted.
+                return Ok(());
+            }
+            return Err(SecretsError::Other(anyhow::anyhow!(
+                "keyctl search failed: {error}"
+            )));
+        }
+
+        // Invalidate the key.
+        let result = unsafe {
+            libc::syscall(
+                libc::SYS_keyctl,
+                0x15_i64, // KEYCTL_INVALIDATE
+                key_id,
+            )
+        };
+        if result < 0 {
+            // KEYCTL_INVALIDATE may not be available on older kernels.
+            // Fall back to KEYCTL_REVOKE.
+            let revoke = unsafe {
+                libc::syscall(
+                    libc::SYS_keyctl,
+                    0x03_i64, // KEYCTL_REVOKE
+                    key_id,
+                )
+            };
+            if revoke < 0 {
+                return Err(SecretsError::Other(anyhow::anyhow!(
+                    "keyctl revoke failed: {}",
+                    std::io::Error::last_os_error()
+                )));
+            }
+        }
+
+        Ok(())
+    }
+}
+
+/// Probe whether the `keyctl` syscall is available on this system.
+///
+/// Call once at startup. Tests `KEYCTL_GET_KEYRING_ID` on the session keyring
+/// — a read-only, side-effect-free operation. If it succeeds, worker keyring
+/// isolation is enabled. If it fails (restrictive seccomp, gVisor, etc.),
+/// workers will still start but without keyring isolation.
+#[cfg(target_os = "linux")]
+pub fn probe_keyring_support() {
+    let result = unsafe {
+        libc::syscall(
+            libc::SYS_keyctl,
+            0x00_i64, // KEYCTL_GET_KEYRING_ID
+            -3_i64,   // KEY_SPEC_SESSION_KEYRING
+            0_i64,    // don't create
+        )
+    };
+    if result >= 0 {
+        KEYRING_ISOLATION_AVAILABLE.store(true, Ordering::Release);
+        tracing::debug!("kernel keyring available — worker keyring isolation enabled");
+    } else {
+        let error = std::io::Error::last_os_error();
+        tracing::warn!(
+            %error,
+            "kernel keyring unavailable — worker keyring isolation disabled \
+             (keyctl blocked by seccomp or unsupported kernel)"
+        );
+    }
+}
+
+/// No-op on non-Linux — keyring isolation is a Linux-only feature.
+#[cfg(not(target_os = "linux"))]
+pub fn probe_keyring_support() {}
+
+/// Whether worker keyring isolation is available (set by `probe_keyring_support`).
+pub fn keyring_isolation_available() -> bool {
+    KEYRING_ISOLATION_AVAILABLE.load(Ordering::Acquire)
+}
+
+/// Spawn a worker subprocess with a fresh empty session keyring (Linux only).
+///
+/// Must be called via `Command::pre_exec()` before `spawn()`. The child gets
+/// a new session keyring and cannot access the parent's keyring (which holds
+/// the master key).
+///
+/// Returns `Ok(())` immediately if keyring isolation is unavailable (probed
+/// at startup). Workers always start — keyring isolation is defense-in-depth,
+/// not a hard requirement.
+///
+/// # Safety
+///
+/// This function is intended to be called from `pre_exec` which runs between
+/// fork and exec — only async-signal-safe operations are permitted. `keyctl`
+/// is a direct syscall and is safe in this context.
+#[cfg(target_os = "linux")]
+pub unsafe fn pre_exec_new_session_keyring() -> std::io::Result<()> {
+    if !KEYRING_ISOLATION_AVAILABLE.load(Ordering::Acquire) {
+        return Ok(());
+    }
+
+    // KEYCTL_JOIN_SESSION_KEYRING with NULL name creates a new anonymous
+    // session keyring for this process.
+    // SAFETY: `libc::syscall` is a direct syscall wrapper. We pass valid
+    // constants and a null pointer (requesting a new anonymous keyring).
+    // This runs in a pre_exec context where only async-signal-safe ops are
+    // permitted — `keyctl` is a direct syscall and qualifies.
+    let result = unsafe {
+        libc::syscall(
+            libc::SYS_keyctl,
+            0x01_i64, // KEYCTL_JOIN_SESSION_KEYRING
+            std::ptr::null::<libc::c_char>(),
+        )
+    };
+    if result < 0 {
+        return Err(std::io::Error::last_os_error());
+    }
+    Ok(())
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "linux")))]
+struct NoopKeyStore;
+
+#[cfg(not(any(target_os = "macos", target_os = "linux")))]
+impl KeyStore for NoopKeyStore {
+    fn store_key(&self, _instance_id: &str, _key: &[u8]) -> Result<(), SecretsError> {
+        Err(SecretsError::Other(anyhow::anyhow!(
+            "no OS keystore available on this platform"
+        )))
+    }
+
+    fn load_key(&self, _instance_id: &str) -> Result<Option<Vec<u8>>, SecretsError> {
+        Ok(None)
+    }
+
+    fn delete_key(&self, _instance_id: &str) -> Result<(), SecretsError> {
+        Ok(())
+    }
+}
diff --git a/src/secrets/scrub.rs b/src/secrets/scrub.rs
new file mode 100644
index 000000000..3ffc354a3
--- /dev/null
+++ b/src/secrets/scrub.rs
@@ -0,0 +1,383 @@
+//! Output scrubbing and leak detection for streaming content.
+//!
+//! Two complementary layers:
+//! 1. **`StreamScrubber`** — exact-match redaction of known secret values.
+//!    Proactive: replaces tool secret values with `[REDACTED:<name>]` before
+//!    content leaves the process.
+//! 2. **`scan_for_leaks()`** — regex-based leak detection for unknown secrets.
+//!    Reactive: catches secrets not in the store by matching known API key formats.
+//!
+//! Sequencing: scrubbing runs first, then leak detection on the scrubbed output.
+//! This ensures stored tool secrets don't trigger leak detection (they're already
+//! redacted), and leak detection only fires on unknown/unstored secrets.
+
+use regex::Regex;
+use std::sync::LazyLock;
+
+/// Regex patterns for known API key formats. Used by `scan_for_leaks()` to
+/// detect secrets that aren't in the store.
+static LEAK_PATTERNS: LazyLock<Vec<Regex>> = LazyLock::new(|| {
+    vec![
+        Regex::new(r"sk-[a-zA-Z0-9]{20,}").expect("hardcoded regex"),
+        Regex::new(r"sk-ant-[a-zA-Z0-9_-]{20,}").expect("hardcoded regex"),
+        Regex::new(r"sk-or-[a-zA-Z0-9_-]{20,}").expect("hardcoded regex"),
+        Regex::new(r"-----BEGIN.*PRIVATE KEY-----").expect("hardcoded regex"),
+        Regex::new(r"ghp_[a-zA-Z0-9]{36}").expect("hardcoded regex"),
+        Regex::new(r"AIza[0-9A-Za-z_-]{35}").expect("hardcoded regex"),
+        Regex::new(r"[MN][A-Za-z0-9]{23,}\.[A-Za-z0-9_-]{6}\.[A-Za-z0-9_-]{27,}")
+            .expect("hardcoded regex"),
+        Regex::new(r"xoxb-[0-9]{10,}-[0-9A-Za-z-]+").expect("hardcoded regex"),
+        Regex::new(r"xapp-[0-9]-[A-Z0-9]+-[0-9]+-[a-f0-9]+").expect("hardcoded regex"),
+        Regex::new(r"\d{8,}:[A-Za-z0-9_-]{35}").expect("hardcoded regex"),
+        Regex::new(r"BSA[a-zA-Z0-9]{20,}").expect("hardcoded regex"),
+    ]
+});
+
+/// Full PEM block pattern (header + base64 body + footer). Used by `scrub_leaks()`
+/// to redact entire private key blocks, not just the header line matched by
+/// `LEAK_PATTERNS`.
+static PEM_BLOCK: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"(?s)-----BEGIN[A-Z \r\n]*PRIVATE KEY-----.*?-----END[A-Z \r\n]*PRIVATE KEY-----")
+        .expect("hardcoded regex")
+});
+
+static BASE64_SEGMENT: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"[A-Za-z0-9+/]{24,}={0,2}").expect("hardcoded regex"));
+
+static HEX_SEGMENT: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"(?i)(?:0x)?([0-9a-f]{40,})").expect("hardcoded regex"));
+
+/// Check content against known API key patterns (plaintext only).
+pub fn match_leak_patterns(content: &str) -> Option<String> {
+    for pattern in LEAK_PATTERNS.iter() {
+        if let Some(matched) = pattern.find(content) {
+            return Some(matched.as_str().to_string());
+        }
+    }
+    None
+}
+
+/// Scan content for potential secret leaks, including encoded forms.
+///
+/// Checks raw content first, then attempts URL-decoding, base64-decoding,
+/// and hex-decoding to catch secrets that an LLM might encode to evade
+/// plaintext pattern matching.
+pub fn scan_for_leaks(content: &str) -> Option<String> {
+    use base64::Engine;
+
+    if let Some(matched) = match_leak_patterns(content) {
+        return Some(matched);
+    }
+
+    // Percent-encoded secrets (e.g. sk%2Dant%2D...)
+    let url_decoded = urlencoding::decode(content).unwrap_or(std::borrow::Cow::Borrowed(""));
+    if url_decoded != content
+        && let Some(matched) = match_leak_patterns(&url_decoded)
+    {
+        return Some(format!("url-encoded: {matched}"));
+    }
+
+    // Base64-wrapped secrets
+    for segment in BASE64_SEGMENT.find_iter(content) {
+        if let Ok(decoded_bytes) =
+            base64::engine::general_purpose::STANDARD.decode(segment.as_str())
+            && let Ok(decoded) = std::str::from_utf8(&decoded_bytes)
+            && let Some(matched) = match_leak_patterns(decoded)
+        {
+            return Some(format!("base64-encoded: {matched}"));
+        }
+        if let Ok(decoded_bytes) =
+            base64::engine::general_purpose::URL_SAFE.decode(segment.as_str())
+            && let Ok(decoded) = std::str::from_utf8(&decoded_bytes)
+            && let Some(matched) = match_leak_patterns(decoded)
+        {
+            return Some(format!("base64-encoded: {matched}"));
+        }
+    }
+
+    // Hex-encoded secrets
+    for caps in HEX_SEGMENT.captures_iter(content) {
+        let hex_str = caps.get(1).map_or("", |m| m.as_str());
+        if let Ok(decoded_bytes) = hex::decode(hex_str)
+            && let Ok(decoded) = std::str::from_utf8(&decoded_bytes)
+            && let Some(matched) = match_leak_patterns(decoded)
+        {
+            return Some(format!("hex-encoded: {matched}"));
+        }
+    }
+
+    None
+}
+
+/// Exact-match stream scrubber for redacting known secret values in chunked output.
+///
+/// Handles the case where a secret value is split across SSE chunk boundaries
+/// by maintaining a rolling buffer of the last N characters (where N is the
+/// length of the longest secret value being scrubbed).
+pub struct StreamScrubber {
+    /// Secret name → value pairs for exact-match redaction.
+    secrets: Vec<(String, String)>,
+    /// Rolling tail buffer to catch secrets split across chunk boundaries.
+    /// Contains the last `max_secret_len` characters from the previous chunk.
+    tail: String,
+    /// Length of the longest secret value.
+    max_secret_len: usize,
+}
+
+impl StreamScrubber {
+    /// Create a new scrubber with the given secret name/value pairs.
+    pub fn new(secrets: Vec<(String, String)>) -> Self {
+        let max_secret_len = secrets
+            .iter()
+            .map(|(_, value)| value.len())
+            .max()
+            .unwrap_or(0);
+        Self {
+            secrets,
+            tail: String::new(),
+            max_secret_len,
+        }
+    }
+
+    /// Scrub a chunk of text, returning the sanitized output.
+    ///
+    /// Holds back the last `max_secret_len` characters of each chunk to handle
+    /// secrets that span chunk boundaries. The held-back portion is prepended
+    /// to the next chunk before scanning. Call `flush()` when the stream ends
+    /// to emit any remaining buffered content.
+    pub fn scrub(&mut self, chunk: &str) -> String {
+        if self.secrets.is_empty() {
+            return chunk.to_string();
+        }
+
+        // Combine the held-back tail from the previous chunk with the new chunk.
+        let combined = format!("{}{}", self.tail, chunk);
+
+        // Apply exact-match redaction on the combined text.
+        let mut scrubbed = combined;
+        for (name, value) in &self.secrets {
+            if !value.is_empty() {
+                scrubbed = scrubbed.replace(value, &format!("[REDACTED:{name}]"));
+            }
+        }
+
+        // Hold back the last max_secret_len chars to catch secrets that might
+        // be split at the next boundary. Emit everything before that.
+        if self.max_secret_len > 0 && scrubbed.len() > self.max_secret_len {
+            let mut split_at = scrubbed.len() - self.max_secret_len;
+            while split_at > 0 && !scrubbed.is_char_boundary(split_at) {
+                split_at -= 1;
+            }
+            self.tail = scrubbed[split_at..].to_string();
+            scrubbed[..split_at].to_string()
+        } else {
+            // The entire scrubbed text fits within the hold-back window.
+            // Buffer it all, emit nothing yet.
+            self.tail = scrubbed;
+            String::new()
+        }
+    }
+
+    /// Flush any remaining buffered content. Call this when the stream ends.
+    ///
+    /// Applies one final round of scrubbing on the remaining buffer.
+    pub fn flush(&mut self) -> String {
+        let tail = std::mem::take(&mut self.tail);
+        if tail.is_empty() {
+            return String::new();
+        }
+
+        // Final scrub pass on the remaining buffer.
+        let mut result = tail;
+        for (name, value) in &self.secrets {
+            if !value.is_empty() {
+                result = result.replace(value, &format!("[REDACTED:{name}]"));
+            }
+        }
+        result
+    }
+}
+
+/// Scrub all tool secret values from a text string in one pass.
+///
+/// Convenience wrapper over `StreamScrubber` for non-streaming content (worker
+/// results, branch conclusions, status text). Replaces each tool secret value
+/// with `[REDACTED:<name>]`.
+pub fn scrub_secrets(text: &str, tool_secrets: &[(String, String)]) -> String {
+    if tool_secrets.is_empty() {
+        return text.to_string();
+    }
+    // Sort by descending value length so longer secrets are replaced first.
+    // This prevents partial replacement when one secret value is a prefix of another.
+    let mut sorted: Vec<&(String, String)> = tool_secrets.iter().collect();
+    sorted.sort_by(|a, b| b.1.len().cmp(&a.1.len()));
+    let mut result = text.to_string();
+    for (name, value) in sorted {
+        if !value.is_empty() {
+            result = result.replace(value.as_str(), &format!("[REDACTED:{name}]"));
+        }
+    }
+    result
+}
+
+/// Scrub tool secret values from text using a `SecretsStore`.
+///
+/// Reads the current tool secrets from the store and performs exact-match
+/// redaction. For use in result paths where a `SecretsStore` reference is
+/// available.
+pub fn scrub_with_store(text: &str, store: &crate::secrets::store::SecretsStore) -> String {
+    let pairs = store.tool_secret_pairs();
+    scrub_secrets(text, &pairs)
+}
+
+/// Replace all detected leak patterns in `content` with a redaction marker.
+///
+/// Unlike `scan_for_leaks()` which returns the first match, this function
+/// replaces **all** plaintext matches of known API key patterns with
+/// `[LEAKED_SECRET_REDACTED]`. Used on egress paths (worker results, branch
+/// conclusions, status updates) to sanitize content that may contain secrets
+/// the LLM encountered during tool execution.
+///
+/// Does NOT check encoded forms (base64, hex, URL-encoded) — those are
+/// unlikely to appear in LLM-generated output text.
+pub fn scrub_leaks(content: &str) -> String {
+    // First, redact full PEM blocks (header + body + footer) so the base64
+    // key material is removed, not just the header line.
+    let mut result = PEM_BLOCK
+        .replace_all(content, "[LEAKED_SECRET_REDACTED]")
+        .into_owned();
+    for pattern in LEAK_PATTERNS.iter() {
+        result = pattern
+            .replace_all(&result, "[LEAKED_SECRET_REDACTED]")
+            .into_owned();
+    }
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn scrubber_redacts_exact_match() {
+        let mut scrubber =
+            StreamScrubber::new(vec![("API_KEY".to_string(), "secret123".to_string())]);
+        let part = scrubber.scrub("the key is secret123 here");
+        let rest = scrubber.flush();
+        let result = format!("{part}{rest}");
+        assert_eq!(result, "the key is [REDACTED:API_KEY] here");
+    }
+
+    #[test]
+    fn scrubber_handles_split_across_chunks() {
+        let mut scrubber = StreamScrubber::new(vec![("TOKEN".to_string(), "abcdef".to_string())]);
+        let part1 = scrubber.scrub("prefix abc");
+        let part2 = scrubber.scrub("def suffix");
+        let rest = scrubber.flush();
+        let combined = format!("{part1}{part2}{rest}");
+        assert!(
+            combined.contains("[REDACTED:TOKEN]"),
+            "expected redaction in: {combined}"
+        );
+        assert!(
+            !combined.contains("abcdef"),
+            "secret should not appear in: {combined}"
+        );
+    }
+
+    #[test]
+    fn scrubber_no_secrets_passes_through() {
+        let mut scrubber = StreamScrubber::new(vec![]);
+        assert_eq!(scrubber.scrub("hello world"), "hello world");
+    }
+
+    #[test]
+    fn scrubber_split_respects_utf8_boundaries() {
+        let mut scrubber = StreamScrubber::new(vec![("DUMMY".to_string(), "abc".to_string())]);
+        let part = scrubber.scrub("ééééé");
+        let rest = scrubber.flush();
+        assert_eq!(format!("{part}{rest}"), "ééééé");
+    }
+
+    #[test]
+    fn leak_detection_catches_anthropic_key() {
+        let result = scan_for_leaks("key is sk-ant-abc123456789012345678");
+        assert!(result.is_some());
+    }
+
+    #[test]
+    fn leak_detection_catches_github_token() {
+        let result = scan_for_leaks("token: ghp_abcdefghijklmnopqrstuvwxyz0123456789");
+        assert!(result.is_some());
+    }
+
+    #[test]
+    fn leak_detection_ignores_normal_text() {
+        let result = scan_for_leaks("this is normal output with no secrets");
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn scrub_leaks_redacts_anthropic_key() {
+        let input = "found key sk-ant-abc123456789012345678 in config";
+        let result = scrub_leaks(input);
+        assert!(
+            !result.contains("sk-ant-abc123456789012345678"),
+            "secret should be redacted in: {result}"
+        );
+        assert!(
+            result.contains("[LEAKED_SECRET_REDACTED]"),
+            "redaction marker missing in: {result}"
+        );
+        assert!(
+            result.contains("found key"),
+            "surrounding text should be preserved in: {result}"
+        );
+    }
+
+    #[test]
+    fn scrub_leaks_redacts_multiple_secrets() {
+        let input =
+            "keys: sk-ant-abc123456789012345678 and ghp_abcdefghijklmnopqrstuvwxyz0123456789";
+        let result = scrub_leaks(input);
+        assert!(
+            !result.contains("sk-ant-"),
+            "first secret should be redacted in: {result}"
+        );
+        assert!(
+            !result.contains("ghp_"),
+            "second secret should be redacted in: {result}"
+        );
+    }
+
+    #[test]
+    fn scrub_leaks_passes_through_clean_text() {
+        let input = "this is normal output with no secrets";
+        assert_eq!(scrub_leaks(input), input);
+    }
+
+    #[test]
+    fn scrub_leaks_redacts_full_pem_block() {
+        let input = "config:\n-----BEGIN RSA PRIVATE KEY-----\n\
+                      MIIEpAIBAAKCAQEA0Z3VS5JJcds3xfn/ygWyF8PbnGy0AHB7MhgHcTz6sE2I2yPB\n\
+                      aFDrBz9vFqU4zK3L3hUfVnEy\n\
+                      -----END RSA PRIVATE KEY-----\nmore text";
+        let result = scrub_leaks(input);
+        assert!(
+            !result.contains("MIIEpAIBAAK"),
+            "PEM body should be redacted in: {result}"
+        );
+        assert!(
+            !result.contains("BEGIN RSA PRIVATE KEY"),
+            "PEM header should be redacted in: {result}"
+        );
+        assert!(
+            result.contains("[LEAKED_SECRET_REDACTED]"),
+            "redaction marker missing in: {result}"
+        );
+        assert!(
+            result.contains("more text"),
+            "surrounding text should be preserved in: {result}"
+        );
+    }
+}
diff --git a/src/secrets/store.rs b/src/secrets/store.rs
index d598be95d..0a89e0961 100644
--- a/src/secrets/store.rs
+++ b/src/secrets/store.rs
@@ -1,18 +1,56 @@
-//! Encrypted credentials storage (AES-256-GCM, redb).
+//! Credential storage with two secret categories: system secrets (internal, never
+//! exposed to subprocesses) and tool secrets (passed to worker subprocesses as env
+//! vars).
+//!
+//! Supports two modes:
+//! - **Unencrypted (default):** secrets stored as plaintext in redb. No master key
+//!   needed. All secret store features work (categories, env sanitization, output
+//!   scrubbing). Only encryption at rest is missing.
+//! - **Encrypted (opt-in):** AES-256-GCM with a master key derived via Argon2id.
+//!   The master key lives in the OS credential store (Keychain / kernel keyring),
+//!   never on disk.
 
 use crate::error::SecretsError;
 use aes_gcm::{Aes256Gcm, KeyInit, Nonce, aead::Aead};
 use rand::RngCore;
 use redb::{Database, ReadableTable, TableDefinition};
-use sha2::{Digest, Sha256};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use std::fmt::{Debug, Display, Formatter};
 use std::path::Path;
+use std::sync::{Mutex, RwLock};
 
+/// Table for secret values. Stores either plaintext UTF-8 or nonce+ciphertext
+/// depending on the store's encryption mode.
 const SECRETS_TABLE: TableDefinition<&str, &[u8]> = TableDefinition::new("secrets");
 
+/// Table for secret metadata (category, timestamps). Always stored as plaintext
+/// JSON so names and categories are readable even when the store is locked.
+const METADATA_TABLE: TableDefinition<&str, &str> = TableDefinition::new("secrets_metadata");
+
+/// Table for store-level configuration (encryption flag, argon2 salt, etc.).
+const STORE_CONFIG_TABLE: TableDefinition<&str, &[u8]> = TableDefinition::new("secrets_config");
+
+/// Key in STORE_CONFIG_TABLE indicating whether encryption is enabled.
+const CONFIG_KEY_ENCRYPTED: &str = "encrypted";
+
+/// Key in STORE_CONFIG_TABLE storing the Argon2id salt (16 bytes).
+const CONFIG_KEY_SALT: &str = "argon2_salt";
+
+/// Key in STORE_CONFIG_TABLE storing a sentinel value encrypted with the master
+/// key. Used to validate the key on unlock without decrypting every secret.
+const CONFIG_KEY_SENTINEL: &str = "sentinel";
+
+/// The plaintext sentinel value. Encrypted during `enable_encryption()` and
+/// verified during `unlock()`.
+const SENTINEL_PLAINTEXT: &[u8] = b"spacebot-secrets-sentinel-v1";
+
+/// Secret value wrapper that redacts in Debug and Display to prevent accidental
+/// logging of credential values.
 pub struct DecryptedSecret(String);
 
 impl DecryptedSecret {
+    /// Access the raw secret value.
     pub fn expose(&self) -> &str {
         &self.0
     }
@@ -30,181 +68,1578 @@ impl Display for DecryptedSecret {
     }
 }
 
+/// Secret category determines subprocess exposure.
+///
+/// All secrets are readable by Rust code via `SecretsStore::get()` regardless
+/// of category. The category answers one question: should this value be injected
+/// as an env var into worker subprocesses?
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum SecretCategory {
+    /// Not exposed to subprocesses. Rust code reads them for internal use
+    /// (LLM clients, messaging adapters, webhook integrations).
+    System,
+    /// Exposed to subprocesses as env vars. CLI tools workers invoke need these
+    /// (gh, npm, aws, etc.). Rust code can also read them.
+    Tool,
+}
+
+impl std::fmt::Display for SecretCategory {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SecretCategory::System => write!(f, "system"),
+            SecretCategory::Tool => write!(f, "tool"),
+        }
+    }
+}
+
+/// Metadata stored alongside each secret (always unencrypted).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SecretMetadata {
+    pub category: SecretCategory,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+    pub updated_at: chrono::DateTime<chrono::Utc>,
+}
+
+/// Store state exposed via the status API.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum StoreState {
+    /// Secrets stored in plaintext in redb. No master key configured.
+    Unencrypted,
+    /// Encryption enabled, master key loaded. Secrets are decrypted and operational.
+    Unlocked,
+    /// Encryption enabled but master key not available. Encrypted secrets are
+    /// inaccessible. Happens after Linux reboot (kernel keyring cleared).
+    Locked,
+}
+
+impl std::fmt::Display for StoreState {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            StoreState::Unencrypted => write!(f, "unencrypted"),
+            StoreState::Unlocked => write!(f, "unlocked"),
+            StoreState::Locked => write!(f, "locked"),
+        }
+    }
+}
+
+/// Status snapshot for the API.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StoreStatus {
+    pub state: StoreState,
+    pub encrypted: bool,
+    pub secret_count: usize,
+    pub system_count: usize,
+    pub tool_count: usize,
+    pub platform_managed: bool,
+}
+
+/// Credential store with system/tool categorization and optional encryption.
+///
+/// Created once per agent, shared via `Arc`. Thread-safe — internal `RwLock`
+/// protects the cipher state for encryption transitions.
 pub struct SecretsStore {
     db: Database,
+    /// Current cipher state. `None` when unencrypted or locked.
+    /// Protected by RwLock for encrypt/unlock/lock transitions.
+    cipher_state: RwLock<Option<CipherState>>,
+    /// Whether the redb store has encrypted secrets (persisted flag).
+    encrypted: RwLock<bool>,
+    /// Serializes mutating operations (`set`, `lock`, `rotate_key`,
+    /// `enable_encryption`) so that multi-step read-then-write sequences
+    /// cannot interleave and corrupt data. These are all cold-path
+    /// operations, so contention is irrelevant.
+    mutation_guard: Mutex<()>,
+}
+
+/// Derived cipher key + salt for the encrypted mode.
+struct CipherState {
+    cipher: Aes256Gcm,
+    #[allow(dead_code)]
+    salt: [u8; 16],
+}
+
+impl Debug for SecretsStore {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SecretsStore")
+            .field("state", &self.state())
+            .finish()
+    }
 }
 
 impl SecretsStore {
+    /// Open or create a secrets store at the given path.
+    ///
+    /// The store starts in unencrypted mode. If the redb file contains the
+    /// `encrypted` flag, the store starts in locked state until `unlock()` is
+    /// called with the master key.
     pub fn new(path: impl AsRef<Path>) -> Result<Self, SecretsError> {
         let db = Database::create(path.as_ref()).map_err(|error| {
             SecretsError::Other(anyhow::anyhow!("failed to open secrets database: {error}"))
         })?;
 
+        // Ensure all tables exist.
         let write_transaction = db.begin_write().map_err(|error| {
             SecretsError::Other(anyhow::anyhow!(
-                "failed to initialize secrets table transaction: {error}"
+                "failed to initialize secrets tables: {error}"
             ))
         })?;
         {
-            let _table = write_transaction
+            let _secrets = write_transaction
                 .open_table(SECRETS_TABLE)
                 .map_err(|error| {
                     SecretsError::Other(anyhow::anyhow!("failed to open secrets table: {error}"))
                 })?;
+            let _metadata = write_transaction
+                .open_table(METADATA_TABLE)
+                .map_err(|error| {
+                    SecretsError::Other(anyhow::anyhow!("failed to open metadata table: {error}"))
+                })?;
+            let _config = write_transaction
+                .open_table(STORE_CONFIG_TABLE)
+                .map_err(|error| {
+                    SecretsError::Other(anyhow::anyhow!(
+                        "failed to open store config table: {error}"
+                    ))
+                })?;
         }
         write_transaction.commit().map_err(|error| {
             SecretsError::Other(anyhow::anyhow!(
-                "failed to commit secrets table initialization: {error}"
+                "failed to commit table initialization: {error}"
             ))
         })?;
 
-        Ok(Self { db })
+        // Check if encryption was previously enabled.
+        let encrypted = {
+            let read_txn = db.begin_read().map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("failed to begin read transaction: {error}"))
+            })?;
+            let table = read_txn.open_table(STORE_CONFIG_TABLE).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!(
+                    "failed to open store config table: {error}"
+                ))
+            })?;
+            match table.get(CONFIG_KEY_ENCRYPTED) {
+                Ok(Some(value)) => value.value() == [1],
+                Ok(None) => false,
+                Err(error) => {
+                    return Err(SecretsError::Other(anyhow::anyhow!(
+                        "failed to read encryption flag: {error}"
+                    )));
+                }
+            }
+        };
+
+        Ok(Self {
+            db,
+            cipher_state: RwLock::new(None),
+            encrypted: RwLock::new(encrypted),
+            mutation_guard: Mutex::new(()),
+        })
+    }
+
+    /// Current store state.
+    pub fn state(&self) -> StoreState {
+        let encrypted = *self.encrypted.read().expect("encrypted lock poisoned");
+        if !encrypted {
+            return StoreState::Unencrypted;
+        }
+        if self
+            .cipher_state
+            .read()
+            .expect("cipher lock poisoned")
+            .is_some()
+        {
+            StoreState::Unlocked
+        } else {
+            StoreState::Locked
+        }
     }
 
-    pub fn set(&self, key: &str, value: &str, master_key: &[u8]) -> Result<(), SecretsError> {
-        let cipher = build_cipher(master_key)?;
+    /// Whether the store has encryption enabled.
+    pub fn is_encrypted(&self) -> bool {
+        *self.encrypted.read().expect("encrypted lock poisoned")
+    }
 
-        let mut nonce_bytes = [0_u8; 12];
-        rand::rng().fill_bytes(&mut nonce_bytes);
-        let nonce = Nonce::from_slice(&nonce_bytes);
+    /// Full status snapshot for the API.
+    pub fn status(&self, platform_managed: bool) -> Result<StoreStatus, SecretsError> {
+        let all_metadata = self.list_metadata()?;
+        let system_count = all_metadata
+            .values()
+            .filter(|m| m.category == SecretCategory::System)
+            .count();
+        let tool_count = all_metadata
+            .values()
+            .filter(|m| m.category == SecretCategory::Tool)
+            .count();
 
-        let ciphertext = cipher
-            .encrypt(nonce, value.as_bytes())
-            .map_err(|error| SecretsError::EncryptionFailed(error.to_string()))?;
+        Ok(StoreStatus {
+            state: self.state(),
+            encrypted: self.is_encrypted(),
+            secret_count: all_metadata.len(),
+            system_count,
+            tool_count,
+            platform_managed,
+        })
+    }
 
-        let mut stored_value = Vec::with_capacity(nonce_bytes.len() + ciphertext.len());
-        stored_value.extend_from_slice(&nonce_bytes);
-        stored_value.extend_from_slice(&ciphertext);
+    /// Store a secret with the given category. Creates or updates.
+    pub fn set(
+        &self,
+        name: &str,
+        value: &str,
+        category: SecretCategory,
+    ) -> Result<(), SecretsError> {
+        let _guard = self.mutation_guard.lock().expect("mutation guard poisoned");
+        let state = self.state();
+        if state == StoreState::Locked {
+            return Err(SecretsError::Other(anyhow::anyhow!(
+                "secret store is locked — unlock with master key first"
+            )));
+        }
 
-        let write_transaction = self.db.begin_write().map_err(|error| {
+        let stored_value = self.encode_value(value)?;
+        let now = chrono::Utc::now();
+
+        // Check if updating an existing secret (preserve created_at).
+        let existing_meta = self.get_metadata(name).ok();
+        let metadata = SecretMetadata {
+            category,
+            created_at: existing_meta.as_ref().map(|m| m.created_at).unwrap_or(now),
+            updated_at: now,
+        };
+        let metadata_json = serde_json::to_string(&metadata).map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!("failed to serialize metadata: {error}"))
+        })?;
+
+        let write_txn = self.db.begin_write().map_err(|error| {
             SecretsError::Other(anyhow::anyhow!(
                 "failed to begin write transaction: {error}"
             ))
         })?;
-
         {
-            let mut table = write_transaction
-                .open_table(SECRETS_TABLE)
+            let mut secrets = write_txn.open_table(SECRETS_TABLE).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("failed to open secrets table: {error}"))
+            })?;
+            secrets
+                .insert(name, stored_value.as_slice())
                 .map_err(|error| {
-                    SecretsError::Other(anyhow::anyhow!("failed to open secrets table: {error}"))
+                    SecretsError::Other(anyhow::anyhow!(
+                        "failed to insert secret '{name}': {error}"
+                    ))
                 })?;
 
-            table
-                .insert(key, stored_value.as_slice())
-                .map_err(|error| {
-                    SecretsError::Other(anyhow::anyhow!("failed to insert secret '{key}': {error}"))
-                })?;
+            let mut meta = write_txn.open_table(METADATA_TABLE).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("failed to open metadata table: {error}"))
+            })?;
+            meta.insert(name, metadata_json.as_str()).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!(
+                    "failed to insert metadata for '{name}': {error}"
+                ))
+            })?;
         }
-
-        write_transaction.commit().map_err(|error| {
-            SecretsError::Other(anyhow::anyhow!("failed to commit secret '{key}': {error}"))
+        write_txn.commit().map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!("failed to commit secret '{name}': {error}"))
         })?;
 
         Ok(())
     }
 
-    pub fn get(&self, key: &str, master_key: &[u8]) -> Result<DecryptedSecret, SecretsError> {
-        let cipher = build_cipher(master_key)?;
+    /// Retrieve a decrypted secret value.
+    pub fn get(&self, name: &str) -> Result<DecryptedSecret, SecretsError> {
+        let state = self.state();
+        if state == StoreState::Locked {
+            return Err(SecretsError::Other(anyhow::anyhow!(
+                "secret store is locked — unlock with master key first"
+            )));
+        }
 
-        let read_transaction = self.db.begin_read().map_err(|error| {
+        let read_txn = self.db.begin_read().map_err(|error| {
             SecretsError::Other(anyhow::anyhow!("failed to begin read transaction: {error}"))
         })?;
-        let table = read_transaction
-            .open_table(SECRETS_TABLE)
+        let table = read_txn.open_table(SECRETS_TABLE).map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!("failed to open secrets table: {error}"))
+        })?;
+
+        let value = table
+            .get(name)
             .map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("failed to read key '{name}': {error}"))
+            })?
+            .ok_or_else(|| SecretsError::NotFound {
+                key: name.to_string(),
+            })?;
+
+        let raw = value.value();
+        self.decode_value(raw)
+    }
+
+    /// Delete a secret.
+    pub fn delete(&self, name: &str) -> Result<(), SecretsError> {
+        let write_txn = self.db.begin_write().map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!(
+                "failed to begin write transaction: {error}"
+            ))
+        })?;
+        {
+            let mut secrets = write_txn.open_table(SECRETS_TABLE).map_err(|error| {
                 SecretsError::Other(anyhow::anyhow!("failed to open secrets table: {error}"))
             })?;
+            secrets.remove(name).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("failed to remove key '{name}': {error}"))
+            })?;
+
+            let mut meta = write_txn.open_table(METADATA_TABLE).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("failed to open metadata table: {error}"))
+            })?;
+            meta.remove(name).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!(
+                    "failed to remove metadata for '{name}': {error}"
+                ))
+            })?;
+        }
+        write_txn.commit().map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!(
+                "failed to commit delete for '{name}': {error}"
+            ))
+        })?;
+
+        Ok(())
+    }
+
+    /// List all secret names.
+    pub fn list(&self) -> Result<Vec<String>, SecretsError> {
+        let read_txn = self.db.begin_read().map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!("failed to begin read transaction: {error}"))
+        })?;
+        let table = read_txn.open_table(METADATA_TABLE).map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!("failed to open metadata table: {error}"))
+        })?;
+
+        let mut names = Vec::new();
+        let iter = table.iter().map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!("failed to iterate metadata table: {error}"))
+        })?;
+        for entry in iter {
+            let (key, _) = entry.map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("failed to read metadata entry: {error}"))
+            })?;
+            names.push(key.value().to_string());
+        }
+
+        Ok(names)
+    }
+
+    /// Get metadata for a specific secret.
+    pub fn get_metadata(&self, name: &str) -> Result<SecretMetadata, SecretsError> {
+        let read_txn = self.db.begin_read().map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!("failed to begin read transaction: {error}"))
+        })?;
+        let table = read_txn.open_table(METADATA_TABLE).map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!("failed to open metadata table: {error}"))
+        })?;
 
         let value = table
-            .get(key)
+            .get(name)
             .map_err(|error| {
-                SecretsError::Other(anyhow::anyhow!("failed to read key '{key}': {error}"))
+                SecretsError::Other(anyhow::anyhow!(
+                    "failed to read metadata for '{name}': {error}"
+                ))
             })?
             .ok_or_else(|| SecretsError::NotFound {
-                key: key.to_string(),
+                key: name.to_string(),
             })?;
 
-        let encrypted_value = value.value();
-        if encrypted_value.len() < 12 {
-            return Err(SecretsError::DecryptionFailed(
-                "stored secret is missing nonce prefix".to_string(),
-            ));
+        serde_json::from_str(value.value()).map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!(
+                "failed to parse metadata for '{name}': {error}"
+            ))
+        })
+    }
+
+    /// List all secrets with their metadata. Works in all states (names and
+    /// categories are stored as unencrypted metadata).
+    pub fn list_metadata(&self) -> Result<HashMap<String, SecretMetadata>, SecretsError> {
+        let read_txn = self.db.begin_read().map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!("failed to begin read transaction: {error}"))
+        })?;
+        let table = read_txn.open_table(METADATA_TABLE).map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!("failed to open metadata table: {error}"))
+        })?;
+
+        let mut result = HashMap::new();
+        let iter = table.iter().map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!("failed to iterate metadata table: {error}"))
+        })?;
+        for entry in iter {
+            let (key, value) = entry.map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("failed to read metadata entry: {error}"))
+            })?;
+            match serde_json::from_str::<SecretMetadata>(value.value()) {
+                Ok(meta) => {
+                    result.insert(key.value().to_string(), meta);
+                }
+                Err(error) => {
+                    tracing::warn!(
+                        key = key.value(),
+                        %error,
+                        "skipping secret with corrupted metadata"
+                    );
+                }
+            }
+        }
+
+        Ok(result)
+    }
+
+    /// Get all tool secrets as name→value pairs for `Sandbox::wrap()` injection.
+    ///
+    /// Returns an empty map when locked (tool secrets unavailable).
+    pub fn tool_env_vars(&self) -> HashMap<String, String> {
+        if self.state() == StoreState::Locked {
+            return HashMap::new();
         }
 
-        let nonce = Nonce::from_slice(&encrypted_value[..12]);
-        let ciphertext = &encrypted_value[12..];
-        let plaintext = cipher
-            .decrypt(nonce, ciphertext)
-            .map_err(|error| SecretsError::DecryptionFailed(error.to_string()))?;
+        let metadata = match self.list_metadata() {
+            Ok(m) => m,
+            Err(error) => {
+                tracing::warn!(%error, "failed to list secret metadata for tool env vars");
+                return HashMap::new();
+            }
+        };
+
+        let mut result = HashMap::new();
+        for (name, meta) in &metadata {
+            if meta.category == SecretCategory::Tool {
+                match self.get(name) {
+                    Ok(secret) => {
+                        result.insert(name.clone(), secret.expose().to_string());
+                    }
+                    Err(error) => {
+                        tracing::warn!(secret = %name, %error, "failed to decrypt tool secret — skipping");
+                    }
+                }
+            }
+        }
+
+        result
+    }
 
-        let plaintext = String::from_utf8(plaintext)
-            .map_err(|error| SecretsError::DecryptionFailed(error.to_string()))?;
+    /// Get names of all tool secrets for injection into worker system prompts.
+    ///
+    /// Returns names even when locked (metadata is always accessible).
+    pub fn tool_secret_names(&self) -> Vec<String> {
+        match self.list_metadata() {
+            Ok(metadata) => metadata
+                .into_iter()
+                .filter(|(_, meta)| meta.category == SecretCategory::Tool)
+                .map(|(name, _)| name)
+                .collect(),
+            Err(error) => {
+                tracing::warn!(%error, "failed to list secret metadata for tool secret names");
+                Vec::new()
+            }
+        }
+    }
 
-        Ok(DecryptedSecret(plaintext))
+    /// Get all tool secret name→value pairs for the output scrubber.
+    ///
+    /// Returns pairs suitable for `StreamScrubber::new()`.
+    pub fn tool_secret_pairs(&self) -> Vec<(String, String)> {
+        self.tool_env_vars().into_iter().collect()
     }
 
-    pub fn delete(&self, key: &str) -> Result<(), SecretsError> {
-        let write_transaction = self.db.begin_write().map_err(|error| {
+    /// Enable encryption. Generates a random master key, encrypts all existing
+    /// secrets in place, stores the key derivation salt and sentinel in redb.
+    ///
+    /// Returns the raw master key bytes for the caller to store in the OS
+    /// credential store and display to the user.
+    pub fn enable_encryption(&self) -> Result<Vec<u8>, SecretsError> {
+        let _guard = self.mutation_guard.lock().expect("mutation guard poisoned");
+        if self.is_encrypted() {
+            return Err(SecretsError::Other(anyhow::anyhow!(
+                "encryption is already enabled"
+            )));
+        }
+
+        // Generate master key and salt.
+        let mut master_key = vec![0u8; 32];
+        rand::rng().fill_bytes(&mut master_key);
+        let mut salt = [0u8; 16];
+        rand::rng().fill_bytes(&mut salt);
+
+        // Derive cipher key.
+        let cipher = derive_cipher(&master_key, &salt)?;
+
+        // Encrypt sentinel value.
+        let encrypted_sentinel = encrypt_bytes(&cipher, SENTINEL_PLAINTEXT)?;
+
+        // Re-encrypt all existing secrets.
+        let names = self.list()?;
+        let mut plain_values: Vec<(String, Vec<u8>)> = Vec::with_capacity(names.len());
+        {
+            let read_txn = self.db.begin_read().map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("failed to begin read transaction: {error}"))
+            })?;
+            let table = read_txn.open_table(SECRETS_TABLE).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("failed to open secrets table: {error}"))
+            })?;
+            for name in &names {
+                if let Some(val) = table.get(name.as_str()).map_err(|error| {
+                    SecretsError::Other(anyhow::anyhow!("failed to read secret '{name}': {error}"))
+                })? {
+                    // Current values are plaintext UTF-8.
+                    plain_values.push((name.clone(), val.value().to_vec()));
+                }
+            }
+        }
+
+        // Write everything in one transaction.
+        let write_txn = self.db.begin_write().map_err(|error| {
             SecretsError::Other(anyhow::anyhow!(
                 "failed to begin write transaction: {error}"
             ))
         })?;
-
         {
-            let mut table = write_transaction
-                .open_table(SECRETS_TABLE)
+            let mut secrets = write_txn.open_table(SECRETS_TABLE).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("failed to open secrets table: {error}"))
+            })?;
+            // Re-encrypt each secret value.
+            for (name, plaintext_bytes) in &plain_values {
+                let encrypted = encrypt_bytes(&cipher, plaintext_bytes)?;
+                secrets
+                    .insert(name.as_str(), encrypted.as_slice())
+                    .map_err(|error| {
+                        SecretsError::Other(anyhow::anyhow!(
+                            "failed to write encrypted secret '{name}': {error}"
+                        ))
+                    })?;
+            }
+
+            let mut config = write_txn.open_table(STORE_CONFIG_TABLE).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!(
+                    "failed to open store config table: {error}"
+                ))
+            })?;
+            config
+                .insert(CONFIG_KEY_ENCRYPTED, &[1u8][..])
                 .map_err(|error| {
-                    SecretsError::Other(anyhow::anyhow!("failed to open secrets table: {error}"))
+                    SecretsError::Other(anyhow::anyhow!("failed to write encryption flag: {error}"))
                 })?;
-
-            table.remove(key).map_err(|error| {
-                SecretsError::Other(anyhow::anyhow!("failed to remove key '{key}': {error}"))
+            config.insert(CONFIG_KEY_SALT, &salt[..]).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("failed to write salt: {error}"))
             })?;
+            config
+                .insert(CONFIG_KEY_SENTINEL, encrypted_sentinel.as_slice())
+                .map_err(|error| {
+                    SecretsError::Other(anyhow::anyhow!("failed to write sentinel: {error}"))
+                })?;
         }
-
-        write_transaction.commit().map_err(|error| {
+        write_txn.commit().map_err(|error| {
             SecretsError::Other(anyhow::anyhow!(
-                "failed to commit delete for '{key}': {error}"
+                "failed to commit encryption enablement: {error}"
             ))
         })?;
 
+        // Update in-memory state.
+        *self.encrypted.write().expect("encrypted lock poisoned") = true;
+        *self.cipher_state.write().expect("cipher lock poisoned") =
+            Some(CipherState { cipher, salt });
+
+        Ok(master_key)
+    }
+
+    /// Unlock the store with the given master key. Validates against the stored
+    /// sentinel before accepting.
+    pub fn unlock(&self, master_key: &[u8]) -> Result<(), SecretsError> {
+        if !self.is_encrypted() {
+            return Err(SecretsError::Other(anyhow::anyhow!(
+                "store is not encrypted — nothing to unlock"
+            )));
+        }
+        if self.state() == StoreState::Unlocked {
+            return Err(SecretsError::Other(anyhow::anyhow!(
+                "store is already unlocked"
+            )));
+        }
+
+        // Read salt and sentinel from redb.
+        let (salt, encrypted_sentinel) = {
+            let read_txn = self.db.begin_read().map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!("failed to begin read transaction: {error}"))
+            })?;
+            let table = read_txn.open_table(STORE_CONFIG_TABLE).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!(
+                    "failed to open store config table: {error}"
+                ))
+            })?;
+
+            let salt_val = table
+                .get(CONFIG_KEY_SALT)
+                .map_err(|error| {
+                    SecretsError::Other(anyhow::anyhow!("failed to read salt: {error}"))
+                })?
+                .ok_or_else(|| {
+                    SecretsError::Other(anyhow::anyhow!("encrypted store missing salt"))
+                })?;
+            let mut salt = [0u8; 16];
+            let raw = salt_val.value();
+            if raw.len() != 16 {
+                return Err(SecretsError::Other(anyhow::anyhow!(
+                    "invalid salt length: {}",
+                    raw.len()
+                )));
+            }
+            salt.copy_from_slice(raw);
+
+            let sentinel_val = table
+                .get(CONFIG_KEY_SENTINEL)
+                .map_err(|error| {
+                    SecretsError::Other(anyhow::anyhow!("failed to read sentinel: {error}"))
+                })?
+                .ok_or_else(|| {
+                    SecretsError::Other(anyhow::anyhow!("encrypted store missing sentinel"))
+                })?;
+
+            (salt, sentinel_val.value().to_vec())
+        };
+
+        // Derive cipher and verify sentinel.
+        let cipher = derive_cipher(master_key, &salt)?;
+        let decrypted_sentinel =
+            decrypt_bytes(&cipher, &encrypted_sentinel).map_err(|_| SecretsError::InvalidKey)?;
+
+        if decrypted_sentinel != SENTINEL_PLAINTEXT {
+            return Err(SecretsError::InvalidKey);
+        }
+
+        // Accept the key.
+        *self.cipher_state.write().expect("cipher lock poisoned") =
+            Some(CipherState { cipher, salt });
+
         Ok(())
     }
 
-    pub fn list(&self) -> Result<Vec<String>, SecretsError> {
-        let read_transaction = self.db.begin_read().map_err(|error| {
-            SecretsError::Other(anyhow::anyhow!("failed to begin read transaction: {error}"))
+    /// Lock the store. Clears the in-memory cipher key. Encrypted secrets become
+    /// inaccessible until `unlock()` is called again.
+    pub fn lock(&self) -> Result<(), SecretsError> {
+        let _guard = self.mutation_guard.lock().expect("mutation guard poisoned");
+        if !self.is_encrypted() {
+            return Err(SecretsError::Other(anyhow::anyhow!(
+                "store is not encrypted — nothing to lock"
+            )));
+        }
+        *self.cipher_state.write().expect("cipher lock poisoned") = None;
+        Ok(())
+    }
+
+    /// Rotate the master key. Generates a new key, re-encrypts all secrets and
+    /// the sentinel, updates the salt. Returns the new master key bytes.
+    pub fn rotate_key(&self) -> Result<Vec<u8>, SecretsError> {
+        let _guard = self.mutation_guard.lock().expect("mutation guard poisoned");
+        if self.state() != StoreState::Unlocked {
+            return Err(SecretsError::Other(anyhow::anyhow!(
+                "store must be unlocked to rotate key"
+            )));
+        }
+
+        // Generate new key and salt.
+        let mut new_master_key = vec![0u8; 32];
+        rand::rng().fill_bytes(&mut new_master_key);
+        let mut new_salt = [0u8; 16];
+        rand::rng().fill_bytes(&mut new_salt);
+
+        let new_cipher = derive_cipher(&new_master_key, &new_salt)?;
+
+        // Decrypt all secrets with old cipher, re-encrypt with new.
+        let names = self.list()?;
+        let mut re_encrypted: Vec<(String, Vec<u8>)> = Vec::with_capacity(names.len());
+        for name in &names {
+            let decrypted = self.get(name)?;
+            let encrypted = encrypt_bytes(&new_cipher, decrypted.expose().as_bytes())?;
+            re_encrypted.push((name.clone(), encrypted));
+        }
+
+        // Re-encrypt sentinel.
+        let new_encrypted_sentinel = encrypt_bytes(&new_cipher, SENTINEL_PLAINTEXT)?;
+
+        // Write everything atomically.
+        let write_txn = self.db.begin_write().map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!(
+                "failed to begin write transaction: {error}"
+            ))
         })?;
-        let table = read_transaction
-            .open_table(SECRETS_TABLE)
-            .map_err(|error| {
+        {
+            let mut secrets = write_txn.open_table(SECRETS_TABLE).map_err(|error| {
                 SecretsError::Other(anyhow::anyhow!("failed to open secrets table: {error}"))
             })?;
+            for (name, encrypted) in &re_encrypted {
+                secrets
+                    .insert(name.as_str(), encrypted.as_slice())
+                    .map_err(|error| {
+                        SecretsError::Other(anyhow::anyhow!(
+                            "failed to write re-encrypted secret '{name}': {error}"
+                        ))
+                    })?;
+            }
 
-        let mut keys = Vec::new();
-        let iter = table.iter().map_err(|error| {
-            SecretsError::Other(anyhow::anyhow!("failed to iterate secrets table: {error}"))
+            let mut config = write_txn.open_table(STORE_CONFIG_TABLE).map_err(|error| {
+                SecretsError::Other(anyhow::anyhow!(
+                    "failed to open store config table: {error}"
+                ))
+            })?;
+            config
+                .insert(CONFIG_KEY_SALT, &new_salt[..])
+                .map_err(|error| {
+                    SecretsError::Other(anyhow::anyhow!("failed to write new salt: {error}"))
+                })?;
+            config
+                .insert(CONFIG_KEY_SENTINEL, new_encrypted_sentinel.as_slice())
+                .map_err(|error| {
+                    SecretsError::Other(anyhow::anyhow!("failed to write new sentinel: {error}"))
+                })?;
+        }
+        write_txn.commit().map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!("failed to commit key rotation: {error}"))
         })?;
 
-        for entry in iter {
-            let (key, _value) = entry.map_err(|error| {
-                SecretsError::Other(anyhow::anyhow!("failed to read secrets entry: {error}"))
-            })?;
-            keys.push(key.value().to_string());
+        // Update in-memory cipher.
+        *self.cipher_state.write().expect("cipher lock poisoned") = Some(CipherState {
+            cipher: new_cipher,
+            salt: new_salt,
+        });
+
+        Ok(new_master_key)
+    }
+
+    /// Check if a secret exists.
+    pub fn exists(&self, name: &str) -> bool {
+        self.get_metadata(name).is_ok()
+    }
+
+    /// Export all secrets as a portable backup.
+    ///
+    /// Returns a JSON blob with all secret names, values, categories, and
+    /// metadata. If encryption is enabled and the store is unlocked, the
+    /// export contains decrypted values (the caller can re-encrypt the file
+    /// at rest). If the store is locked, returns an error.
+    pub fn export_all(&self) -> Result<ExportData, SecretsError> {
+        if self.state() == StoreState::Locked {
+            return Err(SecretsError::Other(anyhow::anyhow!(
+                "secret store is locked — unlock before exporting"
+            )));
         }
 
-        Ok(keys)
+        let metadata = self.list_metadata()?;
+        let mut entries = Vec::with_capacity(metadata.len());
+
+        for (name, meta) in &metadata {
+            let value = self.get(name)?;
+            entries.push(ExportEntry {
+                name: name.clone(),
+                value: value.expose().to_string(),
+                category: meta.category,
+                created_at: meta.created_at,
+                updated_at: meta.updated_at,
+            });
+        }
+
+        entries.sort_by(|a, b| a.name.cmp(&b.name));
+
+        Ok(ExportData {
+            version: 1,
+            encrypted: self.is_encrypted(),
+            entries,
+        })
     }
+
+    /// Import secrets from an export. Optionally overwrites existing secrets
+    /// with the same name.
+    ///
+    /// Returns the count of imported and skipped secrets.
+    pub fn import_all(
+        &self,
+        data: &ExportData,
+        overwrite: bool,
+    ) -> Result<ImportResult, SecretsError> {
+        if self.state() == StoreState::Locked {
+            return Err(SecretsError::Other(anyhow::anyhow!(
+                "secret store is locked — unlock before importing"
+            )));
+        }
+
+        let mut imported = 0usize;
+        let mut skipped = Vec::new();
+
+        for entry in &data.entries {
+            if self.exists(&entry.name) && !overwrite {
+                skipped.push(entry.name.clone());
+                continue;
+            }
+
+            self.set(&entry.name, &entry.value, entry.category)?;
+            imported += 1;
+        }
+
+        Ok(ImportResult { imported, skipped })
+    }
+
+    /// Encode a plaintext value for storage. In encrypted mode, encrypts with
+    /// the current cipher. In unencrypted mode, stores as raw UTF-8 bytes.
+    fn encode_value(&self, plaintext: &str) -> Result<Vec<u8>, SecretsError> {
+        let guard = self.cipher_state.read().expect("cipher lock poisoned");
+        match guard.as_ref() {
+            Some(state) => encrypt_bytes(&state.cipher, plaintext.as_bytes()),
+            None => {
+                // Unencrypted mode — store as raw UTF-8.
+                Ok(plaintext.as_bytes().to_vec())
+            }
+        }
+    }
+
+    /// Decode a stored value. In encrypted mode, decrypts. In unencrypted mode,
+    /// interprets as raw UTF-8.
+    fn decode_value(&self, stored: &[u8]) -> Result<DecryptedSecret, SecretsError> {
+        let guard = self.cipher_state.read().expect("cipher lock poisoned");
+        match guard.as_ref() {
+            Some(state) => {
+                let plaintext = decrypt_bytes(&state.cipher, stored)?;
+                let text = String::from_utf8(plaintext)
+                    .map_err(|error| SecretsError::DecryptionFailed(error.to_string()))?;
+                Ok(DecryptedSecret(text))
+            }
+            None => {
+                // Unencrypted mode — raw UTF-8.
+                let text = String::from_utf8(stored.to_vec())
+                    .map_err(|error| SecretsError::DecryptionFailed(error.to_string()))?;
+                Ok(DecryptedSecret(text))
+            }
+        }
+    }
+}
+
+/// Portable backup format for all secrets in a store.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExportData {
+    /// Format version (currently 1).
+    pub version: u32,
+    /// Whether the source store had encryption enabled (informational only —
+    /// values in this struct are always plaintext).
+    pub encrypted: bool,
+    /// All secrets with their metadata.
+    pub entries: Vec<ExportEntry>,
+}
+
+/// A single secret in the export format.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExportEntry {
+    pub name: String,
+    pub value: String,
+    pub category: SecretCategory,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+    pub updated_at: chrono::DateTime<chrono::Utc>,
 }
 
-fn build_cipher(master_key: &[u8]) -> Result<Aes256Gcm, SecretsError> {
+/// Result of an import operation.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ImportResult {
+    /// Number of secrets successfully imported.
+    pub imported: usize,
+    /// Names of secrets that were skipped because they already existed (and
+    /// overwrite was not requested).
+    pub skipped: Vec<String>,
+}
+
+/// Derive an AES-256-GCM cipher key from a master key using Argon2id.
+///
+/// Argon2id is used instead of SHA-256 because self-hosted users may use a
+/// passphrase as the master key. SHA-256 of a passphrase is trivially brutable;
+/// Argon2id is memory-hard and resistant to GPU/ASIC attacks. The cost is a
+/// one-time ~100ms at startup.
+fn derive_cipher(master_key: &[u8], salt: &[u8; 16]) -> Result<Aes256Gcm, SecretsError> {
     if master_key.is_empty() {
         return Err(SecretsError::InvalidKey);
     }
 
-    let mut hasher = Sha256::new();
-    hasher.update(master_key);
-    let digest = hasher.finalize();
+    let params = argon2::Params::new(
+        64 * 1024, // 64 MiB memory
+        3,         // 3 iterations
+        1,         // 1 degree of parallelism
+        Some(32),  // 32 bytes output
+    )
+    .map_err(|error| SecretsError::Other(anyhow::anyhow!("argon2 params error: {error}")))?;
+
+    let argon2 = argon2::Argon2::new(argon2::Algorithm::Argon2id, argon2::Version::V0x13, params);
+
+    let mut derived_key = [0u8; 32];
+    argon2
+        .hash_password_into(master_key, salt, &mut derived_key)
+        .map_err(|error| {
+            SecretsError::Other(anyhow::anyhow!("argon2 key derivation failed: {error}"))
+        })?;
+
+    Aes256Gcm::new_from_slice(&derived_key).map_err(|_| SecretsError::InvalidKey)
+}
+
+/// Encrypt bytes with AES-256-GCM. Returns nonce (12 bytes) + ciphertext.
+fn encrypt_bytes(cipher: &Aes256Gcm, plaintext: &[u8]) -> Result<Vec<u8>, SecretsError> {
+    let mut nonce_bytes = [0u8; 12];
+    rand::rng().fill_bytes(&mut nonce_bytes);
+    let nonce = Nonce::from_slice(&nonce_bytes);
+
+    let ciphertext = cipher
+        .encrypt(nonce, plaintext)
+        .map_err(|error| SecretsError::EncryptionFailed(error.to_string()))?;
+
+    let mut stored = Vec::with_capacity(12 + ciphertext.len());
+    stored.extend_from_slice(&nonce_bytes);
+    stored.extend_from_slice(&ciphertext);
+    Ok(stored)
+}
+
+/// Decrypt nonce+ciphertext bytes with AES-256-GCM.
+fn decrypt_bytes(cipher: &Aes256Gcm, stored: &[u8]) -> Result<Vec<u8>, SecretsError> {
+    if stored.len() < 12 {
+        return Err(SecretsError::DecryptionFailed(
+            "stored value too short for nonce".to_string(),
+        ));
+    }
+    let nonce = Nonce::from_slice(&stored[..12]);
+    let ciphertext = &stored[12..];
+    cipher
+        .decrypt(nonce, ciphertext)
+        .map_err(|error| SecretsError::DecryptionFailed(error.to_string()))
+}
+
+/// Naming pattern for adapter secret fields that support named instances.
+///
+/// For a Discord adapter named `"alerts"` with pattern
+/// `{ platform_prefix: "DISCORD", field_suffix: "BOT_TOKEN" }`, the derived
+/// secret name is `"DISCORD_ALERTS_BOT_TOKEN"`.
+#[derive(Debug, Clone, Copy)]
+pub struct InstancePattern {
+    /// Platform prefix (e.g. `"DISCORD"`, `"SLACK"`).
+    pub platform_prefix: &'static str,
+    /// Field suffix (e.g. `"BOT_TOKEN"`, `"APP_TOKEN"`).
+    pub field_suffix: &'static str,
+}
+
+/// A credential field declared by a config section.
+///
+/// Used by both messaging adapters and other config sections (LLM providers,
+/// search integrations) to declare which fields contain secrets. The secret
+/// store uses these declarations for auto-categorization and migration.
+///
+/// For fields with an [`InstancePattern`], named adapter instances derive
+/// secret names by inserting the uppercased instance name:
+///
+/// ```text
+/// default:   DISCORD_BOT_TOKEN
+/// instance:  DISCORD_ALERTS_BOT_TOKEN
+/// ```
+#[derive(Debug, Clone, Copy)]
+pub struct SecretField {
+    /// TOML key within the config section (e.g. `"token"`, `"anthropic_key"`).
+    pub toml_key: &'static str,
+    /// Canonical secret name (e.g. `"DISCORD_BOT_TOKEN"`, `"ANTHROPIC_API_KEY"`).
+    pub secret_name: &'static str,
+    /// Instance naming pattern. Only set for messaging adapters that support
+    /// `[[messaging.*.instances]]`. `None` for LLM keys, search keys, etc.
+    pub instance_pattern: Option<InstancePattern>,
+}
+
+impl SecretField {
+    /// Secret name for a named adapter instance.
+    ///
+    /// Given instance name `"alerts"` and pattern `DISCORD / BOT_TOKEN`,
+    /// produces `"DISCORD_ALERTS_BOT_TOKEN"`.
+    ///
+    /// Returns `None` if this field has no instance pattern (e.g. LLM keys).
+    pub fn instance_name(&self, instance: &str) -> Option<String> {
+        let pattern = self.instance_pattern.as_ref()?;
+        Some(format!(
+            "{}_{}_{}",
+            pattern.platform_prefix,
+            instance.to_uppercase(),
+            pattern.field_suffix
+        ))
+    }
+}
+
+/// Trait for config sections to declare their credential fields.
+///
+/// Implemented on messaging adapter configs (e.g. `DiscordConfig`), LLM config,
+/// and any other config section that holds secrets. Used by the secret store for
+/// auto-categorization (any matching name → System) and by the migration endpoint
+/// to scan config.toml for plaintext credentials.
+pub trait SystemSecrets {
+    /// Section identifier used for TOML path construction.
+    ///
+    /// For messaging adapters: `"discord"`, `"slack"`, etc. (paths are
+    /// `messaging.{section}.{toml_key}`).
+    /// For other sections: `"llm"`, `"defaults"`, etc. (paths are
+    /// `{section}.{toml_key}`).
+    fn section() -> &'static str;
+
+    /// Credential fields this config section uses.
+    fn secret_fields() -> &'static [SecretField];
+
+    /// Whether this section is a messaging adapter (has `instances` array).
+    /// Default: `false`.
+    fn is_messaging_adapter() -> bool {
+        false
+    }
+}
+
+/// Collect all system secret fields from every config section that implements
+/// [`SystemSecrets`]. Returns the combined list used for auto-categorization
+/// and migration.
+///
+/// This is the single source of truth — adding a new secret-bearing config
+/// section only requires implementing [`SystemSecrets`] and listing the type
+/// here.
+pub fn system_secret_registry() -> Vec<&'static SecretField> {
+    use crate::config::{
+        DefaultsConfig, DiscordConfig, EmailConfig, LlmConfig, SlackConfig, TelegramConfig,
+        TwitchConfig,
+    };
+
+    let mut fields = Vec::new();
+    // LLM provider keys.
+    fields.extend(LlmConfig::secret_fields());
+    // Search / internal tool keys.
+    fields.extend(DefaultsConfig::secret_fields());
+    // Messaging adapters.
+    fields.extend(DiscordConfig::secret_fields());
+    fields.extend(SlackConfig::secret_fields());
+    fields.extend(TelegramConfig::secret_fields());
+    fields.extend(TwitchConfig::secret_fields());
+    fields.extend(EmailConfig::secret_fields());
+    fields
+}
+
+/// Auto-detect the category for a secret based on its name.
+///
+/// Secrets whose names match a known internal credential (LLM provider key,
+/// messaging adapter token, etc.) are categorized as `System` — never exposed
+/// to worker subprocesses. This includes:
+///
+/// - Exact matches against any [`SystemSecrets`] field's `secret_name`
+/// - Named instance patterns (e.g. `DISCORD_ALERTS_BOT_TOKEN`) — any name that
+///   matches `{PREFIX}_{ANYTHING}_{SUFFIX}` for a known adapter field with an
+///   [`InstancePattern`]
+///
+/// Everything else defaults to `Tool` — exposed to workers as environment
+/// variables. This is the safe default because user-added secrets are almost
+/// always credentials for CLI tools that workers invoke.
+pub fn auto_categorize(name: &str) -> SecretCategory {
+    let upper = name.to_uppercase();
 
-    Aes256Gcm::new_from_slice(&digest).map_err(|_| SecretsError::InvalidKey)
+    for field in system_secret_registry() {
+        // Exact match on the canonical secret name.
+        if upper == field.secret_name {
+            return SecretCategory::System;
+        }
+
+        // Named instance pattern: {PREFIX}_{ANYTHING}_{SUFFIX}
+        // e.g. DISCORD_ALERTS_BOT_TOKEN matches DISCORD + BOT_TOKEN
+        if let Some(pattern) = &field.instance_pattern {
+            let prefix = format!("{}_", pattern.platform_prefix);
+            let suffix = format!("_{}", pattern.field_suffix);
+            if upper.starts_with(&prefix)
+                && upper.ends_with(&suffix)
+                && upper.len() > prefix.len() + suffix.len()
+            {
+                return SecretCategory::System;
+            }
+        }
+    }
+
+    // Unknown secrets default to tool — they're most likely credentials for
+    // CLI tools that workers need (gh, npm, aws, docker, cargo, etc.).
+    SecretCategory::Tool
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::NamedTempFile;
+
+    fn temp_store() -> (SecretsStore, NamedTempFile) {
+        let file = NamedTempFile::new().expect("create temp file");
+        let store = SecretsStore::new(file.path()).expect("create store");
+        (store, file)
+    }
+
+    #[test]
+    fn unencrypted_set_get_delete() {
+        let (store, _file) = temp_store();
+        assert_eq!(store.state(), StoreState::Unencrypted);
+
+        store
+            .set("MY_KEY", "my_value", SecretCategory::Tool)
+            .expect("set");
+        let secret = store.get("MY_KEY").expect("get");
+        assert_eq!(secret.expose(), "my_value");
+
+        let meta = store.get_metadata("MY_KEY").expect("metadata");
+        assert_eq!(meta.category, SecretCategory::Tool);
+
+        store.delete("MY_KEY").expect("delete");
+        assert!(store.get("MY_KEY").is_err());
+    }
+
+    #[test]
+    fn tool_env_vars_returns_only_tool_secrets() {
+        let (store, _file) = temp_store();
+        store
+            .set("ANTHROPIC_API_KEY", "sk-ant-xxx", SecretCategory::System)
+            .expect("set system");
+        store
+            .set("GH_TOKEN", "ghp_abc123", SecretCategory::Tool)
+            .expect("set tool");
+
+        let env_vars = store.tool_env_vars();
+        assert_eq!(env_vars.len(), 1);
+        assert_eq!(env_vars.get("GH_TOKEN").unwrap(), "ghp_abc123");
+        assert!(!env_vars.contains_key("ANTHROPIC_API_KEY"));
+    }
+
+    #[test]
+    fn tool_secret_names_returns_only_tool_names() {
+        let (store, _file) = temp_store();
+        store
+            .set("OPENAI_API_KEY", "sk-xxx", SecretCategory::System)
+            .expect("set system");
+        store
+            .set("NPM_TOKEN", "npm_xxx", SecretCategory::Tool)
+            .expect("set tool");
+        store
+            .set("GH_TOKEN", "ghp_xxx", SecretCategory::Tool)
+            .expect("set tool");
+
+        let names = store.tool_secret_names();
+        assert_eq!(names.len(), 2);
+        assert!(names.contains(&"NPM_TOKEN".to_string()));
+        assert!(names.contains(&"GH_TOKEN".to_string()));
+    }
+
+    #[test]
+    fn encryption_lifecycle() {
+        let (store, _file) = temp_store();
+
+        // Store a secret in unencrypted mode.
+        store
+            .set("MY_SECRET", "plaintext_value", SecretCategory::System)
+            .expect("set");
+
+        // Enable encryption.
+        let master_key = store.enable_encryption().expect("encrypt");
+        assert_eq!(store.state(), StoreState::Unlocked);
+
+        // Secret is still readable.
+        let secret = store.get("MY_SECRET").expect("get after encrypt");
+        assert_eq!(secret.expose(), "plaintext_value");
+
+        // Lock the store.
+        store.lock().expect("lock");
+        assert_eq!(store.state(), StoreState::Locked);
+        assert!(store.get("MY_SECRET").is_err());
+
+        // Unlock with correct key.
+        store.unlock(&master_key).expect("unlock");
+        assert_eq!(store.state(), StoreState::Unlocked);
+        let secret = store.get("MY_SECRET").expect("get after unlock");
+        assert_eq!(secret.expose(), "plaintext_value");
+
+        // Wrong key fails.
+        store.lock().expect("lock again");
+        assert!(store.unlock(b"wrong_key").is_err());
+    }
+
+    #[test]
+    fn key_rotation() {
+        let (store, _file) = temp_store();
+        store
+            .set("MY_SECRET", "value123", SecretCategory::Tool)
+            .expect("set");
+        let _old_key = store.enable_encryption().expect("encrypt");
+
+        // Rotate.
+        let new_key = store.rotate_key().expect("rotate");
+
+        // Secret still readable with new cipher.
+        let secret = store.get("MY_SECRET").expect("get after rotate");
+        assert_eq!(secret.expose(), "value123");
+
+        // Lock and unlock with new key.
+        store.lock().expect("lock");
+        store.unlock(&new_key).expect("unlock with new key");
+        let secret = store.get("MY_SECRET").expect("get after re-unlock");
+        assert_eq!(secret.expose(), "value123");
+    }
+
+    #[test]
+    fn auto_categorize_known_patterns() {
+        // Tool secrets — anything not recognized defaults to Tool.
+        assert_eq!(auto_categorize("GH_TOKEN"), SecretCategory::Tool);
+        assert_eq!(auto_categorize("GITHUB_TOKEN"), SecretCategory::Tool);
+        assert_eq!(auto_categorize("NPM_TOKEN"), SecretCategory::Tool);
+        assert_eq!(auto_categorize("AWS_ACCESS_KEY_ID"), SecretCategory::Tool);
+        assert_eq!(auto_categorize("AWS_SESSION_TOKEN"), SecretCategory::Tool);
+        assert_eq!(auto_categorize("UNKNOWN_CREDENTIAL"), SecretCategory::Tool);
+        assert_eq!(auto_categorize("DOCKER_TOKEN"), SecretCategory::Tool);
+        assert_eq!(
+            auto_categorize("CARGO_REGISTRY_TOKEN"),
+            SecretCategory::Tool
+        );
+
+        // Non-adapter system secrets (LLM provider keys):
+        assert_eq!(auto_categorize("ANTHROPIC_API_KEY"), SecretCategory::System);
+        assert_eq!(auto_categorize("OPENAI_API_KEY"), SecretCategory::System);
+        assert_eq!(
+            auto_categorize("OPENROUTER_API_KEY"),
+            SecretCategory::System
+        );
+        assert_eq!(auto_categorize("GEMINI_API_KEY"), SecretCategory::System);
+        assert_eq!(auto_categorize("DEEPSEEK_API_KEY"), SecretCategory::System);
+        assert_eq!(auto_categorize("CEREBRAS_API_KEY"), SecretCategory::System);
+
+        // Messaging adapter tokens (default adapters via AdapterSecrets):
+        assert_eq!(auto_categorize("DISCORD_BOT_TOKEN"), SecretCategory::System);
+        assert_eq!(auto_categorize("SLACK_BOT_TOKEN"), SecretCategory::System);
+        assert_eq!(auto_categorize("SLACK_APP_TOKEN"), SecretCategory::System);
+        assert_eq!(
+            auto_categorize("TELEGRAM_BOT_TOKEN"),
+            SecretCategory::System
+        );
+        assert_eq!(
+            auto_categorize("TWITCH_OAUTH_TOKEN"),
+            SecretCategory::System
+        );
+        assert_eq!(
+            auto_categorize("TWITCH_CLIENT_SECRET"),
+            SecretCategory::System
+        );
+        assert_eq!(
+            auto_categorize("EMAIL_IMAP_PASSWORD"),
+            SecretCategory::System
+        );
+        assert_eq!(
+            auto_categorize("EMAIL_SMTP_USERNAME"),
+            SecretCategory::System
+        );
+
+        // Named instance patterns — {PREFIX}_{INSTANCE}_{SUFFIX} → System:
+        assert_eq!(
+            auto_categorize("DISCORD_ALERTS_BOT_TOKEN"),
+            SecretCategory::System
+        );
+        assert_eq!(
+            auto_categorize("SLACK_SUPPORT_BOT_TOKEN"),
+            SecretCategory::System
+        );
+        assert_eq!(
+            auto_categorize("SLACK_SUPPORT_APP_TOKEN"),
+            SecretCategory::System
+        );
+        assert_eq!(
+            auto_categorize("TELEGRAM_NOTIFICATIONS_BOT_TOKEN"),
+            SecretCategory::System
+        );
+        assert_eq!(
+            auto_categorize("TWITCH_GAMING_OAUTH_TOKEN"),
+            SecretCategory::System
+        );
+        assert_eq!(
+            auto_categorize("TWITCH_GAMING_CLIENT_SECRET"),
+            SecretCategory::System
+        );
+        assert_eq!(
+            auto_categorize("EMAIL_SUPPORT_IMAP_PASSWORD"),
+            SecretCategory::System
+        );
+        assert_eq!(
+            auto_categorize("EMAIL_BILLING_SMTP_PASSWORD"),
+            SecretCategory::System
+        );
+
+        // Search integrations:
+        assert_eq!(
+            auto_categorize("BRAVE_SEARCH_API_KEY"),
+            SecretCategory::System
+        );
+
+        // Case-insensitive matching:
+        assert_eq!(auto_categorize("anthropic_api_key"), SecretCategory::System);
+        assert_eq!(auto_categorize("Openai_Api_Key"), SecretCategory::System);
+        assert_eq!(
+            auto_categorize("discord_alerts_bot_token"),
+            SecretCategory::System
+        );
+    }
+
+    #[test]
+    fn decrypted_secret_redacts_display() {
+        let secret = DecryptedSecret("super_secret_value".to_string());
+        assert_eq!(format!("{secret}"), "***");
+        assert_eq!(format!("{secret:?}"), "DecryptedSecret(***)");
+        assert_eq!(secret.expose(), "super_secret_value");
+    }
+
+    #[test]
+    fn list_metadata_works_in_all_states() {
+        let (store, _file) = temp_store();
+        store
+            .set("KEY1", "val1", SecretCategory::System)
+            .expect("set");
+        store
+            .set("KEY2", "val2", SecretCategory::Tool)
+            .expect("set");
+
+        // Unencrypted: metadata readable.
+        let meta = store.list_metadata().expect("list");
+        assert_eq!(meta.len(), 2);
+
+        // Enable encryption.
+        let master_key = store.enable_encryption().expect("encrypt");
+
+        // Unlocked: metadata readable.
+        let meta = store.list_metadata().expect("list");
+        assert_eq!(meta.len(), 2);
+
+        // Locked: metadata still readable.
+        store.lock().expect("lock");
+        let meta = store.list_metadata().expect("list");
+        assert_eq!(meta.len(), 2);
+
+        // But values are not.
+        assert!(store.get("KEY1").is_err());
+
+        // Unlock restores access.
+        store.unlock(&master_key).expect("unlock");
+        assert_eq!(store.get("KEY1").expect("get").expose(), "val1");
+    }
+
+    #[test]
+    fn export_import_roundtrip() {
+        let (store1, _file1) = temp_store();
+        store1
+            .set("KEY_A", "value_a", SecretCategory::System)
+            .expect("set");
+        store1
+            .set("KEY_B", "value_b", SecretCategory::Tool)
+            .expect("set");
+
+        let export = store1.export_all().expect("export");
+        assert_eq!(export.entries.len(), 2);
+        assert_eq!(export.version, 1);
+
+        // Import into a fresh store.
+        let (store2, _file2) = temp_store();
+        let result = store2.import_all(&export, false).expect("import");
+        assert_eq!(result.imported, 2);
+        assert!(result.skipped.is_empty());
+
+        assert_eq!(store2.get("KEY_A").expect("get").expose(), "value_a");
+        assert_eq!(store2.get("KEY_B").expect("get").expose(), "value_b");
+        assert_eq!(
+            store2.get_metadata("KEY_B").expect("meta").category,
+            SecretCategory::Tool
+        );
+    }
+
+    #[test]
+    fn import_skips_existing_without_overwrite() {
+        let (store, _file) = temp_store();
+        store
+            .set("EXISTING", "original", SecretCategory::System)
+            .expect("set");
+
+        let export = ExportData {
+            version: 1,
+            encrypted: false,
+            entries: vec![
+                ExportEntry {
+                    name: "EXISTING".to_string(),
+                    value: "new_value".to_string(),
+                    category: SecretCategory::Tool,
+                    created_at: chrono::Utc::now(),
+                    updated_at: chrono::Utc::now(),
+                },
+                ExportEntry {
+                    name: "FRESH".to_string(),
+                    value: "fresh_value".to_string(),
+                    category: SecretCategory::Tool,
+                    created_at: chrono::Utc::now(),
+                    updated_at: chrono::Utc::now(),
+                },
+            ],
+        };
+
+        let result = store.import_all(&export, false).expect("import");
+        assert_eq!(result.imported, 1);
+        assert_eq!(result.skipped, vec!["EXISTING"]);
+
+        // Original value preserved.
+        assert_eq!(store.get("EXISTING").expect("get").expose(), "original");
+        // New secret imported.
+        assert_eq!(store.get("FRESH").expect("get").expose(), "fresh_value");
+    }
+
+    #[test]
+    fn import_overwrites_existing_when_requested() {
+        let (store, _file) = temp_store();
+        store
+            .set("EXISTING", "original", SecretCategory::System)
+            .expect("set");
+
+        let export = ExportData {
+            version: 1,
+            encrypted: false,
+            entries: vec![ExportEntry {
+                name: "EXISTING".to_string(),
+                value: "overwritten".to_string(),
+                category: SecretCategory::Tool,
+                created_at: chrono::Utc::now(),
+                updated_at: chrono::Utc::now(),
+            }],
+        };
+
+        let result = store.import_all(&export, true).expect("import");
+        assert_eq!(result.imported, 1);
+        assert!(result.skipped.is_empty());
+
+        assert_eq!(store.get("EXISTING").expect("get").expose(), "overwritten");
+    }
+
+    #[test]
+    fn set_updates_existing_preserves_created_at() {
+        let (store, _file) = temp_store();
+        store
+            .set("MY_KEY", "v1", SecretCategory::Tool)
+            .expect("set");
+        let meta1 = store.get_metadata("MY_KEY").expect("meta");
+
+        // Update value and category.
+        store
+            .set("MY_KEY", "v2", SecretCategory::System)
+            .expect("update");
+        let meta2 = store.get_metadata("MY_KEY").expect("meta");
+
+        assert_eq!(meta2.created_at, meta1.created_at);
+        assert!(meta2.updated_at >= meta1.updated_at);
+        assert_eq!(meta2.category, SecretCategory::System);
+        assert_eq!(store.get("MY_KEY").expect("get").expose(), "v2");
+    }
+
+    #[test]
+    fn secret_field_name_generation() {
+        // Adapter field with instance pattern.
+        let field = SecretField {
+            toml_key: "token",
+            secret_name: "DISCORD_BOT_TOKEN",
+            instance_pattern: Some(InstancePattern {
+                platform_prefix: "DISCORD",
+                field_suffix: "BOT_TOKEN",
+            }),
+        };
+
+        assert_eq!(field.secret_name, "DISCORD_BOT_TOKEN");
+        assert_eq!(
+            field.instance_name("alerts"),
+            Some("DISCORD_ALERTS_BOT_TOKEN".to_string())
+        );
+        assert_eq!(
+            field.instance_name("my-bot"),
+            Some("DISCORD_MY-BOT_BOT_TOKEN".to_string())
+        );
+
+        // Multi-field adapter (Slack).
+        let bot = SecretField {
+            toml_key: "bot_token",
+            secret_name: "SLACK_BOT_TOKEN",
+            instance_pattern: Some(InstancePattern {
+                platform_prefix: "SLACK",
+                field_suffix: "BOT_TOKEN",
+            }),
+        };
+        let app = SecretField {
+            toml_key: "app_token",
+            secret_name: "SLACK_APP_TOKEN",
+            instance_pattern: Some(InstancePattern {
+                platform_prefix: "SLACK",
+                field_suffix: "APP_TOKEN",
+            }),
+        };
+        assert_eq!(bot.secret_name, "SLACK_BOT_TOKEN");
+        assert_eq!(
+            bot.instance_name("support"),
+            Some("SLACK_SUPPORT_BOT_TOKEN".to_string())
+        );
+        assert_eq!(app.secret_name, "SLACK_APP_TOKEN");
+        assert_eq!(
+            app.instance_name("support"),
+            Some("SLACK_SUPPORT_APP_TOKEN".to_string())
+        );
+
+        // Non-adapter field (LLM key) — no instance pattern.
+        let llm_field = SecretField {
+            toml_key: "anthropic_key",
+            secret_name: "ANTHROPIC_API_KEY",
+            instance_pattern: None,
+        };
+        assert_eq!(llm_field.secret_name, "ANTHROPIC_API_KEY");
+        assert_eq!(llm_field.instance_name("anything"), None);
+    }
+
+    #[test]
+    fn system_secret_registry_contains_all_sections() {
+        let fields = system_secret_registry();
+
+        // Helper: check if a secret name is in the registry.
+        let has_secret = |name: &str| fields.iter().any(|f| f.secret_name == name);
+
+        // LLM provider keys.
+        assert!(has_secret("ANTHROPIC_API_KEY"), "missing ANTHROPIC_API_KEY");
+        assert!(has_secret("OPENAI_API_KEY"), "missing OPENAI_API_KEY");
+        assert!(has_secret("DEEPSEEK_API_KEY"), "missing DEEPSEEK_API_KEY");
+
+        // Search / internal tool keys.
+        assert!(
+            has_secret("BRAVE_SEARCH_API_KEY"),
+            "missing BRAVE_SEARCH_API_KEY"
+        );
+
+        // Messaging adapter defaults.
+        assert!(has_secret("DISCORD_BOT_TOKEN"), "missing DISCORD_BOT_TOKEN");
+        assert!(has_secret("SLACK_BOT_TOKEN"), "missing SLACK_BOT_TOKEN");
+        assert!(has_secret("SLACK_APP_TOKEN"), "missing SLACK_APP_TOKEN");
+        assert!(
+            has_secret("TELEGRAM_BOT_TOKEN"),
+            "missing TELEGRAM_BOT_TOKEN"
+        );
+        assert!(
+            has_secret("TWITCH_OAUTH_TOKEN"),
+            "missing TWITCH_OAUTH_TOKEN"
+        );
+        assert!(
+            has_secret("EMAIL_IMAP_PASSWORD"),
+            "missing EMAIL_IMAP_PASSWORD"
+        );
+
+        // Adapter fields have instance patterns, LLM fields don't.
+        let discord_field = fields
+            .iter()
+            .find(|f| f.secret_name == "DISCORD_BOT_TOKEN")
+            .expect("Discord field");
+        assert!(discord_field.instance_pattern.is_some());
+
+        let anthropic_field = fields
+            .iter()
+            .find(|f| f.secret_name == "ANTHROPIC_API_KEY")
+            .expect("Anthropic field");
+        assert!(anthropic_field.instance_pattern.is_none());
+    }
 }
diff --git a/src/self_awareness.rs b/src/self_awareness.rs
new file mode 100644
index 000000000..03ee39a36
--- /dev/null
+++ b/src/self_awareness.rs
@@ -0,0 +1,693 @@
+//! Embedded Spacebot self-knowledge for introspection and diagnostics.
+//!
+//! This module bundles key docs into the binary and exposes helpers used by:
+//! - cortex chat prompt enrichment (AGENTS + changelog + live config snapshot)
+//! - `spacebot_docs` tool (on-demand document retrieval)
+//! - `config_inspect` tool (redacted runtime config visibility)
+
+use crate::config::{McpTransport, RuntimeConfig};
+use rust_embed::Embed;
+use serde::Serialize;
+use serde_json::json;
+use std::sync::OnceLock;
+
+#[derive(Embed)]
+#[folder = "docs/content/"]
+struct ContentDocsAssets;
+
+const AGENTS_DOC: &str = include_str!("../AGENTS.md");
+const README_DOC: &str = include_str!("../README.md");
+const CHANGELOG_DOC: &str = include_str!("../CHANGELOG.md");
+const DOCS_README_DOC: &str = include_str!("../docs/README.md");
+const DOCS_DOCKER_DOC: &str = include_str!("../docs/docker.md");
+const DOCS_METRICS_DOC: &str = include_str!("../docs/metrics.md");
+const CORTEX_AGENTS_MAX_LINES: usize = 220;
+const CORTEX_AGENTS_MAX_CHARS: usize = 24_000;
+const CORTEX_CHANGELOG_MAX_LINES: usize = 220;
+const CORTEX_CHANGELOG_MAX_CHARS: usize = 24_000;
+
+#[derive(Debug, Clone, Serialize)]
+pub struct EmbeddedDocSummary {
+    pub id: String,
+    pub title: String,
+    pub path: String,
+    pub section: String,
+    pub line_count: usize,
+}
+
+#[derive(Debug, Clone)]
+pub struct EmbeddedDoc {
+    pub summary: EmbeddedDocSummary,
+    pub content: String,
+}
+
+/// Full embedded `AGENTS.md` content.
+pub fn agents_manifest() -> &'static str {
+    AGENTS_DOC
+}
+
+/// Prompt-sized `AGENTS.md` content for cortex chat.
+pub fn agents_manifest_for_prompt() -> String {
+    truncate_for_prompt(
+        AGENTS_DOC,
+        CORTEX_AGENTS_MAX_LINES,
+        CORTEX_AGENTS_MAX_CHARS,
+        "AGENTS.md",
+    )
+}
+
+/// Most recent release notes extracted from `CHANGELOG.md`.
+pub fn changelog_highlights() -> String {
+    let highlights = latest_release_notes(CHANGELOG_DOC, 3).unwrap_or_else(|| {
+        CHANGELOG_DOC
+            .lines()
+            .take(200)
+            .collect::<Vec<_>>()
+            .join("\n")
+    });
+
+    truncate_for_prompt(
+        &highlights,
+        CORTEX_CHANGELOG_MAX_LINES,
+        CORTEX_CHANGELOG_MAX_CHARS,
+        "CHANGELOG.md",
+    )
+}
+
+/// Pretty JSON snapshot of the current live runtime config (redacted).
+pub fn runtime_snapshot_pretty(agent_id: &str, runtime_config: &RuntimeConfig) -> String {
+    serde_json::to_string_pretty(&runtime_snapshot_value(agent_id, runtime_config)).unwrap_or_else(
+        |error| format!("{{\"error\":\"failed to serialize runtime snapshot: {error}\"}}"),
+    )
+}
+
+/// Structured runtime snapshot used by cortex prompting and config inspection.
+pub fn runtime_snapshot_value(agent_id: &str, runtime_config: &RuntimeConfig) -> serde_json::Value {
+    let routing = runtime_config.routing.load();
+    let compaction = runtime_config.compaction.load();
+    let memory_persistence = runtime_config.memory_persistence.load();
+    let coalesce = runtime_config.coalesce.load();
+    let ingestion = runtime_config.ingestion.load();
+    let cortex = runtime_config.cortex.load();
+    let warmup = runtime_config.warmup.load();
+    let warmup_status = runtime_config.warmup_status.load();
+    let browser = runtime_config.browser_config.load();
+    let sandbox = runtime_config.sandbox.load();
+    let opencode = runtime_config.opencode.load();
+    let mcp_servers = runtime_config
+        .mcp
+        .load()
+        .iter()
+        .map(|server| {
+            let transport = match &server.transport {
+                McpTransport::Stdio { command, args, env } => {
+                    let mut env_keys = env.keys().cloned().collect::<Vec<_>>();
+                    env_keys.sort();
+                    json!({
+                        "kind": "stdio",
+                        "command": command,
+                        "args_count": args.len(),
+                        "env_keys": env_keys,
+                    })
+                }
+                McpTransport::Http { url, headers } => {
+                    let mut header_keys = headers.keys().cloned().collect::<Vec<_>>();
+                    header_keys.sort();
+                    json!({
+                        "kind": "http",
+                        "url": url,
+                        "header_keys": header_keys,
+                    })
+                }
+            };
+
+            json!({
+                "name": server.name,
+                "enabled": server.enabled,
+                "transport": transport,
+            })
+        })
+        .collect::<Vec<_>>();
+
+    let readiness = runtime_config.work_readiness();
+    let memory_bulletin = runtime_config.memory_bulletin.load();
+    let secrets = runtime_config.secrets.load();
+    let secrets_snapshot = if let Some(store) = secrets.as_ref() {
+        match store.status(false) {
+            Ok(status) => json!({
+                "configured": true,
+                "state": status.state.to_string(),
+                "encrypted": status.encrypted,
+                "secret_count": status.secret_count,
+                "system_count": status.system_count,
+                "tool_count": status.tool_count,
+            }),
+            Err(error) => json!({
+                "configured": true,
+                "error": error.to_string(),
+            }),
+        }
+    } else {
+        json!({
+            "configured": false,
+        })
+    };
+
+    json!({
+        "generated_at": chrono::Utc::now().to_rfc3339(),
+        "agent_id": agent_id,
+        "binary_version": crate::update::CURRENT_VERSION,
+        "deployment": deployment_label(crate::update::Deployment::detect()),
+        "paths": {
+            "instance_dir": runtime_config.instance_dir.display().to_string(),
+            "workspace_dir": runtime_config.workspace_dir.display().to_string(),
+        },
+        "routing": {
+            "channel": routing.channel,
+            "branch": routing.branch,
+            "worker": routing.worker,
+            "compactor": routing.compactor,
+            "cortex": routing.cortex,
+            "voice": routing.voice,
+            "rate_limit_cooldown_secs": routing.rate_limit_cooldown_secs,
+        },
+        "limits": {
+            "max_turns": **runtime_config.max_turns.load(),
+            "branch_max_turns": **runtime_config.branch_max_turns.load(),
+            "context_window": **runtime_config.context_window.load(),
+            "max_concurrent_branches": **runtime_config.max_concurrent_branches.load(),
+            "max_concurrent_workers": **runtime_config.max_concurrent_workers.load(),
+            "history_backfill_count": **runtime_config.history_backfill_count.load(),
+        },
+        "compaction": {
+            "background_threshold": compaction.background_threshold,
+            "aggressive_threshold": compaction.aggressive_threshold,
+            "emergency_threshold": compaction.emergency_threshold,
+        },
+        "memory_persistence": {
+            "enabled": memory_persistence.enabled,
+            "message_interval": memory_persistence.message_interval,
+        },
+        "coalesce": {
+            "enabled": coalesce.enabled,
+            "debounce_ms": coalesce.debounce_ms,
+            "max_wait_ms": coalesce.max_wait_ms,
+            "min_messages": coalesce.min_messages,
+            "multi_user_only": coalesce.multi_user_only,
+        },
+        "ingestion": {
+            "enabled": ingestion.enabled,
+            "poll_interval_secs": ingestion.poll_interval_secs,
+            "chunk_size": ingestion.chunk_size,
+        },
+        "cortex": {
+            "tick_interval_secs": cortex.tick_interval_secs,
+            "worker_timeout_secs": cortex.worker_timeout_secs,
+            "branch_timeout_secs": cortex.branch_timeout_secs,
+            "circuit_breaker_threshold": cortex.circuit_breaker_threshold,
+            "bulletin_interval_secs": cortex.bulletin_interval_secs,
+            "bulletin_max_words": cortex.bulletin_max_words,
+            "bulletin_max_turns": cortex.bulletin_max_turns,
+            "association_interval_secs": cortex.association_interval_secs,
+            "association_similarity_threshold": cortex.association_similarity_threshold,
+            "association_updates_threshold": cortex.association_updates_threshold,
+            "association_max_per_pass": cortex.association_max_per_pass,
+        },
+        "warmup": {
+            "enabled": warmup.enabled,
+            "eager_embedding_load": warmup.eager_embedding_load,
+            "refresh_secs": warmup.refresh_secs,
+            "startup_delay_secs": warmup.startup_delay_secs,
+            "state": warmup_status.state,
+            "embedding_ready": warmup_status.embedding_ready,
+            "last_refresh_unix_ms": warmup_status.last_refresh_unix_ms,
+            "last_error": warmup_status.last_error,
+            "bulletin_age_secs": warmup_status.bulletin_age_secs,
+        },
+        "work_readiness": {
+            "ready": readiness.ready,
+            "reason": readiness.reason.map(|reason| reason.as_str()),
+            "warmup_state": readiness.warmup_state,
+            "embedding_ready": readiness.embedding_ready,
+            "bulletin_age_secs": readiness.bulletin_age_secs,
+            "stale_after_secs": readiness.stale_after_secs,
+        },
+        "browser": {
+            "enabled": browser.enabled,
+            "headless": browser.headless,
+            "evaluate_enabled": browser.evaluate_enabled,
+            "executable_path": browser.executable_path,
+            "screenshot_dir": browser
+                .screenshot_dir
+                .as_ref()
+                .map(|path| path.display().to_string()),
+            "chrome_cache_dir": browser.chrome_cache_dir.display().to_string(),
+        },
+        "sandbox": {
+            "mode": match sandbox.mode {
+                crate::sandbox::SandboxMode::Enabled => "enabled",
+                crate::sandbox::SandboxMode::Disabled => "disabled",
+            },
+            "writable_paths": sandbox
+                .writable_paths
+                .iter()
+                .map(|path| path.display().to_string())
+                .collect::<Vec<_>>(),
+            "passthrough_env": sandbox.passthrough_env,
+        },
+        "opencode": {
+            "enabled": opencode.enabled,
+            "path": opencode.path,
+            "max_servers": opencode.max_servers,
+            "server_startup_timeout_secs": opencode.server_startup_timeout_secs,
+            "max_restart_retries": opencode.max_restart_retries,
+            "permissions": opencode.permissions,
+        },
+        "mcp_servers": mcp_servers,
+        "brave_search": {
+            "configured": runtime_config.brave_search_key.load().is_some(),
+        },
+        "timezones": {
+            "cron_timezone": runtime_config.cron_timezone.load().as_ref().clone(),
+            "user_timezone": runtime_config.user_timezone.load().as_ref().clone(),
+        },
+        "bulletin": {
+            "is_empty": memory_bulletin.trim().is_empty(),
+            "char_count": memory_bulletin.len(),
+        },
+        "secrets": secrets_snapshot,
+    })
+}
+
+/// List all embedded docs with optional text filter.
+pub fn list_embedded_docs(filter: Option<&str>) -> Vec<EmbeddedDocSummary> {
+    let mut docs = docs_catalog()
+        .iter()
+        .map(|doc| doc.summary.clone())
+        .collect::<Vec<_>>();
+
+    if let Some(raw_filter) = filter {
+        let filter = normalize_lookup(raw_filter);
+        if !filter.is_empty() {
+            docs.retain(|doc| {
+                doc.id.to_ascii_lowercase().contains(&filter)
+                    || doc.path.to_ascii_lowercase().contains(&filter)
+                    || doc.title.to_ascii_lowercase().contains(&filter)
+                    || doc.section.to_ascii_lowercase().contains(&filter)
+            });
+        }
+    }
+
+    docs
+}
+
+/// Search docs by query string (ID, title, section, or path).
+pub fn search_embedded_docs(query: &str) -> Vec<EmbeddedDocSummary> {
+    list_embedded_docs(Some(query))
+}
+
+/// Get a doc by ID/path, with lightweight fuzzy matching.
+///
+/// Matching strategy:
+/// 1. exact ID (case-insensitive)
+/// 2. exact path (case-insensitive)
+/// 3. single fuzzy hit on ID/path/title contains
+pub fn get_embedded_doc(query: &str) -> Option<EmbeddedDoc> {
+    let normalized = normalize_lookup(query);
+    if normalized.is_empty() {
+        return None;
+    }
+
+    if let Some(doc) = docs_catalog()
+        .iter()
+        .find(|doc| normalize_lookup(&doc.summary.id) == normalized)
+    {
+        return Some(doc.clone());
+    }
+
+    if let Some(doc) = docs_catalog()
+        .iter()
+        .find(|doc| normalize_lookup(&doc.summary.path) == normalized)
+    {
+        return Some(doc.clone());
+    }
+
+    let mut matches = docs_catalog()
+        .iter()
+        .filter(|doc| {
+            let id = doc.summary.id.to_ascii_lowercase();
+            let path = doc.summary.path.to_ascii_lowercase();
+            let title = doc.summary.title.to_ascii_lowercase();
+            id.contains(&normalized) || path.contains(&normalized) || title.contains(&normalized)
+        })
+        .cloned()
+        .collect::<Vec<_>>();
+
+    if matches.len() == 1 {
+        return matches.pop();
+    }
+
+    None
+}
+
+fn docs_catalog() -> &'static [EmbeddedDoc] {
+    static CATALOG: OnceLock<Vec<EmbeddedDoc>> = OnceLock::new();
+    CATALOG.get_or_init(build_docs_catalog).as_slice()
+}
+
+fn build_docs_catalog() -> Vec<EmbeddedDoc> {
+    let mut docs = Vec::new();
+
+    push_static_doc(
+        &mut docs,
+        "agents",
+        "AGENTS",
+        "AGENTS.md",
+        "repo",
+        AGENTS_DOC.to_string(),
+    );
+    push_static_doc(
+        &mut docs,
+        "readme",
+        "README",
+        "README.md",
+        "repo",
+        README_DOC.to_string(),
+    );
+    push_static_doc(
+        &mut docs,
+        "changelog",
+        "Changelog",
+        "CHANGELOG.md",
+        "repo",
+        CHANGELOG_DOC.to_string(),
+    );
+    push_static_doc(
+        &mut docs,
+        "docs/readme",
+        "Docs README",
+        "docs/README.md",
+        "docs",
+        DOCS_README_DOC.to_string(),
+    );
+    push_static_doc(
+        &mut docs,
+        "docs/docker",
+        "Docker Guide",
+        "docs/docker.md",
+        "docs",
+        DOCS_DOCKER_DOC.to_string(),
+    );
+    push_static_doc(
+        &mut docs,
+        "docs/metrics",
+        "Metrics",
+        "docs/metrics.md",
+        "docs",
+        DOCS_METRICS_DOC.to_string(),
+    );
+
+    for relative in ContentDocsAssets::iter() {
+        let relative = relative.as_ref();
+        if !is_markdown(relative) {
+            continue;
+        }
+
+        let Some(file) = ContentDocsAssets::get(relative) else {
+            continue;
+        };
+
+        let content = String::from_utf8_lossy(file.data.as_ref()).into_owned();
+        let title = extract_doc_title(&content, relative);
+        let id = product_doc_id(relative);
+        let path = format!("docs/content/{relative}");
+
+        push_static_doc(&mut docs, &id, &title, &path, "product_docs", content);
+    }
+
+    docs.sort_by(|left, right| left.summary.id.cmp(&right.summary.id));
+    docs
+}
+
+fn push_static_doc(
+    docs: &mut Vec<EmbeddedDoc>,
+    id: &str,
+    title: &str,
+    path: &str,
+    section: &str,
+    content: String,
+) {
+    let line_count = content.lines().count();
+    docs.push(EmbeddedDoc {
+        summary: EmbeddedDocSummary {
+            id: id.to_string(),
+            title: title.to_string(),
+            path: path.to_string(),
+            section: section.to_string(),
+            line_count,
+        },
+        content,
+    });
+}
+
+fn latest_release_notes(changelog: &str, max_releases: usize) -> Option<String> {
+    if max_releases == 0 {
+        return None;
+    }
+
+    let is_release_heading = |line: &str| {
+        let heading = line.strip_prefix("## ").map(str::trim).unwrap_or("");
+        let version = heading
+            .strip_prefix('v')
+            .or_else(|| heading.strip_prefix('V'))
+            .unwrap_or(heading);
+        let mut parts = version.split('.');
+        let major = parts.next();
+        let minor = parts.next();
+        let patch = parts.next();
+        let rest = parts.next();
+
+        major.is_some_and(|part| part.chars().all(|c| c.is_ascii_digit()) && !part.is_empty())
+            && minor
+                .is_some_and(|part| part.chars().all(|c| c.is_ascii_digit()) && !part.is_empty())
+            && patch
+                .is_some_and(|part| part.chars().all(|c| c.is_ascii_digit()) && !part.is_empty())
+            && rest.is_none()
+    };
+
+    let mut sections = Vec::new();
+    let mut current = Vec::new();
+    let mut in_release = false;
+
+    for line in changelog.lines() {
+        if line.starts_with("## ") && is_release_heading(line) {
+            if !current.is_empty() {
+                sections.push(current.join("\n"));
+                current.clear();
+            }
+            in_release = true;
+        }
+
+        if in_release {
+            current.push(line);
+        }
+    }
+
+    if !current.is_empty() {
+        sections.push(current.join("\n"));
+    }
+
+    if sections.is_empty() {
+        None
+    } else {
+        Some(
+            sections
+                .into_iter()
+                .take(max_releases)
+                .collect::<Vec<_>>()
+                .join("\n\n"),
+        )
+    }
+}
+
+fn extract_doc_title(content: &str, relative_path: &str) -> String {
+    for line in content.lines() {
+        let trimmed = line.trim();
+        if let Some(title) = trimmed.strip_prefix("title:") {
+            let title = title.trim().trim_matches('"').trim_matches(char::from(39));
+            if !title.is_empty() {
+                return title.to_string();
+            }
+        }
+        if let Some(title) = trimmed.strip_prefix("# ") {
+            let title = title.trim();
+            if !title.is_empty() {
+                return title.to_string();
+            }
+        }
+    }
+
+    let fallback = remove_extension(relative_path)
+        .rsplit('/')
+        .next()
+        .unwrap_or(relative_path)
+        .replace(['-', '_'], " ");
+    if fallback.is_empty() {
+        "Untitled".to_string()
+    } else {
+        fallback
+    }
+}
+
+fn product_doc_id(relative_path: &str) -> String {
+    let mut normalized = normalize_doc_path(remove_extension(relative_path));
+    if let Some(stripped) = normalized.strip_prefix("docs/") {
+        normalized = stripped.to_string();
+    }
+    if normalized == "index" {
+        normalized = "home".to_string();
+    } else if let Some(prefix) = normalized.strip_suffix("/index") {
+        normalized = prefix.to_string();
+    }
+    format!("docs/{normalized}")
+}
+
+fn normalize_doc_path(path: &str) -> String {
+    path.split('/')
+        .filter(|segment| !segment.is_empty())
+        .map(strip_group_segment)
+        .collect::<Vec<_>>()
+        .join("/")
+}
+
+fn strip_group_segment(segment: &str) -> String {
+    if segment.starts_with('(') && segment.ends_with(')') && segment.len() > 2 {
+        return segment[1..segment.len() - 1].to_string();
+    }
+    segment.to_string()
+}
+
+fn remove_extension(path: &str) -> &str {
+    path.strip_suffix(".mdx")
+        .or_else(|| path.strip_suffix(".md"))
+        .unwrap_or(path)
+}
+
+fn is_markdown(path: &str) -> bool {
+    path.ends_with(".md") || path.ends_with(".mdx")
+}
+
+fn normalize_lookup(value: &str) -> String {
+    value.trim().trim_start_matches('/').to_ascii_lowercase()
+}
+
+fn truncate_for_prompt(content: &str, max_lines: usize, max_chars: usize, label: &str) -> String {
+    let limited_lines = content.lines().take(max_lines).collect::<Vec<_>>();
+    let mut output = limited_lines.join("\n");
+    let mut truncated = content.lines().count() > limited_lines.len();
+
+    if output.chars().count() > max_chars {
+        output = output.chars().take(max_chars).collect::<String>();
+        truncated = true;
+    }
+
+    if truncated {
+        output.push_str(&format!(
+            "\n\n_[{label} truncated in prompt; use `spacebot_docs` for full content.]_"
+        ));
+    }
+
+    output
+}
+
+fn deployment_label(deployment: crate::update::Deployment) -> &'static str {
+    match deployment {
+        crate::update::Deployment::Docker => "docker",
+        crate::update::Deployment::Hosted => "hosted",
+        crate::update::Deployment::Native => "native",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::BTreeSet;
+
+    #[test]
+    fn latest_release_notes_returns_top_release_sections() {
+        let changelog = "# Changelog\n\nIntro\n\n## v3.0.0\nA\n\n## What's Changed\n- item\n\n## v2.0.0\nB\n\n## v1.0.0\nC\n";
+        let section = latest_release_notes(changelog, 2).expect("sections should exist");
+        assert!(section.contains("## v3.0.0"));
+        assert!(section.contains("## v2.0.0"));
+        assert!(!section.contains("## v1.0.0"));
+        assert!(section.contains("## What's Changed"));
+    }
+
+    #[test]
+    fn truncate_for_prompt_adds_notice_when_content_is_trimmed() {
+        let text = "line1\nline2\nline3\nline4";
+        let output = truncate_for_prompt(text, 2, 500, "test.md");
+        assert!(output.contains("line1\nline2"));
+        assert!(output.contains("truncated in prompt"));
+    }
+
+    #[test]
+    fn normalize_doc_path_strips_group_segments() {
+        assert_eq!(
+            normalize_doc_path("(core)/architecture"),
+            "core/architecture"
+        );
+        assert_eq!(
+            normalize_doc_path("(messaging)/discord-setup"),
+            "messaging/discord-setup"
+        );
+    }
+
+    #[test]
+    fn product_doc_id_maps_index_to_home_or_section_root() {
+        assert_eq!(product_doc_id("index.mdx"), "docs/home");
+        assert_eq!(product_doc_id("(core)/index.mdx"), "docs/core");
+        assert_eq!(product_doc_id("(core)/cortex.mdx"), "docs/core/cortex");
+        assert_eq!(product_doc_id("docs/(core)/cortex.mdx"), "docs/core/cortex");
+    }
+
+    #[test]
+    fn product_docs_catalog_matches_embedded_content_assets() {
+        let expected = ContentDocsAssets::iter()
+            .map(|relative| relative.to_string())
+            .filter(|relative| is_markdown(relative))
+            .map(|relative| format!("docs/content/{relative}"))
+            .collect::<BTreeSet<_>>();
+
+        let actual = list_embedded_docs(None)
+            .into_iter()
+            .filter(|doc| doc.section == "product_docs")
+            .map(|doc| doc.path)
+            .collect::<BTreeSet<_>>();
+
+        let missing = expected.difference(&actual).cloned().collect::<Vec<_>>();
+        let unexpected = actual.difference(&expected).cloned().collect::<Vec<_>>();
+
+        assert!(
+            missing.is_empty() && unexpected.is_empty(),
+            "product docs mismatch\nmissing: {:?}\nunexpected: {:?}",
+            missing,
+            unexpected
+        );
+    }
+
+    #[test]
+    fn bundled_docs_inventory_is_accessible() {
+        let mut docs = list_embedded_docs(None);
+        docs.sort_by(|left, right| left.id.cmp(&right.id));
+        assert!(
+            !docs.is_empty(),
+            "embedded docs catalog should not be empty"
+        );
+
+        println!("bundled docs: {}", docs.len());
+        for doc in &docs {
+            println!("{} | {} | {}", doc.section, doc.id, doc.path);
+        }
+    }
+}
diff --git a/src/settings.rs b/src/settings.rs
index 8c6d73490..29acb2be2 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -2,4 +2,4 @@
 
 pub mod store;
 
-pub use store::{SettingsStore, WORKER_LOG_MODE_KEY, WorkerLogMode};
+pub use store::{CHANNEL_LISTEN_ONLY_MODE_KEY, SettingsStore, WORKER_LOG_MODE_KEY, WorkerLogMode};
diff --git a/src/settings/store.rs b/src/settings/store.rs
index 387ed6b69..668236c6f 100644
--- a/src/settings/store.rs
+++ b/src/settings/store.rs
@@ -11,6 +11,9 @@ const SETTINGS_TABLE: TableDefinition<&str, &str> = TableDefinition::new("settin
 
 /// Default key for worker log mode setting.
 pub const WORKER_LOG_MODE_KEY: &str = "worker_log_mode";
+/// Key for channel listen-only mode setting.
+pub const CHANNEL_LISTEN_ONLY_MODE_KEY: &str = "channel_listen_only_mode";
+const CHANNEL_LISTEN_ONLY_MODE_PREFIX: &str = "channel_listen_only_mode:";
 
 /// How worker execution logs are stored.
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
@@ -54,6 +57,9 @@ pub struct SettingsStore {
 }
 
 impl SettingsStore {
+    fn channel_listen_only_mode_key(channel_id: &str) -> String {
+        format!("{CHANNEL_LISTEN_ONLY_MODE_PREFIX}{channel_id}")
+    }
     /// Create a new settings store at the given path.
     /// The database will be created if it doesn't exist.
     pub fn new(path: &Path) -> Result<Self> {
@@ -160,6 +166,57 @@ impl SettingsStore {
     pub fn set_worker_log_mode(&self, mode: WorkerLogMode) -> Result<()> {
         self.set_raw(WORKER_LOG_MODE_KEY, &mode.to_string())
     }
+
+    /// Get the channel listen-only mode, if explicitly persisted.
+    pub fn channel_listen_only_mode(&self) -> Result<Option<bool>> {
+        match self.get_raw(CHANNEL_LISTEN_ONLY_MODE_KEY) {
+            Ok(raw) => raw.parse::<bool>().map(Some).map_err(|error| {
+                SettingsError::ReadFailed {
+                    key: CHANNEL_LISTEN_ONLY_MODE_KEY.to_string(),
+                    details: format!("invalid boolean value '{raw}': {error}"),
+                }
+                .into()
+            }),
+            Err(crate::error::Error::Settings(settings_error)) => match *settings_error {
+                SettingsError::NotFound { .. } => Ok(None),
+                other => Err(other.into()),
+            },
+            Err(other) => Err(other),
+        }
+    }
+
+    /// Persist channel listen-only mode.
+    pub fn set_channel_listen_only_mode(&self, enabled: bool) -> Result<()> {
+        self.set_raw(
+            CHANNEL_LISTEN_ONLY_MODE_KEY,
+            if enabled { "true" } else { "false" },
+        )
+    }
+
+    /// Get the listen-only mode for a specific channel, if explicitly persisted.
+    pub fn channel_listen_only_mode_for(&self, channel_id: &str) -> Result<Option<bool>> {
+        let key = Self::channel_listen_only_mode_key(channel_id);
+        match self.get_raw(&key) {
+            Ok(raw) => raw.parse::<bool>().map(Some).map_err(|error| {
+                SettingsError::ReadFailed {
+                    key: key.clone(),
+                    details: format!("invalid boolean value '{raw}': {error}"),
+                }
+                .into()
+            }),
+            Err(crate::error::Error::Settings(settings_error)) => match *settings_error {
+                SettingsError::NotFound { .. } => Ok(None),
+                other => Err(other.into()),
+            },
+            Err(other) => Err(other),
+        }
+    }
+
+    /// Persist listen-only mode for a specific channel.
+    pub fn set_channel_listen_only_mode_for(&self, channel_id: &str, enabled: bool) -> Result<()> {
+        let key = Self::channel_listen_only_mode_key(channel_id);
+        self.set_raw(&key, if enabled { "true" } else { "false" })
+    }
 }
 
 impl std::fmt::Debug for SettingsStore {
diff --git a/src/skills.rs b/src/skills.rs
index da6cfe550..33136a429 100644
--- a/src/skills.rs
+++ b/src/skills.rs
@@ -35,6 +35,8 @@ pub struct Skill {
     pub content: String,
     /// Where this skill was loaded from.
     pub source: SkillSource,
+    /// GitHub `owner/repo` that this skill was installed from, if any.
+    pub source_repo: Option<String>,
 }
 
 /// Where a skill was loaded from, used for precedence tracking.
@@ -213,6 +215,7 @@ impl SkillSet {
                 file_path: s.file_path.clone(),
                 base_dir: s.base_dir.clone(),
                 source: s.source.clone(),
+                source_repo: s.source_repo.clone(),
             })
             .collect()
     }
@@ -226,6 +229,7 @@ pub struct SkillInfo {
     pub file_path: PathBuf,
     pub base_dir: PathBuf,
     pub source: SkillSource,
+    pub source_repo: Option<String>,
 }
 
 /// Load all skills from a directory.
@@ -293,6 +297,7 @@ async fn load_skill(
     });
 
     let description = frontmatter.get("description").cloned().unwrap_or_default();
+    let source_repo = frontmatter.get("source_repo").cloned();
 
     // Resolve {baseDir} template variable in the body
     let base_dir_str = base_dir.to_string_lossy();
@@ -305,6 +310,7 @@ async fn load_skill(
         base_dir: base_dir.to_path_buf(),
         content,
         source,
+        source_repo,
     })
 }
 
@@ -465,6 +471,7 @@ mod tests {
                 base_dir: PathBuf::from("/skills/weather"),
                 content: "# Weather\n\nUse curl.".into(),
                 source: SkillSource::Instance,
+                source_repo: None,
             },
         );
 
@@ -487,6 +494,7 @@ mod tests {
                 base_dir: PathBuf::from("/skills/weather"),
                 content: "# Weather\n\nUse curl.".into(),
                 source: SkillSource::Instance,
+                source_repo: None,
             },
         );
 
diff --git a/src/skills/installer.rs b/src/skills/installer.rs
index bbb4d785a..48e85caa8 100644
--- a/src/skills/installer.rs
+++ b/src/skills/installer.rs
@@ -63,7 +63,15 @@ pub async fn install_from_github(spec: &str, target_dir: &Path) -> Result<Vec<St
     drop(file);
 
     // Extract and install
-    let installed = extract_and_install(&zip_path, target_dir, skill_path.as_deref()).await?;
+    let mut source_repo = format!("{owner}/{repo}");
+    source_repo.retain(|ch| ch != '\n' && ch != '\r');
+    let installed = extract_and_install(
+        &zip_path,
+        target_dir,
+        skill_path.as_deref(),
+        Some(&source_repo),
+    )
+    .await?;
 
     tracing::info!(
         installed = ?installed,
@@ -84,7 +92,7 @@ pub async fn install_from_file(skill_file: &Path, target_dir: &Path) -> Result<V
         "installing skill from file"
     );
 
-    let installed = extract_and_install(skill_file, target_dir, None).await?;
+    let installed = extract_and_install(skill_file, target_dir, None, None).await?;
 
     tracing::info!(
         installed = ?installed,
@@ -102,6 +110,7 @@ async fn extract_and_install(
     zip_path: &Path,
     target_dir: &Path,
     skill_path: Option<&str>,
+    source_repo: Option<&str>,
 ) -> Result<Vec<String>> {
     let file = std::fs::File::open(zip_path).context("failed to open zip file")?;
 
@@ -176,6 +185,32 @@ async fn extract_and_install(
         // Copy skill directory
         copy_dir_recursive(&skill_dir, &target_skill_dir).await?;
 
+        // Write source_repo into SKILL.md frontmatter so we can track provenance
+        if let Some(repo) = source_repo {
+            let skill_md = target_skill_dir.join("SKILL.md");
+            if skill_md.exists() {
+                match fs::read_to_string(&skill_md).await {
+                    Ok(content) => {
+                        let patched = inject_source_repo(&content, repo);
+                        if let Err(error) = fs::write(&skill_md, patched).await {
+                            tracing::warn!(
+                                skill = %skill_name,
+                                %error,
+                                "failed to write source_repo to SKILL.md"
+                            );
+                        }
+                    }
+                    Err(error) => {
+                        tracing::warn!(
+                            skill = %skill_name,
+                            %error,
+                            "failed to read SKILL.md for source_repo injection"
+                        );
+                    }
+                }
+            }
+        }
+
         installed.push(skill_name.to_string());
 
         tracing::debug!(
@@ -188,6 +223,42 @@ async fn extract_and_install(
     Ok(installed)
 }
 
+/// Inject or update `source_repo` in SKILL.md frontmatter.
+fn inject_source_repo(content: &str, repo: &str) -> String {
+    let trimmed = content.trim_start();
+    let line = format!("source_repo: {repo}");
+
+    if !trimmed.starts_with("---") {
+        // No frontmatter — add one
+        return format!("---\n{line}\n---\n{content}");
+    }
+
+    let after_opening = &trimmed[3..];
+    let Some((end_pos, delimiter_len)) = after_opening
+        .find("\n---\n")
+        .map(|pos| (pos, 5))
+        .or_else(|| after_opening.find("\n---").map(|pos| (pos, 4)))
+    else {
+        // Malformed frontmatter, prepend
+        return format!("---\n{line}\n---\n{content}");
+    };
+
+    let fm_block = &after_opening[..end_pos];
+    let body = &after_opening[end_pos + delimiter_len..];
+
+    // Remove any existing source_repo line
+    let filtered: Vec<&str> = fm_block
+        .lines()
+        .filter(|l| !l.trim_start().starts_with("source_repo:"))
+        .collect();
+
+    let mut new_fm = filtered.join("\n");
+    new_fm.push('\n');
+    new_fm.push_str(&line);
+
+    format!("---{new_fm}\n---\n{body}")
+}
+
 /// Parse a GitHub spec: `owner/repo` or `owner/repo/skill-name`
 fn parse_github_spec(spec: &str) -> Result<(String, String, Option<String>)> {
     let parts: Vec<&str> = spec.split('/').collect();
@@ -308,4 +379,65 @@ mod tests {
         assert!(parse_github_spec("invalid").is_err());
         assert!(parse_github_spec("too/many/slashes/here").is_err());
     }
+
+    #[test]
+    fn test_inject_source_repo_into_existing_frontmatter() {
+        let content = "---\nname: weather\ndescription: Get weather\n---\n\n# Weather\n";
+        let result = inject_source_repo(content, "anthropics/skills");
+        assert!(result.contains("source_repo: anthropics/skills"));
+        assert!(result.contains("name: weather"));
+        assert!(result.contains("# Weather"));
+        // source_repo should be inside the frontmatter delimiters
+        let after_first = result.split_once("---").unwrap().1;
+        let fm = after_first.split("\n---").next().unwrap();
+        assert!(fm.contains("source_repo: anthropics/skills"));
+    }
+
+    #[test]
+    fn test_inject_source_repo_no_frontmatter() {
+        let content = "# Just markdown\n\nNo frontmatter here.";
+        let result = inject_source_repo(content, "owner/repo");
+        assert!(result.starts_with("---\nsource_repo: owner/repo\n---\n"));
+        assert!(result.contains("# Just markdown"));
+    }
+
+    #[test]
+    fn test_inject_source_repo_updates_existing() {
+        let content = "---\nname: weather\nsource_repo: old/repo\ndescription: foo\n---\n\nBody\n";
+        let result = inject_source_repo(content, "new/repo");
+        assert!(result.contains("source_repo: new/repo"));
+        assert!(!result.contains("old/repo"));
+        // Should only have one source_repo line
+        assert_eq!(result.matches("source_repo:").count(), 1);
+    }
+
+    #[test]
+    fn test_inject_source_repo_malformed_frontmatter() {
+        let content = "---\nname: broken\nno closing delimiter";
+        let result = inject_source_repo(content, "owner/repo");
+        // Falls back to prepending new frontmatter
+        assert!(result.starts_with("---\nsource_repo: owner/repo\n---\n"));
+        assert!(result.contains("no closing delimiter"));
+    }
+
+    #[test]
+    fn test_inject_source_repo_preserves_delimiter_body_newline() {
+        let content = "---\nname: weather\n---\n# Weather\n";
+        let patched = inject_source_repo(content, "anthropics/skills");
+        assert!(patched.contains("\n---\n# Weather\n"));
+    }
+
+    #[test]
+    fn test_inject_source_repo_roundtrip_with_parse() {
+        use crate::skills::parse_frontmatter;
+        let content = "---\nname: weather\ndescription: Get weather\n---\n\n# Weather\n";
+        let patched = inject_source_repo(content, "anthropics/skills");
+        let (fm, body) = parse_frontmatter(&patched).unwrap();
+        assert_eq!(
+            fm.get("source_repo").unwrap(),
+            &"anthropics/skills".to_string()
+        );
+        assert_eq!(fm.get("name").unwrap(), &"weather".to_string());
+        assert!(body.contains("# Weather"));
+    }
 }
diff --git a/src/tasks.rs b/src/tasks.rs
new file mode 100644
index 000000000..c9b216c97
--- /dev/null
+++ b/src/tasks.rs
@@ -0,0 +1,7 @@
+//! Task tracking data model and storage.
+
+pub mod store;
+
+pub use store::{
+    CreateTaskInput, Task, TaskPriority, TaskStatus, TaskStore, TaskSubtask, UpdateTaskInput,
+};
diff --git a/src/tasks/store.rs b/src/tasks/store.rs
new file mode 100644
index 000000000..8c3bf45ed
--- /dev/null
+++ b/src/tasks/store.rs
@@ -0,0 +1,698 @@
+//! Task CRUD storage (SQLite).
+
+use crate::error::Result;
+use anyhow::Context as _;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use sqlx::{Row as _, SqlitePool};
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum TaskStatus {
+    PendingApproval,
+    Backlog,
+    Ready,
+    InProgress,
+    Done,
+}
+
+impl TaskStatus {
+    pub const ALL: [TaskStatus; 5] = [
+        TaskStatus::PendingApproval,
+        TaskStatus::Backlog,
+        TaskStatus::Ready,
+        TaskStatus::InProgress,
+        TaskStatus::Done,
+    ];
+
+    pub fn as_str(self) -> &'static str {
+        match self {
+            TaskStatus::PendingApproval => "pending_approval",
+            TaskStatus::Backlog => "backlog",
+            TaskStatus::Ready => "ready",
+            TaskStatus::InProgress => "in_progress",
+            TaskStatus::Done => "done",
+        }
+    }
+
+    pub fn parse(value: &str) -> Option<Self> {
+        match value {
+            "pending_approval" => Some(TaskStatus::PendingApproval),
+            "backlog" => Some(TaskStatus::Backlog),
+            "ready" => Some(TaskStatus::Ready),
+            "in_progress" => Some(TaskStatus::InProgress),
+            "done" => Some(TaskStatus::Done),
+            _ => None,
+        }
+    }
+}
+
+impl std::fmt::Display for TaskStatus {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum TaskPriority {
+    Critical,
+    High,
+    Medium,
+    Low,
+}
+
+impl TaskPriority {
+    pub const ALL: [TaskPriority; 4] = [
+        TaskPriority::Critical,
+        TaskPriority::High,
+        TaskPriority::Medium,
+        TaskPriority::Low,
+    ];
+
+    pub fn as_str(self) -> &'static str {
+        match self {
+            TaskPriority::Critical => "critical",
+            TaskPriority::High => "high",
+            TaskPriority::Medium => "medium",
+            TaskPriority::Low => "low",
+        }
+    }
+
+    pub fn parse(value: &str) -> Option<Self> {
+        match value {
+            "critical" => Some(TaskPriority::Critical),
+            "high" => Some(TaskPriority::High),
+            "medium" => Some(TaskPriority::Medium),
+            "low" => Some(TaskPriority::Low),
+            _ => None,
+        }
+    }
+}
+
+impl std::fmt::Display for TaskPriority {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct TaskSubtask {
+    pub title: String,
+    pub completed: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Task {
+    pub id: String,
+    pub agent_id: String,
+    pub task_number: i64,
+    pub title: String,
+    pub description: Option<String>,
+    pub status: TaskStatus,
+    pub priority: TaskPriority,
+    pub subtasks: Vec<TaskSubtask>,
+    pub metadata: Value,
+    pub source_memory_id: Option<String>,
+    pub worker_id: Option<String>,
+    pub created_by: String,
+    pub approved_at: Option<String>,
+    pub approved_by: Option<String>,
+    pub created_at: String,
+    pub updated_at: String,
+    pub completed_at: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct CreateTaskInput {
+    pub agent_id: String,
+    pub title: String,
+    pub description: Option<String>,
+    pub status: TaskStatus,
+    pub priority: TaskPriority,
+    pub subtasks: Vec<TaskSubtask>,
+    pub metadata: Value,
+    pub source_memory_id: Option<String>,
+    pub created_by: String,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct UpdateTaskInput {
+    pub title: Option<String>,
+    pub description: Option<String>,
+    pub status: Option<TaskStatus>,
+    pub priority: Option<TaskPriority>,
+    pub subtasks: Option<Vec<TaskSubtask>>,
+    pub metadata: Option<Value>,
+    pub worker_id: Option<String>,
+    pub clear_worker_id: bool,
+    pub approved_by: Option<String>,
+    pub complete_subtask: Option<usize>,
+}
+
+#[derive(Debug, Clone)]
+pub struct TaskStore {
+    pool: SqlitePool,
+}
+
+impl TaskStore {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+
+    /// Maximum number of retries when a concurrent create races on the same
+    /// `(agent_id, task_number)` UNIQUE constraint.
+    const MAX_CREATE_RETRIES: usize = 3;
+
+    pub async fn create(&self, input: CreateTaskInput) -> Result<Task> {
+        let subtasks_json =
+            serde_json::to_string(&input.subtasks).context("failed to serialize subtasks")?;
+        let metadata_json = input.metadata.to_string();
+
+        for attempt in 0..Self::MAX_CREATE_RETRIES {
+            let mut tx = self
+                .pool
+                .begin()
+                .await
+                .context("failed to open task create transaction")?;
+
+            let task_number: i64 = sqlx::query_scalar(
+                "SELECT COALESCE(MAX(task_number), 0) + 1 FROM tasks WHERE agent_id = ?",
+            )
+            .bind(&input.agent_id)
+            .fetch_one(&mut *tx)
+            .await
+            .context("failed to allocate next task number")?;
+
+            let task_id = uuid::Uuid::new_v4().to_string();
+
+            let insert_result = sqlx::query(
+                r#"
+                INSERT INTO tasks (
+                    id, agent_id, task_number, title, description, status, priority,
+                    subtasks, metadata, source_memory_id, created_by
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                "#,
+            )
+            .bind(&task_id)
+            .bind(&input.agent_id)
+            .bind(task_number)
+            .bind(&input.title)
+            .bind(&input.description)
+            .bind(input.status.as_str())
+            .bind(input.priority.as_str())
+            .bind(&subtasks_json)
+            .bind(&metadata_json)
+            .bind(&input.source_memory_id)
+            .bind(&input.created_by)
+            .execute(&mut *tx)
+            .await;
+
+            match insert_result {
+                Ok(_) => {
+                    tx.commit()
+                        .await
+                        .context("failed to commit task create transaction")?;
+
+                    return self
+                        .get_by_number(&input.agent_id, task_number)
+                        .await?
+                        .context("task inserted but not found")
+                        .map_err(Into::into);
+                }
+                Err(sqlx::Error::Database(ref db_error))
+                    if db_error.code().as_deref() == Some("2067") =>
+                {
+                    // UNIQUE constraint violation — another concurrent create won the
+                    // race for this task_number. Roll back and retry.
+                    tracing::debug!(
+                        attempt,
+                        task_number,
+                        agent_id = %input.agent_id,
+                        "task_number collision, retrying"
+                    );
+                    // tx is dropped here which rolls back automatically.
+                    continue;
+                }
+                Err(error) => {
+                    return Err(anyhow::anyhow!("failed to insert task: {error}").into());
+                }
+            }
+        }
+
+        Err(anyhow::anyhow!(
+            "failed to create task after {} retries due to concurrent task_number collisions",
+            Self::MAX_CREATE_RETRIES
+        )
+        .into())
+    }
+
+    pub async fn list(
+        &self,
+        agent_id: &str,
+        status: Option<TaskStatus>,
+        priority: Option<TaskPriority>,
+        limit: i64,
+    ) -> Result<Vec<Task>> {
+        let mut query = String::from(
+            "SELECT id, agent_id, task_number, title, description, status, priority, subtasks, metadata, source_memory_id, worker_id, created_by, approved_at, approved_by, created_at, updated_at, completed_at FROM tasks WHERE agent_id = ?",
+        );
+
+        if status.is_some() {
+            query.push_str(" AND status = ?");
+        }
+        if priority.is_some() {
+            query.push_str(" AND priority = ?");
+        }
+        query.push_str(" ORDER BY task_number DESC LIMIT ?");
+
+        let mut sql = sqlx::query(&query).bind(agent_id);
+        if let Some(status) = status {
+            sql = sql.bind(status.as_str());
+        }
+        if let Some(priority) = priority {
+            sql = sql.bind(priority.as_str());
+        }
+        sql = sql.bind(limit.clamp(1, 500));
+
+        let rows = sql
+            .fetch_all(&self.pool)
+            .await
+            .context("failed to list tasks")?;
+
+        rows.into_iter().map(task_from_row).collect()
+    }
+
+    pub async fn list_ready(&self, agent_id: &str, limit: i64) -> Result<Vec<Task>> {
+        self.list(agent_id, Some(TaskStatus::Ready), None, limit)
+            .await
+    }
+
+    pub async fn get_by_number(&self, agent_id: &str, task_number: i64) -> Result<Option<Task>> {
+        let row = sqlx::query(
+            "SELECT id, agent_id, task_number, title, description, status, priority, subtasks, metadata, source_memory_id, worker_id, created_by, approved_at, approved_by, created_at, updated_at, completed_at FROM tasks WHERE agent_id = ? AND task_number = ?",
+        )
+        .bind(agent_id)
+        .bind(task_number)
+        .fetch_optional(&self.pool)
+        .await
+        .context("failed to fetch task by number")?;
+
+        row.map(task_from_row).transpose()
+    }
+
+    pub async fn update(
+        &self,
+        agent_id: &str,
+        task_number: i64,
+        input: UpdateTaskInput,
+    ) -> Result<Option<Task>> {
+        let Some(current) = self.get_by_number(agent_id, task_number).await? else {
+            return Ok(None);
+        };
+
+        if let Some(next_status) = input.status
+            && !can_transition(current.status, next_status)
+        {
+            return Err(crate::error::Error::Other(anyhow::anyhow!(
+                "invalid task status transition: {} -> {}",
+                current.status,
+                next_status
+            )));
+        }
+
+        let mut subtasks = input.subtasks.unwrap_or(current.subtasks);
+        if let Some(index) = input.complete_subtask
+            && let Some(subtask) = subtasks.get_mut(index)
+        {
+            subtask.completed = true;
+        }
+
+        let next_status = input.status.unwrap_or(current.status);
+        let next_priority = input.priority.unwrap_or(current.priority);
+        let next_metadata = merge_json_object(current.metadata, input.metadata);
+        let next_worker_id = if let Some(worker_id) = input.worker_id {
+            Some(worker_id)
+        } else {
+            current.worker_id
+        };
+
+        let approved_at = if current.approved_at.is_none() && next_status == TaskStatus::Ready {
+            Some("datetime('now')")
+        } else {
+            None
+        };
+
+        let completed_at = if next_status == TaskStatus::Done {
+            Some("datetime('now')")
+        } else if current.completed_at.is_some() && next_status != TaskStatus::Done {
+            Some("NULL")
+        } else {
+            None
+        };
+
+        let mut query = String::from(
+            "UPDATE tasks SET title = ?, description = ?, status = ?, priority = ?, subtasks = ?, metadata = ?, ",
+        );
+
+        if input.clear_worker_id {
+            query.push_str("worker_id = NULL, ");
+        } else {
+            query.push_str("worker_id = ?, ");
+        }
+
+        query.push_str("approved_by = COALESCE(?, approved_by), updated_at = datetime('now')");
+
+        if approved_at.is_some() {
+            query.push_str(", approved_at = datetime('now')");
+        }
+        if let Some(value) = completed_at {
+            if value == "datetime('now')" {
+                query.push_str(", completed_at = datetime('now')");
+            } else {
+                query.push_str(", completed_at = NULL");
+            }
+        }
+
+        query.push_str(" WHERE agent_id = ? AND task_number = ?");
+
+        let mut sql = sqlx::query(&query)
+            .bind(input.title.unwrap_or(current.title))
+            .bind(input.description.or(current.description))
+            .bind(next_status.as_str())
+            .bind(next_priority.as_str())
+            .bind(serde_json::to_string(&subtasks).context("failed to serialize subtasks")?)
+            .bind(next_metadata.to_string());
+
+        if !input.clear_worker_id {
+            sql = sql.bind(next_worker_id);
+        }
+
+        sql.bind(input.approved_by)
+            .bind(agent_id)
+            .bind(task_number)
+            .execute(&self.pool)
+            .await
+            .context("failed to update task")?;
+
+        self.get_by_number(agent_id, task_number).await
+    }
+
+    pub async fn delete(&self, agent_id: &str, task_number: i64) -> Result<bool> {
+        let result = sqlx::query("DELETE FROM tasks WHERE agent_id = ? AND task_number = ?")
+            .bind(agent_id)
+            .bind(task_number)
+            .execute(&self.pool)
+            .await
+            .context("failed to delete task")?;
+
+        Ok(result.rows_affected() > 0)
+    }
+
+    pub async fn claim_next_ready(&self, agent_id: &str) -> Result<Option<Task>> {
+        let row = sqlx::query(
+            "SELECT task_number FROM tasks WHERE agent_id = ? AND status = 'ready' \
+             ORDER BY CASE priority \
+               WHEN 'critical' THEN 0 \
+               WHEN 'high' THEN 1 \
+               WHEN 'medium' THEN 2 \
+               WHEN 'low' THEN 3 \
+               ELSE 4 END ASC, \
+             task_number ASC \
+             LIMIT 1",
+        )
+        .bind(agent_id)
+        .fetch_optional(&self.pool)
+        .await
+        .context("failed to find ready task")?;
+
+        let Some(row) = row else {
+            return Ok(None);
+        };
+
+        let task_number: i64 = row
+            .try_get("task_number")
+            .context("failed to read task_number from ready task row")?;
+        let result = sqlx::query(
+            "UPDATE tasks SET status = 'in_progress', updated_at = datetime('now') WHERE agent_id = ? AND task_number = ? AND status = 'ready'",
+        )
+        .bind(agent_id)
+        .bind(task_number)
+        .execute(&self.pool)
+        .await
+        .context("failed to claim ready task")?;
+
+        if result.rows_affected() == 0 {
+            return Ok(None);
+        }
+
+        self.get_by_number(agent_id, task_number).await
+    }
+
+    pub async fn get_by_worker_id(&self, worker_id: &str) -> Result<Option<Task>> {
+        let row = sqlx::query(
+            "SELECT id, agent_id, task_number, title, description, status, priority, subtasks, metadata, source_memory_id, worker_id, created_by, approved_at, approved_by, created_at, updated_at, completed_at FROM tasks WHERE worker_id = ? ORDER BY updated_at DESC LIMIT 1",
+        )
+        .bind(worker_id)
+        .fetch_optional(&self.pool)
+        .await
+        .context("failed to fetch task by worker id")?;
+
+        row.map(task_from_row).transpose()
+    }
+}
+
+fn can_transition(current: TaskStatus, next: TaskStatus) -> bool {
+    if current == next {
+        return true;
+    }
+
+    if next == TaskStatus::Backlog {
+        return true;
+    }
+
+    matches!(
+        (current, next),
+        (TaskStatus::PendingApproval, TaskStatus::Ready)
+            | (TaskStatus::Ready, TaskStatus::InProgress)
+            | (TaskStatus::InProgress, TaskStatus::Done)
+            | (TaskStatus::InProgress, TaskStatus::Ready)
+            | (TaskStatus::Backlog, TaskStatus::Ready)
+    )
+}
+
+fn merge_json_object(current: Value, patch: Option<Value>) -> Value {
+    let Some(patch) = patch else {
+        return current;
+    };
+
+    let mut merged = current.as_object().cloned().unwrap_or_default();
+    if let Some(patch_object) = patch.as_object() {
+        for (key, value) in patch_object {
+            merged.insert(key.clone(), value.clone());
+        }
+    }
+    Value::Object(merged)
+}
+
+fn parse_subtasks(value: &str) -> Vec<TaskSubtask> {
+    serde_json::from_str(value).unwrap_or_default()
+}
+
+fn parse_metadata(value: &str) -> Value {
+    serde_json::from_str(value).unwrap_or_else(|_| Value::Object(serde_json::Map::new()))
+}
+
+fn task_from_row(row: sqlx::sqlite::SqliteRow) -> Result<Task> {
+    let status_value: String = row
+        .try_get("status")
+        .context("failed to read task status")?;
+    let priority_value: String = row
+        .try_get("priority")
+        .context("failed to read task priority")?;
+    let subtasks_value: String = row.try_get("subtasks").unwrap_or_else(|_| "[]".to_string());
+    let metadata_value: String = row.try_get("metadata").unwrap_or_else(|_| "{}".to_string());
+
+    let status = TaskStatus::parse(&status_value)
+        .with_context(|| format!("invalid task status in database: {status_value}"))?;
+    let priority = TaskPriority::parse(&priority_value)
+        .with_context(|| format!("invalid task priority in database: {priority_value}"))?;
+
+    Ok(Task {
+        id: row.try_get("id").context("failed to read task id")?,
+        agent_id: row
+            .try_get("agent_id")
+            .context("failed to read task agent_id")?,
+        task_number: row
+            .try_get("task_number")
+            .context("failed to read task_number")?,
+        title: row.try_get("title").context("failed to read task title")?,
+        description: row.try_get("description").ok(),
+        status,
+        priority,
+        subtasks: parse_subtasks(&subtasks_value),
+        metadata: parse_metadata(&metadata_value),
+        source_memory_id: row.try_get("source_memory_id").ok(),
+        worker_id: row
+            .try_get::<Option<String>, _>("worker_id")
+            .ok()
+            .flatten()
+            .and_then(|value| if value.is_empty() { None } else { Some(value) }),
+        created_by: row
+            .try_get("created_by")
+            .context("failed to read task created_by")?,
+        approved_at: row
+            .try_get::<Option<chrono::NaiveDateTime>, _>("approved_at")
+            .ok()
+            .flatten()
+            .map(|v| v.and_utc().to_rfc3339()),
+        approved_by: row.try_get("approved_by").ok(),
+        created_at: row
+            .try_get::<chrono::NaiveDateTime, _>("created_at")
+            .map(|v| v.and_utc().to_rfc3339())
+            .context("failed to read task created_at")?,
+        updated_at: row
+            .try_get::<chrono::NaiveDateTime, _>("updated_at")
+            .map(|v| v.and_utc().to_rfc3339())
+            .context("failed to read task updated_at")?,
+        completed_at: row
+            .try_get::<chrono::NaiveDateTime, _>("completed_at")
+            .ok()
+            .map(|v| v.and_utc().to_rfc3339()),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use sqlx::sqlite::SqlitePoolOptions;
+
+    async fn setup_store() -> TaskStore {
+        let pool = SqlitePoolOptions::new()
+            .max_connections(1)
+            .connect("sqlite::memory:")
+            .await
+            .expect("in-memory sqlite should connect");
+
+        sqlx::query(
+            r#"
+            CREATE TABLE tasks (
+                id TEXT PRIMARY KEY,
+                agent_id TEXT NOT NULL,
+                task_number INTEGER NOT NULL,
+                title TEXT NOT NULL,
+                description TEXT,
+                status TEXT NOT NULL DEFAULT 'backlog',
+                priority TEXT NOT NULL DEFAULT 'medium',
+                subtasks TEXT,
+                metadata TEXT,
+                source_memory_id TEXT,
+                worker_id TEXT,
+                created_by TEXT NOT NULL,
+                approved_at TIMESTAMP,
+                approved_by TEXT,
+                created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                completed_at TIMESTAMP,
+                UNIQUE(agent_id, task_number)
+            )
+            "#,
+        )
+        .execute(&pool)
+        .await
+        .expect("tasks schema should be created");
+
+        TaskStore::new(pool)
+    }
+
+    #[tokio::test]
+    async fn rejects_invalid_status_transition() {
+        let store = setup_store().await;
+        let created = store
+            .create(CreateTaskInput {
+                agent_id: "agent-test".to_string(),
+                title: "pending task".to_string(),
+                description: None,
+                status: TaskStatus::PendingApproval,
+                priority: TaskPriority::Medium,
+                subtasks: Vec::new(),
+                metadata: serde_json::json!({}),
+                source_memory_id: None,
+                created_by: "cortex".to_string(),
+            })
+            .await
+            .expect("task should be created");
+
+        let error = store
+            .update(
+                "agent-test",
+                created.task_number,
+                UpdateTaskInput {
+                    status: Some(TaskStatus::InProgress),
+                    ..Default::default()
+                },
+            )
+            .await
+            .expect_err("pending_approval -> in_progress must fail");
+
+        assert!(error.to_string().contains("invalid task status transition"));
+    }
+
+    #[tokio::test]
+    async fn can_requeue_in_progress_and_clear_worker_binding() {
+        let store = setup_store().await;
+        let created = store
+            .create(CreateTaskInput {
+                agent_id: "agent-test".to_string(),
+                title: "ready task".to_string(),
+                description: None,
+                status: TaskStatus::Ready,
+                priority: TaskPriority::Medium,
+                subtasks: Vec::new(),
+                metadata: serde_json::json!({}),
+                source_memory_id: None,
+                created_by: "branch".to_string(),
+            })
+            .await
+            .expect("task should be created");
+
+        let in_progress = store
+            .update(
+                "agent-test",
+                created.task_number,
+                UpdateTaskInput {
+                    status: Some(TaskStatus::InProgress),
+                    worker_id: Some("worker-1".to_string()),
+                    ..Default::default()
+                },
+            )
+            .await
+            .expect("update should succeed")
+            .expect("task should exist");
+
+        assert_eq!(in_progress.worker_id.as_deref(), Some("worker-1"));
+
+        let requeued = store
+            .update(
+                "agent-test",
+                created.task_number,
+                UpdateTaskInput {
+                    status: Some(TaskStatus::Ready),
+                    clear_worker_id: true,
+                    ..Default::default()
+                },
+            )
+            .await
+            .expect("requeue should succeed")
+            .expect("task should exist");
+
+        assert_eq!(requeued.status, TaskStatus::Ready);
+        assert!(
+            requeued.worker_id.is_none(),
+            "expected worker binding to clear, got {:?}",
+            requeued.worker_id
+        );
+    }
+}
diff --git a/src/telemetry/registry.rs b/src/telemetry/registry.rs
index 99cbd8474..55efad796 100644
--- a/src/telemetry/registry.rs
+++ b/src/telemetry/registry.rs
@@ -79,6 +79,10 @@ pub struct Metrics {
     /// Labels: agent_id, dispatch_type, reason.
     pub dispatch_while_cold_count: IntCounterVec,
 
+    /// Total broadcast events dropped because a receiver lagged.
+    /// Labels: agent_id, receiver.
+    pub event_receiver_lagged_events_total: IntCounterVec,
+
     /// Time-to-recovery for forced warmup passes kicked by dispatch paths, in ms.
     /// Labels: agent_id, dispatch_type.
     pub warmup_recovery_latency_ms: HistogramVec,
@@ -208,6 +212,15 @@ impl Metrics {
         )
         .expect("hardcoded metric descriptor");
 
+        let event_receiver_lagged_events_total = IntCounterVec::new(
+            Opts::new(
+                "spacebot_event_receiver_lagged_events_total",
+                "Total broadcast events dropped because a receiver lagged",
+            ),
+            &["agent_id", "receiver"],
+        )
+        .expect("hardcoded metric descriptor");
+
         let warmup_recovery_latency_ms = HistogramVec::new(
             HistogramOpts::new(
                 "spacebot_warmup_recovery_latency_ms",
@@ -265,6 +278,9 @@ impl Metrics {
         registry
             .register(Box::new(dispatch_while_cold_count.clone()))
             .expect("hardcoded metric");
+        registry
+            .register(Box::new(event_receiver_lagged_events_total.clone()))
+            .expect("hardcoded metric");
         registry
             .register(Box::new(warmup_recovery_latency_ms.clone()))
             .expect("hardcoded metric");
@@ -286,6 +302,7 @@ impl Metrics {
             process_errors_total,
             memory_updates_total,
             dispatch_while_cold_count,
+            event_receiver_lagged_events_total,
             warmup_recovery_latency_ms,
         }
     }
diff --git a/src/tools.rs b/src/tools.rs
index 5dab9da1a..e88d9e820 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -12,21 +12,29 @@
 //! - No memory tools — the channel delegates memory work to branches.
 //!
 //! **Branch ToolServer** (one per branch, isolated):
-//! - `memory_save` + `memory_recall` + `memory_delete` — registered at creation
+//! - `memory_save` + `memory_recall` + `memory_delete` + `channel_recall`
+//! - `spacebot_docs` for embedded self-documentation lookup
+//! - `task_create` + `task_list` + `task_update`
+//! - `spawn_worker` is included for channel-originated branches only
 //!
 //! **Worker ToolServer** (one per worker, created at spawn time):
 //! - `shell`, `file`, `exec` — stateless, registered at creation
+//! - `task_update` — scoped to the worker's assigned task
 //! - `set_status` — per-worker instance, registered at creation
 //!
 //! **Cortex ToolServer** (one per agent):
 //! - `memory_save` — registered at startup
+//!
+//! **Cortex Chat ToolServer** (interactive admin chat):
+//! - branch + worker tool superset plus `spacebot_docs` and `config_inspect`
 
 pub mod branch_tool;
 pub mod browser;
 pub mod cancel;
 pub mod channel_recall;
-pub mod conclude_link;
+pub mod config_inspect;
 pub mod cron;
+pub mod email_search;
 pub mod exec;
 pub mod file;
 pub mod mcp;
@@ -37,29 +45,35 @@ pub mod react;
 pub mod read_skill;
 pub mod reply;
 pub mod route;
+pub mod secret_set;
 pub mod send_agent_message;
 pub mod send_file;
 pub mod send_message_to_another_channel;
 pub mod set_status;
 pub mod shell;
 pub mod skip;
+pub mod spacebot_docs;
 pub mod spawn_worker;
+pub mod task_create;
+pub mod task_list;
+pub mod task_update;
 pub mod web_search;
+pub mod worker_inspect;
 
 pub use branch_tool::{BranchArgs, BranchError, BranchOutput, BranchTool};
 pub use browser::{
     ActKind, BrowserAction, BrowserArgs, BrowserError, BrowserOutput, BrowserTool, ElementSummary,
-    TabInfo,
+    SharedBrowserHandle, TabInfo,
 };
 pub use cancel::{CancelArgs, CancelError, CancelOutput, CancelTool};
 pub use channel_recall::{
     ChannelRecallArgs, ChannelRecallError, ChannelRecallOutput, ChannelRecallTool,
 };
-pub use conclude_link::{
-    ConcludeLinkArgs, ConcludeLinkError, ConcludeLinkFlag, ConcludeLinkOutput, ConcludeLinkSummary,
-    ConcludeLinkTool, new_conclude_link,
+pub use config_inspect::{
+    ConfigInspectArgs, ConfigInspectError, ConfigInspectOutput, ConfigInspectTool,
 };
 pub use cron::{CronArgs, CronError, CronOutput, CronTool};
+pub use email_search::{EmailSearchArgs, EmailSearchError, EmailSearchOutput, EmailSearchTool};
 pub use exec::{EnvVar, ExecArgs, ExecError, ExecOutput, ExecResult, ExecTool};
 pub use file::{FileArgs, FileEntry, FileEntryOutput, FileError, FileOutput, FileTool, FileType};
 pub use mcp::{McpToolAdapter, McpToolError, McpToolOutput};
@@ -76,6 +90,7 @@ pub use react::{ReactArgs, ReactError, ReactOutput, ReactTool};
 pub use read_skill::{ReadSkillArgs, ReadSkillError, ReadSkillOutput, ReadSkillTool};
 pub use reply::{RepliedFlag, ReplyArgs, ReplyError, ReplyOutput, ReplyTool, new_replied_flag};
 pub use route::{RouteArgs, RouteError, RouteOutput, RouteTool};
+pub use secret_set::{SecretSetArgs, SecretSetError, SecretSetOutput, SecretSetTool};
 pub use send_agent_message::{
     SendAgentMessageArgs, SendAgentMessageError, SendAgentMessageOutput, SendAgentMessageTool,
 };
@@ -83,16 +98,26 @@ pub use send_file::{SendFileArgs, SendFileError, SendFileOutput, SendFileTool};
 pub use send_message_to_another_channel::{
     SendMessageArgs, SendMessageError, SendMessageOutput, SendMessageTool,
 };
-pub use set_status::{SetStatusArgs, SetStatusError, SetStatusOutput, SetStatusTool};
+pub use set_status::{SetStatusArgs, SetStatusError, SetStatusOutput, SetStatusTool, StatusKind};
 pub use shell::{ShellArgs, ShellError, ShellOutput, ShellResult, ShellTool};
 pub use skip::{SkipArgs, SkipError, SkipFlag, SkipOutput, SkipTool, new_skip_flag};
+pub use spacebot_docs::{
+    SpacebotDocContent, SpacebotDocsArgs, SpacebotDocsError, SpacebotDocsOutput, SpacebotDocsTool,
+};
 pub use spawn_worker::{SpawnWorkerArgs, SpawnWorkerError, SpawnWorkerOutput, SpawnWorkerTool};
+pub use task_create::{TaskCreateArgs, TaskCreateError, TaskCreateOutput, TaskCreateTool};
+pub use task_list::{TaskListArgs, TaskListError, TaskListOutput, TaskListTool};
+pub use task_update::{TaskUpdateArgs, TaskUpdateError, TaskUpdateOutput, TaskUpdateTool};
 pub use web_search::{SearchResult, WebSearchArgs, WebSearchError, WebSearchOutput, WebSearchTool};
+pub use worker_inspect::{
+    WorkerInspectArgs, WorkerInspectError, WorkerInspectOutput, WorkerInspectTool,
+};
 
 use crate::agent::channel::ChannelState;
 use crate::config::{BrowserConfig, RuntimeConfig};
 use crate::memory::MemorySearch;
 use crate::sandbox::Sandbox;
+use crate::tasks::TaskStore;
 use crate::{AgentId, ChannelId, OutboundResponse, ProcessEvent, WorkerId};
 use rig::tool::Tool as _;
 use rig::tool::server::{ToolServer, ToolServerHandle};
@@ -157,16 +182,20 @@ pub const MAX_DIR_ENTRIES: usize = 500;
 /// Cuts at the last valid char boundary before `max_bytes` so we never split
 /// a multi-byte character. The truncation notice tells the LLM the original
 /// size and how to get the rest (pipe through head/tail or read with offset).
+fn truncate_at_char_boundary(value: &str, max_bytes: usize) -> usize {
+    let mut end = max_bytes.min(value.len());
+    while end > 0 && !value.is_char_boundary(end) {
+        end -= 1;
+    }
+    end
+}
+
 pub fn truncate_output(value: &str, max_bytes: usize) -> String {
     if value.len() <= max_bytes {
         return value.to_string();
     }
 
-    // Find the last char boundary at or before max_bytes
-    let mut end = max_bytes;
-    while end > 0 && !value.is_char_boundary(end) {
-        end -= 1;
-    }
+    let end = truncate_at_char_boundary(value, max_bytes);
 
     let total = value.len();
     let truncated_bytes = total - end;
@@ -177,6 +206,74 @@ pub fn truncate_output(value: &str, max_bytes: usize) -> String {
     )
 }
 
+/// Truncate to a byte limit and append `...`, preserving UTF-8 boundaries.
+///
+/// The returned string will never exceed `max_bytes`. If there's not enough
+/// room for both content and "...", only the content is returned (truncated
+/// to fit within `max_bytes`).
+pub fn truncate_utf8_ellipsis(value: &str, max_bytes: usize) -> String {
+    if value.len() <= max_bytes {
+        return value.to_string();
+    }
+
+    // Try to leave room for "..." (3 bytes)
+    let available = max_bytes.saturating_sub(3);
+    let end = truncate_at_char_boundary(value, available);
+
+    // If we have room for "...", append it; otherwise just return truncated content
+    if end > 0 && end + 3 <= max_bytes {
+        format!("{}...", &value[..end])
+    } else {
+        // Not enough room for "...", return as much as fits
+        let end = truncate_at_char_boundary(value, max_bytes);
+        value[..end].to_string()
+    }
+}
+
+/// Returns true when text looks like structured/tool payloads that should never
+/// be sent to end users as plain chat output.
+pub fn should_block_user_visible_text(value: &str) -> bool {
+    const TOOL_PREFIXES: &[&str] = &[
+        "[reply]",
+        "(reply)",
+        "[react]",
+        "(react)",
+        "[skip]",
+        "(skip)",
+        "[branch]",
+        "(branch)",
+        "[spawn_worker]",
+        "(spawn_worker)",
+        "[route]",
+        "(route)",
+        "[cancel]",
+        "(cancel)",
+    ];
+
+    let trimmed = value.trim_start();
+    if trimmed.is_empty() {
+        return false;
+    }
+
+    if trimmed.starts_with('{') || trimmed.starts_with('[') || trimmed.starts_with('(') {
+        return true;
+    }
+
+    let lower = trimmed.to_ascii_lowercase();
+    if TOOL_PREFIXES.iter().any(|prefix| lower.starts_with(prefix)) {
+        return true;
+    }
+
+    let punctuation_trimmed = lower.trim_matches(|character: char| {
+        character.is_ascii_punctuation() || character.is_ascii_whitespace()
+    });
+    if punctuation_trimmed == "skip" {
+        return true;
+    }
+
+    lower.starts_with("<system-reminder>") || lower.starts_with("<path>")
+}
+
 /// Add per-turn tools to a channel's ToolServer.
 ///
 /// Called when a conversation turn begins. These tools hold per-turn state
@@ -192,68 +289,44 @@ pub async fn add_channel_tools(
     replied_flag: RepliedFlag,
     cron_tool: Option<CronTool>,
     send_agent_message_tool: Option<SendAgentMessageTool>,
-    conclude_link: Option<(ConcludeLinkFlag, ConcludeLinkSummary)>,
-    message_source: Option<String>,
-    originating_channel_override: Option<String>,
-    originating_source_override: Option<String>,
+    allow_direct_reply: bool,
 ) -> Result<(), rig::tool::server::ToolServerError> {
     let conversation_id = conversation_id.into();
-    let is_link_channel = conversation_id.starts_with("link:");
-    let current_link_counterparty =
-        link_counterparty_for_agent(&conversation_id, state.deps.agent_id.as_ref());
-    // In direct link channels, only expose send_agent_message when this agent
-    // can initiate to at least one other linked agent (not the current peer).
-    // This avoids LLM loops where agents try to delegate back to the same peer
-    // or hallucinate unrelated targets instead of using `reply`.
-    let has_other_delegation_targets =
-        if let Some(counterparty_id) = current_link_counterparty.as_deref() {
-            let agent_id = state.deps.agent_id.as_ref();
-            let links = state.deps.links.load();
-
-            links.iter().any(|link| {
-                let (target_id, can_initiate) = if link.from_agent_id == agent_id {
-                    (&link.to_agent_id, true)
-                } else if link.to_agent_id == agent_id {
-                    (
-                        &link.from_agent_id,
-                        link.direction == crate::links::LinkDirection::TwoWay,
-                    )
-                } else {
-                    return false;
-                };
-
-                can_initiate
-                    && target_id != counterparty_id
-                    && state.deps.agent_names.contains_key(target_id)
-            })
-        } else {
-            true
-        };
 
-    let agent_display_name = state
-        .deps
-        .agent_names
-        .get(state.deps.agent_id.as_ref())
-        .cloned()
-        .unwrap_or_else(|| state.deps.agent_id.to_string());
-    handle
-        .add_tool(ReplyTool::new(
-            response_tx.clone(),
-            conversation_id.clone(),
-            state.conversation_logger.clone(),
-            state.channel_id.clone(),
-            replied_flag.clone(),
-            agent_display_name,
-        ))
-        .await?;
+    if allow_direct_reply {
+        let agent_display_name = state
+            .deps
+            .agent_names
+            .get(state.deps.agent_id.as_ref())
+            .cloned()
+            .unwrap_or_else(|| state.deps.agent_id.to_string());
+        handle
+            .add_tool(ReplyTool::new(
+                response_tx.clone(),
+                conversation_id.clone(),
+                state.conversation_logger.clone(),
+                state.channel_id.clone(),
+                replied_flag.clone(),
+                agent_display_name,
+            ))
+            .await?;
+    }
     handle.add_tool(BranchTool::new(state.clone())).await?;
     handle.add_tool(SpawnWorkerTool::new(state.clone())).await?;
     handle.add_tool(RouteTool::new(state.clone())).await?;
-    if !is_link_channel && let Some(messaging_manager) = &state.deps.messaging_manager {
+    if let Some(messaging_manager) = &state.deps.messaging_manager {
+        let send_message_display_name = state
+            .deps
+            .agent_names
+            .get(state.deps.agent_id.as_ref())
+            .cloned()
+            .unwrap_or_else(|| state.deps.agent_id.to_string());
         handle
             .add_tool(SendMessageTool::new(
                 messaging_manager.clone(),
                 state.channel_store.clone(),
+                state.conversation_logger.clone(),
+                send_message_display_name,
             ))
             .await?;
     }
@@ -261,6 +334,7 @@ pub async fn add_channel_tools(
         .add_tool(SendFileTool::new(
             response_tx.clone(),
             state.deps.runtime_config.workspace_dir.clone(),
+            state.deps.sandbox.clone(),
         ))
         .await?;
     handle.add_tool(CancelTool::new(state)).await?;
@@ -268,42 +342,25 @@ pub async fn add_channel_tools(
         .add_tool(SkipTool::new(skip_flag.clone(), response_tx.clone()))
         .await?;
     handle.add_tool(ReactTool::new(response_tx.clone())).await?;
-    if let Some(cron) = cron_tool {
-        handle.add_tool(cron).await?;
+    if let Some(cron_tool) = cron_tool {
+        let cron_tool = cron_tool.with_default_delivery_target(
+            default_delivery_target_for_conversation(&conversation_id),
+        );
+        handle.add_tool(cron_tool).await?;
     }
-    if let Some(mut agent_msg) = send_agent_message_tool
-        && has_other_delegation_targets
-    {
-        // Bind per-turn state so the tool auto-ends the turn after sending and
-        // propagates the correct adapter name for conclusion routing.
+    if let Some(mut agent_msg) = send_agent_message_tool {
         agent_msg = agent_msg.with_skip_flag(skip_flag.clone());
-        if let Some(originating_channel) = originating_channel_override {
-            agent_msg = agent_msg.with_originating_channel(originating_channel);
-        }
-        // Prefer the upstream originating_source (for multi-hop chains) over
-        // the current message source (which is "internal" on link channels).
-        let effective_source = originating_source_override.or(message_source);
-        if let Some(source) = effective_source {
-            agent_msg = agent_msg.with_originating_source(source);
-        }
         handle.add_tool(agent_msg).await?;
     }
-    if let Some((flag, summary)) = conclude_link {
-        handle
-            .add_tool(ConcludeLinkTool::new(flag, summary, response_tx))
-            .await?;
-    }
     Ok(())
 }
 
-fn link_counterparty_for_agent(conversation_id: &str, agent_id: &str) -> Option<String> {
-    let rest = conversation_id.strip_prefix("link:")?;
-    let (self_id, counterparty_id) = rest.split_once(':')?;
-    if self_id == agent_id {
-        Some(counterparty_id.to_string())
-    } else {
-        None
+fn default_delivery_target_for_conversation(conversation_id: &str) -> Option<String> {
+    let parsed = crate::messaging::target::parse_delivery_target(conversation_id)?;
+    if parsed.adapter != "discord" {
+        return None;
     }
+    Some(parsed.to_string())
 }
 
 /// Remove per-channel tools from a running ToolServer.
@@ -312,8 +369,11 @@ fn link_counterparty_for_agent(conversation_id: &str, agent_id: &str) -> Option<
 /// tools from being invoked with dead senders.
 pub async fn remove_channel_tools(
     handle: &ToolServerHandle,
+    allow_direct_reply: bool,
 ) -> Result<(), rig::tool::server::ToolServerError> {
-    handle.remove_tool(ReplyTool::NAME).await?;
+    if allow_direct_reply {
+        handle.remove_tool(ReplyTool::NAME).await?;
+    }
     handle.remove_tool(BranchTool::NAME).await?;
     handle.remove_tool(SpawnWorkerTool::NAME).await?;
     handle.remove_tool(RouteTool::NAME).await?;
@@ -321,30 +381,63 @@ pub async fn remove_channel_tools(
     handle.remove_tool(SkipTool::NAME).await?;
     handle.remove_tool(SendFileTool::NAME).await?;
     handle.remove_tool(ReactTool::NAME).await?;
-    // Cron, send_message, send_agent_message, and conclude_link removal is best-effort since not all channels have them
+    // Cron, send_message, and send_agent_message removal is best-effort since not all channels have them
     let _ = handle.remove_tool(CronTool::NAME).await;
     let _ = handle.remove_tool(SendMessageTool::NAME).await;
     let _ = handle.remove_tool(SendAgentMessageTool::NAME).await;
-    let _ = handle.remove_tool(ConcludeLinkTool::NAME).await;
     Ok(())
 }
 
+fn memory_save_with_events(
+    memory_search: Arc<MemorySearch>,
+    agent_id: AgentId,
+    memory_event_tx: broadcast::Sender<ProcessEvent>,
+) -> MemorySaveTool {
+    MemorySaveTool::new(memory_search).with_event_bus(agent_id, memory_event_tx)
+}
+
 /// Create a per-branch ToolServer with memory tools.
 ///
 /// Each branch gets its own isolated ToolServer so `memory_recall` is never
-/// visible to the channel. Both `memory_save` and `memory_recall` are
-/// registered at creation.
+/// visible to the channel. Includes memory tools, task-board tools, and
+/// `spacebot_docs` for on-demand self-documentation lookup.
+#[allow(clippy::too_many_arguments)]
 pub fn create_branch_tool_server(
+    state: Option<ChannelState>,
+    agent_id: AgentId,
+    task_store: Arc<TaskStore>,
     memory_search: Arc<MemorySearch>,
+    runtime_config: Arc<RuntimeConfig>,
+    memory_event_tx: broadcast::Sender<ProcessEvent>,
     conversation_logger: crate::conversation::history::ConversationLogger,
     channel_store: crate::conversation::ChannelStore,
+    run_logger: crate::conversation::history::ProcessRunLogger,
 ) -> ToolServerHandle {
-    ToolServer::new()
-        .tool(MemorySaveTool::new(memory_search.clone()))
+    let mut server = ToolServer::new()
+        .tool(memory_save_with_events(
+            memory_search.clone(),
+            agent_id.clone(),
+            memory_event_tx.clone(),
+        ))
         .tool(MemoryRecallTool::new(memory_search.clone()))
         .tool(MemoryDeleteTool::new(memory_search))
         .tool(ChannelRecallTool::new(conversation_logger, channel_store))
-        .run()
+        .tool(SpacebotDocsTool::new())
+        .tool(EmailSearchTool::new(runtime_config))
+        .tool(WorkerInspectTool::new(run_logger, agent_id.to_string()))
+        .tool(TaskCreateTool::new(
+            task_store.clone(),
+            agent_id.to_string(),
+            "branch",
+        ))
+        .tool(TaskListTool::new(task_store.clone(), agent_id.to_string()))
+        .tool(TaskUpdateTool::for_branch(task_store, agent_id.clone()));
+
+    if let Some(state) = state {
+        server = server.tool(SpawnWorkerTool::new(state));
+    }
+
+    server.run()
 }
 
 /// Create a per-worker ToolServer with task-appropriate tools.
@@ -360,6 +453,7 @@ pub fn create_worker_tool_server(
     agent_id: AgentId,
     worker_id: WorkerId,
     channel_id: Option<ChannelId>,
+    task_store: Arc<TaskStore>,
     event_tx: broadcast::Sender<ProcessEvent>,
     browser_config: BrowserConfig,
     screenshot_dir: PathBuf,
@@ -371,15 +465,37 @@ pub fn create_worker_tool_server(
 ) -> ToolServerHandle {
     let mut server = ToolServer::new()
         .tool(ShellTool::new(workspace.clone(), sandbox.clone()))
-        .tool(FileTool::new(workspace.clone()))
+        .tool(FileTool::new(workspace.clone(), sandbox.clone()))
         .tool(ExecTool::new(workspace, sandbox))
-        .tool(SetStatusTool::new(
-            agent_id, worker_id, channel_id, event_tx,
+        .tool(TaskUpdateTool::for_worker(
+            task_store,
+            agent_id.clone(),
+            worker_id,
         ))
-        .tool(ReadSkillTool::new(runtime_config));
+        .tool({
+            let mut status_tool = SetStatusTool::new(agent_id, worker_id, channel_id, event_tx);
+            if let Some(store) = runtime_config.secrets.load().as_ref() {
+                status_tool = status_tool.with_tool_secrets(store.tool_secret_pairs());
+            }
+            status_tool
+        })
+        .tool(ReadSkillTool::new(runtime_config.clone()));
+
+    if let Some(store) = runtime_config.secrets.load().as_ref() {
+        server = server.tool(SecretSetTool::new(store.clone()));
+    }
 
     if browser_config.enabled {
-        server = server.tool(BrowserTool::new(browser_config, screenshot_dir));
+        let browser_tool = if let Some(shared) = runtime_config
+            .shared_browser
+            .as_ref()
+            .filter(|_| browser_config.persist_session)
+        {
+            BrowserTool::new_shared(shared.clone(), browser_config, screenshot_dir)
+        } else {
+            BrowserTool::new(browser_config, screenshot_dir)
+        };
+        server = server.tool(browser_tool);
     }
 
     if let Some(key) = brave_search_key {
@@ -397,9 +513,17 @@ pub fn create_worker_tool_server(
 ///
 /// The cortex only needs memory_save for consolidation. Additional tools can be
 /// added later as cortex capabilities expand.
-pub fn create_cortex_tool_server(memory_search: Arc<MemorySearch>) -> ToolServerHandle {
+pub fn create_cortex_tool_server(
+    agent_id: AgentId,
+    memory_event_tx: broadcast::Sender<ProcessEvent>,
+    memory_search: Arc<MemorySearch>,
+) -> ToolServerHandle {
     ToolServer::new()
-        .tool(MemorySaveTool::new(memory_search))
+        .tool(memory_save_with_events(
+            memory_search,
+            agent_id,
+            memory_event_tx,
+        ))
         .run()
 }
 
@@ -408,28 +532,61 @@ pub fn create_cortex_tool_server(memory_search: Arc<MemorySearch>) -> ToolServer
 /// Combines branch tools (memory) with worker tools (shell, file, exec) to give
 /// the interactive cortex full capabilities. Does not include channel-specific
 /// tools (reply, react, skip) since the cortex chat doesn't talk to platforms.
+/// Adds `config_inspect` for live runtime config introspection and
+/// `spacebot_docs` for embedded docs/changelog retrieval.
 #[allow(clippy::too_many_arguments)]
 pub fn create_cortex_chat_tool_server(
+    agent_id: AgentId,
+    task_store: Arc<TaskStore>,
     memory_search: Arc<MemorySearch>,
+    memory_event_tx: broadcast::Sender<ProcessEvent>,
     conversation_logger: crate::conversation::history::ConversationLogger,
     channel_store: crate::conversation::ChannelStore,
+    run_logger: crate::conversation::history::ProcessRunLogger,
     browser_config: BrowserConfig,
     screenshot_dir: PathBuf,
     brave_search_key: Option<String>,
     workspace: PathBuf,
     sandbox: Arc<Sandbox>,
+    runtime_config: Arc<RuntimeConfig>,
 ) -> ToolServerHandle {
     let mut server = ToolServer::new()
-        .tool(MemorySaveTool::new(memory_search.clone()))
+        .tool(memory_save_with_events(
+            memory_search.clone(),
+            agent_id.clone(),
+            memory_event_tx,
+        ))
         .tool(MemoryRecallTool::new(memory_search.clone()))
         .tool(MemoryDeleteTool::new(memory_search))
         .tool(ChannelRecallTool::new(conversation_logger, channel_store))
+        .tool(SpacebotDocsTool::new())
+        .tool(ConfigInspectTool::new(
+            agent_id.to_string(),
+            runtime_config.clone(),
+        ))
+        .tool(WorkerInspectTool::new(run_logger, agent_id.to_string()))
+        .tool(TaskCreateTool::new(
+            task_store.clone(),
+            agent_id.to_string(),
+            "cortex",
+        ))
+        .tool(TaskListTool::new(task_store.clone(), agent_id.to_string()))
+        .tool(TaskUpdateTool::for_branch(task_store, agent_id.clone()))
         .tool(ShellTool::new(workspace.clone(), sandbox.clone()))
-        .tool(FileTool::new(workspace.clone()))
+        .tool(FileTool::new(workspace.clone(), sandbox.clone()))
         .tool(ExecTool::new(workspace, sandbox));
 
     if browser_config.enabled {
-        server = server.tool(BrowserTool::new(browser_config, screenshot_dir));
+        let browser_tool = if let Some(shared) = runtime_config
+            .shared_browser
+            .as_ref()
+            .filter(|_| browser_config.persist_session)
+        {
+            BrowserTool::new_shared(shared.clone(), browser_config, screenshot_dir)
+        } else {
+            BrowserTool::new(browser_config, screenshot_dir)
+        };
+        server = server.tool(browser_tool);
     }
 
     if let Some(key) = brave_search_key {
@@ -483,4 +640,45 @@ mod tests {
             serde_json::from_str(r#"{"program": "/bin/ls", "timeout_seconds": 90}"#).unwrap();
         assert_eq!(args.timeout_seconds, 90);
     }
+
+    #[test]
+    fn blocks_json_bracket_and_tool_syntax_output() {
+        assert!(should_block_user_visible_text("{\"content\":\"hello\"}"));
+        assert!(should_block_user_visible_text("[\"one\",\"two\"]"));
+        assert!(should_block_user_visible_text(
+            "(just commentary - skipping)"
+        ));
+        assert!(should_block_user_visible_text(
+            "(Empty response: {'content': [{'type': 'thinking'}]})"
+        ));
+        assert!(should_block_user_visible_text("skip"));
+        assert!(should_block_user_visible_text("  SKIP  "));
+        assert!(should_block_user_visible_text(
+            "[reply]\n{\"content\":\"hello\"}"
+        ));
+        assert!(should_block_user_visible_text(
+            "<system-reminder>hidden</system-reminder>"
+        ));
+    }
+
+    #[test]
+    fn allows_normal_plaintext_output() {
+        assert!(!should_block_user_visible_text("hello team"));
+        assert!(!should_block_user_visible_text("skipping for now"));
+        assert!(!should_block_user_visible_text(
+            "I can skip that if you want."
+        ));
+        assert!(!should_block_user_visible_text("- first\n- second"));
+    }
+
+    #[test]
+    fn truncate_helpers_preserve_utf8_boundaries() {
+        let text = "🙂🙂🙂";
+        // For max_bytes=5: can fit "🙂" (4 bytes) but not "🙂..." (7 bytes)
+        // So we get just "🙂" without ellipsis since it wouldn't fit
+        assert_eq!(truncate_utf8_ellipsis(text, 5), "🙂");
+        // For larger max_bytes=10: can fit "🙂..." (7 bytes)
+        assert_eq!(truncate_utf8_ellipsis(text, 10), "🙂...");
+        assert!(truncate_output(text, 5).starts_with("🙂"));
+    }
 }
diff --git a/src/tools/branch_tool.rs b/src/tools/branch_tool.rs
index 06bae2d64..a51be90eb 100644
--- a/src/tools/branch_tool.rs
+++ b/src/tools/branch_tool.rs
@@ -1,7 +1,8 @@
 //! Branch tool for forking context and thinking (channel only).
 
 use crate::BranchId;
-use crate::agent::channel::{ChannelState, spawn_branch_from_state};
+use crate::agent::channel::ChannelState;
+use crate::agent::channel_dispatch::spawn_branch_from_state;
 use rig::completion::ToolDefinition;
 use rig::tool::Tool;
 use schemars::JsonSchema;
diff --git a/src/tools/browser.rs b/src/tools/browser.rs
index f6e692f9b..60fffd9a9 100644
--- a/src/tools/browser.rs
+++ b/src/tools/browser.rs
@@ -6,6 +6,7 @@
 
 use crate::config::BrowserConfig;
 use chromiumoxide::browser::{Browser, BrowserConfig as ChromeConfig};
+use chromiumoxide::fetcher::{BrowserFetcher, BrowserFetcherOptions};
 use chromiumoxide::page::ScreenshotParams;
 use chromiumoxide_cdp::cdp::browser_protocol::accessibility::{
     EnableParams as AxEnableParams, GetFullAxTreeParams,
@@ -22,7 +23,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use tokio::sync::Mutex;
 use tokio::task::JoinHandle;
@@ -124,6 +125,17 @@ fn is_v4_mapped_blocked(ip: Ipv6Addr) -> bool {
     }
 }
 
+/// Opaque handle to shared browser state that persists across worker lifetimes.
+///
+/// Held by `RuntimeConfig` when `persist_session = true`. All workers for the
+/// same agent clone this handle and share a single browser process / tab set.
+pub type SharedBrowserHandle = Arc<Mutex<BrowserState>>;
+
+/// Create a new shared browser handle for use in `RuntimeConfig`.
+pub fn new_shared_browser_handle() -> SharedBrowserHandle {
+    Arc::new(Mutex::new(BrowserState::new()))
+}
+
 /// Tool for browser automation (worker-only).
 #[derive(Debug, Clone)]
 pub struct BrowserTool {
@@ -132,8 +144,12 @@ pub struct BrowserTool {
     screenshot_dir: PathBuf,
 }
 
-/// Internal browser state managed across tool invocations within a single worker.
-struct BrowserState {
+/// Internal browser state managed across tool invocations.
+///
+/// When `persist_session` is enabled this struct lives in `RuntimeConfig` (via
+/// `SharedBrowserHandle`) and is shared across worker lifetimes. Otherwise each
+/// `BrowserTool` owns its own instance.
+pub struct BrowserState {
     browser: Option<Browser>,
     /// Background task driving the CDP WebSocket handler.
     _handler_task: Option<JoinHandle<()>>,
@@ -145,6 +161,48 @@ struct BrowserState {
     element_refs: HashMap<String, ElementRef>,
     /// Counter for generating element refs.
     next_ref: usize,
+    /// Per-launch temp directory for Chrome's user data. Cleaned up on drop to
+    /// prevent stale singleton locks from blocking subsequent launches.
+    user_data_dir: Option<PathBuf>,
+}
+
+impl BrowserState {
+    fn new() -> Self {
+        Self {
+            browser: None,
+            _handler_task: None,
+            pages: HashMap::new(),
+            active_target: None,
+            element_refs: HashMap::new(),
+            next_ref: 0,
+            user_data_dir: None,
+        }
+    }
+}
+
+impl Drop for BrowserState {
+    fn drop(&mut self) {
+        // Browser and handler task are dropped automatically —
+        // chromiumoxide's Child has kill_on_drop(true).
+        if let Some(dir) = self.user_data_dir.take() {
+            // Offload sync fs cleanup to a blocking thread so we don't stall
+            // the tokio worker that's dropping this state.
+            if let Ok(handle) = tokio::runtime::Handle::try_current() {
+                handle.spawn_blocking(move || {
+                    if let Err(error) = std::fs::remove_dir_all(&dir) {
+                        tracing::debug!(
+                            path = %dir.display(),
+                            %error,
+                            "failed to clean up browser user data dir"
+                        );
+                    }
+                });
+            } else {
+                // Dropped outside a tokio runtime (unlikely) — clean up inline.
+                let _ = std::fs::remove_dir_all(&dir);
+            }
+        }
+    }
 }
 
 impl std::fmt::Debug for BrowserState {
@@ -171,16 +229,27 @@ struct ElementRef {
 }
 
 impl BrowserTool {
+    /// Create a tool with its own isolated browser state (default, non-persistent).
     pub fn new(config: BrowserConfig, screenshot_dir: PathBuf) -> Self {
         Self {
-            state: Arc::new(Mutex::new(BrowserState {
-                browser: None,
-                _handler_task: None,
-                pages: HashMap::new(),
-                active_target: None,
-                element_refs: HashMap::new(),
-                next_ref: 0,
-            })),
+            state: Arc::new(Mutex::new(BrowserState::new())),
+            config,
+            screenshot_dir,
+        }
+    }
+
+    /// Create a tool backed by a shared browser state handle.
+    ///
+    /// Used when `persist_session = true`. Multiple workers share the same
+    /// `SharedBrowserHandle`, so the browser process and tabs survive across
+    /// worker lifetimes.
+    pub fn new_shared(
+        shared_state: SharedBrowserHandle,
+        config: BrowserConfig,
+        screenshot_dir: PathBuf,
+    ) -> Self {
+        Self {
+            state: shared_state,
             config,
             screenshot_dir,
         }
@@ -466,29 +535,47 @@ impl Tool for BrowserTool {
 
 impl BrowserTool {
     async fn handle_launch(&self) -> Result<BrowserOutput, BrowserError> {
-        let mut state = self.state.lock().await;
-
-        if state.browser.is_some() {
-            return Ok(BrowserOutput::success("Browser already running"));
+        // Quick check under the lock — if a browser is already running and
+        // we're in persistent mode, reconnect to existing tabs.
+        {
+            let mut state = self.state.lock().await;
+            if state.browser.is_some() {
+                if self.config.persist_session {
+                    return self.reconnect_existing_tabs(&mut state).await;
+                }
+                return Ok(BrowserOutput::success("Browser already running"));
+            }
         }
 
-        let mut builder = ChromeConfig::builder().no_sandbox();
+        // Resolve the Chrome executable path (may download ~150MB on first use):
+        //   1. Explicit config override
+        //   2. CHROME / CHROME_PATH env vars
+        //   3. chromiumoxide default detection (system PATH + well-known paths)
+        //   4. Auto-download via BrowserFetcher (cached in chrome_cache_dir)
+        let executable = resolve_chrome_executable(&self.config).await?;
+
+        // Use a unique temp dir per launch to avoid singleton lock collisions
+        // when multiple workers launch browsers or a previous session crashed.
+        let user_data_dir =
+            std::env::temp_dir().join(format!("spacebot-browser-{}", uuid::Uuid::new_v4()));
+
+        let mut builder = ChromeConfig::builder()
+            .no_sandbox()
+            .chrome_executable(&executable)
+            .user_data_dir(&user_data_dir);
 
         if !self.config.headless {
             builder = builder.with_head().window_size(1280, 900);
         }
 
-        if let Some(path) = &self.config.executable_path {
-            builder = builder.chrome_executable(path);
-        }
-
         let chrome_config = builder.build().map_err(|error| {
             BrowserError::new(format!("failed to build browser config: {error}"))
         })?;
 
         tracing::info!(
             headless = self.config.headless,
-            executable = ?self.config.executable_path,
+            executable = %executable.display(),
+            user_data_dir = %user_data_dir.display(),
             "launching chrome"
         );
 
@@ -498,13 +585,114 @@ impl BrowserTool {
 
         let handler_task = tokio::spawn(async move { while handler.next().await.is_some() {} });
 
+        // Re-acquire the lock only to store state.
+        let mut state = self.state.lock().await;
+
+        // Guard against a concurrent launch that won the race.
+        if state.browser.is_some() {
+            // Another call launched while we were downloading/starting. Clean up
+            // the browser we just created and return success.
+            drop(browser);
+            handler_task.abort();
+            // Clean up the temp user data dir asynchronously so we don't block
+            // while holding the shared mutex.
+            let dir = user_data_dir;
+            tokio::spawn(async move {
+                let _ = tokio::fs::remove_dir_all(&dir).await;
+            });
+
+            if self.config.persist_session {
+                return self.reconnect_existing_tabs(&mut state).await;
+            }
+            return Ok(BrowserOutput::success("Browser already running"));
+        }
+
         state.browser = Some(browser);
         state._handler_task = Some(handler_task);
+        state.user_data_dir = Some(user_data_dir);
 
         tracing::info!("browser launched");
         Ok(BrowserOutput::success("Browser launched successfully"))
     }
 
+    /// Discover existing tabs from the browser and rebuild the page map.
+    ///
+    /// Called when a worker connects to an already-running persistent browser.
+    /// Rebuilds `state.pages` from `browser.pages()` so stale entries (tabs
+    /// closed externally) are pruned. Validates that `active_target` still
+    /// points to a live page.
+    ///
+    /// Note: holds the mutex across CDP calls. `Browser::pages()` and the
+    /// per-tab title/url queries are quick CDP round-trips, and concurrent
+    /// browser use during reconnect is rare (workers typically call `launch`
+    /// once at the start of their run).
+    async fn reconnect_existing_tabs(
+        &self,
+        state: &mut BrowserState,
+    ) -> Result<BrowserOutput, BrowserError> {
+        let browser = state
+            .browser
+            .as_ref()
+            .ok_or_else(|| BrowserError::new("browser not launched"))?;
+
+        let pages = browser.pages().await.map_err(|error| {
+            BrowserError::new(format!("failed to enumerate existing tabs: {error}"))
+        })?;
+
+        // Rebuild the page map from the live browser, pruning stale entries.
+        let previous_ids: std::collections::HashSet<String> = state.pages.keys().cloned().collect();
+        let mut refreshed_pages = HashMap::with_capacity(pages.len());
+        for page in pages {
+            let target_id = page_target_id(&page);
+            refreshed_pages.insert(target_id, page);
+        }
+        let discovered = refreshed_pages
+            .keys()
+            .filter(|id| !previous_ids.contains(*id))
+            .count();
+        state.pages = refreshed_pages;
+
+        // Ensure active_target points to a valid page.
+        let active_valid = state
+            .active_target
+            .as_ref()
+            .is_some_and(|id| state.pages.contains_key(id));
+        if !active_valid {
+            state.active_target = state.pages.keys().next().cloned();
+        }
+
+        let tab_count = state.pages.len();
+        let mut tabs = Vec::with_capacity(tab_count);
+        for (id, page) in &state.pages {
+            let title = page.get_title().await.ok().flatten();
+            let url = page.url().await.ok().flatten();
+            let is_active = state.active_target.as_deref() == Some(id);
+            tabs.push(TabInfo {
+                target_id: id.clone(),
+                url,
+                title,
+                active: is_active,
+            });
+        }
+
+        tracing::info!(tab_count, discovered, "reconnected to persistent browser");
+
+        Ok(BrowserOutput {
+            success: true,
+            message: format!(
+                "Connected to persistent browser ({tab_count} tab{} open, {discovered} newly discovered)",
+                if tab_count == 1 { "" } else { "s" }
+            ),
+            url: None,
+            title: None,
+            elements: None,
+            tabs: Some(tabs),
+            screenshot_path: None,
+            eval_result: None,
+            content: None,
+        })
+    }
+
     async fn handle_navigate(&self, url: Option<String>) -> Result<BrowserOutput, BrowserError> {
         let Some(url) = url else {
             return Err(BrowserError::new("url is required for navigate action"));
@@ -953,22 +1141,102 @@ impl BrowserTool {
     }
 
     async fn handle_close(&self) -> Result<BrowserOutput, BrowserError> {
-        let mut state = self.state.lock().await;
+        use crate::config::ClosePolicy;
+
+        match self.config.close_policy {
+            ClosePolicy::Detach => {
+                let mut state = self.state.lock().await;
+                // Clear per-worker element refs but preserve tabs, browser,
+                // handler, and active_target so the next worker picks up
+                // exactly where this one left off.
+                state.element_refs.clear();
+                state.next_ref = 0;
+                tracing::info!(policy = "detach", "worker detached from browser");
+                Ok(BrowserOutput::success(
+                    "Detached from browser (tabs and session preserved)",
+                ))
+            }
+            ClosePolicy::CloseTabs => {
+                // Drain pages under the lock, then close them outside it so
+                // other workers aren't blocked by CDP round-trips.
+                let pages_to_close: Vec<(String, chromiumoxide::Page)> = {
+                    let mut state = self.state.lock().await;
+                    let pages = state.pages.drain().collect();
+                    state.active_target = None;
+                    state.element_refs.clear();
+                    state.next_ref = 0;
+                    pages
+                };
 
-        if let Some(mut browser) = state.browser.take()
-            && let Err(error) = browser.close().await
-        {
-            tracing::warn!(%error, "browser close returned error");
-        }
+                let mut close_errors = Vec::new();
+                for (id, page) in pages_to_close {
+                    if let Err(error) = page.close().await {
+                        close_errors.push(format!("{id}: {error}"));
+                    }
+                }
 
-        state.pages.clear();
-        state.active_target = None;
-        state.element_refs.clear();
-        state.next_ref = 0;
-        state._handler_task = None;
+                if !close_errors.is_empty() {
+                    let message = format!(
+                        "failed to close {} tab(s): {}",
+                        close_errors.len(),
+                        close_errors.join("; ")
+                    );
+                    tracing::warn!(policy = "close_tabs", %message);
+                    return Err(BrowserError::new(message));
+                }
 
-        tracing::info!("browser closed");
-        Ok(BrowserOutput::success("Browser closed"))
+                tracing::info!(
+                    policy = "close_tabs",
+                    "closed all tabs, browser still running"
+                );
+                Ok(BrowserOutput::success(
+                    "All tabs closed (browser still running)",
+                ))
+            }
+            ClosePolicy::CloseBrowser => {
+                // Take everything out of state under the lock, then do the
+                // actual teardown outside it.
+                let (browser, handler_task, user_data_dir) = {
+                    let mut state = self.state.lock().await;
+                    let browser = state.browser.take();
+                    let handler_task = state._handler_task.take();
+                    let user_data_dir = state.user_data_dir.take();
+                    state.pages.clear();
+                    state.active_target = None;
+                    state.element_refs.clear();
+                    state.next_ref = 0;
+                    (browser, handler_task, user_data_dir)
+                };
+
+                if let Some(task) = handler_task {
+                    task.abort();
+                }
+
+                if let Some(mut browser) = browser
+                    && let Err(error) = browser.close().await
+                {
+                    let message = format!("failed to close browser: {error}");
+                    tracing::warn!(policy = "close_browser", %message);
+                    return Err(BrowserError::new(message));
+                }
+
+                // Clean up the per-launch user data dir to free disk space.
+                if let Some(dir) = user_data_dir {
+                    tokio::spawn(async move {
+                        if let Err(error) = tokio::fs::remove_dir_all(&dir).await {
+                            tracing::debug!(
+                                path = %dir.display(),
+                                %error,
+                                "failed to clean up browser user data dir"
+                            );
+                        }
+                    });
+                }
+
+                tracing::info!(policy = "close_browser", "browser closed");
+                Ok(BrowserOutput::success("Browser closed"))
+            }
+        }
     }
 
     /// Get the active page, or create a first one if the browser has no pages yet.
@@ -1108,3 +1376,88 @@ fn truncate_for_display(text: &str, max_len: usize) -> String {
         format!("{}...", &text[..max_len])
     }
 }
+
+/// Resolve the Chrome/Chromium executable path using a layered detection chain:
+///
+/// 1. Explicit config override (`executable_path` in TOML)
+/// 2. `CHROME` / `CHROME_PATH` environment variables
+/// 3. chromiumoxide default detection (system PATH + well-known install paths)
+/// 4. Auto-download via `BrowserFetcher` (cached in `chrome_cache_dir`)
+async fn resolve_chrome_executable(config: &BrowserConfig) -> Result<PathBuf, BrowserError> {
+    // 1. Explicit config
+    if let Some(path) = &config.executable_path {
+        let path = PathBuf::from(path);
+        if path.exists() {
+            tracing::debug!(path = %path.display(), "using configured chrome executable");
+            return Ok(path);
+        }
+        tracing::warn!(
+            path = %path.display(),
+            "configured executable_path does not exist, falling through to detection"
+        );
+    }
+
+    // 2. Environment variables
+    if let Some(path) = detect_chrome_from_env() {
+        tracing::debug!(path = %path.display(), "using chrome from environment variable");
+        return Ok(path);
+    }
+
+    // 3. chromiumoxide default detection (PATH lookup + well-known install paths)
+    if let Ok(path) = chromiumoxide::detection::default_executable(Default::default()) {
+        tracing::debug!(path = %path.display(), "using system-detected chrome");
+        return Ok(path);
+    }
+
+    // 4. Auto-download via fetcher
+    tracing::info!(
+        cache_dir = %config.chrome_cache_dir.display(),
+        "no system Chrome found, downloading via fetcher"
+    );
+    fetch_chrome(&config.chrome_cache_dir).await
+}
+
+/// Check `CHROME` and `CHROME_PATH` environment variables for a Chrome binary.
+fn detect_chrome_from_env() -> Option<PathBuf> {
+    for variable in ["CHROME", "CHROME_PATH"] {
+        if let Ok(value) = std::env::var(variable) {
+            let path = PathBuf::from(&value);
+            if path.exists() {
+                return Some(path);
+            }
+        }
+    }
+    None
+}
+
+/// Download Chromium using chromiumoxide's built-in fetcher.
+/// The binary is cached in `cache_dir` and reused on subsequent launches.
+async fn fetch_chrome(cache_dir: &Path) -> Result<PathBuf, BrowserError> {
+    tokio::fs::create_dir_all(cache_dir)
+        .await
+        .map_err(|error| {
+            BrowserError::new(format!(
+                "failed to create chrome cache dir {}: {error}",
+                cache_dir.display()
+            ))
+        })?;
+
+    let options = BrowserFetcherOptions::builder()
+        .with_path(cache_dir)
+        .build()
+        .map_err(|error| {
+            BrowserError::new(format!("failed to build browser fetcher options: {error}"))
+        })?;
+
+    let fetcher = BrowserFetcher::new(options);
+    let info = fetcher
+        .fetch()
+        .await
+        .map_err(|error| BrowserError::new(format!("failed to download chrome: {error}")))?;
+
+    tracing::info!(
+        path = %info.executable_path.display(),
+        "chrome downloaded and cached"
+    );
+    Ok(info.executable_path)
+}
diff --git a/src/tools/cancel.rs b/src/tools/cancel.rs
index ea1fd950c..2c07ace96 100644
--- a/src/tools/cancel.rs
+++ b/src/tools/cancel.rs
@@ -83,6 +83,12 @@ impl Tool for CancelTool {
     }
 
     async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
+        let reason = args
+            .reason
+            .as_deref()
+            .map(str::trim)
+            .filter(|reason| !reason.is_empty())
+            .unwrap_or("cancelled by tool");
         match args.process_type.as_str() {
             "branch" => {
                 let branch_id = args
@@ -90,7 +96,7 @@ impl Tool for CancelTool {
                     .parse::<BranchId>()
                     .map_err(|e| CancelError(format!("Invalid branch ID: {e}")))?;
                 self.state
-                    .cancel_branch(branch_id)
+                    .cancel_branch_with_reason(branch_id, reason)
                     .await
                     .map_err(CancelError)?;
             }
@@ -100,14 +106,18 @@ impl Tool for CancelTool {
                     .parse::<WorkerId>()
                     .map_err(|e| CancelError(format!("Invalid worker ID: {e}")))?;
                 self.state
-                    .cancel_worker(worker_id)
+                    .cancel_worker_with_reason(worker_id, reason)
                     .await
                     .map_err(CancelError)?;
             }
             other => return Err(CancelError(format!("Unknown process type: {other}"))),
         }
 
-        let message = if let Some(reason) = &args.reason {
+        let message = if args
+            .reason
+            .as_deref()
+            .is_some_and(|reason| !reason.trim().is_empty())
+        {
             format!(
                 "{} {} cancelled: {reason}",
                 args.process_type, args.process_id
diff --git a/src/tools/channel_recall.rs b/src/tools/channel_recall.rs
index 08a344078..4d8744081 100644
--- a/src/tools/channel_recall.rs
+++ b/src/tools/channel_recall.rs
@@ -1,4 +1,4 @@
-//! Cross-channel transcript recall tool for branches.
+//! Channel transcript recall tool for branches. Queries any channel including the current one.
 
 use crate::conversation::channels::ChannelStore;
 use crate::conversation::history::ConversationLogger;
@@ -11,7 +11,7 @@ use serde::{Deserialize, Serialize};
 /// Maximum messages to return in a single recall.
 const MAX_TRANSCRIPT_MESSAGES: i64 = 100;
 
-/// Tool for recalling conversation transcript from other channels.
+/// Tool for recalling conversation transcript from any channel.
 #[derive(Debug, Clone)]
 pub struct ChannelRecallTool {
     conversation_logger: ConversationLogger,
@@ -43,6 +43,16 @@ pub struct ChannelRecallArgs {
     /// Maximum number of messages to return (default 50, max 100).
     #[serde(default = "default_message_limit")]
     pub limit: i64,
+    /// Only return messages sent before this timestamp (RFC 3339, e.g. "2026-01-15T00:00:00Z").
+    #[serde(default)]
+    pub before: Option<String>,
+    /// Only return messages sent after this timestamp (RFC 3339, e.g. "2026-01-15T00:00:00Z").
+    #[serde(default)]
+    pub after: Option<String>,
+    /// When true, returns the oldest matching messages first instead of the most recent.
+    /// Useful for finding the earliest messages in a channel.
+    #[serde(default)]
+    pub oldest_first: bool,
 }
 
 fn default_message_limit() -> i64 {
@@ -107,6 +117,19 @@ impl Tool for ChannelRecallTool {
                         "maximum": 100,
                         "default": 50,
                         "description": "Maximum number of messages to retrieve (1-100)"
+                    },
+                    "before": {
+                        "type": "string",
+                        "description": "Only return messages before this timestamp (RFC 3339, e.g. \"2026-01-15T00:00:00Z\")"
+                    },
+                    "after": {
+                        "type": "string",
+                        "description": "Only return messages after this timestamp (RFC 3339, e.g. \"2026-01-15T00:00:00Z\")"
+                    },
+                    "oldest_first": {
+                        "type": "boolean",
+                        "default": false,
+                        "description": "Return oldest messages first instead of most recent. Use this to find the earliest messages in a channel."
                     }
                 }
             }),
@@ -139,7 +162,13 @@ impl Tool for ChannelRecallTool {
         // Load transcript
         let messages = self
             .conversation_logger
-            .load_channel_transcript(&channel.id, limit)
+            .load_channel_transcript(
+                &channel.id,
+                limit,
+                args.before.as_deref(),
+                args.after.as_deref(),
+                args.oldest_first,
+            )
             .await
             .map_err(|e| ChannelRecallError(format!("Failed to load transcript: {e}")))?;
 
diff --git a/src/tools/conclude_link.rs b/src/tools/conclude_link.rs
deleted file mode 100644
index 315a3f2d5..000000000
--- a/src/tools/conclude_link.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-//! Conclude link tool: gracefully ends a link conversation.
-//!
-//! When an agent determines the conversation objective is met, it calls this
-//! tool with a summary. The channel checks the flag after the LLM turn and
-//! routes the summary back to the originating channel as a system message.
-
-use crate::OutboundResponse;
-use rig::completion::ToolDefinition;
-use rig::tool::Tool;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use std::sync::atomic::{AtomicBool, Ordering};
-use tokio::sync::{RwLock, mpsc};
-
-/// Shared flag between the ConcludeLinkTool and the channel event loop.
-pub type ConcludeLinkFlag = Arc<AtomicBool>;
-
-/// Shared storage for the conclusion summary.
-pub type ConcludeLinkSummary = Arc<RwLock<Option<String>>>;
-
-/// Create a new conclude flag + summary pair.
-pub fn new_conclude_link() -> (ConcludeLinkFlag, ConcludeLinkSummary) {
-    (
-        Arc::new(AtomicBool::new(false)),
-        Arc::new(RwLock::new(None)),
-    )
-}
-
-/// Tool that signals the link conversation should end.
-#[derive(Debug, Clone)]
-pub struct ConcludeLinkTool {
-    flag: ConcludeLinkFlag,
-    summary: ConcludeLinkSummary,
-    response_tx: mpsc::Sender<OutboundResponse>,
-}
-
-impl ConcludeLinkTool {
-    pub fn new(
-        flag: ConcludeLinkFlag,
-        summary: ConcludeLinkSummary,
-        response_tx: mpsc::Sender<OutboundResponse>,
-    ) -> Self {
-        Self {
-            flag,
-            summary,
-            response_tx,
-        }
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-#[error("Conclude link failed: {0}")]
-pub struct ConcludeLinkError(String);
-
-#[derive(Debug, Deserialize, JsonSchema)]
-pub struct ConcludeLinkArgs {
-    /// Summary of the conversation outcomes, decisions, and any action items.
-    pub summary: String,
-}
-
-#[derive(Debug, Serialize)]
-pub struct ConcludeLinkOutput {
-    pub concluded: bool,
-}
-
-impl Tool for ConcludeLinkTool {
-    const NAME: &'static str = "conclude_link";
-
-    type Error = ConcludeLinkError;
-    type Args = ConcludeLinkArgs;
-    type Output = ConcludeLinkOutput;
-
-    async fn definition(&self, _prompt: String) -> ToolDefinition {
-        ToolDefinition {
-            name: Self::NAME.to_string(),
-            description: crate::prompts::text::get("tools/conclude_link").to_string(),
-            parameters: serde_json::json!({
-                "type": "object",
-                "properties": {
-                    "summary": {
-                        "type": "string",
-                        "description": "Summary of the conversation outcomes, decisions made, and any action items."
-                    }
-                },
-                "required": ["summary"]
-            }),
-        }
-    }
-
-    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
-        self.flag.store(true, Ordering::Relaxed);
-
-        let summary_len = args.summary.len();
-        *self.summary.write().await = Some(args.summary);
-
-        let _ = self
-            .response_tx
-            .send(OutboundResponse::Status(crate::StatusUpdate::StopTyping))
-            .await;
-
-        tracing::info!(
-            summary_len,
-            "conclude_link tool called, ending link conversation"
-        );
-
-        Ok(ConcludeLinkOutput { concluded: true })
-    }
-}
diff --git a/src/tools/config_inspect.rs b/src/tools/config_inspect.rs
new file mode 100644
index 000000000..9b8020e75
--- /dev/null
+++ b/src/tools/config_inspect.rs
@@ -0,0 +1,124 @@
+//! Live runtime configuration inspection for cortex chat.
+
+use crate::config::RuntimeConfig;
+use rig::completion::ToolDefinition;
+use rig::tool::Tool;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+/// Tool for inspecting the current resolved runtime config (redacted).
+#[derive(Debug, Clone)]
+pub struct ConfigInspectTool {
+    agent_id: String,
+    runtime_config: Arc<RuntimeConfig>,
+}
+
+impl ConfigInspectTool {
+    pub fn new(agent_id: impl Into<String>, runtime_config: Arc<RuntimeConfig>) -> Self {
+        Self {
+            agent_id: agent_id.into(),
+            runtime_config,
+        }
+    }
+}
+
+/// Error type for `config_inspect`.
+#[derive(Debug, thiserror::Error)]
+#[error("config_inspect failed: {0}")]
+pub struct ConfigInspectError(String);
+
+/// Arguments for `config_inspect`.
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct ConfigInspectArgs {
+    /// Optional section selector. Defaults to "all".
+    pub section: Option<String>,
+}
+
+/// Output from `config_inspect`.
+#[derive(Debug, Serialize)]
+pub struct ConfigInspectOutput {
+    pub success: bool,
+    pub agent_id: String,
+    pub generated_at: String,
+    pub section: String,
+    pub snapshot: serde_json::Value,
+}
+
+impl Tool for ConfigInspectTool {
+    const NAME: &'static str = "config_inspect";
+
+    type Error = ConfigInspectError;
+    type Args = ConfigInspectArgs;
+    type Output = ConfigInspectOutput;
+
+    async fn definition(&self, _prompt: String) -> ToolDefinition {
+        ToolDefinition {
+            name: Self::NAME.to_string(),
+            description: crate::prompts::text::get("tools/config_inspect").to_string(),
+            parameters: serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "section": {
+                        "type": "string",
+                        "description": "Optional subsection to return. Valid values: all, paths, routing, limits, compaction, memory_persistence, coalesce, ingestion, cortex, warmup, work_readiness, browser, sandbox, opencode, mcp_servers, brave_search, timezones, bulletin, secrets, binary_version, deployment"
+                    }
+                }
+            }),
+        }
+    }
+
+    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
+        let snapshot =
+            crate::self_awareness::runtime_snapshot_value(&self.agent_id, &self.runtime_config);
+        let section = args
+            .section
+            .unwrap_or_else(|| "all".to_string())
+            .trim()
+            .to_ascii_lowercase();
+
+        let selected = if section == "all" {
+            snapshot
+        } else {
+            select_section(&snapshot, &section)?
+        };
+
+        Ok(ConfigInspectOutput {
+            success: true,
+            agent_id: self.agent_id.clone(),
+            generated_at: chrono::Utc::now().to_rfc3339(),
+            section,
+            snapshot: selected,
+        })
+    }
+}
+
+fn select_section(
+    snapshot: &serde_json::Value,
+    section: &str,
+) -> Result<serde_json::Value, ConfigInspectError> {
+    match section {
+        "binary_version" => snapshot
+            .get("binary_version")
+            .cloned()
+            .ok_or_else(|| unknown_section_error("binary_version")),
+        "deployment" => snapshot
+            .get("deployment")
+            .cloned()
+            .ok_or_else(|| unknown_section_error("deployment")),
+        "mcp" => snapshot
+            .get("mcp_servers")
+            .cloned()
+            .ok_or_else(|| unknown_section_error("mcp")),
+        other => snapshot
+            .get(other)
+            .cloned()
+            .ok_or_else(|| unknown_section_error(other)),
+    }
+}
+
+fn unknown_section_error(section: &str) -> ConfigInspectError {
+    ConfigInspectError(format!(
+        "unknown section '{section}'. valid sections: all, paths, routing, limits, compaction, memory_persistence, coalesce, ingestion, cortex, warmup, work_readiness, browser, sandbox, opencode, mcp_servers (or mcp), brave_search, timezones, bulletin, secrets, binary_version, deployment"
+    ))
+}
diff --git a/src/tools/cron.rs b/src/tools/cron.rs
index fe35b072a..84dc1e222 100644
--- a/src/tools/cron.rs
+++ b/src/tools/cron.rs
@@ -6,6 +6,7 @@ use rig::completion::ToolDefinition;
 use rig::tool::Tool;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
+use std::str::FromStr;
 use std::sync::Arc;
 
 /// Minimum allowed interval between cron job runs (seconds).
@@ -19,11 +20,21 @@ const MAX_CRON_PROMPT_LENGTH: usize = 10_000;
 pub struct CronTool {
     store: Arc<CronStore>,
     scheduler: Arc<Scheduler>,
+    default_delivery_target: Option<String>,
 }
 
 impl CronTool {
     pub fn new(store: Arc<CronStore>, scheduler: Arc<Scheduler>) -> Self {
-        Self { store, scheduler }
+        Self {
+            store,
+            scheduler,
+            default_delivery_target: None,
+        }
+    }
+
+    pub fn with_default_delivery_target(mut self, default_delivery_target: Option<String>) -> Self {
+        self.default_delivery_target = default_delivery_target;
+        self
     }
 }
 
@@ -41,10 +52,14 @@ pub struct CronArgs {
     /// Required for "create": the prompt/instruction to execute on each run.
     #[serde(default)]
     pub prompt: Option<String>,
+    /// Optional for "create": strict wall-clock cron expression (5-field syntax).
+    /// When provided, this takes precedence over interval-based scheduling.
+    #[serde(default)]
+    pub cron_expr: Option<String>,
     /// Required for "create": interval in seconds between runs.
     #[serde(default)]
     pub interval_secs: Option<u64>,
-    /// Required for "create": where to deliver results, in "adapter:target" format (e.g. "discord:123456789").
+    /// Optional for "create": where to deliver results, in "adapter:target" format (e.g. "discord:123456789"). If omitted, defaults to the current conversation when available.
     #[serde(default)]
     pub delivery_target: Option<String>,
     /// Optional for "create": hour (0-23) when the job becomes active.
@@ -78,6 +93,7 @@ pub struct CronOutput {
 pub struct CronEntry {
     pub id: String,
     pub prompt: String,
+    pub cron_expr: Option<String>,
     pub interval_secs: u64,
     pub delivery_target: String,
     pub run_once: bool,
@@ -111,13 +127,17 @@ impl Tool for CronTool {
                         "type": "string",
                         "description": "For 'create': the instruction to execute on each run."
                     },
+                    "cron_expr": {
+                        "type": "string",
+                        "description": "For 'create': strict wall-clock schedule in cron format (e.g. '0 9 * * *' for daily at 09:00)."
+                    },
                     "interval_secs": {
                         "type": "integer",
                         "description": "For 'create': seconds between runs (e.g. 3600 = hourly, 86400 = daily)."
                     },
                     "delivery_target": {
                         "type": "string",
-                        "description": "For 'create': where to send results, format 'adapter:target' (e.g. 'discord:123456789')."
+                        "description": "For 'create': where to send results, format 'adapter:target' (e.g. 'discord:dm:123456789' for DM, 'discord:channel_id' for server). If omitted, defaults to the current conversation."
                     },
                     "active_start_hour": {
                         "type": "integer",
@@ -167,12 +187,26 @@ impl CronTool {
         let prompt = args
             .prompt
             .ok_or_else(|| CronError("'prompt' is required for create".into()))?;
-        let interval_secs = args
-            .interval_secs
-            .ok_or_else(|| CronError("'interval_secs' is required for create".into()))?;
+        let cron_expr = args
+            .cron_expr
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .map(ToString::to_string);
+        let interval_secs = args.interval_secs.unwrap_or(3600);
         let delivery_target = args
             .delivery_target
-            .ok_or_else(|| CronError("'delivery_target' is required for create".into()))?;
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .map(|value| value.to_string())
+            .or_else(|| self.default_delivery_target.clone())
+            .ok_or_else(|| {
+                CronError(
+                    "'delivery_target' is required for create when no conversation default is available"
+                        .into(),
+                )
+            })?;
 
         // Validate cron job ID: alphanumeric, hyphens, underscores only
         if id.is_empty()
@@ -188,12 +222,23 @@ impl CronTool {
         }
 
         // Prevent excessively short intervals that could cause resource exhaustion
-        if interval_secs < MIN_CRON_INTERVAL_SECS {
+        if cron_expr.is_none() && interval_secs < MIN_CRON_INTERVAL_SECS {
             return Err(CronError(format!(
                 "'interval_secs' must be at least {MIN_CRON_INTERVAL_SECS} (got {interval_secs})"
             )));
         }
 
+        if let Some(expr) = cron_expr.as_deref() {
+            let field_count = expr.split_whitespace().count();
+            if field_count != 5 {
+                return Err(CronError(format!(
+                    "'cron_expr' must have exactly 5 fields (got {field_count}): '{expr}'"
+                )));
+            }
+            cron::Schedule::from_str(expr)
+                .map_err(|error| CronError(format!("invalid 'cron_expr' '{expr}': {error}")))?;
+        }
+
         // Cap prompt length to prevent context flooding
         if prompt.len() > MAX_CRON_PROMPT_LENGTH {
             return Err(CronError(format!(
@@ -224,6 +269,7 @@ impl CronTool {
         let config = CronConfig {
             id: id.clone(),
             prompt: prompt.clone(),
+            cron_expr: cron_expr.clone(),
             interval_secs,
             delivery_target: delivery_target.clone(),
             active_hours,
@@ -244,12 +290,15 @@ impl CronTool {
             .await
             .map_err(|error| CronError(format!("failed to register: {error}")))?;
 
-        let interval_desc = format_interval(interval_secs);
+        let schedule_desc = cron_expr
+            .as_deref()
+            .map(|expr| format!("on schedule `{expr}`"))
+            .unwrap_or_else(|| format_interval(interval_secs));
         let timezone = self.scheduler.cron_timezone_label();
         let mut message = if run_once {
-            format!("Cron job '{id}' created. First run {interval_desc}; it then disables itself.")
+            format!("Cron job '{id}' created. First run {schedule_desc}; it then disables itself.")
         } else {
-            format!("Cron job '{id}' created. Runs {interval_desc}.")
+            format!("Cron job '{id}' created. Runs {schedule_desc}.")
         };
         if let Some((start, end)) = active_hours {
             if timezone == "system" {
@@ -286,6 +335,7 @@ impl CronTool {
             .map(|config| CronEntry {
                 id: config.id,
                 prompt: config.prompt,
+                cron_expr: config.cron_expr,
                 interval_secs: config.interval_secs,
                 delivery_target: config.delivery_target,
                 run_once: config.run_once,
diff --git a/src/tools/email_search.rs b/src/tools/email_search.rs
new file mode 100644
index 000000000..6f71c54a3
--- /dev/null
+++ b/src/tools/email_search.rs
@@ -0,0 +1,264 @@
+//! Search email directly from IMAP for read-back and retrieval.
+
+use crate::config::{Config, EmailConfig, RuntimeConfig};
+use crate::messaging::email::EmailSearchQuery;
+use rig::completion::ToolDefinition;
+use rig::tool::Tool;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+use std::sync::Arc;
+
+/// Tool for searching mailbox content through IMAP.
+#[derive(Debug, Clone)]
+pub struct EmailSearchTool {
+    runtime_config: Arc<RuntimeConfig>,
+}
+
+impl EmailSearchTool {
+    pub fn new(runtime_config: Arc<RuntimeConfig>) -> Self {
+        Self { runtime_config }
+    }
+}
+
+/// Error type for email_search tool.
+#[derive(Debug, thiserror::Error)]
+#[error("email_search failed: {0}")]
+pub struct EmailSearchError(String);
+
+/// Arguments for email_search.
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct EmailSearchArgs {
+    /// Full-text query against message body and headers.
+    #[serde(default)]
+    pub query: Option<String>,
+    /// Sender filter (email or display-name fragment).
+    #[serde(default)]
+    pub from: Option<String>,
+    /// Subject filter.
+    #[serde(default)]
+    pub subject: Option<String>,
+    /// Optional folder list. Defaults to configured email folders.
+    #[serde(default)]
+    pub folders: Vec<String>,
+    /// When true, restricts to unread messages.
+    #[serde(default)]
+    pub unread_only: bool,
+    /// Search lookback window in days. Defaults to 30.
+    #[serde(default)]
+    pub since_days: Option<u32>,
+    /// Maximum results to return (1..50). Defaults to 10.
+    #[serde(default)]
+    pub limit: Option<usize>,
+}
+
+/// A single email search result.
+#[derive(Debug, Serialize)]
+pub struct EmailSearchResult {
+    pub folder: String,
+    pub uid: u32,
+    pub from: String,
+    pub subject: String,
+    pub date: Option<String>,
+    pub message_id: Option<String>,
+    pub body_snippet: String,
+    pub attachment_names: Vec<String>,
+}
+
+/// Output for email_search.
+#[derive(Debug, Serialize)]
+pub struct EmailSearchOutput {
+    pub criteria: String,
+    pub result_count: usize,
+    pub results: Vec<EmailSearchResult>,
+}
+
+impl Tool for EmailSearchTool {
+    const NAME: &'static str = "email_search";
+
+    type Error = EmailSearchError;
+    type Args = EmailSearchArgs;
+    type Output = EmailSearchOutput;
+
+    async fn definition(&self, _prompt: String) -> ToolDefinition {
+        ToolDefinition {
+            name: Self::NAME.to_string(),
+            description: crate::prompts::text::get("tools/email_search").to_string(),
+            parameters: serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Optional full-text query for message bodies and headers."
+                    },
+                    "from": {
+                        "type": "string",
+                        "description": "Optional sender filter (e.g. alice@example.com)."
+                    },
+                    "subject": {
+                        "type": "string",
+                        "description": "Optional subject filter."
+                    },
+                    "folders": {
+                        "type": "array",
+                        "description": "Optional folder names to search. Defaults to configured folders.",
+                        "items": { "type": "string" }
+                    },
+                    "unread_only": {
+                        "type": "boolean",
+                        "description": "When true, search only unread messages."
+                    },
+                    "since_days": {
+                        "type": "integer",
+                        "description": "Search lookback in days (defaults to 30)."
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum results (1-50, default 10)."
+                    }
+                }
+            }),
+        }
+    }
+
+    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
+        let query = EmailSearchQuery {
+            text: clean_optional(args.query),
+            from: clean_optional(args.from),
+            subject: clean_optional(args.subject),
+            unread_only: args.unread_only,
+            since_days: args.since_days.filter(|days| *days > 0).or(Some(30)),
+            folders: args.folders,
+            limit: args.limit.unwrap_or(10).clamp(1, 50),
+        };
+
+        let criteria = format_search_criteria(&query);
+
+        let instance_dir = self.runtime_config.instance_dir.clone();
+        let search_query = query.clone();
+        let hits = tokio::task::spawn_blocking(move || {
+            let email_config = load_email_config(&instance_dir)?;
+            crate::messaging::email::search_mailbox(&email_config, search_query)
+                .map_err(|error| EmailSearchError(error.to_string()))
+        })
+        .await
+        .map_err(|error| EmailSearchError(format!("email search task failed: {error}")))??;
+
+        let results = hits
+            .into_iter()
+            .map(|hit| EmailSearchResult {
+                folder: hit.folder,
+                uid: hit.uid,
+                from: hit.from,
+                subject: hit.subject,
+                date: hit.date,
+                message_id: hit.message_id,
+                body_snippet: truncate_snippet(&hit.body, 1600),
+                attachment_names: hit.attachment_names,
+            })
+            .collect::<Vec<_>>();
+
+        Ok(EmailSearchOutput {
+            criteria,
+            result_count: results.len(),
+            results,
+        })
+    }
+}
+
+fn load_email_config(instance_dir: &Path) -> Result<EmailConfig, EmailSearchError> {
+    let config = Config::load_for_instance(instance_dir).map_err(|error| {
+        EmailSearchError(format!(
+            "failed to resolve config for {}: {error}",
+            instance_dir.display()
+        ))
+    })?;
+
+    let email = config
+        .messaging
+        .email
+        .ok_or_else(|| EmailSearchError("email adapter is not configured".to_string()))?;
+
+    if !email.enabled {
+        return Err(EmailSearchError(
+            "email adapter is configured but disabled".to_string(),
+        ));
+    }
+
+    Ok(email)
+}
+
+fn clean_optional(value: Option<String>) -> Option<String> {
+    value
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+}
+
+fn format_search_criteria(query: &EmailSearchQuery) -> String {
+    let mut parts = Vec::new();
+    if let Some(from) = &query.from {
+        parts.push(format!("from={from}"));
+    }
+    if let Some(subject) = &query.subject {
+        parts.push(format!("subject={subject}"));
+    }
+    if let Some(text) = &query.text {
+        parts.push(format!("query={text}"));
+    }
+    if query.unread_only {
+        parts.push("unread_only=true".to_string());
+    }
+    if let Some(since_days) = query.since_days {
+        parts.push(format!("since_days={since_days}"));
+    }
+    if !query.folders.is_empty() {
+        parts.push(format!("folders={}", query.folders.join(",")));
+    }
+    parts.push(format!("limit={}", query.limit));
+
+    parts.join("; ")
+}
+
+fn truncate_snippet(value: &str, max_bytes: usize) -> String {
+    if value.len() <= max_bytes {
+        return value.to_string();
+    }
+
+    let mut end = max_bytes;
+    while end > 0 && !value.is_char_boundary(end) {
+        end -= 1;
+    }
+
+    format!("{}\n\n[snippet truncated]", &value[..end])
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{clean_optional, format_search_criteria};
+    use crate::messaging::email::EmailSearchQuery;
+
+    #[test]
+    fn clean_optional_rejects_empty_values() {
+        assert_eq!(clean_optional(None), None);
+        assert_eq!(clean_optional(Some("   ".to_string())), None);
+        assert_eq!(
+            clean_optional(Some("  value ".to_string())),
+            Some("value".to_string())
+        );
+    }
+
+    #[test]
+    fn format_search_criteria_includes_defaults() {
+        let criteria = format_search_criteria(&EmailSearchQuery {
+            text: None,
+            from: None,
+            subject: None,
+            unread_only: false,
+            since_days: Some(30),
+            folders: Vec::new(),
+            limit: 10,
+        });
+
+        assert_eq!(criteria, "since_days=30; limit=10");
+    }
+}
diff --git a/src/tools/exec.rs b/src/tools/exec.rs
index 8cbd07ddb..5ef86a6fa 100644
--- a/src/tools/exec.rs
+++ b/src/tools/exec.rs
@@ -5,7 +5,7 @@ use rig::completion::ToolDefinition;
 use rig::tool::Tool;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::process::Stdio;
 use std::sync::Arc;
 use tokio::process::Command;
@@ -159,23 +159,33 @@ impl Tool for ExecTool {
     }
 
     async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
-        // Validate working_dir stays within workspace if specified
+        // Relative working_dir values resolve from the workspace.
+        // Workspace boundary enforcement only applies when sandbox mode is enabled.
         let working_dir = if let Some(ref dir) = args.working_dir {
-            let path = std::path::Path::new(dir);
-            let canonical = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
-            let workspace_canonical = self
-                .workspace
-                .canonicalize()
-                .unwrap_or_else(|_| self.workspace.clone());
-            if !canonical.starts_with(&workspace_canonical) {
-                return Err(ExecError {
-                    message: format!(
-                        "working_dir must be within the workspace ({}).",
-                        self.workspace.display()
-                    ),
-                    exit_code: -1,
-                });
+            let raw_path = Path::new(dir);
+            let resolved = if raw_path.is_absolute() {
+                raw_path.to_path_buf()
+            } else {
+                self.workspace.join(raw_path)
+            };
+            let canonical = resolved.canonicalize().unwrap_or(resolved);
+
+            if self.sandbox.mode_enabled() {
+                let workspace_canonical = self
+                    .workspace
+                    .canonicalize()
+                    .unwrap_or_else(|_| self.workspace.clone());
+                if !canonical.starts_with(&workspace_canonical) {
+                    return Err(ExecError {
+                        message: format!(
+                            "working_dir must be within the workspace ({}).",
+                            self.workspace.display()
+                        ),
+                        exit_code: -1,
+                    });
+                }
             }
+
             canonical
         } else {
             self.workspace.clone()
diff --git a/src/tools/file.rs b/src/tools/file.rs
index 077a10eae..eb622d720 100644
--- a/src/tools/file.rs
+++ b/src/tools/file.rs
@@ -1,28 +1,36 @@
 //! File tool for reading/writing/listing files (task workers only).
 
+use crate::sandbox::Sandbox;
 use rig::completion::ToolDefinition;
 use rig::tool::Tool;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
-/// Tool for file operations, restricted to the agent's workspace directory.
+/// Tool for file operations with sandbox-aware path validation.
+///
+/// When sandbox mode is enabled, file access is restricted to the workspace
+/// boundary. When sandbox is disabled, any path accessible to the process is
+/// allowed (relative paths are still resolved against the workspace root).
 #[derive(Debug, Clone)]
 pub struct FileTool {
     workspace: PathBuf,
+    sandbox: Arc<Sandbox>,
 }
 
 impl FileTool {
-    /// Create a new file tool restricted to the given workspace directory.
-    pub fn new(workspace: PathBuf) -> Self {
-        Self { workspace }
+    /// Create a new file tool with sandbox-aware path validation.
+    pub fn new(workspace: PathBuf, sandbox: Arc<Sandbox>) -> Self {
+        Self { workspace, sandbox }
     }
 
-    /// Resolve and validate a path, ensuring it stays within the workspace boundary.
+    /// Resolve and validate a path.
     ///
-    /// Relative paths are resolved against the workspace root. Absolute paths are
-    /// accepted only if they fall within the workspace. Symlink traversal and `..`
-    /// components are handled via canonicalization.
+    /// Relative paths are resolved against the workspace root. When sandbox mode
+    /// is enabled, absolute paths must fall within the workspace and symlink
+    /// traversal is blocked. When sandbox is disabled, any readable/writable
+    /// path is accepted.
     fn resolve_path(&self, raw: &str) -> Result<PathBuf, FileError> {
         let path = Path::new(raw);
         let resolved = if path.is_absolute() {
@@ -35,6 +43,11 @@ impl FileTool {
         // existing ancestor and append the remaining components.
         let canonical = best_effort_canonicalize(&resolved);
 
+        // When sandbox is disabled, skip workspace boundary enforcement.
+        if !self.sandbox.mode_enabled() {
+            return Ok(canonical);
+        }
+
         let workspace_canonical = self
             .workspace
             .canonicalize()
@@ -200,19 +213,22 @@ impl Tool for FileTool {
         match args.operation.as_str() {
             "read" => do_file_read(&path).await,
             "write" => {
-                // Identity files remain readable, but writes must go through
-                // the dedicated identity API to keep update flow consistent.
-                let file_name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
-                const PROTECTED_FILES: &[&str] = &["SOUL.md", "IDENTITY.md", "USER.md"];
-                if PROTECTED_FILES
-                    .iter()
-                    .any(|f| file_name.eq_ignore_ascii_case(f))
-                {
-                    return Err(FileError(
-                        "ACCESS DENIED: Identity files are protected and cannot be modified \
-                         through file operations. Use the identity management API instead."
-                            .to_string(),
-                    ));
+                // When sandbox is enabled, identity files must go through the
+                // dedicated identity API to keep the update flow consistent.
+                // When sandbox is disabled, the user has opted into full access.
+                if self.sandbox.mode_enabled() {
+                    let file_name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
+                    const PROTECTED_FILES: &[&str] = &["SOUL.md", "IDENTITY.md", "USER.md"];
+                    if PROTECTED_FILES
+                        .iter()
+                        .any(|f| file_name.eq_ignore_ascii_case(f))
+                    {
+                        return Err(FileError(
+                            "ACCESS DENIED: Identity files are protected and cannot be modified \
+                             through file operations. Use the identity management API instead."
+                                .to_string(),
+                        ));
+                    }
                 }
 
                 let content = args.content.ok_or_else(|| {
@@ -402,3 +418,156 @@ pub async fn file_list(path: impl AsRef<Path>) -> crate::error::Result<Vec<FileE
         })
         .collect())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::sandbox::{Sandbox, SandboxConfig, SandboxMode};
+    use std::fs;
+
+    fn create_sandbox(mode: SandboxMode, workspace: &Path) -> Arc<Sandbox> {
+        let config = SandboxConfig {
+            mode,
+            ..Default::default()
+        };
+        let config = Arc::new(arc_swap::ArcSwap::from_pointee(config));
+        Arc::new(Sandbox::new_for_test(config, workspace.to_path_buf()))
+    }
+
+    #[tokio::test]
+    async fn sandbox_enabled_rejects_read_outside_workspace() {
+        let temp_dir = tempfile::tempdir().expect("failed to create temp dir");
+        let workspace = temp_dir.path().join("workspace");
+        let outside = temp_dir.path().join("outside");
+        fs::create_dir_all(&workspace).expect("failed to create workspace");
+        fs::create_dir_all(&outside).expect("failed to create outside dir");
+
+        let file = outside.join("secret.txt");
+        fs::write(&file, "secret data").expect("failed to write file");
+
+        let sandbox = create_sandbox(SandboxMode::Enabled, &workspace);
+        let tool = FileTool::new(workspace, sandbox);
+
+        let result = tool
+            .call(FileArgs {
+                operation: "read".to_string(),
+                path: file.to_string_lossy().into_owned(),
+                content: None,
+                create_dirs: false,
+            })
+            .await;
+
+        let error = result
+            .expect_err("should reject path outside workspace")
+            .to_string();
+        assert!(error.contains("ACCESS DENIED"), "unexpected error: {error}");
+    }
+
+    #[tokio::test]
+    async fn sandbox_disabled_allows_read_outside_workspace() {
+        let temp_dir = tempfile::tempdir().expect("failed to create temp dir");
+        let workspace = temp_dir.path().join("workspace");
+        let outside = temp_dir.path().join("outside");
+        fs::create_dir_all(&workspace).expect("failed to create workspace");
+        fs::create_dir_all(&outside).expect("failed to create outside dir");
+
+        let file = outside.join("report.txt");
+        fs::write(&file, "public data").expect("failed to write file");
+
+        let sandbox = create_sandbox(SandboxMode::Disabled, &workspace);
+        let tool = FileTool::new(workspace, sandbox);
+
+        let result = tool
+            .call(FileArgs {
+                operation: "read".to_string(),
+                path: file.to_string_lossy().into_owned(),
+                content: None,
+                create_dirs: false,
+            })
+            .await
+            .expect("should succeed when sandbox is disabled");
+
+        assert!(result.success);
+        assert_eq!(result.content.as_deref(), Some("public data"));
+    }
+
+    #[tokio::test]
+    async fn sandbox_disabled_allows_write_outside_workspace() {
+        let temp_dir = tempfile::tempdir().expect("failed to create temp dir");
+        let workspace = temp_dir.path().join("workspace");
+        let outside = temp_dir.path().join("outside");
+        fs::create_dir_all(&workspace).expect("failed to create workspace");
+        fs::create_dir_all(&outside).expect("failed to create outside dir");
+
+        let file = outside.join("output.txt");
+
+        let sandbox = create_sandbox(SandboxMode::Disabled, &workspace);
+        let tool = FileTool::new(workspace, sandbox);
+
+        let result = tool
+            .call(FileArgs {
+                operation: "write".to_string(),
+                path: file.to_string_lossy().into_owned(),
+                content: Some("written outside workspace".to_string()),
+                create_dirs: false,
+            })
+            .await
+            .expect("should succeed when sandbox is disabled");
+
+        assert!(result.success);
+        let written = fs::read_to_string(&file).expect("failed to read written file");
+        assert_eq!(written, "written outside workspace");
+    }
+
+    #[tokio::test]
+    async fn sandbox_enabled_blocks_identity_file_write() {
+        let temp_dir = tempfile::tempdir().expect("failed to create temp dir");
+        let workspace = temp_dir.path().join("workspace");
+        fs::create_dir_all(&workspace).expect("failed to create workspace");
+
+        let sandbox = create_sandbox(SandboxMode::Enabled, &workspace);
+        let tool = FileTool::new(workspace.clone(), sandbox);
+
+        let result = tool
+            .call(FileArgs {
+                operation: "write".to_string(),
+                path: workspace.join("SOUL.md").to_string_lossy().into_owned(),
+                content: Some("overwritten".to_string()),
+                create_dirs: false,
+            })
+            .await;
+
+        let error = result
+            .expect_err("should block identity file write")
+            .to_string();
+        assert!(
+            error.contains("Identity files are protected"),
+            "unexpected error: {error}"
+        );
+    }
+
+    #[tokio::test]
+    async fn sandbox_disabled_allows_identity_file_write() {
+        let temp_dir = tempfile::tempdir().expect("failed to create temp dir");
+        let workspace = temp_dir.path().join("workspace");
+        fs::create_dir_all(&workspace).expect("failed to create workspace");
+
+        let sandbox = create_sandbox(SandboxMode::Disabled, &workspace);
+        let tool = FileTool::new(workspace.clone(), sandbox);
+
+        let result = tool
+            .call(FileArgs {
+                operation: "write".to_string(),
+                path: workspace.join("IDENTITY.md").to_string_lossy().into_owned(),
+                content: Some("new identity".to_string()),
+                create_dirs: false,
+            })
+            .await
+            .expect("should allow identity file write when sandbox is disabled");
+
+        assert!(result.success);
+        let written =
+            fs::read_to_string(workspace.join("IDENTITY.md")).expect("failed to read file");
+        assert_eq!(written, "new identity");
+    }
+}
diff --git a/src/tools/memory_save.rs b/src/tools/memory_save.rs
index 07225bffe..a21d3e687 100644
--- a/src/tools/memory_save.rs
+++ b/src/tools/memory_save.rs
@@ -3,6 +3,7 @@
 use crate::error::Result;
 use crate::memory::types::Association;
 use crate::memory::{Memory, MemorySearch, MemoryType};
+use crate::{AgentId, ProcessEvent};
 use rig::completion::ToolDefinition;
 use rig::tool::Tool;
 use schemars::JsonSchema;
@@ -17,12 +18,35 @@ const MAX_MEMORY_CONTENT_BYTES: usize = 50_000;
 #[derive(Debug, Clone)]
 pub struct MemorySaveTool {
     memory_search: Arc<MemorySearch>,
+    event_context: Option<MemorySaveEventContext>,
+}
+
+#[derive(Debug, Clone)]
+struct MemorySaveEventContext {
+    agent_id: AgentId,
+    memory_event_tx: tokio::sync::broadcast::Sender<ProcessEvent>,
 }
 
 impl MemorySaveTool {
     /// Create a new memory save tool.
     pub fn new(memory_search: Arc<MemorySearch>) -> Self {
-        Self { memory_search }
+        Self {
+            memory_search,
+            event_context: None,
+        }
+    }
+
+    /// Enable process event emission for successful memory saves.
+    pub fn with_event_bus(
+        mut self,
+        agent_id: AgentId,
+        memory_event_tx: tokio::sync::broadcast::Sender<ProcessEvent>,
+    ) -> Self {
+        self.event_context = Some(MemorySaveEventContext {
+            agent_id,
+            memory_event_tx,
+        });
+        self
     }
 }
 
@@ -290,6 +314,26 @@ impl Tool for MemorySaveTool {
             tracing::warn!(%error, "failed to ensure FTS index after memory save");
         }
 
+        if let Some(event_context) = &self.event_context
+            && event_context.memory_event_tx.receiver_count() > 0
+        {
+            let event = ProcessEvent::MemorySaved {
+                agent_id: event_context.agent_id.clone(),
+                memory_id: memory.id.clone(),
+                channel_id: memory.channel_id.clone(),
+                memory_type: memory.memory_type,
+                importance: memory.importance,
+                content_summary: summarize_memory_content(&memory.content),
+            };
+            if let Err(error) = event_context.memory_event_tx.send(event) {
+                tracing::debug!(
+                    memory_id = %memory.id,
+                    %error,
+                    "failed to emit memory-saved event"
+                );
+            }
+        }
+
         #[cfg(feature = "metrics")]
         {
             let metrics = crate::telemetry::Metrics::global();
@@ -330,3 +374,25 @@ pub async fn save_fact(
         .map_err(|e| crate::error::AgentError::Other(anyhow::anyhow!(e)))?;
     Ok(output.memory_id)
 }
+
+fn summarize_memory_content(content: &str) -> String {
+    crate::summarize_first_non_empty_line(content, crate::EVENT_SUMMARY_MAX_CHARS)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::summarize_memory_content;
+
+    #[test]
+    fn summarize_memory_content_prefers_first_non_empty_line() {
+        let content = "\n\nFirst line summary\nSecond line details";
+        assert_eq!(summarize_memory_content(content), "First line summary");
+    }
+
+    #[test]
+    fn summarize_memory_content_truncates_to_max_chars() {
+        let content = "a".repeat(200);
+        let summary = summarize_memory_content(&content);
+        assert_eq!(summary.chars().count(), crate::EVENT_SUMMARY_MAX_CHARS);
+    }
+}
diff --git a/src/tools/reply.rs b/src/tools/reply.rs
index 3bec9e1c9..91c68b2e9 100644
--- a/src/tools/reply.rs
+++ b/src/tools/reply.rs
@@ -327,9 +327,17 @@ impl Tool for ReplyTool {
             "required": ["content"]
         });
 
+        let source = self.conversation_id.split(':').next().unwrap_or("unknown");
+        let mut description = crate::prompts::text::get("tools/reply").to_string();
+        if source == "email" {
+            description.push_str(
+                " In email conversations this sends an actual outbound email to the sender. Use only when an explicit reply is required; otherwise prefer branch + skip.",
+            );
+        }
+
         ToolDefinition {
             name: Self::NAME.to_string(),
-            description: crate::prompts::text::get("tools/reply").to_string(),
+            description,
             parameters,
         }
     }
@@ -354,18 +362,39 @@ impl Tool for ReplyTool {
         )
         .await;
 
-        self.conversation_logger.log_bot_message_with_name(
-            &self.channel_id,
-            &converted_content,
-            Some(&self.agent_display_name),
-        );
+        if crate::tools::should_block_user_visible_text(&converted_content) {
+            tracing::warn!(
+                conversation_id = %self.conversation_id,
+                "reply tool blocked structured or tool-like output"
+            );
+            return Err(ReplyError(
+                "blocked reply content: looks like tool syntax or structured payload".into(),
+            ));
+        }
 
-        let response = if let Some(ref name) = args.thread_name {
+        let thread_name = args
+            .thread_name
+            .as_ref()
+            .map(|name| name.trim())
+            .filter(|name| !name.is_empty());
+
+        if let Some(leak) = crate::secrets::scrub::scan_for_leaks(&converted_content) {
+            tracing::error!(
+                conversation_id = %self.conversation_id,
+                leak_prefix = %&leak[..leak.len().min(8)],
+                "reply tool blocked content matching secret pattern"
+            );
+            return Err(ReplyError(
+                "blocked reply content: potential secret detected".into(),
+            ));
+        }
+
+        let response = if let Some(name) = thread_name {
             // Cap thread names at 100 characters (Discord limit)
             let thread_name = if name.len() > 100 {
                 name[..name.floor_char_boundary(100)].to_string()
             } else {
-                name.clone()
+                name.to_string()
             };
             OutboundResponse::ThreadReply {
                 thread_name,
@@ -375,7 +404,7 @@ impl Tool for ReplyTool {
         {
             OutboundResponse::RichMessage {
                 text: converted_content.clone(),
-                blocks: vec![], // No block generation for now; Slack adapters will fall back to text
+                blocks: vec![],
                 cards: args.cards.unwrap_or_default(),
                 interactive_elements: args.interactive_elements.unwrap_or_default(),
                 poll: args.poll,
@@ -389,6 +418,12 @@ impl Tool for ReplyTool {
             .await
             .map_err(|e| ReplyError(format!("failed to send reply: {e}")))?;
 
+        self.conversation_logger.log_bot_message_with_name(
+            &self.channel_id,
+            &converted_content,
+            Some(&self.agent_display_name),
+        );
+
         // Mark the turn as handled so handle_agent_result skips the fallback send.
         self.replied_flag.store(true, Ordering::Relaxed);
 
diff --git a/src/tools/secret_set.rs b/src/tools/secret_set.rs
new file mode 100644
index 000000000..cbcb86c00
--- /dev/null
+++ b/src/tools/secret_set.rs
@@ -0,0 +1,148 @@
+//! Tool for workers to store secrets in the instance-level secret store.
+//!
+//! Useful for autonomous workflows where a worker creates accounts, generates
+//! API keys, or obtains credentials that should be persisted for future use.
+
+use crate::secrets::store::{SecretCategory, SecretsStore, auto_categorize};
+use rig::completion::ToolDefinition;
+use rig::tool::Tool;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+/// Tool for storing secrets from worker subprocesses.
+#[derive(Debug, Clone)]
+pub struct SecretSetTool {
+    secrets_store: Arc<SecretsStore>,
+}
+
+impl SecretSetTool {
+    /// Create a new secret set tool with access to the instance-level store.
+    pub fn new(secrets_store: Arc<SecretsStore>) -> Self {
+        Self { secrets_store }
+    }
+}
+
+/// Error type for secret set tool.
+#[derive(Debug, thiserror::Error)]
+#[error("Failed to set secret: {0}")]
+pub struct SecretSetError(String);
+
+/// Arguments for secret set tool.
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct SecretSetArgs {
+    /// The name of the secret (e.g. "GH_TOKEN", "STRIPE_API_KEY").
+    /// Use UPPER_SNAKE_CASE by convention.
+    pub name: String,
+    /// The secret value to store.
+    pub value: String,
+    /// Optional category override: "system" or "tool".
+    /// If omitted, the category is auto-assigned based on the name.
+    /// Most worker-created secrets should be "tool" (exposed to subprocesses).
+    pub category: Option<String>,
+}
+
+/// Output from secret set tool.
+#[derive(Debug, Serialize)]
+pub struct SecretSetOutput {
+    /// Whether the secret was stored successfully.
+    pub success: bool,
+    /// The name of the secret that was stored.
+    pub name: String,
+    /// The category that was assigned.
+    pub category: String,
+    /// Whether this was an update to an existing secret.
+    pub updated: bool,
+}
+
+impl Tool for SecretSetTool {
+    const NAME: &'static str = "secret_set";
+
+    type Error = SecretSetError;
+    type Args = SecretSetArgs;
+    type Output = SecretSetOutput;
+
+    async fn definition(&self, _prompt: String) -> ToolDefinition {
+        ToolDefinition {
+            name: Self::NAME.to_string(),
+            description: crate::prompts::text::get("tools/secret_set").to_string(),
+            parameters: serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "type": "string",
+                        "description": "Secret name in UPPER_SNAKE_CASE (e.g. GH_TOKEN, STRIPE_API_KEY)"
+                    },
+                    "value": {
+                        "type": "string",
+                        "description": "The secret value to store"
+                    },
+                    "category": {
+                        "type": "string",
+                        "enum": ["system", "tool"],
+                        "description": "Optional category override. Defaults to auto-categorization based on the name. 'tool' secrets are exposed as env vars in future worker subprocesses. 'system' secrets are only accessible internally."
+                    }
+                },
+                "required": ["name", "value"]
+            }),
+        }
+    }
+
+    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
+        let name = args.name.trim().to_uppercase();
+
+        if name.is_empty() {
+            return Err(SecretSetError("secret name cannot be empty".to_string()));
+        }
+
+        // Secret names are injected as environment variables, so they must be
+        // valid env var identifiers: start with a letter, contain only uppercase
+        // letters, digits, and underscores.
+        if !name.bytes().next().is_some_and(|b| b.is_ascii_uppercase())
+            || !name
+                .bytes()
+                .all(|b| b.is_ascii_uppercase() || b.is_ascii_digit() || b == b'_')
+        {
+            return Err(SecretSetError(
+                "secret name must be a valid env var name (A-Z, 0-9, _ only, starting with a letter)".to_string(),
+            ));
+        }
+
+        if args.value.is_empty() {
+            return Err(SecretSetError("secret value cannot be empty".to_string()));
+        }
+
+        // Determine category: explicit override or auto-categorize.
+        let category = match args.category.as_deref() {
+            Some("system") => SecretCategory::System,
+            Some("tool") => SecretCategory::Tool,
+            Some(other) => {
+                return Err(SecretSetError(format!(
+                    "invalid category '{other}' — must be 'system' or 'tool'"
+                )));
+            }
+            None => auto_categorize(&name),
+        };
+
+        // Check if this is an update to an existing secret.
+        let updated = self.secrets_store.get_metadata(&name).is_ok();
+
+        self.secrets_store
+            .set(&name, &args.value, category)
+            .map_err(|error| SecretSetError(format!("{error}")))?;
+
+        tracing::info!(
+            name = %name,
+            category = %category,
+            updated,
+            "worker stored secret via secret_set tool"
+        );
+
+        Ok(SecretSetOutput {
+            success: true,
+            name,
+            category: category.to_string(),
+            updated,
+        })
+    }
+}
diff --git a/src/tools/send_agent_message.rs b/src/tools/send_agent_message.rs
index a2f3e03d3..213f1da31 100644
--- a/src/tools/send_agent_message.rs
+++ b/src/tools/send_agent_message.rs
@@ -1,13 +1,17 @@
-//! Send message to another agent through the communication graph.
-
-use crate::conversation::ChannelStore;
+//! Assign a task to another agent through the communication graph.
+//!
+//! When called, creates a task in the target agent's task store (skipping
+//! `pending_approval` for agent-delegated tasks) and logs a system message
+//! in the link channel between the two agents. The calling agent's turn ends
+//! immediately — the result will be delivered when the target agent's cortex
+//! picks up and completes the task.
+
+use crate::conversation::history::ConversationLogger;
 use crate::links::AgentLink;
-use crate::messaging::MessagingManager;
+use crate::tasks::TaskStore;
 use crate::tools::SkipFlag;
-use crate::{AgentId, InboundMessage, MessageContent, ProcessEvent};
 
 use arc_swap::ArcSwap;
-use chrono::Utc;
 use rig::completion::ToolDefinition;
 use rig::tool::Tool;
 use schemars::JsonSchema;
@@ -15,33 +19,26 @@ use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::sync::atomic::Ordering;
-use tokio::sync::broadcast;
 
-/// Tool for sending messages to other agents through the agent communication graph.
+/// Tool for delegating tasks to other agents through the agent communication graph.
 ///
 /// Resolves the target agent by ID or name, validates the link exists and permits
-/// messaging in this direction, constructs an `InboundMessage` with source "internal",
-/// and delivers via `MessagingManager::inject_message()`.
+/// this direction, creates a task in the target agent's task store, and logs the
+/// delegation in the link channel. The calling agent's turn ends after delegation.
 #[derive(Clone)]
 pub struct SendAgentMessageTool {
-    agent_id: AgentId,
-    agent_name: String,
-    channel_id: crate::ChannelId,
+    agent_id: crate::AgentId,
     links: Arc<ArcSwap<Vec<AgentLink>>>,
-    messaging_manager: Arc<MessagingManager>,
-    channel_store: ChannelStore,
-    event_tx: broadcast::Sender<ProcessEvent>,
     /// Map of known agent IDs to display names, for resolving targets.
     agent_names: Arc<HashMap<String, String>>,
-    /// Per-turn skip flag. When set after sending, the channel turn ends immediately
-    /// instead of looping back to the LLM (which would burn depth calling skip).
+    /// Cross-agent task store registry for creating tasks on target agents.
+    task_store_registry: Arc<ArcSwap<HashMap<String, Arc<TaskStore>>>>,
+    /// Per-agent conversation logger for writing link channel audit records.
+    conversation_logger: ConversationLogger,
+    /// Per-turn skip flag. When set after delegation, the channel turn ends immediately.
     skip_flag: Option<SkipFlag>,
-    /// Source of the originating channel's inbound message (e.g. "webchat", "discord").
-    /// Propagated through metadata so conclusion routing uses the correct adapter.
-    originating_source: Option<String>,
-    /// Channel that originated the current link conversation (if any).
-    /// Used for guardrails to prevent re-delegating to the upstream counterparty
-    /// instead of concluding back to them.
+    /// The originating channel (conversation_id) where the user request came from.
+    /// Set per-turn so task completion notifications route back to the right place.
     originating_channel: Option<String>,
 }
 
@@ -54,51 +51,55 @@ impl std::fmt::Debug for SendAgentMessageTool {
 }
 
 impl SendAgentMessageTool {
-    #[allow(clippy::too_many_arguments)]
     pub fn new(
-        agent_id: AgentId,
-        agent_name: String,
-        channel_id: crate::ChannelId,
+        agent_id: crate::AgentId,
         links: Arc<ArcSwap<Vec<AgentLink>>>,
-        messaging_manager: Arc<MessagingManager>,
-        channel_store: ChannelStore,
-        event_tx: broadcast::Sender<ProcessEvent>,
         agent_names: Arc<HashMap<String, String>>,
+        task_store_registry: Arc<ArcSwap<HashMap<String, Arc<TaskStore>>>>,
+        conversation_logger: ConversationLogger,
     ) -> Self {
         Self {
             agent_id,
-            agent_name,
-            channel_id,
             links,
-            messaging_manager,
-            channel_store,
-            event_tx,
             agent_names,
+            task_store_registry,
+            conversation_logger,
             skip_flag: None,
-            originating_source: None,
             originating_channel: None,
         }
     }
-}
 
-impl SendAgentMessageTool {
-    /// Set the per-turn skip flag so the channel turn ends after sending.
+    /// Set the per-turn skip flag so the channel turn ends after delegation.
     pub fn with_skip_flag(mut self, flag: SkipFlag) -> Self {
         self.skip_flag = Some(flag);
         self
     }
 
-    /// Set the originating source (adapter name) for conclusion routing.
-    pub fn with_originating_source(mut self, source: String) -> Self {
-        self.originating_source = Some(source);
-        self
-    }
-
-    /// Set the direct originating channel for this turn.
+    /// Set the originating channel for this turn so task completion notifications
+    /// route back to the conversation where the user asked for the work.
     pub fn with_originating_channel(mut self, channel_id: String) -> Self {
         self.originating_channel = Some(channel_id);
         self
     }
+
+    /// Resolve an agent target string to an agent ID.
+    /// Checks both IDs and display names (case-insensitive).
+    fn resolve_agent_id(&self, target: &str) -> Option<String> {
+        // Direct ID match
+        if self.agent_names.contains_key(target) {
+            return Some(target.to_string());
+        }
+
+        // Name match (case-insensitive)
+        let target_lower = target.to_lowercase();
+        for (agent_id, name) in self.agent_names.iter() {
+            if name.to_lowercase() == target_lower {
+                return Some(agent_id.clone());
+            }
+        }
+
+        None
+    }
 }
 
 /// Error type for send_agent_message tool.
@@ -111,7 +112,8 @@ pub struct SendAgentMessageError(String);
 pub struct SendAgentMessageArgs {
     /// Target agent ID or name.
     pub target: String,
-    /// The message content to send.
+    /// The task to assign. First sentence is used as the task title;
+    /// full content becomes the task description.
     pub message: String,
 }
 
@@ -120,7 +122,8 @@ pub struct SendAgentMessageArgs {
 pub struct SendAgentMessageOutput {
     pub success: bool,
     pub target_agent: String,
-    pub channel_id: String,
+    pub task_number: Option<i64>,
+    pub message: String,
 }
 
 impl Tool for SendAgentMessageTool {
@@ -143,7 +146,7 @@ impl Tool for SendAgentMessageTool {
                     },
                     "message": {
                         "type": "string",
-                        "description": "The message content to send to the target agent."
+                        "description": "The task to assign. First sentence becomes the title; full content is the description."
                     }
                 },
                 "required": ["target", "message"]
@@ -167,32 +170,6 @@ impl Tool for SendAgentMessageTool {
             ))
         })?;
 
-        // In link channels, responding to the current counterparty should use the reply tool
-        // so metadata and conclusion routing stay on the same conversation chain.
-        if self
-            .current_link_counterparty_id()
-            .as_deref()
-            .is_some_and(|counterparty| counterparty == target_agent_id)
-        {
-            return Err(SendAgentMessageError(
-                "you are already in a direct link conversation with this agent. Use reply to respond in the current link channel. Use send_agent_message to contact a different agent.".to_string(),
-            ));
-        }
-
-        // In nested link flows, if the target is the upstream counterparty
-        // from the parent link channel, the correct action is conclude_link.
-        // Re-sending to that agent creates parallel link threads with incorrect
-        // originating metadata.
-        if self
-            .upstream_counterparty_id()
-            .as_deref()
-            .is_some_and(|counterparty| counterparty == target_agent_id)
-        {
-            return Err(SendAgentMessageError(
-                "this target is the upstream counterparty for this link conversation. Use conclude_link to route the result back up the chain instead of send_agent_message.".to_string(),
-            ));
-        }
-
         // Look up the link between sending agent and target
         let links = self.links.load();
         let link = crate::links::find_link_between(&links, &self.agent_id, &target_agent_id)
@@ -201,12 +178,10 @@ impl Tool for SendAgentMessageTool {
                     "no communication link exists between you and agent '{}'.",
                     args.target
                 ))
-            })?
-            .clone();
+            })?;
 
         // Check direction: if the link is one_way, only from_agent can initiate
         let sending_agent_id = self.agent_id.as_ref();
-        let is_from_agent = link.from_agent_id == sending_agent_id;
         let is_to_agent = link.to_agent_id == sending_agent_id;
 
         if link.direction == crate::links::LinkDirection::OneWay && is_to_agent {
@@ -216,155 +191,127 @@ impl Tool for SendAgentMessageTool {
             )));
         }
 
-        // Determine the receiving agent and the relationship from sender's perspective
-        let receiving_agent_id = if is_from_agent {
+        let receiving_agent_id = if link.from_agent_id == sending_agent_id {
             &link.to_agent_id
         } else {
             &link.from_agent_id
         };
 
-        let target_agent_arc: AgentId = Arc::from(receiving_agent_id.as_str());
-        // Each agent gets its own side of the link channel
-        let receiver_channel = link.channel_id_for(receiving_agent_id);
-        let sender_channel = link.channel_id_for(sending_agent_id);
-
-        // Materialize the sender-side link channel immediately so both sides
-        // are visible in their channel lists even before the first reply.
-        let sender_channel_metadata: HashMap<String, serde_json::Value> = HashMap::new();
-        self.channel_store
-            .upsert(&sender_channel, &sender_channel_metadata);
-
-        // Construct the internal message targeting the receiver's link channel.
-        // originating_channel is always the current channel — the direct parent
-        // of this link conversation. Conclusions route one hop back, not to the root.
-        let mut metadata = HashMap::from([
-            ("from_agent_id".into(), serde_json::json!(sending_agent_id)),
-            ("link_kind".into(), serde_json::json!(link.kind.as_str())),
-            ("reply_to_agent".into(), serde_json::json!(sending_agent_id)),
-            (
-                "reply_to_channel".into(),
-                serde_json::json!(&sender_channel),
-            ),
-            (
-                "originating_channel".into(),
-                serde_json::json!(self.channel_id.as_ref()),
-            ),
-            (
-                "original_sent_message".into(),
-                serde_json::json!(&args.message),
-            ),
-        ]);
-        // Propagate the adapter name from the originating channel so conclusion
-        // routing can look up the correct messaging adapter (e.g. "webchat").
-        if let Some(source) = &self.originating_source {
-            metadata.insert("originating_source".into(), serde_json::json!(source));
-        }
+        let target_display = self
+            .agent_names
+            .get(receiving_agent_id)
+            .cloned()
+            .unwrap_or_else(|| receiving_agent_id.to_string());
 
-        let message = InboundMessage {
-            id: uuid::Uuid::new_v4().to_string(),
-            source: "internal".into(),
-            conversation_id: receiver_channel.clone(),
-            sender_id: sending_agent_id.to_string(),
-            agent_id: Some(target_agent_arc),
-            content: MessageContent::Text(args.message),
-            timestamp: Utc::now(),
-            metadata,
-            formatted_author: Some(format!("[{}]", self.agent_name)),
-        };
+        // Look up the target agent's task store from the cross-agent registry.
+        let registry = self.task_store_registry.load();
+        let target_task_store = registry.get(receiving_agent_id).ok_or_else(|| {
+            SendAgentMessageError(format!(
+                "target agent '{}' has no task store available. It may not be initialized.",
+                target_display
+            ))
+        })?;
 
-        // Inject into the messaging pipeline
-        self.messaging_manager
-            .inject_message(message)
+        // Extract title from the message: first sentence or first 120 chars.
+        let title = extract_task_title(&args.message);
+
+        // Build task metadata with delegation context.
+        let metadata = serde_json::json!({
+            "delegated_by": sending_agent_id,
+            "delegating_agent_id": sending_agent_id,
+            "originating_channel": self.originating_channel,
+        });
+
+        // Create the task on the target agent's store.
+        // Agent-delegated tasks skip pending_approval and go straight to ready.
+        let task = target_task_store
+            .create(crate::tasks::CreateTaskInput {
+                agent_id: receiving_agent_id.to_string(),
+                title: title.clone(),
+                description: Some(args.message.clone()),
+                status: crate::tasks::TaskStatus::Ready,
+                priority: crate::tasks::TaskPriority::Medium,
+                subtasks: Vec::new(),
+                metadata,
+                source_memory_id: None,
+                created_by: format!("agent:{}", sending_agent_id),
+            })
             .await
             .map_err(|error| {
-                SendAgentMessageError(format!("failed to deliver message: {error}"))
+                SendAgentMessageError(format!(
+                    "failed to create task on agent '{}': {error}",
+                    target_display
+                ))
             })?;
 
-        // End the current turn immediately. Delegating to another agent means
-        // this agent is done — without this, the LLM loops calling skip and
-        // burns through its depth budget while waiting for a response that
-        // arrives asynchronously.
-        if let Some(ref flag) = self.skip_flag {
-            flag.store(true, Ordering::Relaxed);
-        }
+        let task_number = task.task_number;
 
-        // Emit process event for dashboard visibility
-        self.event_tx
-            .send(ProcessEvent::AgentMessageSent {
-                from_agent_id: self.agent_id.clone(),
-                to_agent_id: Arc::from(receiving_agent_id.as_str()),
-                link_id: receiver_channel.clone(),
-                channel_id: Arc::from(receiver_channel.as_str()),
-            })
-            .ok();
-
-        let target_display = self
+        // Log delegation record in the link channel (system message).
+        let sender_display = self
             .agent_names
-            .get(receiving_agent_id)
+            .get(sending_agent_id)
             .cloned()
-            .unwrap_or_else(|| receiving_agent_id.to_string());
+            .unwrap_or_else(|| sending_agent_id.to_string());
+        let link_channel_id = link.channel_id_for(sending_agent_id);
+
+        self.conversation_logger.log_system_message(
+            &link_channel_id,
+            &format!(
+                "{sender_display} assigned task #{task_number} to {target_display}: \"{title}\""
+            ),
+        );
+
+        // Also log to the receiver's side of the link channel.
+        let receiver_link_channel_id = link.channel_id_for(receiving_agent_id);
+        self.conversation_logger.log_system_message(
+            &receiver_link_channel_id,
+            &format!(
+                "{sender_display} assigned task #{task_number} to {target_display}: \"{title}\""
+            ),
+        );
+
+        // End the current turn immediately after delegation.
+        if let Some(ref flag) = self.skip_flag {
+            flag.store(true, Ordering::Relaxed);
+        }
 
         tracing::info!(
             from = %self.agent_id,
             to = %receiving_agent_id,
-            receiver_channel = %receiver_channel,
-            sender_channel = %sender_channel,
-            "agent message sent"
+            task_number,
+            "task delegated to target agent"
         );
 
         Ok(SendAgentMessageOutput {
             success: true,
             target_agent: target_display,
-            channel_id: sender_channel,
+            task_number: Some(task_number),
+            message: format!(
+                "Task #{task_number} assigned. The target agent's cortex will pick it up and execute it autonomously. \
+                 You will be notified when it completes."
+            ),
         })
     }
 }
 
-impl SendAgentMessageTool {
-    /// If this tool is running in a link channel, return the peer agent ID.
-    fn current_link_counterparty_id(&self) -> Option<String> {
-        self.channel_id
-            .as_ref()
-            .strip_prefix("link:")
-            .and_then(|rest| {
-                let (self_id, peer_id) = rest.split_once(':')?;
-                if self_id == self.agent_id.as_ref() {
-                    Some(peer_id.to_string())
-                } else {
-                    None
-                }
-            })
-    }
+/// Extract a task title from the message content.
+/// Uses the first sentence (up to first `.`, `!`, or `?`) or truncates at 120 chars.
+fn extract_task_title(message: &str) -> String {
+    let first_line = message.lines().next().unwrap_or(message);
 
-    /// If this link conversation was initiated from another link channel,
-    /// return that upstream link's counterparty agent ID.
-    fn upstream_counterparty_id(&self) -> Option<String> {
-        let originating = self.originating_channel.as_deref()?;
-        let rest = originating.strip_prefix("link:")?;
-        let (self_id, counterparty_id) = rest.split_once(':')?;
-        if self_id == self.agent_id.as_ref() {
-            Some(counterparty_id.to_string())
-        } else {
-            None
+    // Find the first sentence-ending punctuation
+    if let Some(position) = first_line.find(['.', '!', '?']) {
+        let title = &first_line[..=position];
+        if title.len() <= 120 {
+            return title.trim().to_string();
         }
     }
 
-    /// Resolve an agent target string to an agent ID.
-    /// Checks both IDs and display names.
-    fn resolve_agent_id(&self, target: &str) -> Option<String> {
-        // Direct ID match
-        if self.agent_names.contains_key(target) {
-            return Some(target.to_string());
-        }
-
-        // Name match (case-insensitive)
-        let target_lower = target.to_lowercase();
-        for (agent_id, name) in self.agent_names.iter() {
-            if name.to_lowercase() == target_lower {
-                return Some(agent_id.clone());
-            }
-        }
-
-        None
+    // Fall back to first 120 chars
+    if first_line.len() <= 120 {
+        first_line.trim().to_string()
+    } else {
+        let boundary = first_line.floor_char_boundary(120);
+        format!("{}...", first_line[..boundary].trim())
     }
 }
diff --git a/src/tools/send_file.rs b/src/tools/send_file.rs
index 02437e829..60e4ce8f5 100644
--- a/src/tools/send_file.rs
+++ b/src/tools/send_file.rs
@@ -1,11 +1,13 @@
 //! Send file tool for delivering file attachments to users (channel only).
 
 use crate::OutboundResponse;
+use crate::sandbox::Sandbox;
 use rig::completion::ToolDefinition;
 use rig::tool::Tool;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
+use std::sync::Arc;
 use tokio::sync::mpsc;
 
 /// Tool for sending files to users.
@@ -13,22 +15,33 @@ use tokio::sync::mpsc;
 /// Reads a file from the local filesystem and sends it as an attachment
 /// in the conversation. The channel process creates a response sender per
 /// conversation turn and this tool routes file responses through it.
-/// File access is restricted to the agent's workspace boundary.
+/// When sandbox mode is enabled, file access is restricted to the agent's
+/// workspace boundary. When sandbox is disabled, any readable path is allowed.
 #[derive(Debug, Clone)]
 pub struct SendFileTool {
     response_tx: mpsc::Sender<OutboundResponse>,
     workspace: PathBuf,
+    sandbox: Arc<Sandbox>,
 }
 
 impl SendFileTool {
-    pub fn new(response_tx: mpsc::Sender<OutboundResponse>, workspace: PathBuf) -> Self {
+    pub fn new(
+        response_tx: mpsc::Sender<OutboundResponse>,
+        workspace: PathBuf,
+        sandbox: Arc<Sandbox>,
+    ) -> Self {
         Self {
             response_tx,
             workspace,
+            sandbox,
         }
     }
 
     /// Validate that a path falls within the workspace boundary.
+    ///
+    /// Checks both the canonicalized path and individual path components for
+    /// symlinks to prevent TOCTOU races where a symlink is swapped between
+    /// validation and the actual file read.
     fn validate_workspace_path(&self, path: &std::path::Path) -> Result<PathBuf, SendFileError> {
         let workspace = &self.workspace;
 
@@ -47,6 +60,32 @@ impl SendFileTool {
             )));
         }
 
+        // Reject paths containing symlinks within the workspace to prevent
+        // TOCTOU races where a path component is replaced with a symlink
+        // between this check and the file read.
+        let relative_original = path
+            .strip_prefix(workspace)
+            .or_else(|_| path.strip_prefix(&workspace_canonical))
+            .unwrap_or(path);
+        let mut walk = workspace_canonical.clone();
+        for component in relative_original.components() {
+            walk.push(component);
+            match walk.symlink_metadata() {
+                Ok(meta) if meta.is_symlink() => {
+                    return Err(SendFileError(
+                        "ACCESS DENIED: Symlinks are not allowed within the workspace.".into(),
+                    ));
+                }
+                Ok(_) => {}
+                Err(error) => {
+                    return Err(SendFileError(format!(
+                        "can't verify path component '{}': {error}",
+                        walk.display()
+                    )));
+                }
+            }
+        }
+
         Ok(canonical)
     }
 }
@@ -112,7 +151,16 @@ impl Tool for SendFileTool {
             return Err(SendFileError("file_path must be an absolute path".into()));
         }
 
-        let path = self.validate_workspace_path(&raw_path)?;
+        let path = if self.sandbox.mode_enabled() {
+            self.validate_workspace_path(&raw_path)?
+        } else {
+            raw_path.canonicalize().map_err(|error| {
+                SendFileError(format!(
+                    "can't resolve path '{}': {error}",
+                    raw_path.display()
+                ))
+            })?
+        };
 
         let metadata = tokio::fs::metadata(&path).await.map_err(|error| {
             SendFileError(format!("can't read file '{}': {error}", path.display()))
@@ -172,3 +220,131 @@ impl Tool for SendFileTool {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::sandbox::{SandboxConfig, SandboxMode};
+    use std::fs;
+
+    fn create_sandbox(mode: SandboxMode, workspace: &std::path::Path) -> Arc<Sandbox> {
+        let config = SandboxConfig {
+            mode,
+            ..Default::default()
+        };
+        let config = Arc::new(arc_swap::ArcSwap::from_pointee(config));
+        Arc::new(Sandbox::new_for_test(config, workspace.to_path_buf()))
+    }
+
+    fn create_tool(workspace: PathBuf) -> SendFileTool {
+        let sandbox = create_sandbox(SandboxMode::Enabled, &workspace);
+        let (response_tx, _response_rx) = mpsc::channel(1);
+        SendFileTool::new(response_tx, workspace, sandbox)
+    }
+
+    #[test]
+    fn validate_workspace_path_accepts_regular_file() {
+        let temp_dir = tempfile::tempdir().expect("failed to create temp dir");
+        let workspace = temp_dir.path().join("workspace");
+        fs::create_dir_all(&workspace).expect("failed to create workspace");
+
+        let path = workspace.join("report.txt");
+        fs::write(&path, "ok").expect("failed to write test file");
+
+        let tool = create_tool(workspace.clone());
+        let validated = tool
+            .validate_workspace_path(&path)
+            .expect("path should be accepted");
+
+        assert_eq!(
+            validated,
+            path.canonicalize().expect("failed to canonicalize")
+        );
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn validate_workspace_path_rejects_symlink_components() {
+        use std::os::unix::fs::symlink;
+
+        let temp_dir = tempfile::tempdir().expect("failed to create temp dir");
+        let workspace = temp_dir.path().join("workspace");
+        let real_dir = workspace.join("real");
+        let real_file = real_dir.join("file.txt");
+        let link_dir = workspace.join("link");
+
+        fs::create_dir_all(&real_dir).expect("failed to create real dir");
+        fs::write(&real_file, "secret").expect("failed to write test file");
+        symlink(&real_dir, &link_dir).expect("failed to create symlink");
+
+        let tool = create_tool(workspace.clone());
+        let result = tool.validate_workspace_path(&link_dir.join("file.txt"));
+
+        assert!(result.is_err(), "symlink traversal should be rejected");
+        let error = result.expect_err("missing expected error").to_string();
+        assert!(
+            error.contains("Symlinks are not allowed"),
+            "unexpected error: {error}"
+        );
+    }
+
+    #[test]
+    fn sandbox_enabled_rejects_file_outside_workspace() {
+        let temp_dir = tempfile::tempdir().expect("failed to create temp dir");
+        let workspace = temp_dir.path().join("workspace");
+        let outside = temp_dir.path().join("outside");
+        fs::create_dir_all(&workspace).expect("failed to create workspace");
+        fs::create_dir_all(&outside).expect("failed to create outside dir");
+
+        let file = outside.join("secret.txt");
+        fs::write(&file, "secret data").expect("failed to write file");
+
+        let tool = create_tool(workspace);
+        let result = tool.validate_workspace_path(&file);
+
+        assert!(result.is_err(), "should reject path outside workspace");
+        let error = result.expect_err("missing expected error").to_string();
+        assert!(error.contains("ACCESS DENIED"), "unexpected error: {error}");
+    }
+
+    #[tokio::test]
+    async fn sandbox_disabled_allows_file_outside_workspace() {
+        let temp_dir = tempfile::tempdir().expect("failed to create temp dir");
+        let workspace = temp_dir.path().join("workspace");
+        let outside = temp_dir.path().join("outside");
+        fs::create_dir_all(&workspace).expect("failed to create workspace");
+        fs::create_dir_all(&outside).expect("failed to create outside dir");
+
+        let file = outside.join("report.txt");
+        fs::write(&file, "public data").expect("failed to write file");
+
+        let sandbox = create_sandbox(SandboxMode::Disabled, &workspace);
+        let (response_tx, mut response_rx) = mpsc::channel(1);
+        let tool = SendFileTool::new(response_tx, workspace, sandbox);
+
+        let result = tool
+            .call(SendFileArgs {
+                file_path: file.to_string_lossy().into_owned(),
+                caption: None,
+            })
+            .await
+            .expect("should succeed when sandbox is disabled");
+
+        assert!(result.success);
+        assert_eq!(result.filename, "report.txt");
+        assert_eq!(result.size_bytes, 11);
+
+        // Verify the file data was actually sent through the channel.
+        let response = response_rx
+            .try_recv()
+            .expect("should have received response");
+        match response {
+            crate::OutboundResponse::File { filename, data, .. } => {
+                assert_eq!(filename, "report.txt");
+                assert_eq!(data, b"public data");
+            }
+            other => panic!("expected File response, got {other:?}"),
+        }
+    }
+}
diff --git a/src/tools/send_message_to_another_channel.rs b/src/tools/send_message_to_another_channel.rs
index 0ee550b11..2523ca5e0 100644
--- a/src/tools/send_message_to_another_channel.rs
+++ b/src/tools/send_message_to_another_channel.rs
@@ -1,6 +1,8 @@
 //! Send message tool for cross-channel messaging and DMs.
 
+use crate::ChannelId;
 use crate::conversation::ChannelStore;
+use crate::conversation::history::ConversationLogger;
 use crate::messaging::MessagingManager;
 
 use rig::completion::ToolDefinition;
@@ -13,11 +15,14 @@ use std::sync::Arc;
 ///
 /// Resolves targets by name or ID via the channel store, extracts the
 /// platform-specific target from channel metadata, and delivers via
-/// `MessagingManager::broadcast()`.
+/// `MessagingManager::broadcast()`. Logs the sent message to the destination
+/// channel's conversation history so it appears in future transcripts.
 #[derive(Clone)]
 pub struct SendMessageTool {
     messaging_manager: Arc<MessagingManager>,
     channel_store: ChannelStore,
+    conversation_logger: ConversationLogger,
+    agent_display_name: String,
 }
 
 impl std::fmt::Debug for SendMessageTool {
@@ -27,10 +32,17 @@ impl std::fmt::Debug for SendMessageTool {
 }
 
 impl SendMessageTool {
-    pub fn new(messaging_manager: Arc<MessagingManager>, channel_store: ChannelStore) -> Self {
+    pub fn new(
+        messaging_manager: Arc<MessagingManager>,
+        channel_store: ChannelStore,
+        conversation_logger: ConversationLogger,
+        agent_display_name: String,
+    ) -> Self {
         Self {
             messaging_manager,
             channel_store,
+            conversation_logger,
+            agent_display_name,
         }
     }
 }
@@ -66,16 +78,30 @@ impl Tool for SendMessageTool {
     type Output = SendMessageOutput;
 
     async fn definition(&self, _prompt: String) -> ToolDefinition {
+        let email_adapter_available = self.messaging_manager.has_adapter("email").await;
+
+        let mut description =
+            crate::prompts::text::get("tools/send_message_to_another_channel").to_string();
+        let mut target_description = "The target channel name, channel ID, or user identifier. Use a channel name like 'general' or a full channel ID from the available channels list.".to_string();
+
+        if email_adapter_available {
+            description.push_str(
+                " Email delivery is enabled: for intentional outbound email you may target `email:alice@example.com` (or bare `alice@example.com`).",
+            );
+            target_description.push_str(
+                " With email enabled, explicit email targets are also allowed: `email:alice@example.com` or `alice@example.com`.",
+            );
+        }
+
         ToolDefinition {
             name: Self::NAME.to_string(),
-            description: crate::prompts::text::get("tools/send_message_to_another_channel")
-                .to_string(),
+            description,
             parameters: serde_json::json!({
                 "type": "object",
                 "properties": {
                     "target": {
                         "type": "string",
-                        "description": "The target channel name, channel ID, or user identifier. Use a channel name like 'general' or a full channel ID from the available channels list."
+                        "description": target_description
                     },
                     "message": {
                         "type": "string",
@@ -94,6 +120,30 @@ impl Tool for SendMessageTool {
             "send_message_to_another_channel tool called"
         );
 
+        if let Some(explicit_target) = parse_explicit_email_target(&args.target) {
+            self.messaging_manager
+                .broadcast(
+                    &explicit_target.adapter,
+                    &explicit_target.target,
+                    crate::OutboundResponse::Text(args.message),
+                )
+                .await
+                .map_err(|error| SendMessageError(format!("failed to send message: {error}")))?;
+
+            tracing::info!(
+                adapter = %explicit_target.adapter,
+                broadcast_target = %explicit_target.target,
+                "message sent via explicit target"
+            );
+
+            // Email targets don't have a channel to log to.
+            return Ok(SendMessageOutput {
+                success: true,
+                target: explicit_target.target,
+                platform: explicit_target.adapter,
+            });
+        }
+
         let channel = self
             .channel_store
             .find_by_name(&args.target)
@@ -101,7 +151,7 @@ impl Tool for SendMessageTool {
             .map_err(|error| SendMessageError(format!("failed to search channels: {error}")))?
             .ok_or_else(|| {
                 SendMessageError(format!(
-                    "no channel found matching '{}'. Use a channel name or ID from the available channels list.",
+                    "no channel found matching '{}'. Use a channel name/ID from the available channels list or an explicit email target like email:alice@example.com.",
                     args.target
                 ))
             })?;
@@ -119,16 +169,26 @@ impl Tool for SendMessageTool {
             .broadcast(
                 &broadcast_target.adapter,
                 &broadcast_target.target,
-                crate::OutboundResponse::Text(args.message),
+                crate::OutboundResponse::Text(args.message.clone()),
             )
             .await
             .map_err(|error| SendMessageError(format!("failed to send message: {error}")))?;
 
+        // Log the sent message to the destination channel's conversation history
+        // so it appears in future transcripts and channel recall.
+        let destination_channel_id: ChannelId = Arc::from(channel.id.as_str());
+        self.conversation_logger.log_bot_message_with_name(
+            &destination_channel_id,
+            &args.message,
+            Some(&self.agent_display_name),
+        );
+
         tracing::info!(
             adapter = %broadcast_target.adapter,
             broadcast_target = %broadcast_target.target,
             channel_name = channel.display_name.as_deref().unwrap_or("unknown"),
-            "message sent to channel"
+            destination_channel_id = %channel.id,
+            "message sent to channel and logged to destination history"
         );
 
         Ok(SendMessageOutput {
@@ -138,3 +198,56 @@ impl Tool for SendMessageTool {
         })
     }
 }
+
+fn parse_explicit_email_target(raw: &str) -> Option<crate::messaging::target::BroadcastTarget> {
+    let trimmed = raw.trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+
+    if let Some(parsed) = crate::messaging::target::parse_delivery_target(trimmed) {
+        return (parsed.adapter == "email").then_some(parsed);
+    }
+
+    if !trimmed.contains('@') {
+        return None;
+    }
+
+    crate::messaging::target::parse_delivery_target(&format!("email:{trimmed}"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::parse_explicit_email_target;
+
+    #[test]
+    fn parses_prefixed_email_target() {
+        let target = parse_explicit_email_target("email:alice@example.com").expect("email target");
+        assert_eq!(target.adapter, "email");
+        assert_eq!(target.target, "alice@example.com");
+    }
+
+    #[test]
+    fn parses_bare_email_target() {
+        let target = parse_explicit_email_target("alice@example.com").expect("email target");
+        assert_eq!(target.adapter, "email");
+        assert_eq!(target.target, "alice@example.com");
+    }
+
+    #[test]
+    fn parses_display_name_email_target() {
+        let target = parse_explicit_email_target("Alice <alice@example.com>").expect("email");
+        assert_eq!(target.adapter, "email");
+        assert_eq!(target.target, "alice@example.com");
+    }
+
+    #[test]
+    fn ignores_non_email_prefixed_target() {
+        assert!(parse_explicit_email_target("discord:123").is_none());
+    }
+
+    #[test]
+    fn ignores_channel_name_target() {
+        assert!(parse_explicit_email_target("general").is_none());
+    }
+}
diff --git a/src/tools/set_status.rs b/src/tools/set_status.rs
index 39f66f1db..8ad89b35d 100644
--- a/src/tools/set_status.rs
+++ b/src/tools/set_status.rs
@@ -14,6 +14,8 @@ pub struct SetStatusTool {
     worker_id: WorkerId,
     channel_id: Option<ChannelId>,
     event_tx: broadcast::Sender<ProcessEvent>,
+    /// Tool secret pairs for scrubbing status text before it reaches the channel.
+    tool_secret_pairs: Vec<(String, String)>,
 }
 
 impl SetStatusTool {
@@ -29,8 +31,15 @@ impl SetStatusTool {
             worker_id,
             channel_id,
             event_tx,
+            tool_secret_pairs: Vec::new(),
         }
     }
+
+    /// Set tool secret pairs for output scrubbing.
+    pub fn with_tool_secrets(mut self, pairs: Vec<(String, String)>) -> Self {
+        self.tool_secret_pairs = pairs;
+        self
+    }
 }
 
 /// Error type for set status tool.
@@ -38,11 +47,32 @@ impl SetStatusTool {
 #[error("Failed to set status: {0}")]
 pub struct SetStatusError(String);
 
+/// The kind of status update.
+///
+/// `progress` (default) reports intermediate progress. `outcome` signals that
+/// the worker has reached a terminal result — the task is done (or failed in a
+/// way the worker can describe). Workers **must** emit an `outcome` status
+/// before finishing; the system will nudge them back to work if they try to
+/// stop without one.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Deserialize, Serialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum StatusKind {
+    /// Intermediate progress update (default).
+    #[default]
+    Progress,
+    /// Terminal outcome — the task is complete or has a definitive result.
+    Outcome,
+}
+
 /// Arguments for set status tool.
 #[derive(Debug, Deserialize, JsonSchema)]
 pub struct SetStatusArgs {
     /// The status message to report.
     pub status: String,
+    /// The kind of status update: "progress" (default) for intermediate
+    /// updates, "outcome" when the task has reached a terminal result.
+    #[serde(default)]
+    pub kind: StatusKind,
 }
 
 /// Output from set status tool.
@@ -54,6 +84,8 @@ pub struct SetStatusOutput {
     pub worker_id: WorkerId,
     /// The status that was set.
     pub status: String,
+    /// The kind of status that was set.
+    pub kind: StatusKind,
 }
 
 impl Tool for SetStatusTool {
@@ -72,7 +104,13 @@ impl Tool for SetStatusTool {
                 "properties": {
                     "status": {
                         "type": "string",
-                        "description": "A concise status message describing your current progress (1-2 sentences)"
+                        "description": "A concise status message describing your current progress or final result (1-2 sentences)"
+                    },
+                    "kind": {
+                        "type": "string",
+                        "enum": ["progress", "outcome"],
+                        "default": "progress",
+                        "description": "Use \"progress\" for intermediate updates. Use \"outcome\" when the task has reached a terminal result (success or failure) and you are ready to finish."
                     }
                 },
                 "required": ["status"]
@@ -91,6 +129,12 @@ impl Tool for SetStatusTool {
             args.status
         };
 
+        // Scrub tool secret values before the status reaches the channel.
+        // Layer 1: exact-match redaction of known secrets from the store.
+        // Layer 2: regex-based redaction of unknown secret patterns.
+        let status = crate::secrets::scrub::scrub_secrets(&status, &self.tool_secret_pairs);
+        let status = crate::secrets::scrub::scrub_leaks(&status);
+
         let event = ProcessEvent::WorkerStatus {
             agent_id: self.agent_id.clone(),
             worker_id: self.worker_id,
@@ -104,6 +148,7 @@ impl Tool for SetStatusTool {
             success: true,
             worker_id: self.worker_id,
             status,
+            kind: args.kind,
         })
     }
 }
diff --git a/src/tools/shell.rs b/src/tools/shell.rs
index 60f161228..afd3c6abb 100644
--- a/src/tools/shell.rs
+++ b/src/tools/shell.rs
@@ -5,7 +5,7 @@ use rig::completion::ToolDefinition;
 use rig::tool::Tool;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::process::Stdio;
 use std::sync::Arc;
 use tokio::process::Command;
@@ -102,33 +102,41 @@ impl Tool for ShellTool {
     }
 
     async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
-        // Validate working_dir stays within workspace if specified
+        // Relative working_dir values resolve from the workspace.
+        // Workspace boundary enforcement only applies when sandbox mode is enabled.
         let working_dir = if let Some(ref dir) = args.working_dir {
-            let path = std::path::Path::new(dir);
-            let canonical = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
-            let workspace_canonical = self
-                .workspace
-                .canonicalize()
-                .unwrap_or_else(|_| self.workspace.clone());
-            if !canonical.starts_with(&workspace_canonical) {
-                return Err(ShellError {
-                    message: format!(
-                        "working_dir must be within the workspace ({}).",
-                        self.workspace.display()
-                    ),
-                    exit_code: -1,
-                });
+            let raw_path = Path::new(dir);
+            let resolved = if raw_path.is_absolute() {
+                raw_path.to_path_buf()
+            } else {
+                self.workspace.join(raw_path)
+            };
+            let canonical = resolved.canonicalize().unwrap_or(resolved);
+
+            if self.sandbox.mode_enabled() {
+                let workspace_canonical = self
+                    .workspace
+                    .canonicalize()
+                    .unwrap_or_else(|_| self.workspace.clone());
+                if !canonical.starts_with(&workspace_canonical) {
+                    return Err(ShellError {
+                        message: format!(
+                            "working_dir must be within the workspace ({}).",
+                            self.workspace.display()
+                        ),
+                        exit_code: -1,
+                    });
+                }
             }
+
             canonical
         } else {
             self.workspace.clone()
         };
 
         let mut cmd = if cfg!(target_os = "windows") {
-            let mut c = Command::new("cmd");
-            c.arg("/C").arg(&args.command);
-            c.current_dir(&working_dir);
-            c
+            self.sandbox
+                .wrap("cmd", &["/C", &args.command], &working_dir)
         } else {
             self.sandbox
                 .wrap("sh", &["-c", &args.command], &working_dir)
diff --git a/src/tools/spacebot_docs.rs b/src/tools/spacebot_docs.rs
new file mode 100644
index 000000000..21c0d9180
--- /dev/null
+++ b/src/tools/spacebot_docs.rs
@@ -0,0 +1,360 @@
+//! Read embedded Spacebot docs, AGENTS guide, and changelog notes.
+
+use rig::completion::ToolDefinition;
+use rig::tool::Tool;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Tool for reading Spacebot's embedded self-documentation.
+#[derive(Debug, Clone)]
+pub struct SpacebotDocsTool;
+
+impl SpacebotDocsTool {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl Default for SpacebotDocsTool {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Error type for `spacebot_docs`.
+#[derive(Debug, thiserror::Error)]
+#[error("spacebot_docs failed: {0}")]
+pub struct SpacebotDocsError(String);
+
+/// Arguments for `spacebot_docs`.
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct SpacebotDocsArgs {
+    /// Action to perform: `list` or `read`.
+    #[serde(default = "default_action")]
+    pub action: String,
+    /// Document ID/path to read (required when `action = "read"`).
+    pub doc_id: Option<String>,
+    /// Optional text filter for list output (or fallback lookup hint for read).
+    pub query: Option<String>,
+    /// 1-based line number to start reading from.
+    #[serde(default = "default_start_line")]
+    pub start_line: usize,
+    /// Maximum lines to return.
+    #[serde(default = "default_max_lines")]
+    pub max_lines: usize,
+}
+
+fn default_action() -> String {
+    "list".to_string()
+}
+
+fn default_start_line() -> usize {
+    1
+}
+
+fn default_max_lines() -> usize {
+    300
+}
+
+/// Read payload for `action = "read"`.
+#[derive(Debug, Serialize)]
+pub struct SpacebotDocContent {
+    pub id: String,
+    pub title: String,
+    pub path: String,
+    pub section: String,
+    pub start_line: usize,
+    pub end_line: usize,
+    pub total_lines: usize,
+    pub has_more: bool,
+    pub content: String,
+}
+
+/// Output from `spacebot_docs`.
+#[derive(Debug, Serialize)]
+pub struct SpacebotDocsOutput {
+    pub success: bool,
+    pub action: String,
+    pub message: String,
+    pub error: Option<String>,
+    pub docs: Vec<crate::self_awareness::EmbeddedDocSummary>,
+    pub document: Option<SpacebotDocContent>,
+}
+
+impl Tool for SpacebotDocsTool {
+    const NAME: &'static str = "spacebot_docs";
+
+    type Error = SpacebotDocsError;
+    type Args = SpacebotDocsArgs;
+    type Output = SpacebotDocsOutput;
+
+    async fn definition(&self, _prompt: String) -> ToolDefinition {
+        ToolDefinition {
+            name: Self::NAME.to_string(),
+            description: crate::prompts::text::get("tools/spacebot_docs").to_string(),
+            parameters: serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "action": {
+                        "type": "string",
+                        "enum": ["list", "read"],
+                        "default": "list",
+                        "description": "Use `list` to discover available docs, or `read` to fetch one doc by ID/path."
+                    },
+                    "doc_id": {
+                        "type": "string",
+                        "description": "Doc ID or path to read (required for `read`). Example IDs: `agents`, `changelog`, `docs/core/cortex`."
+                    },
+                    "query": {
+                        "type": "string",
+                        "description": "Optional filter for list output (matches ID/title/path/section)."
+                    },
+                    "start_line": {
+                        "type": "integer",
+                        "minimum": 1,
+                        "default": 1,
+                        "description": "1-based line number to start from when reading."
+                    },
+                    "max_lines": {
+                        "type": "integer",
+                        "minimum": 1,
+                        "maximum": 2000,
+                        "default": 300,
+                        "description": "Maximum number of lines to return when reading."
+                    }
+                }
+            }),
+        }
+    }
+
+    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
+        let action = args.action.trim().to_ascii_lowercase();
+
+        match action.as_str() {
+            "list" => {
+                let mut docs = crate::self_awareness::list_embedded_docs(args.query.as_deref());
+                if docs.len() > 200 {
+                    docs.truncate(200);
+                }
+
+                Ok(SpacebotDocsOutput {
+                    success: true,
+                    action,
+                    message: format!(
+                        "{} docs available{}",
+                        docs.len(),
+                        args.query
+                            .as_deref()
+                            .filter(|query| !query.trim().is_empty())
+                            .map(|query| format!(" (filtered by '{query}')"))
+                            .unwrap_or_default()
+                    ),
+                    error: None,
+                    docs,
+                    document: None,
+                })
+            }
+            "read" => {
+                let requested_id = args
+                    .doc_id
+                    .as_deref()
+                    .or(args.query.as_deref())
+                    .map(str::trim)
+                    .filter(|value| !value.is_empty());
+
+                let Some(requested_id) = requested_id else {
+                    let error =
+                        "`doc_id` is required for action=read. Call with action=list first if you need IDs.".to_string();
+                    return Ok(failure_output(&action, error));
+                };
+
+                let Some(document) = crate::self_awareness::get_embedded_doc(requested_id) else {
+                    return Ok(failure_output(&action, unknown_doc_message(requested_id)));
+                };
+
+                let requested_start_line = args.start_line.max(1);
+                let max_lines = args.max_lines.clamp(1, 2000);
+                let (content, end_line, total_lines, has_more) =
+                    slice_lines(&document.content, requested_start_line, max_lines);
+                let start_line = normalize_start_line(requested_start_line, total_lines);
+                let message = if total_lines == 0 {
+                    format!("read '{}' empty document", document.summary.id)
+                } else if requested_start_line > total_lines {
+                    format!(
+                        "read '{}' start_line {} past EOF; normalized to {} of {}",
+                        document.summary.id, requested_start_line, total_lines, total_lines
+                    )
+                } else {
+                    format!(
+                        "read '{}' lines {}-{} of {}",
+                        document.summary.id, start_line, end_line, total_lines
+                    )
+                };
+
+                Ok(SpacebotDocsOutput {
+                    success: true,
+                    action,
+                    message,
+                    error: None,
+                    docs: Vec::new(),
+                    document: Some(SpacebotDocContent {
+                        id: document.summary.id,
+                        title: document.summary.title,
+                        path: document.summary.path,
+                        section: document.summary.section,
+                        start_line,
+                        end_line,
+                        total_lines,
+                        has_more,
+                        content,
+                    }),
+                })
+            }
+            other => Ok(failure_output(
+                &action,
+                format!("invalid action '{other}'. valid actions: list, read"),
+            )),
+        }
+    }
+}
+
+fn failure_output(action: &str, error: String) -> SpacebotDocsOutput {
+    SpacebotDocsOutput {
+        success: false,
+        action: action.to_string(),
+        message: error.clone(),
+        error: Some(error),
+        docs: Vec::new(),
+        document: None,
+    }
+}
+
+fn unknown_doc_message(requested_id: &str) -> String {
+    let matches = crate::self_awareness::search_embedded_docs(requested_id);
+    if matches.is_empty() {
+        return format!(
+            "document '{requested_id}' not found. Use action=list to see available IDs."
+        );
+    }
+
+    let suggestions = matches
+        .iter()
+        .take(8)
+        .map(|doc| doc.id.as_str())
+        .collect::<Vec<_>>()
+        .join(", ");
+
+    format!(
+        "document '{requested_id}' is ambiguous or not an exact match. Try one of: {suggestions}"
+    )
+}
+
+fn slice_lines(content: &str, start_line: usize, max_lines: usize) -> (String, usize, usize, bool) {
+    let total_lines = content.lines().count();
+
+    if total_lines == 0 {
+        return (String::new(), 0, 0, false);
+    }
+
+    if start_line > total_lines {
+        return (String::new(), total_lines, total_lines, false);
+    }
+
+    let start_index = start_line.saturating_sub(1);
+    let end_index = (start_index + max_lines).min(total_lines);
+    let has_more = end_index < total_lines;
+    let content = content
+        .lines()
+        .skip(start_index)
+        .take(end_index - start_index)
+        .collect::<Vec<_>>()
+        .join("\n");
+
+    (content, end_index, total_lines, has_more)
+}
+
+fn normalize_start_line(requested_start_line: usize, total_lines: usize) -> usize {
+    if total_lines == 0 {
+        0
+    } else {
+        requested_start_line.min(total_lines)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn normalize_start_line_caps_to_total_lines() {
+        assert_eq!(normalize_start_line(20, 5), 5);
+    }
+
+    #[test]
+    fn normalize_start_line_for_empty_doc_is_zero() {
+        assert_eq!(normalize_start_line(1, 0), 0);
+    }
+
+    #[test]
+    fn slice_lines_past_eof_returns_empty_at_eof() {
+        let (content, end_line, total_lines, has_more) = slice_lines("a\nb\nc", 10, 100);
+        assert!(content.is_empty());
+        assert_eq!(end_line, 3);
+        assert_eq!(total_lines, 3);
+        assert!(!has_more);
+    }
+
+    #[tokio::test]
+    async fn read_without_doc_id_returns_structured_failure() {
+        let output = SpacebotDocsTool::new()
+            .call(SpacebotDocsArgs {
+                action: "read".to_string(),
+                doc_id: None,
+                query: None,
+                start_line: 1,
+                max_lines: 100,
+            })
+            .await
+            .expect("tool call should not error");
+
+        assert!(!output.success);
+        assert!(output.error.is_some());
+        assert!(output.document.is_none());
+    }
+
+    #[tokio::test]
+    async fn invalid_action_returns_structured_failure() {
+        let output = SpacebotDocsTool::new()
+            .call(SpacebotDocsArgs {
+                action: "nope".to_string(),
+                doc_id: None,
+                query: None,
+                start_line: 1,
+                max_lines: 100,
+            })
+            .await
+            .expect("tool call should not error");
+
+        assert!(!output.success);
+        assert!(output.error.is_some());
+        assert!(output.error.unwrap().contains("invalid action"));
+    }
+
+    #[tokio::test]
+    async fn unknown_doc_returns_structured_failure() {
+        let output = SpacebotDocsTool::new()
+            .call(SpacebotDocsArgs {
+                action: "read".to_string(),
+                doc_id: Some("definitely-not-a-real-doc-id".to_string()),
+                query: None,
+                start_line: 1,
+                max_lines: 100,
+            })
+            .await
+            .expect("tool call should not error");
+
+        assert!(!output.success);
+        assert!(output.error.is_some());
+        assert!(output.document.is_none());
+    }
+}
diff --git a/src/tools/spawn_worker.rs b/src/tools/spawn_worker.rs
index 44d73a50c..814fc0bba 100644
--- a/src/tools/spawn_worker.rs
+++ b/src/tools/spawn_worker.rs
@@ -1,9 +1,8 @@
 //! Spawn worker tool for creating new workers.
 
 use crate::WorkerId;
-use crate::agent::channel::{
-    ChannelState, spawn_opencode_worker_from_state, spawn_worker_from_state,
-};
+use crate::agent::channel::ChannelState;
+use crate::agent::channel_dispatch::{spawn_opencode_worker_from_state, spawn_worker_from_state};
 use rig::completion::ToolDefinition;
 use rig::tool::Tool;
 use schemars::JsonSchema;
@@ -87,7 +86,7 @@ impl Tool for SpawnWorkerTool {
         }
 
         let opencode_note = if opencode_enabled {
-            " Set worker_type to \"opencode\" with a directory path for complex coding tasks — this spawns a full OpenCode coding agent with codebase exploration, context management, and its own tool suite."
+            " Set `worker_type` to \"opencode\" with a `directory` path for complex coding tasks — this spawns a full OpenCode coding agent with codebase exploration, context management, and its own tool suite. If `worker_type` is omitted, the builtin worker is used."
         } else {
             ""
         };
@@ -121,7 +120,7 @@ impl Tool for SpawnWorkerTool {
                     "type": "string",
                     "enum": ["builtin", "opencode"],
                     "default": "builtin",
-                    "description": "\"builtin\" (default) runs a Rig agent loop. \"opencode\" spawns a full OpenCode coding agent — use for complex multi-file coding tasks."
+                    "description": "\"builtin\" (default) runs a Rig agent loop. \"opencode\" spawns a full OpenCode coding agent — use for complex multi-file coding tasks. Do not claim OpenCode unless this field is explicitly set to \"opencode\"."
                 }),
             );
             obj.insert(
diff --git a/src/tools/task_create.rs b/src/tools/task_create.rs
new file mode 100644
index 000000000..95a797abf
--- /dev/null
+++ b/src/tools/task_create.rs
@@ -0,0 +1,143 @@
+//! Task creation tool for branch processes.
+
+use crate::tasks::{CreateTaskInput, TaskPriority, TaskStatus, TaskStore, TaskSubtask};
+use rig::completion::ToolDefinition;
+use rig::tool::Tool;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+pub struct TaskCreateTool {
+    task_store: Arc<TaskStore>,
+    agent_id: String,
+    created_by: String,
+}
+
+impl TaskCreateTool {
+    pub fn new(
+        task_store: Arc<TaskStore>,
+        agent_id: impl Into<String>,
+        created_by: impl Into<String>,
+    ) -> Self {
+        Self {
+            task_store,
+            agent_id: agent_id.into(),
+            created_by: created_by.into(),
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("task_create failed: {0}")]
+pub struct TaskCreateError(String);
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct TaskCreateArgs {
+    pub title: String,
+    pub description: Option<String>,
+    #[serde(default = "default_priority")]
+    pub priority: String,
+    #[serde(default)]
+    pub subtasks: Vec<String>,
+    #[serde(default)]
+    pub metadata: Option<serde_json::Value>,
+    #[serde(default)]
+    pub status: Option<String>,
+}
+
+fn default_priority() -> String {
+    "medium".to_string()
+}
+
+#[derive(Debug, Serialize)]
+pub struct TaskCreateOutput {
+    pub success: bool,
+    pub task_number: i64,
+    pub status: String,
+    pub message: String,
+}
+
+impl Tool for TaskCreateTool {
+    const NAME: &'static str = "task_create";
+
+    type Error = TaskCreateError;
+    type Args = TaskCreateArgs;
+    type Output = TaskCreateOutput;
+
+    async fn definition(&self, _prompt: String) -> ToolDefinition {
+        ToolDefinition {
+            name: Self::NAME.to_string(),
+            description: crate::prompts::text::get("tools/task_create").to_string(),
+            parameters: serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "title": { "type": "string", "description": "Short task title" },
+                    "description": { "type": "string", "description": "Optional detailed description" },
+                    "priority": {
+                        "type": "string",
+                        "enum": crate::tasks::TaskPriority::ALL.iter().map(|p| p.to_string()).collect::<Vec<_>>(),
+                        "description": "Task priority"
+                    },
+                    "subtasks": {
+                        "type": "array",
+                        "items": { "type": "string" },
+                        "description": "Optional checklist items"
+                    },
+                    "metadata": {
+                        "type": "object",
+                        "description": "Optional metadata object"
+                    },
+                    "status": {
+                        "type": "string",
+                        "enum": crate::tasks::TaskStatus::ALL.iter().map(|s| s.to_string()).collect::<Vec<_>>(),
+                        "description": "Optional initial status"
+                    }
+                },
+                "required": ["title"]
+            }),
+        }
+    }
+
+    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
+        let priority = TaskPriority::parse(&args.priority)
+            .ok_or_else(|| TaskCreateError(format!("invalid priority: {}", args.priority)))?;
+        let status = match args.status.as_deref() {
+            None => TaskStatus::Backlog,
+            Some(value) => TaskStatus::parse(value)
+                .ok_or_else(|| TaskCreateError(format!("invalid status: {value}")))?,
+        };
+
+        let subtasks = args
+            .subtasks
+            .into_iter()
+            .map(|title| TaskSubtask {
+                title,
+                completed: false,
+            })
+            .collect::<Vec<_>>();
+
+        let task = self
+            .task_store
+            .create(CreateTaskInput {
+                agent_id: self.agent_id.clone(),
+                title: args.title,
+                description: args.description,
+                status,
+                priority,
+                subtasks,
+                metadata: args.metadata.unwrap_or_else(|| serde_json::json!({})),
+                source_memory_id: None,
+                created_by: self.created_by.clone(),
+            })
+            .await
+            .map_err(|error| TaskCreateError(format!("{error}")))?;
+
+        Ok(TaskCreateOutput {
+            success: true,
+            task_number: task.task_number,
+            status: task.status.to_string(),
+            message: format!("Created task #{}: {}", task.task_number, task.title),
+        })
+    }
+}
diff --git a/src/tools/task_list.rs b/src/tools/task_list.rs
new file mode 100644
index 000000000..efa34b2bd
--- /dev/null
+++ b/src/tools/task_list.rs
@@ -0,0 +1,109 @@
+//! Task listing tool for branch processes.
+
+use crate::tasks::{TaskPriority, TaskStatus, TaskStore};
+use rig::completion::ToolDefinition;
+use rig::tool::Tool;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+pub struct TaskListTool {
+    task_store: Arc<TaskStore>,
+    agent_id: String,
+}
+
+impl TaskListTool {
+    pub fn new(task_store: Arc<TaskStore>, agent_id: impl Into<String>) -> Self {
+        Self {
+            task_store,
+            agent_id: agent_id.into(),
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("task_list failed: {0}")]
+pub struct TaskListError(String);
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct TaskListArgs {
+    pub status: Option<String>,
+    pub priority: Option<String>,
+    #[serde(default = "default_limit")]
+    pub limit: i32,
+}
+
+fn default_limit() -> i32 {
+    20
+}
+
+#[derive(Debug, Serialize)]
+pub struct TaskListOutput {
+    pub success: bool,
+    pub count: usize,
+    pub tasks: Vec<crate::tasks::Task>,
+}
+
+impl Tool for TaskListTool {
+    const NAME: &'static str = "task_list";
+
+    type Error = TaskListError;
+    type Args = TaskListArgs;
+    type Output = TaskListOutput;
+
+    async fn definition(&self, _prompt: String) -> ToolDefinition {
+        ToolDefinition {
+            name: Self::NAME.to_string(),
+            description: crate::prompts::text::get("tools/task_list").to_string(),
+            parameters: serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "status": {
+                        "type": "string",
+                        "enum": crate::tasks::TaskStatus::ALL.iter().map(|s| s.to_string()).collect::<Vec<_>>(),
+                        "description": "Optional status filter"
+                    },
+                    "priority": {
+                        "type": "string",
+                        "enum": crate::tasks::TaskPriority::ALL.iter().map(|p| p.to_string()).collect::<Vec<_>>(),
+                        "description": "Optional priority filter"
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum number of tasks to return"
+                    }
+                }
+            }),
+        }
+    }
+
+    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
+        let status = match args.status.as_deref() {
+            None => None,
+            Some(value) => Some(
+                TaskStatus::parse(value)
+                    .ok_or_else(|| TaskListError(format!("invalid status filter: {value}")))?,
+            ),
+        };
+        let priority = match args.priority.as_deref() {
+            None => None,
+            Some(value) => Some(
+                TaskPriority::parse(value)
+                    .ok_or_else(|| TaskListError(format!("invalid priority filter: {value}")))?,
+            ),
+        };
+        let limit = i64::from(args.limit).clamp(1, 500);
+        let tasks = self
+            .task_store
+            .list(&self.agent_id, status, priority, limit)
+            .await
+            .map_err(|error| TaskListError(format!("{error}")))?;
+
+        Ok(TaskListOutput {
+            success: true,
+            count: tasks.len(),
+            tasks,
+        })
+    }
+}
diff --git a/src/tools/task_update.rs b/src/tools/task_update.rs
new file mode 100644
index 000000000..d26cf356e
--- /dev/null
+++ b/src/tools/task_update.rs
@@ -0,0 +1,235 @@
+//! Task update tool for branch and worker processes.
+
+use crate::tasks::{TaskPriority, TaskStatus, TaskStore, TaskSubtask, UpdateTaskInput};
+use crate::{AgentId, WorkerId};
+use rig::completion::ToolDefinition;
+use rig::tool::Tool;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+pub enum TaskUpdateScope {
+    Branch,
+    Worker(WorkerId),
+}
+
+#[derive(Debug, Clone)]
+pub struct TaskUpdateTool {
+    task_store: Arc<TaskStore>,
+    agent_id: AgentId,
+    scope: TaskUpdateScope,
+}
+
+impl TaskUpdateTool {
+    pub fn for_branch(task_store: Arc<TaskStore>, agent_id: AgentId) -> Self {
+        Self {
+            task_store,
+            agent_id,
+            scope: TaskUpdateScope::Branch,
+        }
+    }
+
+    pub fn for_worker(task_store: Arc<TaskStore>, agent_id: AgentId, worker_id: WorkerId) -> Self {
+        Self {
+            task_store,
+            agent_id,
+            scope: TaskUpdateScope::Worker(worker_id),
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("task_update failed: {0}")]
+pub struct TaskUpdateError(String);
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct TaskUpdateArgs {
+    pub task_number: i32,
+    pub title: Option<String>,
+    pub description: Option<String>,
+    pub status: Option<String>,
+    pub priority: Option<String>,
+    pub subtasks: Option<Vec<TaskSubtask>>,
+    pub metadata: Option<serde_json::Value>,
+    pub complete_subtask: Option<i32>,
+    pub worker_id: Option<String>,
+    pub approved_by: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct TaskUpdateOutput {
+    pub success: bool,
+    pub task_number: i64,
+    pub status: String,
+    pub message: String,
+}
+
+impl Tool for TaskUpdateTool {
+    const NAME: &'static str = "task_update";
+
+    type Error = TaskUpdateError;
+    type Args = TaskUpdateArgs;
+    type Output = TaskUpdateOutput;
+
+    async fn definition(&self, _prompt: String) -> ToolDefinition {
+        let is_worker = matches!(self.scope, TaskUpdateScope::Worker(_));
+
+        // Workers only see subtask/metadata fields; branches/cortex see everything.
+        let parameters = if is_worker {
+            serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "task_number": { "type": "integer", "description": "Task number reference (#N)" },
+                    "subtasks": {
+                        "type": "array",
+                        "description": "Optional full replacement of subtask list",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "title": { "type": "string" },
+                                "completed": { "type": "boolean" }
+                            },
+                            "required": ["title", "completed"]
+                        }
+                    },
+                    "metadata": { "type": "object", "description": "Metadata object merged with current metadata" },
+                    "complete_subtask": { "type": "integer", "description": "Subtask index to mark complete" }
+                },
+                "required": ["task_number"]
+            })
+        } else {
+            serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "task_number": { "type": "integer", "description": "Task number reference (#N)" },
+                    "title": { "type": "string", "description": "Optional new title" },
+                    "description": { "type": "string", "description": "Optional new description" },
+                    "status": {
+                        "type": "string",
+                        "enum": crate::tasks::TaskStatus::ALL.iter().map(|s| s.to_string()).collect::<Vec<_>>(),
+                        "description": "Optional new status"
+                    },
+                    "priority": {
+                        "type": "string",
+                        "enum": crate::tasks::TaskPriority::ALL.iter().map(|p| p.to_string()).collect::<Vec<_>>(),
+                        "description": "Optional new priority"
+                    },
+                    "subtasks": {
+                        "type": "array",
+                        "description": "Optional full replacement of subtask list",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "title": { "type": "string" },
+                                "completed": { "type": "boolean" }
+                            },
+                            "required": ["title", "completed"]
+                        }
+                    },
+                    "metadata": { "type": "object", "description": "Metadata object merged with current metadata" },
+                    "complete_subtask": { "type": "integer", "description": "Subtask index to mark complete" },
+                    "worker_id": { "type": "string", "description": "Optional worker ID to bind to this task" },
+                    "approved_by": { "type": "string", "description": "Optional approver identifier" }
+                },
+                "required": ["task_number"]
+            })
+        };
+
+        ToolDefinition {
+            name: Self::NAME.to_string(),
+            description: crate::prompts::text::get("tools/task_update").to_string(),
+            parameters,
+        }
+    }
+
+    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
+        let task_number = i64::from(args.task_number);
+
+        if let TaskUpdateScope::Worker(ref worker_id) = self.scope {
+            let current = self
+                .task_store
+                .get_by_worker_id(&worker_id.to_string())
+                .await
+                .map_err(|error| TaskUpdateError(format!("{error}")))?;
+
+            let Some(task) = current else {
+                return Err(TaskUpdateError(
+                    "worker is not assigned to a task".to_string(),
+                ));
+            };
+
+            if task.task_number != task_number {
+                return Err(TaskUpdateError(format!(
+                    "worker {} can only update task #{}",
+                    worker_id, task.task_number
+                )));
+            }
+
+            // Workers can only update subtasks and metadata — not status, priority,
+            // title, description, worker binding, or approval.
+            if args.title.is_some()
+                || args.description.is_some()
+                || args.status.is_some()
+                || args.priority.is_some()
+                || args.worker_id.is_some()
+                || args.approved_by.is_some()
+            {
+                return Err(TaskUpdateError(
+                    "workers can only update subtasks and metadata".to_string(),
+                ));
+            }
+        }
+
+        let status = match args.status.as_deref() {
+            None => None,
+            Some(value) => Some(
+                TaskStatus::parse(value)
+                    .ok_or_else(|| TaskUpdateError(format!("invalid status: {value}")))?,
+            ),
+        };
+        let priority = match args.priority.as_deref() {
+            None => None,
+            Some(value) => Some(
+                TaskPriority::parse(value)
+                    .ok_or_else(|| TaskUpdateError(format!("invalid priority: {value}")))?,
+            ),
+        };
+        let complete_subtask = match args.complete_subtask {
+            None => None,
+            Some(value) => Some(
+                usize::try_from(value)
+                    .map_err(|_| TaskUpdateError(format!("invalid subtask index: {value}")))?,
+            ),
+        };
+
+        let updated = self
+            .task_store
+            .update(
+                &self.agent_id,
+                task_number,
+                UpdateTaskInput {
+                    title: args.title,
+                    description: args.description,
+                    status,
+                    priority,
+                    subtasks: args.subtasks,
+                    metadata: args.metadata,
+                    worker_id: args.worker_id,
+                    clear_worker_id: false,
+                    approved_by: args.approved_by,
+                    complete_subtask,
+                },
+            )
+            .await
+            .map_err(|error| TaskUpdateError(format!("{error}")))?
+            .ok_or_else(|| TaskUpdateError(format!("task #{} not found", task_number)))?;
+
+        Ok(TaskUpdateOutput {
+            success: true,
+            task_number: updated.task_number,
+            status: updated.status.to_string(),
+            message: format!("Updated task #{}", updated.task_number),
+        })
+    }
+}
diff --git a/src/tools/worker_inspect.rs b/src/tools/worker_inspect.rs
new file mode 100644
index 000000000..039b6e4d8
--- /dev/null
+++ b/src/tools/worker_inspect.rs
@@ -0,0 +1,223 @@
+//! Worker transcript inspection tool for branches.
+//!
+//! Allows a branch to retrieve the full transcript of a completed worker run,
+//! or list recent worker runs to find the right one.
+
+use crate::conversation::history::ProcessRunLogger;
+use crate::conversation::worker_transcript;
+
+use super::truncate_utf8_ellipsis;
+
+use rig::completion::ToolDefinition;
+use rig::tool::Tool;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Tool for inspecting worker run transcripts.
+#[derive(Debug, Clone)]
+pub struct WorkerInspectTool {
+    run_logger: ProcessRunLogger,
+    agent_id: String,
+}
+
+impl WorkerInspectTool {
+    pub fn new(run_logger: ProcessRunLogger, agent_id: String) -> Self {
+        Self {
+            run_logger,
+            agent_id,
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("Worker inspect failed: {0}")]
+pub struct WorkerInspectError(String);
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub struct WorkerInspectArgs {
+    /// The worker ID to inspect. Omit to list recent worker runs.
+    #[serde(default)]
+    pub worker_id: Option<String>,
+    /// Maximum number of worker runs to list (default 10, max 50). Only used when listing.
+    #[serde(default = "default_list_limit")]
+    pub limit: i64,
+}
+
+fn default_list_limit() -> i64 {
+    10
+}
+
+#[derive(Debug, Serialize)]
+pub struct WorkerInspectOutput {
+    pub action: String,
+    pub summary: String,
+}
+
+impl Tool for WorkerInspectTool {
+    const NAME: &'static str = "worker_inspect";
+
+    type Error = WorkerInspectError;
+    type Args = WorkerInspectArgs;
+    type Output = WorkerInspectOutput;
+
+    async fn definition(&self, _prompt: String) -> ToolDefinition {
+        ToolDefinition {
+            name: Self::NAME.to_string(),
+            description: crate::prompts::text::get("tools/worker_inspect").to_string(),
+            parameters: serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "worker_id": {
+                        "type": "string",
+                        "description": "UUID of the worker run to inspect. Omit to list recent workers."
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "minimum": 1,
+                        "maximum": 50,
+                        "default": 10,
+                        "description": "Number of recent workers to list (1-50). Only used when worker_id is omitted."
+                    }
+                }
+            }),
+        }
+    }
+
+    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
+        let Some(worker_id) = args.worker_id else {
+            return self.list_workers(args.limit).await;
+        };
+
+        let detail = self
+            .run_logger
+            .get_worker_detail(&self.agent_id, &worker_id)
+            .await
+            .map_err(|e| WorkerInspectError(format!("Failed to query worker: {e}")))?
+            .ok_or_else(|| WorkerInspectError(format!("No worker found with ID {worker_id}")))?;
+
+        let mut summary = format!(
+            "## Worker {}\n\n**Task:** {}\n**Status:** {}\n**Started:** {}\n",
+            detail.id, detail.task, detail.status, detail.started_at,
+        );
+
+        if let Some(completed_at) = &detail.completed_at {
+            summary.push_str(&format!("**Completed:** {completed_at}\n"));
+        }
+
+        if let Some(result) = &detail.result {
+            summary.push_str(&format!("\n### Result\n\n{result}\n"));
+        }
+
+        if let Some(blob) = &detail.transcript_blob {
+            match worker_transcript::deserialize_transcript(blob) {
+                Ok(steps) => {
+                    summary.push_str(&format!("\n### Transcript ({} steps)\n\n", steps.len()));
+                    for step in &steps {
+                        match step {
+                            worker_transcript::TranscriptStep::Action { content } => {
+                                for item in content {
+                                    match item {
+                                        worker_transcript::ActionContent::Text { text } => {
+                                            summary.push_str(&format!("**Agent:** {text}\n\n"));
+                                        }
+                                        worker_transcript::ActionContent::ToolCall {
+                                            name,
+                                            args,
+                                            ..
+                                        } => {
+                                            summary.push_str(&format!(
+                                                "**Tool call:** `{name}`\n```\n{args}\n```\n\n"
+                                            ));
+                                        }
+                                    }
+                                }
+                            }
+                            worker_transcript::TranscriptStep::ToolResult {
+                                name, text, ..
+                            } => {
+                                let label = if name.is_empty() { "tool" } else { name };
+                                let display = if text.len() > 500 {
+                                    format!(
+                                        "{}\n[truncated, {} bytes total]",
+                                        truncate_utf8_ellipsis(text, 500),
+                                        text.len()
+                                    )
+                                } else {
+                                    text.clone()
+                                };
+                                summary.push_str(&format!(
+                                    "**Result ({label}):**\n```\n{display}\n```\n\n"
+                                ));
+                            }
+                        }
+                    }
+                }
+                Err(error) => {
+                    summary.push_str(&format!(
+                        "\n*Transcript could not be decompressed: {error}*\n"
+                    ));
+                }
+            }
+        } else {
+            summary.push_str("\n*No transcript available for this worker.*\n");
+        }
+
+        Ok(WorkerInspectOutput {
+            action: "inspect".to_string(),
+            summary,
+        })
+    }
+}
+
+impl WorkerInspectTool {
+    async fn list_workers(&self, limit: i64) -> Result<WorkerInspectOutput, WorkerInspectError> {
+        let limit = limit.clamp(1, 50);
+        let (rows, total) = self
+            .run_logger
+            .list_worker_runs(&self.agent_id, limit, 0, None)
+            .await
+            .map_err(|e| WorkerInspectError(format!("Failed to list workers: {e}")))?;
+
+        if rows.is_empty() {
+            return Ok(WorkerInspectOutput {
+                action: "list".to_string(),
+                summary: "No worker runs found.".to_string(),
+            });
+        }
+
+        let mut summary = format!("## Recent Workers ({} of {total})\n\n", rows.len());
+
+        for row in &rows {
+            let status_marker = match row.status.as_str() {
+                "running" => "[running]",
+                "done" => "[done]",
+                "failed" => "[failed]",
+                _ => "[-]",
+            };
+            summary.push_str(&format!(
+                "{status_marker} `{}` — {} ({})\n",
+                row.id, row.task, row.status,
+            ));
+            if let Some(channel) = &row.channel_name {
+                summary.push_str(&format!("  Channel: {channel}\n"));
+            }
+            summary.push_str(&format!(
+                "  Started: {} | {} tool calls{}\n\n",
+                row.started_at,
+                row.tool_calls,
+                if row.has_transcript {
+                    " | transcript available"
+                } else {
+                    ""
+                },
+            ));
+        }
+
+        summary.push_str("Use `worker_inspect` with a `worker_id` to view the full transcript.");
+
+        Ok(WorkerInspectOutput {
+            action: "list".to_string(),
+            summary,
+        })
+    }
+}
diff --git a/src/update.rs b/src/update.rs
index b782fe8dd..8bddbe8b3 100644
--- a/src/update.rs
+++ b/src/update.rs
@@ -34,11 +34,26 @@ impl Deployment {
         match std::env::var("SPACEBOT_DEPLOYMENT").as_deref() {
             Ok("docker") => Deployment::Docker,
             Ok("hosted") => Deployment::Hosted,
+            _ if is_running_in_container() => Deployment::Docker,
             _ => Deployment::Native,
         }
     }
 }
 
+fn is_running_in_container() -> bool {
+    if std::path::Path::new("/.dockerenv").exists() {
+        return true;
+    }
+
+    let Ok(cgroup) = std::fs::read_to_string("/proc/1/cgroup") else {
+        return false;
+    };
+
+    ["docker", "containerd", "kubepods", "podman"]
+        .iter()
+        .any(|marker| cgroup.contains(marker))
+}
+
 /// Result of an update check.
 #[derive(Debug, Clone, Serialize)]
 pub struct UpdateStatus {
@@ -50,6 +65,10 @@ pub struct UpdateStatus {
     pub deployment: Deployment,
     /// Whether the Docker socket is accessible (enables one-click update).
     pub can_apply: bool,
+    /// Human-readable reason when one-click apply is unavailable.
+    pub cannot_apply_reason: Option<String>,
+    /// Current container image reference when running in Docker.
+    pub docker_image: Option<String>,
     pub checked_at: Option<chrono::DateTime<chrono::Utc>>,
     pub error: Option<String>,
 }
@@ -64,6 +83,8 @@ impl Default for UpdateStatus {
             release_notes: None,
             deployment: Deployment::detect(),
             can_apply: false,
+            cannot_apply_reason: None,
+            docker_image: None,
             checked_at: None,
             error: None,
         }
@@ -75,8 +96,24 @@ pub type SharedUpdateStatus = Arc<ArcSwap<UpdateStatus>>;
 
 pub fn new_shared_status() -> SharedUpdateStatus {
     let mut status = UpdateStatus::default();
-    // Probe Docker socket availability on init
-    status.can_apply = status.deployment == Deployment::Docker && docker_socket_available();
+    match status.deployment {
+        Deployment::Docker => {
+            status.can_apply = docker_socket_available();
+            if !status.can_apply {
+                status.cannot_apply_reason =
+                    Some("Mount /var/run/docker.sock to enable one-click updates.".to_string());
+            }
+        }
+        Deployment::Native => {
+            status.cannot_apply_reason =
+                Some("Native/source installs update manually (rebuild + restart).".to_string());
+        }
+        Deployment::Hosted => {
+            status.cannot_apply_reason = Some(
+                "Hosted instances are updated by platform rollout, not self-service.".to_string(),
+            );
+        }
+    }
     Arc::new(ArcSwap::from_pointee(status))
 }
 
@@ -93,10 +130,13 @@ pub async fn check_for_update(status: &SharedUpdateStatus) {
     let result = fetch_latest_release().await;
 
     let current = status.load();
+    let capability = detect_apply_capability(current.deployment).await;
     let mut next = UpdateStatus {
         current_version: CURRENT_VERSION.to_string(),
         deployment: current.deployment,
-        can_apply: current.can_apply,
+        can_apply: capability.can_apply,
+        cannot_apply_reason: capability.cannot_apply_reason,
+        docker_image: capability.docker_image,
         checked_at: Some(chrono::Utc::now()),
         ..Default::default()
     };
@@ -182,6 +222,90 @@ fn docker_socket_available() -> bool {
     std::path::Path::new("/var/run/docker.sock").exists()
 }
 
+#[derive(Debug, Clone)]
+struct ApplyCapability {
+    can_apply: bool,
+    cannot_apply_reason: Option<String>,
+    docker_image: Option<String>,
+}
+
+async fn detect_apply_capability(deployment: Deployment) -> ApplyCapability {
+    match deployment {
+        Deployment::Native => ApplyCapability {
+            can_apply: false,
+            cannot_apply_reason: Some(
+                "Native/source installs update manually (rebuild + restart).".to_string(),
+            ),
+            docker_image: None,
+        },
+        Deployment::Hosted => ApplyCapability {
+            can_apply: false,
+            cannot_apply_reason: Some(
+                "Hosted instances are updated by platform rollout, not self-service.".to_string(),
+            ),
+            docker_image: None,
+        },
+        Deployment::Docker => {
+            if !docker_socket_available() {
+                return ApplyCapability {
+                    can_apply: false,
+                    cannot_apply_reason: Some(
+                        "Mount /var/run/docker.sock to enable one-click updates.".to_string(),
+                    ),
+                    docker_image: None,
+                };
+            }
+
+            let docker = match bollard::Docker::connect_with_local_defaults() {
+                Ok(client) => client,
+                Err(error) => {
+                    return ApplyCapability {
+                        can_apply: false,
+                        cannot_apply_reason: Some(format!(
+                            "Docker socket is present but cannot be opened: {error}"
+                        )),
+                        docker_image: None,
+                    };
+                }
+            };
+
+            if let Err(error) = docker.ping().await {
+                return ApplyCapability {
+                    can_apply: false,
+                    cannot_apply_reason: Some(format!(
+                        "Docker socket is mounted but engine is not reachable: {error}"
+                    )),
+                    docker_image: None,
+                };
+            }
+
+            let docker_image = detect_current_docker_image(&docker).await.ok();
+
+            ApplyCapability {
+                can_apply: true,
+                cannot_apply_reason: None,
+                docker_image,
+            }
+        }
+    }
+}
+
+async fn detect_current_docker_image(docker: &bollard::Docker) -> anyhow::Result<String> {
+    let container_id = get_own_container_id()?;
+    let container_info = docker
+        .inspect_container(&container_id, None)
+        .await
+        .map_err(|error| anyhow::anyhow!("failed to inspect container: {error}"))?;
+
+    let image = container_info
+        .config
+        .as_ref()
+        .and_then(|config| config.image.as_deref())
+        .ok_or_else(|| anyhow::anyhow!("could not determine current image"))?;
+
+    Ok(image.to_string())
+}
+
 /// Apply a Docker self-update: pull the new image, recreate this container.
 ///
 /// This function does not return on success — the current container is stopped
@@ -195,8 +319,14 @@ pub async fn apply_docker_update(status: &SharedUpdateStatus) -> anyhow::Result<
     if current.deployment != Deployment::Docker {
         anyhow::bail!("not running in Docker");
     }
-    if !current.can_apply {
-        anyhow::bail!("Docker socket not available");
+    let capability = detect_apply_capability(current.deployment).await;
+    if !capability.can_apply {
+        anyhow::bail!(
+            "{}",
+            capability
+                .cannot_apply_reason
+                .unwrap_or_else(|| "Docker socket not available".to_string())
+        );
     }
 
     let latest_version = current
@@ -228,7 +358,7 @@ pub async fn apply_docker_update(status: &SharedUpdateStatus) -> anyhow::Result<
         .to_string();
 
     // Resolve the target image: same base name, new version tag.
-    // e.g. ghcr.io/spacedriveapp/spacebot:v0.1.0-slim -> ghcr.io/spacedriveapp/spacebot:v0.2.0-slim
+    // e.g. ghcr.io/spacedriveapp/spacebot:v0.1.0 -> ghcr.io/spacedriveapp/spacebot:v0.2.0
     let target_image = resolve_target_image(&current_image, latest_version);
 
     tracing::info!(
@@ -255,6 +385,15 @@ pub async fn apply_docker_update(status: &SharedUpdateStatus) -> anyhow::Result<
                 }
             }
             Err(error) => {
+                let error_text = error.to_string();
+                if error_text.contains("manifest unknown")
+                    || error_text.contains("not found")
+                    || error_text.contains("pull access denied")
+                {
+                    anyhow::bail!(
+                        "image pull failed for {target_image}. this image does not have Spacebot release tags; rebuild and redeploy manually"
+                    );
+                }
                 anyhow::bail!("image pull failed: {}", error);
             }
         }
@@ -410,19 +549,28 @@ fn get_own_container_id() -> anyhow::Result<String> {
 /// Given a current image reference and a new version, produce the target image tag.
 ///
 /// Examples:
-///   - `ghcr.io/spacedriveapp/spacebot:v0.1.0-slim` + `0.2.0` -> `ghcr.io/spacedriveapp/spacebot:v0.2.0-slim`
-///   - `ghcr.io/spacedriveapp/spacebot:slim` + `0.2.0` -> `ghcr.io/spacedriveapp/spacebot:v0.2.0-slim`
-///   - `ghcr.io/spacedriveapp/spacebot:latest` + `0.2.0` -> `ghcr.io/spacedriveapp/spacebot:v0.2.0-slim`
+///   - `ghcr.io/spacedriveapp/spacebot:v0.1.0` + `0.2.0` -> `ghcr.io/spacedriveapp/spacebot:v0.2.0`
+///   - `ghcr.io/spacedriveapp/spacebot:latest` + `0.2.0` -> `ghcr.io/spacedriveapp/spacebot:v0.2.0`
+///   - `ghcr.io/spacedriveapp/spacebot:v0.1.0-full` + `0.2.0` -> `ghcr.io/spacedriveapp/spacebot:v0.2.0`
+///
+/// Legacy `-slim`/`-full` suffixes are stripped during migration to the unified image.
 fn resolve_target_image(current_image: &str, new_version: &str) -> String {
-    let (base, tag) = match current_image.rsplit_once(':') {
-        Some((b, t)) => (b, t),
-        None => (current_image, "latest"),
-    };
+    let image_without_digest = current_image
+        .split_once('@')
+        .map(|(name, _)| name)
+        .unwrap_or(current_image);
 
-    // Determine the variant suffix (slim, full, or default to slim)
-    let variant = if tag.contains("full") { "full" } else { "slim" };
+    let last_slash = image_without_digest.rfind('/');
+    let last_colon = image_without_digest.rfind(':');
+
+    let base = match last_colon {
+        Some(colon) if last_slash.is_none_or(|slash| colon > slash) => {
+            &image_without_digest[..colon]
+        }
+        _ => image_without_digest,
+    };
 
-    format!("{}:v{}-{}", base, new_version, variant)
+    format!("{base}:v{new_version}")
 }
 
 #[cfg(test)]
@@ -439,21 +587,35 @@ mod tests {
 
     #[test]
     fn test_resolve_target_image() {
+        // Versioned tag
+        assert_eq!(
+            resolve_target_image("ghcr.io/spacedriveapp/spacebot:v0.1.0", "0.2.0"),
+            "ghcr.io/spacedriveapp/spacebot:v0.2.0"
+        );
+        // Latest tag
+        assert_eq!(
+            resolve_target_image("ghcr.io/spacedriveapp/spacebot:latest", "0.2.0"),
+            "ghcr.io/spacedriveapp/spacebot:v0.2.0"
+        );
+        // Legacy slim tag (strips variant)
         assert_eq!(
             resolve_target_image("ghcr.io/spacedriveapp/spacebot:v0.1.0-slim", "0.2.0"),
-            "ghcr.io/spacedriveapp/spacebot:v0.2.0-slim"
+            "ghcr.io/spacedriveapp/spacebot:v0.2.0"
         );
+        // Legacy full tag (strips variant)
         assert_eq!(
             resolve_target_image("ghcr.io/spacedriveapp/spacebot:v0.1.0-full", "0.2.0"),
-            "ghcr.io/spacedriveapp/spacebot:v0.2.0-full"
+            "ghcr.io/spacedriveapp/spacebot:v0.2.0"
         );
+        // Custom registry with port in host
         assert_eq!(
-            resolve_target_image("ghcr.io/spacedriveapp/spacebot:latest", "0.2.0"),
-            "ghcr.io/spacedriveapp/spacebot:v0.2.0-slim"
+            resolve_target_image("registry.local:5000/spacebot", "0.2.0"),
+            "registry.local:5000/spacebot:v0.2.0"
         );
+        // Digest reference
         assert_eq!(
-            resolve_target_image("ghcr.io/spacedriveapp/spacebot:slim", "0.2.0"),
-            "ghcr.io/spacedriveapp/spacebot:v0.2.0-slim"
+            resolve_target_image("ghcr.io/spacedriveapp/spacebot@sha256:abcdef", "0.2.0"),
+            "ghcr.io/spacedriveapp/spacebot:v0.2.0"
         );
     }
 }
diff --git a/tests/bulletin.rs b/tests/bulletin.rs
index aaddb5eba..a2e811f93 100644
--- a/tests/bulletin.rs
+++ b/tests/bulletin.rs
@@ -9,9 +9,31 @@
 use anyhow::Context as _;
 use std::sync::Arc;
 
+/// Set up the secrets store thread-local so `secret:` references in config.toml
+/// resolve correctly. Mirrors the bootstrap logic in main.rs.
+fn bootstrap_secrets_for_config() {
+    let instance_dir = spacebot::config::Config::default_instance_dir();
+    let secrets_path = instance_dir.join("data").join("secrets.redb");
+    if !secrets_path.exists() {
+        return;
+    }
+    if let Ok(store) = spacebot::secrets::store::SecretsStore::new(&secrets_path) {
+        let store = Arc::new(store);
+        // Auto-unlock via OS keystore if encrypted.
+        if store.is_encrypted() {
+            let keystore = spacebot::secrets::keystore::platform_keystore();
+            if let Some(key) = keystore.load_key("instance").ok().flatten() {
+                let _ = store.unlock(&key);
+            }
+        }
+        spacebot::config::set_resolve_secrets_store(store);
+    }
+}
+
 /// Bootstrap an AgentDeps from the real ~/.spacebot config, using the first
 /// (default) agent's databases and config.
 async fn bootstrap_deps() -> anyhow::Result<spacebot::AgentDeps> {
+    bootstrap_secrets_for_config();
     let config =
         spacebot::config::Config::load().context("failed to load ~/.spacebot/config.toml")?;
 
@@ -49,6 +71,7 @@ async fn bootstrap_deps() -> anyhow::Result<spacebot::AgentDeps> {
         embedding_table,
         embedding_model,
     ));
+    let task_store = Arc::new(spacebot::tasks::TaskStore::new(db.sqlite.clone()));
 
     let identity = spacebot::identity::Identity::load(&agent_config.workspace).await;
     let prompts =
@@ -65,14 +88,17 @@ async fn bootstrap_deps() -> anyhow::Result<spacebot::AgentDeps> {
         skills,
     ));
 
-    let (event_tx, _) = tokio::sync::broadcast::channel(16);
+    let (event_tx, memory_event_tx) = spacebot::create_process_event_buses_with_capacity(16, 32);
 
     let agent_id: spacebot::AgentId = Arc::from(agent_config.id.as_str());
     let mcp_manager = Arc::new(spacebot::mcp::McpManager::new(agent_config.mcp.clone()));
 
+    let sandbox_config = Arc::new(arc_swap::ArcSwap::from_pointee(
+        agent_config.sandbox.clone(),
+    ));
     let sandbox = Arc::new(
         spacebot::sandbox::Sandbox::new(
-            &agent_config.sandbox,
+            sandbox_config,
             agent_config.workspace.clone(),
             &config.instance_dir,
             agent_config.data_dir.clone(),
@@ -85,14 +111,23 @@ async fn bootstrap_deps() -> anyhow::Result<spacebot::AgentDeps> {
         memory_search,
         llm_manager,
         mcp_manager,
+        task_store,
         cron_tool: None,
         runtime_config,
         event_tx,
+        memory_event_tx,
         sqlite_pool: db.sqlite.clone(),
         messaging_manager: None,
         sandbox,
         links: Arc::new(arc_swap::ArcSwap::from_pointee(Vec::new())),
         agent_names: Arc::new(std::collections::HashMap::new()),
+        task_store_registry: Arc::new(arc_swap::ArcSwap::from_pointee(
+            std::collections::HashMap::new(),
+        )),
+        process_control_registry: Arc::new(
+            spacebot::agent::process_control::ProcessControlRegistry::new(),
+        ),
+        injection_tx: tokio::sync::mpsc::channel(1).0,
     })
 }
 
diff --git a/tests/context_dump.rs b/tests/context_dump.rs
index 30780f261..64e5b21fb 100644
--- a/tests/context_dump.rs
+++ b/tests/context_dump.rs
@@ -10,8 +10,29 @@
 use anyhow::Context as _;
 use std::sync::Arc;
 
+/// Set up the secrets store thread-local so `secret:` references in config.toml
+/// resolve correctly. Mirrors the bootstrap logic in main.rs.
+fn bootstrap_secrets_for_config() {
+    let instance_dir = spacebot::config::Config::default_instance_dir();
+    let secrets_path = instance_dir.join("data").join("secrets.redb");
+    if !secrets_path.exists() {
+        return;
+    }
+    if let Ok(store) = spacebot::secrets::store::SecretsStore::new(&secrets_path) {
+        let store = Arc::new(store);
+        if store.is_encrypted() {
+            let keystore = spacebot::secrets::keystore::platform_keystore();
+            if let Some(key) = keystore.load_key("instance").ok().flatten() {
+                let _ = store.unlock(&key);
+            }
+        }
+        spacebot::config::set_resolve_secrets_store(store);
+    }
+}
+
 /// Bootstrap AgentDeps from the real ~/.spacebot config (same as bulletin test).
 async fn bootstrap_deps() -> anyhow::Result<(spacebot::AgentDeps, spacebot::config::Config)> {
+    bootstrap_secrets_for_config();
     let config =
         spacebot::config::Config::load().context("failed to load ~/.spacebot/config.toml")?;
 
@@ -49,6 +70,7 @@ async fn bootstrap_deps() -> anyhow::Result<(spacebot::AgentDeps, spacebot::conf
         embedding_table,
         embedding_model,
     ));
+    let task_store = Arc::new(spacebot::tasks::TaskStore::new(db.sqlite.clone()));
 
     let identity = spacebot::identity::Identity::load(&agent_config.workspace).await;
     let prompts =
@@ -65,14 +87,17 @@ async fn bootstrap_deps() -> anyhow::Result<(spacebot::AgentDeps, spacebot::conf
         skills,
     ));
 
-    let (event_tx, _) = tokio::sync::broadcast::channel(16);
+    let (event_tx, memory_event_tx) = spacebot::create_process_event_buses_with_capacity(16, 32);
 
     let agent_id: spacebot::AgentId = Arc::from(agent_config.id.as_str());
     let mcp_manager = Arc::new(spacebot::mcp::McpManager::new(agent_config.mcp.clone()));
 
+    let sandbox_config = Arc::new(arc_swap::ArcSwap::from_pointee(
+        agent_config.sandbox.clone(),
+    ));
     let sandbox = Arc::new(
         spacebot::sandbox::Sandbox::new(
-            &agent_config.sandbox,
+            sandbox_config,
             agent_config.workspace.clone(),
             &config.instance_dir,
             agent_config.data_dir.clone(),
@@ -85,14 +110,23 @@ async fn bootstrap_deps() -> anyhow::Result<(spacebot::AgentDeps, spacebot::conf
         memory_search,
         llm_manager,
         mcp_manager,
+        task_store,
         cron_tool: None,
         runtime_config,
         event_tx,
+        memory_event_tx,
         sqlite_pool: db.sqlite.clone(),
         messaging_manager: None,
         sandbox,
         links: Arc::new(arc_swap::ArcSwap::from_pointee(Vec::new())),
         agent_names: Arc::new(std::collections::HashMap::new()),
+        task_store_registry: Arc::new(arc_swap::ArcSwap::from_pointee(
+            std::collections::HashMap::new(),
+        )),
+        process_control_registry: Arc::new(
+            spacebot::agent::process_control::ProcessControlRegistry::new(),
+        ),
+        injection_tx: tokio::sync::mpsc::channel(1).0,
     };
 
     Ok((deps, config))
@@ -165,6 +199,7 @@ fn build_channel_system_prompt(rc: &spacebot::config::RuntimeConfig) -> String {
             None,
             None,
             None,
+            false,
         )
         .expect("failed to render channel prompt")
 }
@@ -195,12 +230,12 @@ async fn dump_channel_context() {
         history: Arc::new(tokio::sync::RwLock::new(Vec::new())),
         active_branches: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
         worker_handles: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
-        process_run_logger: spacebot::conversation::ProcessRunLogger::new(deps.sqlite_pool.clone()),
         active_workers: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
         worker_inputs: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
         status_block,
         deps: deps.clone(),
         conversation_logger,
+        process_run_logger: spacebot::conversation::ProcessRunLogger::new(deps.sqlite_pool.clone()),
         channel_store,
         screenshot_dir: std::path::PathBuf::from("/tmp/screenshots"),
         logs_dir: std::path::PathBuf::from("/tmp/logs"),
@@ -219,10 +254,7 @@ async fn dump_channel_context() {
         replied_flag,
         None,
         None,
-        None,
-        None,
-        None,
-        None,
+        true,
     )
     .await
     .expect("failed to add channel tools");
@@ -274,10 +306,17 @@ async fn dump_branch_context() {
     let conversation_logger =
         spacebot::conversation::ConversationLogger::new(deps.sqlite_pool.clone());
     let channel_store = spacebot::conversation::ChannelStore::new(deps.sqlite_pool.clone());
+    let run_logger = spacebot::conversation::ProcessRunLogger::new(deps.sqlite_pool.clone());
     let branch_tool_server = spacebot::tools::create_branch_tool_server(
+        None,
+        deps.agent_id.clone(),
+        deps.task_store.clone(),
         deps.memory_search.clone(),
+        deps.runtime_config.clone(),
+        deps.memory_event_tx.clone(),
         conversation_logger,
         channel_store,
+        run_logger,
     );
 
     let tool_defs = branch_tool_server
@@ -318,7 +357,15 @@ async fn dump_worker_context() {
     let instance_dir = rc.instance_dir.to_string_lossy();
     let workspace_dir = rc.workspace_dir.to_string_lossy();
     let worker_prompt = prompt_engine
-        .render_worker_prompt(&instance_dir, &workspace_dir)
+        .render_worker_prompt(
+            &instance_dir,
+            &workspace_dir,
+            false,
+            false,
+            Vec::new(),
+            Vec::new(),
+            &[],
+        )
         .expect("failed to render worker prompt");
     print_section("WORKER SYSTEM PROMPT", &worker_prompt);
     print_stats("System prompt", &worker_prompt);
@@ -332,6 +379,7 @@ async fn dump_worker_context() {
         deps.agent_id.clone(),
         worker_id,
         None,
+        deps.task_store.clone(),
         deps.event_tx.clone(),
         browser_config,
         std::path::PathBuf::from("/tmp/screenshots"),
@@ -410,7 +458,6 @@ async fn dump_all_contexts() {
         history: Arc::new(tokio::sync::RwLock::new(Vec::new())),
         active_branches: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
         worker_handles: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
-        process_run_logger: spacebot::conversation::ProcessRunLogger::new(deps.sqlite_pool.clone()),
         active_workers: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
         worker_inputs: Arc::new(tokio::sync::RwLock::new(std::collections::HashMap::new())),
         status_block: Arc::new(tokio::sync::RwLock::new(
@@ -418,6 +465,7 @@ async fn dump_all_contexts() {
         )),
         deps: deps.clone(),
         conversation_logger: conversation_logger.clone(),
+        process_run_logger: spacebot::conversation::ProcessRunLogger::new(deps.sqlite_pool.clone()),
         channel_store: channel_store.clone(),
         screenshot_dir: std::path::PathBuf::from("/tmp/screenshots"),
         logs_dir: std::path::PathBuf::from("/tmp/logs"),
@@ -435,10 +483,7 @@ async fn dump_all_contexts() {
         replied_flag,
         None,
         None,
-        None,
-        None,
-        None,
-        None,
+        true,
     )
     .await
     .expect("failed to add channel tools");
@@ -459,10 +504,17 @@ async fn dump_all_contexts() {
     let branch_prompt = prompt_engine
         .render_branch_prompt(&instance_dir, &workspace_dir)
         .expect("failed to render branch prompt");
+    let run_logger = spacebot::conversation::ProcessRunLogger::new(deps.sqlite_pool.clone());
     let branch_tool_server = spacebot::tools::create_branch_tool_server(
+        None,
+        deps.agent_id.clone(),
+        deps.task_store.clone(),
         deps.memory_search.clone(),
+        deps.runtime_config.clone(),
+        deps.memory_event_tx.clone(),
         conversation_logger,
         channel_store,
+        run_logger,
     );
     let branch_tool_defs = branch_tool_server.get_tool_defs(None).await.unwrap();
     let branch_tools_text = format_tool_defs(&branch_tool_defs);
@@ -479,7 +531,15 @@ async fn dump_all_contexts() {
 
     // ── Worker ──
     let worker_prompt = prompt_engine
-        .render_worker_prompt(&instance_dir, &workspace_dir)
+        .render_worker_prompt(
+            &instance_dir,
+            &workspace_dir,
+            false,
+            false,
+            Vec::new(),
+            Vec::new(),
+            &[],
+        )
         .expect("failed to render worker prompt");
     let browser_config = (**rc.browser_config.load()).clone();
     let brave_search_key = (**rc.brave_search_key.load()).clone();
@@ -487,6 +547,7 @@ async fn dump_all_contexts() {
         deps.agent_id.clone(),
         uuid::Uuid::new_v4(),
         None,
+        deps.task_store.clone(),
         deps.event_tx.clone(),
         browser_config,
         std::path::PathBuf::from("/tmp/screenshots"),
diff --git a/tests/detached_worker_bootstrap.rs b/tests/detached_worker_bootstrap.rs
new file mode 100644
index 000000000..77fe4b85d
--- /dev/null
+++ b/tests/detached_worker_bootstrap.rs
@@ -0,0 +1,96 @@
+//! Integration coverage for detached worker bootstrap behavior.
+//!
+//! Verifies that supervision control entries are not leaked when task bootstrap
+//! fails after registration.
+
+use spacebot::AgentId;
+use spacebot::agent::cortex::register_detached_worker_for_pickup;
+use spacebot::agent::process_control::ProcessControlRegistry;
+use spacebot::tasks::TaskStore;
+use sqlx::sqlite::SqlitePoolOptions;
+
+#[tokio::test]
+async fn detached_bootstrap_rolls_back_control_entry_on_database_failure() {
+    let pool = SqlitePoolOptions::new()
+        .max_connections(1)
+        .connect("sqlite::memory:")
+        .await
+        .expect("failed to create sqlite memory pool");
+
+    sqlx::query(
+        "CREATE TABLE tasks (
+            id TEXT PRIMARY KEY,
+            agent_id TEXT NOT NULL,
+            task_number INTEGER NOT NULL,
+            title TEXT NOT NULL,
+            description TEXT,
+            status TEXT NOT NULL DEFAULT 'backlog',
+            priority TEXT NOT NULL DEFAULT 'medium',
+            subtasks TEXT,
+            metadata TEXT,
+            source_memory_id TEXT,
+            worker_id TEXT,
+            created_by TEXT NOT NULL,
+            approved_at TIMESTAMP,
+            approved_by TEXT,
+            created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            completed_at TIMESTAMP,
+            UNIQUE(agent_id, task_number)
+        )",
+    )
+    .execute(&pool)
+    .await
+    .expect("failed to create tasks table");
+
+    let task_store = TaskStore::new(pool.clone());
+    let registry = ProcessControlRegistry::new();
+    let agent_id: AgentId = "agent-1".into();
+    let task_number = 7_i64;
+    let worker_id = uuid::Uuid::new_v4();
+
+    sqlx::query(
+        "INSERT INTO tasks (
+            id, agent_id, task_number, title, description, status, priority,
+            subtasks, metadata, source_memory_id, created_by
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+    )
+    .bind(uuid::Uuid::new_v4().to_string())
+    .bind(&agent_id[..])
+    .bind(task_number)
+    .bind("detached bootstrap test")
+    .bind(Some("integration test"))
+    .bind("ready")
+    .bind("medium")
+    .bind("[]")
+    .bind("{}")
+    .bind(Option::<String>::None)
+    .bind("system")
+    .execute(&pool)
+    .await
+    .expect("failed to insert ready task fixture");
+
+    sqlx::query("DROP TABLE tasks")
+        .execute(&pool)
+        .await
+        .expect("failed to drop tasks table");
+
+    let result = register_detached_worker_for_pickup(
+        &registry,
+        &task_store,
+        &agent_id,
+        task_number,
+        worker_id,
+    )
+    .await;
+
+    assert!(
+        result.is_err(),
+        "bootstrap should fail when the task table is missing"
+    );
+
+    assert!(
+        !registry.unregister_detached_worker(worker_id).await,
+        "registry entry should be cleaned up on bootstrap failure"
+    );
+}
diff --git a/tests/tool_nudge.rs b/tests/tool_nudge.rs
new file mode 100644
index 000000000..44121a4b7
--- /dev/null
+++ b/tests/tool_nudge.rs
@@ -0,0 +1,319 @@
+//! Integration test for tool nudging behavior.
+//!
+//! Tests the public API surface of tool nudging:
+//! - Policy enum and its defaults
+//! - Hook constants and helpers
+//! - Event emission
+//! - Process-type scoping
+
+/// Test that the TOOL_NUDGE_REASON constant is accessible and correct.
+#[test]
+fn tool_nudge_reason_constant_is_valid() {
+    assert_eq!(
+        spacebot::hooks::SpacebotHook::TOOL_NUDGE_REASON,
+        "spacebot_tool_nudge_retry"
+    );
+    // Prompt should instruct the worker to continue and signal outcome.
+    assert!(
+        spacebot::hooks::SpacebotHook::TOOL_NUDGE_PROMPT.contains("set_status"),
+        "Nudge prompt should reference set_status for outcome signaling"
+    );
+    assert_eq!(spacebot::hooks::SpacebotHook::TOOL_NUDGE_MAX_RETRIES, 2);
+}
+
+/// Test that is_tool_nudge_reason correctly identifies nudge reasons.
+#[test]
+fn is_tool_nudge_reason_detects_nudge() {
+    assert!(spacebot::hooks::SpacebotHook::is_tool_nudge_reason(
+        "spacebot_tool_nudge_retry"
+    ));
+    assert!(!spacebot::hooks::SpacebotHook::is_tool_nudge_reason(
+        "some_other_reason"
+    ));
+    assert!(!spacebot::hooks::SpacebotHook::is_tool_nudge_reason(""));
+}
+
+/// Test ToolNudgePolicy enum values and display.
+#[test]
+fn tool_nudge_policy_enum_values() {
+    use spacebot::hooks::ToolNudgePolicy;
+
+    // Test that the enum variants exist and can be matched
+    let enabled = ToolNudgePolicy::Enabled;
+    let disabled = ToolNudgePolicy::Disabled;
+
+    match enabled {
+        ToolNudgePolicy::Enabled => {}
+        ToolNudgePolicy::Disabled => panic!("Expected Enabled"),
+    }
+
+    match disabled {
+        ToolNudgePolicy::Enabled => panic!("Expected Disabled"),
+        ToolNudgePolicy::Disabled => {}
+    }
+
+    // Test Debug output
+    let debug_str = format!("{:?}", enabled);
+    assert!(debug_str.contains("Enabled"));
+}
+
+/// Test that ToolNudgePolicy::for_process returns correct defaults.
+#[test]
+fn tool_nudge_policy_for_process_defaults() {
+    use spacebot::hooks::ToolNudgePolicy;
+
+    assert!(matches!(
+        ToolNudgePolicy::for_process(spacebot::ProcessType::Worker),
+        ToolNudgePolicy::Enabled
+    ));
+
+    assert!(matches!(
+        ToolNudgePolicy::for_process(spacebot::ProcessType::Branch),
+        ToolNudgePolicy::Disabled
+    ));
+
+    assert!(matches!(
+        ToolNudgePolicy::for_process(spacebot::ProcessType::Channel),
+        ToolNudgePolicy::Disabled
+    ));
+}
+
+/// Test that workers are created with the correct default policy.
+#[test]
+fn worker_hook_has_enabled_policy_by_default() {
+    use spacebot::hooks::ToolNudgePolicy;
+
+    let (event_tx, _event_rx) = tokio::sync::broadcast::channel(8);
+    let hook = spacebot::hooks::SpacebotHook::new(
+        std::sync::Arc::from("test-agent"),
+        spacebot::ProcessId::Worker(uuid::Uuid::new_v4()),
+        spacebot::ProcessType::Worker,
+        None,
+        event_tx,
+    );
+
+    assert_eq!(hook.tool_nudge_policy(), ToolNudgePolicy::Enabled);
+
+    // Clone to verify Clone impl works
+    let _cloned = hook.clone();
+}
+
+/// Test that branches are created with the correct default policy.
+#[test]
+fn branch_hook_has_disabled_policy_by_default() {
+    use spacebot::hooks::ToolNudgePolicy;
+
+    let (event_tx, _event_rx) = tokio::sync::broadcast::channel(8);
+    let hook = spacebot::hooks::SpacebotHook::new(
+        std::sync::Arc::from("test-agent"),
+        spacebot::ProcessId::Branch(uuid::Uuid::new_v4()),
+        spacebot::ProcessType::Branch,
+        None,
+        event_tx,
+    );
+
+    assert_eq!(hook.tool_nudge_policy(), ToolNudgePolicy::Disabled);
+
+    let _cloned = hook.clone();
+}
+
+/// Test that channels are created with the correct default policy.
+#[test]
+fn channel_hook_has_disabled_policy_by_default() {
+    use spacebot::hooks::ToolNudgePolicy;
+
+    let (event_tx, _event_rx) = tokio::sync::broadcast::channel(8);
+    let hook = spacebot::hooks::SpacebotHook::new(
+        std::sync::Arc::from("test-agent"),
+        spacebot::ProcessId::Channel(std::sync::Arc::from("test-channel")),
+        spacebot::ProcessType::Channel,
+        Some(std::sync::Arc::from("test-channel")),
+        event_tx,
+    );
+
+    assert_eq!(hook.tool_nudge_policy(), ToolNudgePolicy::Disabled);
+
+    let _cloned = hook.clone();
+}
+
+/// Test hook clone works (used in follow-up handling).
+#[test]
+fn hook_clone_works() {
+    let (event_tx, _event_rx) = tokio::sync::broadcast::channel(8);
+    let hook = spacebot::hooks::SpacebotHook::new(
+        std::sync::Arc::from("test-agent"),
+        spacebot::ProcessId::Worker(uuid::Uuid::new_v4()),
+        spacebot::ProcessType::Worker,
+        None,
+        event_tx,
+    );
+
+    // Clone the hook (simulating what happens in follow-up handling)
+    let _cloned = hook.clone();
+}
+
+/// Test that send_status works and generates the correct event.
+#[tokio::test]
+async fn hook_send_status_generates_event() {
+    let (event_tx, mut event_rx) = tokio::sync::broadcast::channel(8);
+    let hook = spacebot::hooks::SpacebotHook::new(
+        std::sync::Arc::from("test-agent"),
+        spacebot::ProcessId::Worker(uuid::Uuid::new_v4()),
+        spacebot::ProcessType::Worker,
+        None,
+        event_tx,
+    );
+
+    hook.send_status("test status");
+
+    let event = event_rx.try_recv().expect("Should receive status event");
+    match event {
+        spacebot::ProcessEvent::StatusUpdate { status, .. } => {
+            assert_eq!(status, "test status");
+        }
+        _ => panic!("Expected StatusUpdate event, got {:?}", event),
+    }
+}
+
+/// Test that tool call events are emitted correctly.
+#[tokio::test]
+async fn tool_call_emits_started_event() {
+    use rig::agent::PromptHook;
+
+    let (event_tx, mut event_rx) = tokio::sync::broadcast::channel(8);
+    let hook = spacebot::hooks::SpacebotHook::new(
+        std::sync::Arc::from("test-agent"),
+        spacebot::ProcessId::Worker(uuid::Uuid::new_v4()),
+        spacebot::ProcessType::Worker,
+        None,
+        event_tx,
+    );
+
+    let action =
+        <spacebot::hooks::SpacebotHook as PromptHook<spacebot::llm::SpacebotModel>>::on_tool_call(
+            &hook,
+            "test_tool",
+            Some("call_123".to_string()),
+            "internal_id",
+            "{}",
+        )
+        .await;
+
+    assert!(
+        matches!(action, rig::agent::ToolCallHookAction::Continue),
+        "Tool call should be allowed"
+    );
+
+    let event = event_rx
+        .try_recv()
+        .expect("Should receive tool started event");
+    match event {
+        spacebot::ProcessEvent::ToolStarted { tool_name, .. } => {
+            assert_eq!(tool_name, "test_tool");
+        }
+        _ => panic!("Expected ToolStarted event, got {:?}", event),
+    }
+}
+
+/// Test that tool result events are emitted correctly.
+#[tokio::test]
+async fn tool_result_emits_completed_event() {
+    use rig::agent::PromptHook;
+
+    let (event_tx, mut event_rx) = tokio::sync::broadcast::channel(8);
+    let hook = spacebot::hooks::SpacebotHook::new(
+        std::sync::Arc::from("test-agent"),
+        spacebot::ProcessId::Worker(uuid::Uuid::new_v4()),
+        spacebot::ProcessType::Worker,
+        None,
+        event_tx,
+    );
+
+    // First emit a tool started event to get a call_id
+    let _ =
+        <spacebot::hooks::SpacebotHook as PromptHook<spacebot::llm::SpacebotModel>>::on_tool_call(
+            &hook,
+            "test_tool",
+            Some("call_123".to_string()),
+            "internal_id",
+            "{}",
+        )
+        .await;
+
+    // Consume the started event
+    let _ = event_rx.try_recv();
+
+    // Now emit the result
+    let action = <spacebot::hooks::SpacebotHook as PromptHook<spacebot::llm::SpacebotModel>>::on_tool_result(
+        &hook,
+        "test_tool",
+        Some("call_123".to_string()),
+        "internal_id",
+        "{}",
+        "Tool result content",
+    )
+    .await;
+
+    assert!(
+        matches!(action, rig::agent::HookAction::Continue),
+        "Tool result should continue, got {:?}",
+        action
+    );
+
+    let event = event_rx
+        .try_recv()
+        .expect("Should receive tool completed event");
+    match event {
+        spacebot::ProcessEvent::ToolCompleted {
+            tool_name, result, ..
+        } => {
+            assert_eq!(tool_name, "test_tool");
+            assert_eq!(result, "Tool result content");
+        }
+        _ => panic!("Expected ToolCompleted event, got {:?}", event),
+    }
+}
+
+/// Test that completion call and response hooks work.
+#[tokio::test]
+async fn completion_hooks_work() {
+    use rig::OneOrMany;
+    use rig::agent::{HookAction, PromptHook};
+    use rig::completion::{CompletionResponse, Message, Usage};
+
+    let (event_tx, _event_rx) = tokio::sync::broadcast::channel(8);
+    let hook = spacebot::hooks::SpacebotHook::new(
+        std::sync::Arc::from("test-agent"),
+        spacebot::ProcessId::Worker(uuid::Uuid::new_v4()),
+        spacebot::ProcessType::Worker,
+        None,
+        event_tx,
+    );
+
+    let prompt = Message::from("Test prompt");
+
+    // Test on_completion_call
+    let action = <spacebot::hooks::SpacebotHook as PromptHook<spacebot::llm::SpacebotModel>>::on_completion_call(
+        &hook, &prompt, &[],
+    )
+    .await;
+    assert!(matches!(action, HookAction::Continue));
+
+    // Test on_completion_response (will continue since nudging is not activated)
+    let response = CompletionResponse {
+        choice: OneOrMany::one(rig::message::AssistantContent::text("Response")),
+        message_id: None,
+        usage: Usage::default(),
+        raw_response: spacebot::llm::model::RawResponse {
+            body: serde_json::json!({}),
+        },
+    };
+
+    let action = <spacebot::hooks::SpacebotHook as PromptHook<spacebot::llm::SpacebotModel>>::on_completion_response(
+        &hook, &prompt, &response,
+    )
+    .await;
+
+    // Without nudge activation, should continue
+    assert!(matches!(action, HookAction::Continue));
+}
diff --git a/vendor/imap-proto-0.10.2/Cargo.toml b/vendor/imap-proto-0.10.2/Cargo.toml
new file mode 100644
index 000000000..0ccce171e
--- /dev/null
+++ b/vendor/imap-proto-0.10.2/Cargo.toml
@@ -0,0 +1,37 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+edition = "2018"
+name = "imap-proto"
+version = "0.10.2"
+authors = ["Dirkjan Ochtman <dirkjan@ochtman.nl>"]
+description = "IMAP protocol parser and data structures"
+homepage = "https://github.com/djc/tokio-imap"
+documentation = "https://docs.rs/imap-proto"
+keywords = ["imap", "email"]
+categories = ["email", "network-programming", "parser-implementations"]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/djc/tokio-imap"
+[dependencies.nom]
+version = "5"
+features = ["std"]
+default-features = false
+[dev-dependencies.assert_matches]
+version = "1.3"
+[badges.azure-devops]
+build = "4"
+pipeline = "tokio-imap"
+project = "dochtman/Projects"
+
+[badges.maintenance]
+status = "passively-maintained"
diff --git a/vendor/imap-proto-0.10.2/src/body.rs b/vendor/imap-proto-0.10.2/src/body.rs
new file mode 100644
index 000000000..a0a37a3c0
--- /dev/null
+++ b/vendor/imap-proto-0.10.2/src/body.rs
@@ -0,0 +1,65 @@
+use crate::core::*;
+use crate::types::*;
+
+named!(pub section_part<Vec<u32>>, do_parse!(
+    part: number >>
+    rest: many0!(do_parse!(
+        tag!(".") >>
+        part: number >>
+        (part)
+    ))  >> ({
+        let mut res = vec![part];
+        res.extend(rest);
+        res
+    })
+));
+
+named!(pub section_msgtext<MessageSection>, alt!(
+    do_parse!(
+        tag_no_case!("HEADER.FIELDS") >>
+        opt!(tag_no_case!(".NOT")) >>
+        tag!(" ") >>
+        parenthesized_list!(astring) >>
+        (MessageSection::Header)) |
+    do_parse!(tag_no_case!("HEADER") >> (MessageSection::Header)) |
+    do_parse!(tag_no_case!("TEXT") >> (MessageSection::Text))
+));
+
+named!(pub section_text<MessageSection>, alt!(
+    section_msgtext |
+    do_parse!(tag_no_case!("MIME") >> (MessageSection::Mime))
+));
+
+named!(pub section_spec<SectionPath>, alt!(
+    map!(section_msgtext, |val| SectionPath::Full(val)) |
+    do_parse!(
+        part: section_part >>
+        text: opt!(do_parse!(
+            tag!(".") >>
+            text: section_text >>
+            (text)
+        )) >>
+        (SectionPath::Part(part, text))
+    )
+));
+
+named!(pub section<Option<SectionPath>>, do_parse!(
+    tag!("[") >>
+    spec: opt!(section_spec) >>
+    tag!("]") >>
+    (spec)
+));
+
+named!(pub msg_att_body_section<AttributeValue>, do_parse!(
+    tag_no_case!("BODY") >>
+    section: section >>
+    index: opt!(do_parse!(
+        tag!("<") >>
+        num: number >>
+        tag!(">") >>
+        (num)
+    )) >>
+    tag!(" ") >>
+    data: nstring >>
+    (AttributeValue::BodySection { section, index, data })
+));
diff --git a/vendor/imap-proto-0.10.2/src/body_structure.rs b/vendor/imap-proto-0.10.2/src/body_structure.rs
new file mode 100644
index 000000000..9478eaec7
--- /dev/null
+++ b/vendor/imap-proto-0.10.2/src/body_structure.rs
@@ -0,0 +1,485 @@
+// rustfmt doesn't do a very good job on nom parser invocations.
+#![cfg_attr(rustfmt, rustfmt_skip)]
+
+use crate::core::*;
+use crate::types::*;
+
+use crate::parser::envelope;
+
+struct BodyFields<'a> {
+    pub param: BodyParams<'a>,
+    pub id: Option<&'a str>,
+    pub description: Option<&'a str>,
+    pub transfer_encoding: ContentEncoding<'a>,
+    pub octets: u32,
+}
+
+// body-fields     = body-fld-param SP body-fld-id SP body-fld-desc SP
+//                   body-fld-enc SP body-fld-octets
+named!(body_fields<BodyFields>, do_parse!(
+    param: body_param >>
+    tag!(" ") >>
+    // body id seems to refer to the Message-ID or possibly Content-ID header, which
+    // by the definition in RFC 2822 seems to resolve to all ASCII characters (through
+    // a large amount of indirection which I did not have the patience to fully explore)
+    id: nstring_utf8 >>
+    tag!(" ") >>
+    // Per https://tools.ietf.org/html/rfc2045#section-8, description should be all ASCII
+    description: nstring_utf8 >>
+    tag!(" ") >>
+    transfer_encoding: body_encoding >>
+    tag!(" ") >>
+    octets: number >>
+    (BodyFields { param, id, description, transfer_encoding, octets })
+));
+
+struct BodyExt1Part<'a> {
+    pub md5: Option<&'a str>,
+    pub disposition: Option<ContentDisposition<'a>>,
+    pub language: Option<Vec<&'a str>>,
+    pub location: Option<&'a str>,
+    pub extension: Option<BodyExtension<'a>>,
+}
+
+// body-ext-1part  = body-fld-md5 [SP body-fld-dsp [SP body-fld-lang
+//                   [SP body-fld-loc *(SP body-extension)]]]
+//                     ; MUST NOT be returned on non-extensible
+//                     ; "BODY" fetch
+named!(body_ext_1part<BodyExt1Part>, do_parse!(
+    // Per RFC 1864, MD5 values are base64-encoded
+    md5: opt_opt!(preceded!(tag!(" "), nstring_utf8)) >>
+    disposition: opt_opt!(preceded!(tag!(" "), body_disposition)) >>
+    language: opt_opt!(preceded!(tag!(" "), body_lang)) >>
+    // Location appears to reference a URL, which by RFC 1738 (section 2.2) should be ASCII
+    location: opt_opt!(preceded!(tag!(" "), nstring_utf8)) >>
+    extension: opt!(preceded!(tag!(" "), body_extension)) >>
+    (BodyExt1Part { md5, disposition, language, location, extension })
+));
+
+struct BodyExtMPart<'a> {
+    pub param: BodyParams<'a>,
+    pub disposition: Option<ContentDisposition<'a>>,
+    pub language: Option<Vec<&'a str>>,
+    pub location: Option<&'a str>,
+    pub extension: Option<BodyExtension<'a>>,
+}
+
+// body-ext-mpart  = body-fld-param [SP body-fld-dsp [SP body-fld-lang
+//                   [SP body-fld-loc *(SP body-extension)]]]
+//                     ; MUST NOT be returned on non-extensible
+//                     ; "BODY" fetch
+named!(body_ext_mpart<BodyExtMPart>, do_parse!(
+    param: opt_opt!(preceded!(tag!(" "), body_param)) >>
+    disposition: opt_opt!(preceded!(tag!(" "), body_disposition)) >>
+    language: opt_opt!(preceded!(tag!(" "), body_lang)) >>
+    // Location appears to reference a URL, which by RFC 1738 (section 2.2) should be ASCII
+    location: opt_opt!(preceded!(tag!(" "), nstring_utf8)) >>
+    extension: opt!(preceded!(tag!(" "), body_extension)) >>
+    (BodyExtMPart { param, disposition, language, location, extension })
+));
+
+named!(body_encoding<ContentEncoding>, alt!(
+    delimited!(char!('"'), alt!(
+        map!(tag_no_case!("7BIT"), |_| ContentEncoding::SevenBit) |
+        map!(tag_no_case!("8BIT"), |_| ContentEncoding::EightBit) |
+        map!(tag_no_case!("BINARY"), |_| ContentEncoding::Binary) |
+        map!(tag_no_case!("BASE64"), |_| ContentEncoding::Base64) |
+        map!(tag_no_case!("QUOTED-PRINTABLE"), |_| ContentEncoding::QuotedPrintable)
+    ), char!('"')) |
+    map!(string_utf8, |enc| ContentEncoding::Other(enc))
+));
+
+named!(body_lang<Option<Vec<&str>>>, alt!(
+    // body language seems to refer to RFC 3066 language tags, which should be ASCII-only
+    map!(nstring_utf8, |v| v.map(|s| vec![s])) |
+    map!(parenthesized_nonempty_list!(string_utf8), Option::from)
+));
+
+named!(body_param<BodyParams>, alt!(
+    map!(nil, |_| None) |
+    map!(parenthesized_nonempty_list!(do_parse!(
+        key: string_utf8 >>
+        tag!(" ") >>
+        val: string_utf8 >>
+        ((key, val))
+    )), Option::from)
+));
+
+named!(body_extension<BodyExtension>, alt!(
+    map!(number, |n| BodyExtension::Num(n)) |
+    // Cannot find documentation on character encoding for body extension values.
+    // So far, assuming UTF-8 seems fine, please report if you run into issues here.
+    map!(nstring_utf8, |s| BodyExtension::Str(s)) |
+    map!(parenthesized_nonempty_list!(body_extension), |ext| BodyExtension::List(ext))
+));
+
+named!(body_disposition<Option<ContentDisposition>>, alt!(
+    map!(nil, |_| None) |
+    paren_delimited!(do_parse!(
+        ty: string_utf8 >>
+        tag!(" ") >>
+        params: body_param >>
+        (Some(ContentDisposition {
+            ty,
+            params
+        }))
+    ))
+));
+
+named!(body_type_basic<BodyStructure>, do_parse!(
+    media_type: string_utf8 >>
+    tag!(" ") >>
+    media_subtype: string_utf8 >>
+    tag!(" ") >>
+    fields: body_fields >>
+    ext: body_ext_1part >>
+    (BodyStructure::Basic {
+        common: BodyContentCommon {
+            ty: ContentType {
+                ty: media_type,
+                subtype: media_subtype,
+                params: fields.param,
+            },
+            disposition: ext.disposition,
+            language: ext.language,
+            location: ext.location,
+        },
+        other: BodyContentSinglePart {
+            id: fields.id,
+            md5: ext.md5,
+            octets: fields.octets,
+            description: fields.description,
+            transfer_encoding: fields.transfer_encoding,
+        },
+        extension: ext.extension,
+    })
+));
+
+named!(body_type_text<BodyStructure>, do_parse!(
+    tag_no_case!("\"TEXT\"") >>
+    tag!(" ") >>
+    media_subtype: string_utf8 >>
+    tag!(" ") >>
+    fields: body_fields >>
+    tag!(" ") >>
+    lines: number >>
+    ext: body_ext_1part >>
+    (BodyStructure::Text {
+        common: BodyContentCommon {
+            ty: ContentType {
+                ty: "TEXT",
+                subtype: media_subtype,
+                params: fields.param,
+            },
+            disposition: ext.disposition,
+            language: ext.language,
+            location: ext.location,
+        },
+        other: BodyContentSinglePart {
+            id: fields.id,
+            md5: ext.md5,
+            octets: fields.octets,
+            description: fields.description,
+            transfer_encoding: fields.transfer_encoding,
+        },
+        lines,
+        extension: ext.extension,
+    })
+));
+
+named!(body_type_message<BodyStructure>, do_parse!(
+    tag_no_case!("\"MESSAGE\" \"RFC822\"") >>
+    tag!(" ") >>
+    fields: body_fields >>
+    tag!(" ") >>
+    envelope: envelope >>
+    tag!(" ") >>
+    body: body >>
+    tag!(" ") >>
+    lines: number >>
+    ext: body_ext_1part >>
+    (BodyStructure::Message {
+        common: BodyContentCommon {
+            ty: ContentType {
+                ty: "MESSAGE",
+                subtype: "RFC822",
+                params: fields.param,
+            },
+            disposition: ext.disposition,
+            language: ext.language,
+            location: ext.location,
+        },
+        other: BodyContentSinglePart {
+            id: fields.id,
+            md5: ext.md5,
+            octets: fields.octets,
+            description: fields.description,
+            transfer_encoding: fields.transfer_encoding,
+        },
+        envelope,
+        body: Box::new(body),
+        lines,
+        extension: ext.extension,
+    })
+));
+
+named!(body_type_multipart<BodyStructure>, do_parse!(
+    bodies: many1!(body) >>
+    tag!(" ") >>
+    media_subtype: string_utf8 >>
+    ext: body_ext_mpart >>
+    (BodyStructure::Multipart {
+        common: BodyContentCommon {
+            ty: ContentType {
+                ty: "MULTIPART",
+                subtype: media_subtype,
+                params: ext.param,
+            },
+            disposition: ext.disposition,
+            language: ext.language,
+            location: ext.location,
+        },
+        bodies,
+        extension: ext.extension,
+    })
+));
+
+named!(pub(crate) body<BodyStructure>, paren_delimited!(
+    alt!(body_type_text | body_type_message | body_type_basic | body_type_multipart)
+));
+
+named!(pub(crate) msg_att_body_structure<AttributeValue>, do_parse!(
+    tag_no_case!("BODYSTRUCTURE ") >>
+    body: body >>
+    (AttributeValue::BodyStructure(body))
+));
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const EMPTY: &[u8] = &[];
+
+    // body-fld-param SP body-fld-id SP body-fld-desc SP body-fld-enc SP body-fld-octets
+    const BODY_FIELDS: &str = r#"("foo" "bar") "id" "desc" "7BIT" 1337"#;
+    const BODY_FIELD_PARAM_PAIR: (&str, &str) = ("foo", "bar");
+    const BODY_FIELD_ID: Option<&str> = Some("id");
+    const BODY_FIELD_DESC: Option<&str> = Some("desc");
+    const BODY_FIELD_ENC: ContentEncoding = ContentEncoding::SevenBit;
+    const BODY_FIELD_OCTETS: u32 = 1337;
+
+    fn mock_body_text() -> (String, BodyStructure<'static>) {
+        (
+            format!(r#"("TEXT" "PLAIN" {} 42)"#, BODY_FIELDS),
+            BodyStructure::Text {
+                common: BodyContentCommon {
+                    ty: ContentType {
+                        ty: "TEXT",
+                        subtype: "PLAIN",
+                        params: Some(vec![BODY_FIELD_PARAM_PAIR]),
+                    },
+                    disposition: None,
+                    language: None,
+                    location: None,
+                },
+                other: BodyContentSinglePart {
+                    md5: None,
+                    transfer_encoding: BODY_FIELD_ENC,
+                    octets: BODY_FIELD_OCTETS,
+                    id: BODY_FIELD_ID,
+                    description: BODY_FIELD_DESC,
+                },
+                lines: 42,
+                extension: None,
+            }
+        )
+    }
+
+    #[test]
+    fn test_body_param_data() {
+        assert_matches!(
+            body_param(br#"NIL"#),
+            Ok((EMPTY, None))
+        );
+
+        assert_matches!(
+            body_param(br#"("foo" "bar")"#),
+            Ok((EMPTY, Some(param))) => {
+                assert_eq!(param, vec![("foo", "bar")]);
+            }
+        );
+    }
+
+    #[test]
+    fn test_body_lang_data() {
+        assert_matches!(
+            body_lang(br#""bob""#),
+            Ok((EMPTY, Some(langs))) => {
+                assert_eq!(langs, vec!["bob"]);
+            }
+        );
+
+        assert_matches!(
+            body_lang(br#"("one" "two")"#),
+            Ok((EMPTY, Some(langs))) => {
+                assert_eq!(langs, vec!["one", "two"]);
+            }
+        );
+
+        assert_matches!(
+            body_lang(br#"NIL"#),
+            Ok((EMPTY, None))
+        );
+    }
+
+    #[test]
+    fn test_body_extension_data() {
+        assert_matches!(
+            body_extension(br#""blah""#),
+            Ok((EMPTY, BodyExtension::Str(Some("blah"))))
+        );
+
+        assert_matches!(
+            body_extension(br#"NIL"#),
+            Ok((EMPTY, BodyExtension::Str(None)))
+        );
+
+        assert_matches!(
+            body_extension(br#"("hello")"#),
+            Ok((EMPTY, BodyExtension::List(list))) => {
+                assert_eq!(list, vec![BodyExtension::Str(Some("hello"))]);
+            }
+        );
+
+        assert_matches!(
+            body_extension(br#"(1337)"#),
+            Ok((EMPTY, BodyExtension::List(list))) => {
+                assert_eq!(list, vec![BodyExtension::Num(1337)]);
+            }
+        );
+    }
+
+    #[test]
+    fn test_body_disposition_data() {
+        assert_matches!(
+            body_disposition(br#"NIL"#),
+            Ok((EMPTY, None))
+        );
+
+        assert_matches!(
+            body_disposition(br#"("attachment" ("FILENAME" "pages.pdf"))"#),
+            Ok((EMPTY, Some(disposition))) => {
+                assert_eq!(disposition, ContentDisposition {
+                    ty: "attachment",
+                    params: Some(vec![
+                        ("FILENAME", "pages.pdf")
+                    ])
+                });
+            }
+        );
+    }
+
+    #[test]
+    fn test_body_structure_text() {
+        let (body_str, body_struct) = mock_body_text();
+
+        assert_matches!(
+            body(body_str.as_bytes()),
+            Ok((_, text)) => {
+                assert_eq!(text, body_struct);
+            }
+        );
+    }
+
+    #[test]
+    fn test_body_structure_text_with_ext() {
+        let body_str = format!(r#"("TEXT" "PLAIN" {} 42 NIL NIL NIL NIL)"#, BODY_FIELDS);
+        let (_, text_body_struct) = mock_body_text();
+
+        assert_matches!(
+            body(body_str.as_bytes()),
+            Ok((_, text)) => {
+                assert_eq!(text, text_body_struct)
+            }
+        );
+    }
+
+    #[test]
+    fn test_body_structure_basic() {
+        const BODY: &[u8] = br#"("APPLICATION" "PDF" ("NAME" "pages.pdf") NIL NIL "BASE64" 38838 NIL ("attachment" ("FILENAME" "pages.pdf")) NIL NIL)"#;
+
+        assert_matches!(
+            body(BODY),
+            Ok((_, basic)) => {
+                assert_eq!(basic, BodyStructure::Basic {
+                    common: BodyContentCommon {
+                        ty: ContentType {
+                            ty: "APPLICATION",
+                            subtype: "PDF",
+                            params: Some(vec![("NAME", "pages.pdf")])
+                        },
+                        disposition: Some(ContentDisposition {
+                            ty: "attachment",
+                            params: Some(vec![("FILENAME", "pages.pdf")])
+                        }),
+                        language: None,
+                        location: None,
+                    },
+                    other: BodyContentSinglePart {
+                        transfer_encoding: ContentEncoding::Base64,
+                        octets: 38838,
+                        id: None,
+                        md5: None,
+                        description: None,
+                    },
+                    extension: None,
+                })
+            }
+        );
+    }
+
+    #[test]
+    fn test_body_structure_message() {
+        let (text_body_str, _) = mock_body_text();
+        let envelope_str = r#"("Wed, 17 Jul 1996 02:23:25 -0700 (PDT)" "IMAP4rev1 WG mtg summary and minutes" (("Terry Gray" NIL "gray" "cac.washington.edu")) (("Terry Gray" NIL "gray" "cac.washington.edu")) (("Terry Gray" NIL "gray" "cac.washington.edu")) ((NIL NIL "imap" "cac.washington.edu")) ((NIL NIL "minutes" "CNRI.Reston.VA.US") ("John Klensin" NIL "KLENSIN" "MIT.EDU")) NIL NIL "<B27397-0100000@cac.washington.edu>")"#;
+        let body_str = format!(r#"("MESSAGE" "RFC822" {} {} {} 42)"#, BODY_FIELDS, envelope_str, text_body_str);
+
+        assert_matches!(
+            body(body_str.as_bytes()),
+            Ok((_, BodyStructure::Message { .. }))
+        );
+    }
+
+    #[test]
+    fn test_body_structure_multipart() {
+        let (text_body_str1, text_body_struct1) = mock_body_text();
+        let (text_body_str2, text_body_struct2) = mock_body_text();
+        let body_str = format!(
+            r#"({}{} "ALTERNATIVE" NIL NIL NIL NIL)"#,
+            text_body_str1, text_body_str2
+        );
+
+        assert_matches!(
+            body(body_str.as_bytes()),
+            Ok((_, multipart)) => {
+                assert_eq!(multipart, BodyStructure::Multipart {
+                    common: BodyContentCommon {
+                        ty: ContentType {
+                            ty: "MULTIPART",
+                            subtype: "ALTERNATIVE",
+                            params: None
+                        },
+                        language: None,
+                        location: None,
+                        disposition: None,
+                    },
+                    bodies: vec![
+                        text_body_struct1,
+                        text_body_struct2,
+                    ],
+                    extension: None
+                });
+            }
+        );
+    }
+}
diff --git a/vendor/imap-proto-0.10.2/src/builders/command.rs b/vendor/imap-proto-0.10.2/src/builders/command.rs
new file mode 100644
index 000000000..d9548fd53
--- /dev/null
+++ b/vendor/imap-proto-0.10.2/src/builders/command.rs
@@ -0,0 +1,254 @@
+use crate::quoted_string;
+use crate::types::{AttrMacro, Attribute, State};
+
+pub struct CommandBuilder {}
+
+impl CommandBuilder {
+    pub fn check() -> Command {
+        let args = b"CHECK".to_vec();
+        Command {
+            args,
+            next_state: None,
+        }
+    }
+
+    pub fn close() -> Command {
+        let args = b"CLOSE".to_vec();
+        Command {
+            args,
+            next_state: Some(State::Authenticated),
+        }
+    }
+
+    pub fn examine(mailbox: &str) -> Command {
+        let args = format!("EXAMINE \"{}\"", quoted_string(mailbox).unwrap()).into_bytes();
+        Command {
+            args,
+            next_state: Some(State::Selected),
+        }
+    }
+
+    pub fn fetch() -> FetchCommandEmpty {
+        let args = b"FETCH ".to_vec();
+        FetchCommandEmpty { args }
+    }
+
+    pub fn list(reference: &str, glob: &str) -> Command {
+        let args = format!(
+            "LIST \"{}\" \"{}\"",
+            quoted_string(reference).unwrap(),
+            quoted_string(glob).unwrap()
+        )
+        .into_bytes();
+        Command {
+            args,
+            next_state: None,
+        }
+    }
+
+    pub fn login(user_name: &str, password: &str) -> Command {
+        let args = format!(
+            "LOGIN \"{}\" \"{}\"",
+            quoted_string(user_name).unwrap(),
+            quoted_string(password).unwrap()
+        )
+        .into_bytes();
+        Command {
+            args,
+            next_state: Some(State::Authenticated),
+        }
+    }
+
+    pub fn select(mailbox: &str) -> Command {
+        let args = format!("SELECT \"{}\"", quoted_string(mailbox).unwrap()).into_bytes();
+        Command {
+            args,
+            next_state: Some(State::Selected),
+        }
+    }
+
+    pub fn uid_fetch() -> FetchCommandEmpty {
+        let args = b"UID FETCH ".to_vec();
+        FetchCommandEmpty { args }
+    }
+}
+
+pub struct Command {
+    args: Vec<u8>,
+    next_state: Option<State>,
+}
+
+impl Command {
+    pub fn into_parts(self) -> (Vec<u8>, Option<State>) {
+        let Command { args, next_state } = self;
+        (args, next_state)
+    }
+}
+
+pub struct FetchCommandEmpty {
+    args: Vec<u8>,
+}
+
+impl FetchBuilderMessages for FetchCommandEmpty {
+    fn prepare(self) -> FetchCommandMessages {
+        FetchCommandMessages { args: self.args }
+    }
+}
+
+pub struct FetchCommandMessages {
+    args: Vec<u8>,
+}
+
+impl FetchBuilderMessages for FetchCommandMessages {
+    fn prepare(self) -> FetchCommandMessages {
+        let FetchCommandMessages { mut args } = self;
+        args.push(b',');
+        FetchCommandMessages { args }
+    }
+}
+
+impl FetchCommandMessages {
+    pub fn attr_macro(self, named: AttrMacro) -> FetchCommand {
+        let FetchCommandMessages { mut args } = self;
+        args.push(b' ');
+        args.extend(
+            match named {
+                AttrMacro::All => "ALL",
+                AttrMacro::Fast => "FAST",
+                AttrMacro::Full => "FULL",
+            }
+            .as_bytes(),
+        );
+        FetchCommand { args }
+    }
+}
+
+pub trait FetchBuilderMessages
+where
+    Self: Sized,
+{
+    fn prepare(self) -> FetchCommandMessages;
+
+    fn num(self, num: u32) -> FetchCommandMessages {
+        let FetchCommandMessages { mut args } = self.prepare();
+        args.extend(num.to_string().as_bytes());
+        FetchCommandMessages { args }
+    }
+
+    fn range(self, start: u32, stop: u32) -> FetchCommandMessages {
+        let FetchCommandMessages { mut args } = self.prepare();
+        args.extend(start.to_string().as_bytes());
+        args.push(b':');
+        args.extend(stop.to_string().as_bytes());
+        FetchCommandMessages { args }
+    }
+
+    fn all_after(self, start: u32) -> FetchCommandMessages {
+        let FetchCommandMessages { mut args } = self.prepare();
+        args.extend(start.to_string().as_bytes());
+        args.extend(b":*");
+        FetchCommandMessages { args }
+    }
+}
+
+pub struct FetchCommandAttributes {
+    args: Vec<u8>,
+}
+
+impl FetchBuilderAttributes for FetchCommandMessages {
+    fn prepare(self) -> FetchCommandAttributes {
+        let FetchCommandMessages { mut args } = self;
+        args.extend(b" (");
+        FetchCommandAttributes { args }
+    }
+}
+
+impl FetchBuilderAttributes for FetchCommandAttributes {
+    fn prepare(self) -> FetchCommandAttributes {
+        let FetchCommandAttributes { mut args } = self;
+        args.push(b' ');
+        FetchCommandAttributes { args }
+    }
+}
+
+pub trait FetchBuilderAttributes
+where
+    Self: Sized,
+{
+    fn prepare(self) -> FetchCommandAttributes;
+    fn attr(self, attr: Attribute) -> FetchCommandAttributes {
+        let FetchCommandAttributes { mut args } = self.prepare();
+        args.extend(
+            match attr {
+                Attribute::Body => "BODY",
+                Attribute::Envelope => "ENVELOPE",
+                Attribute::Flags => "FLAGS",
+                Attribute::InternalDate => "INTERNALDATE",
+                Attribute::ModSeq => "MODSEQ",
+                Attribute::Rfc822 => "RFC822",
+                Attribute::Rfc822Size => "RFC822.SIZE",
+                Attribute::Rfc822Text => "RFC822.TEXT",
+                Attribute::Uid => "UID",
+            }
+            .as_bytes(),
+        );
+        FetchCommandAttributes { args }
+    }
+}
+
+pub struct FetchCommand {
+    args: Vec<u8>,
+}
+
+pub trait FetchBuilderModifiers
+where
+    Self: Sized,
+{
+    fn prepare(self) -> FetchCommand;
+    fn build(self) -> Command {
+        let FetchCommand { args } = self.prepare();
+        Command {
+            args,
+            next_state: None,
+        }
+    }
+    fn changed_since(self, seq: u64) -> FetchCommand {
+        let FetchCommand { mut args } = self.prepare();
+        args.extend(b" (CHANGEDSINCE ");
+        args.extend(seq.to_string().as_bytes());
+        args.push(b')');
+        FetchCommand { args }
+    }
+}
+
+impl FetchBuilderModifiers for FetchCommandAttributes {
+    fn prepare(self) -> FetchCommand {
+        let FetchCommandAttributes { mut args, .. } = self;
+        args.push(b')');
+        FetchCommand { args }
+    }
+}
+
+impl FetchBuilderModifiers for FetchCommand {
+    fn prepare(self) -> FetchCommand {
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::CommandBuilder;
+    #[test]
+    fn login() {
+        assert_eq!(
+            CommandBuilder::login("djc", "s3cr3t").into_parts().0,
+            b"LOGIN \"djc\" \"s3cr3t\""
+        );
+        assert_eq!(
+            CommandBuilder::login("djc", "domain\\password")
+                .into_parts()
+                .0,
+            b"LOGIN \"djc\" \"domain\\\\password\""
+        );
+    }
+}
diff --git a/vendor/imap-proto-0.10.2/src/builders/mod.rs b/vendor/imap-proto-0.10.2/src/builders/mod.rs
new file mode 100644
index 000000000..9fe79612b
--- /dev/null
+++ b/vendor/imap-proto-0.10.2/src/builders/mod.rs
@@ -0,0 +1 @@
+pub mod command;
diff --git a/vendor/imap-proto-0.10.2/src/core.rs b/vendor/imap-proto-0.10.2/src/core.rs
new file mode 100644
index 000000000..36e04c22f
--- /dev/null
+++ b/vendor/imap-proto-0.10.2/src/core.rs
@@ -0,0 +1,159 @@
+use nom::{self, IResult};
+
+use std::str;
+
+// list-wildcards = "%" / "*"
+pub fn list_wildcards(c: u8) -> bool {
+    c == b'%' || c == b'*'
+}
+
+// quoted-specials = DQUOTE / "\"
+pub fn quoted_specials(c: u8) -> bool {
+    c == b'"' || c == b'\\'
+}
+
+// resp-specials = "]"
+pub fn resp_specials(c: u8) -> bool {
+    c == b']'
+}
+
+// atom-specials = "(" / ")" / "{" / SP / CTL / list-wildcards / quoted-specials / resp-specials
+pub fn atom_specials(c: u8) -> bool {
+    c == b'('
+        || c == b')'
+        || c == b'{'
+        || c == b' '
+        || c < 32
+        || list_wildcards(c)
+        || quoted_specials(c)
+        || resp_specials(c)
+}
+
+// ATOM-CHAR = <any CHAR except atom-specials>
+pub fn atom_char(c: u8) -> bool {
+    !atom_specials(c)
+}
+
+// nil = "NIL"
+named!(pub nil, tag_no_case!("NIL"));
+
+// ASTRING-CHAR = ATOM-CHAR / resp-specials
+pub fn astring_char(c: u8) -> bool {
+    atom_char(c) || resp_specials(c)
+}
+
+// QUOTED-CHAR = <any TEXT-CHAR except quoted-specials> / "\" quoted-specials
+pub fn quoted_data(i: &[u8]) -> IResult<&[u8], &[u8]> {
+    // Ideally this should use nom's `escaped` macro, but it suffers from broken
+    // type inference unless compiled with the verbose-errors feature enabled.
+    let mut escape = false;
+    let mut len = 0;
+    for c in i {
+        if *c == b'"' && !escape {
+            break;
+        }
+        len += 1;
+        if *c == b'\\' && !escape {
+            escape = true
+        } else if escape {
+            escape = false;
+        }
+    }
+    Ok((&i[len..], &i[..len]))
+}
+
+// quoted = DQUOTE *QUOTED-CHAR DQUOTE
+named!(pub quoted<&[u8]>, delimited!(
+    char!('"'),
+    quoted_data,
+    char!('"')
+));
+
+// quoted bytes as as utf8
+named!(pub quoted_utf8<&str>, map_res!(quoted, str::from_utf8));
+
+// literal = "{" number "}" CRLF *CHAR8
+//            ; Number represents the number of CHAR8s
+named!(pub literal<&[u8]>, do_parse!(
+    tag!("{") >>
+    len: number >>
+    tag!("}") >>
+    tag!("\r\n") >>
+    data: take!(len) >>
+    (data)
+));
+
+// string = quoted / literal
+named!(pub string<&[u8]>, alt!(quoted | literal));
+
+// string bytes as as utf8
+named!(pub string_utf8<&str>, map_res!(string, str::from_utf8));
+
+// nstring = string / nil
+named!(pub nstring<Option<&[u8]>>, alt!(
+    map!(nil, |_| None) |
+    map!(string, |s| Some(s))
+));
+
+// nstring bytes as utf8
+named!(pub nstring_utf8<Option<&str>>, alt!(
+    map!(nil, |_| None) |
+    map!(string_utf8, |s| Some(s))
+));
+
+// number          = 1*DIGIT
+//                    ; Unsigned 32-bit integer
+//                    ; (0 <= n < 4,294,967,296)
+named!(pub number<u32>, flat_map!(nom::character::streaming::digit1, parse_to!(u32)));
+
+// same as `number` but 64-bit
+named!(pub number_64<u64>, flat_map!(nom::character::streaming::digit1, parse_to!(u64)));
+
+// atom = 1*ATOM-CHAR
+named!(pub atom<&str>, map_res!(take_while1!(atom_char),
+    str::from_utf8
+));
+
+// astring = 1*ASTRING-CHAR / string
+named!(pub astring<&[u8]>, alt!(
+    take_while1!(astring_char) |
+    string
+));
+
+// astring bytes as as utf8
+named!(pub astring_utf8<&str>, map_res!(astring, str::from_utf8));
+
+// text = 1*TEXT-CHAR
+named!(pub text<&str>, map_res!(take_while!(text_char),
+    str::from_utf8
+));
+
+// TEXT-CHAR = <any CHAR except CR and LF>
+pub fn text_char(c: u8) -> bool {
+    c != b'\r' && c != b'\n'
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_string_literal() {
+        match string(b"{3}\r\nXYZ") {
+            Ok((_, value)) => {
+                assert_eq!(value, b"XYZ");
+            }
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+    }
+
+    #[test]
+    fn test_astring() {
+        match astring(b"text ") {
+            Ok((_, value)) => {
+                assert_eq!(value, b"text");
+            }
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+    }
+}
diff --git a/vendor/imap-proto-0.10.2/src/lib.rs b/vendor/imap-proto-0.10.2/src/lib.rs
new file mode 100644
index 000000000..32b9fef20
--- /dev/null
+++ b/vendor/imap-proto-0.10.2/src/lib.rs
@@ -0,0 +1,77 @@
+#[macro_use]
+extern crate nom;
+
+#[cfg(test)]
+#[macro_use]
+extern crate assert_matches;
+
+#[macro_use]
+mod macros;
+
+pub mod body;
+pub mod body_structure;
+pub mod builders;
+pub mod core;
+mod parser;
+pub mod types;
+
+pub use crate::parser::{parse_response, resp_metadata, ParseResult};
+pub use crate::types::*;
+
+use std::borrow::Cow;
+
+// Returns an escaped string if necessary for use as a "quoted" string per
+// the IMAPv4 RFC. Return value does not include surrounding quote characters.
+// Will return Err if the argument contains illegal characters.
+//
+// Relevant definitions from RFC 3501 formal syntax:
+//
+// string = quoted / literal [literal elided here]
+// quoted = DQUOTE *QUOTED-CHAR DQUOTE
+// QUOTED-CHAR = <any TEXT-CHAR except quoted-specials> / "\" quoted-specials
+// quoted-specials = DQUOTE / "\"
+// TEXT-CHAR = <any CHAR except CR and LF>
+fn quoted_string(s: &str) -> Result<Cow<'_, str>, &'static str> {
+    let bytes = s.as_bytes();
+    let (mut start, mut new) = (0, Vec::<u8>::new());
+    for (i, b) in bytes.iter().enumerate() {
+        match *b {
+            b'\r' | b'\n' => {
+                return Err("CR and LF not allowed in quoted strings");
+            }
+            b'\\' | b'"' => {
+                if start < i {
+                    new.extend(&bytes[start..i]);
+                }
+                new.push(b'\\');
+                new.push(*b);
+                start = i + 1;
+            }
+            _ => {}
+        };
+    }
+    if start == 0 {
+        Ok(Cow::Borrowed(s))
+    } else {
+        if start < bytes.len() {
+            new.extend(&bytes[start..]);
+        }
+        // Since the argument is a str, it must contain valid UTF-8. Since
+        // this function's transformation preserves the UTF-8 validity,
+        // unwrapping here should be okay.
+        Ok(Cow::Owned(String::from_utf8(new).unwrap()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::quoted_string;
+    #[test]
+    fn test_quoted_string() {
+        assert_eq!(quoted_string("a").unwrap(), "a");
+        assert_eq!(quoted_string("").unwrap(), "");
+        assert_eq!(quoted_string("a\"b\\c").unwrap(), "a\\\"b\\\\c");
+        assert_eq!(quoted_string("\"foo\\").unwrap(), "\\\"foo\\\\");
+        assert!(quoted_string("\n").is_err());
+    }
+}
diff --git a/vendor/imap-proto-0.10.2/src/macros.rs b/vendor/imap-proto-0.10.2/src/macros.rs
new file mode 100644
index 000000000..ebf5de4f7
--- /dev/null
+++ b/vendor/imap-proto-0.10.2/src/macros.rs
@@ -0,0 +1,44 @@
+macro_rules! paren_delimited (
+    ($i:expr, $submac:ident!( $($args:tt)* )) => ({
+        delimited!($i, char!('('), $submac!($($args)*), char!(')'))
+    });
+    ($i:expr, $f:expr) => (
+        paren_delimited!($i, call!($f))
+    );
+);
+
+macro_rules! parenthesized_list (
+    ($i:expr, $submac:ident!( $($args:tt)* )) => ({
+        paren_delimited!($i, separated_list!(char!(' '), $submac!($($args)*)))
+    });
+    ($i:expr, $f:expr) => (
+        parenthesized_list!($i, call!($f))
+    );
+);
+
+macro_rules! parenthesized_nonempty_list (
+    ($i:expr, $submac:ident!( $($args:tt)* )) => ({
+        paren_delimited!($i, separated_nonempty_list!(char!(' '), $submac!($($args)*)))
+    });
+    ($i:expr, $f:expr) => (
+        parenthesized_nonempty_list!($i, call!($f))
+    );
+);
+
+macro_rules! opt_opt(
+    ($i:expr, $submac:ident!( $($args:tt)* )) => ({
+        use nom::lib::std::result::Result::*;
+        use nom::lib::std::option::Option::*;
+        use nom::Err;
+
+        let i_ = $i.clone();
+        match $submac!(i_, $($args)*) {
+            Ok((i,o))          => Ok((i, o)),
+            Err(Err::Error(_)) => Ok(($i, None)),
+            Err(e)             => Err(e),
+        }
+    });
+    ($i:expr, $f:expr) => (
+        opt_opt!($i, call!($f))
+    );
+);
diff --git a/vendor/imap-proto-0.10.2/src/parser/mod.rs b/vendor/imap-proto-0.10.2/src/parser/mod.rs
new file mode 100644
index 000000000..fbfb14a87
--- /dev/null
+++ b/vendor/imap-proto-0.10.2/src/parser/mod.rs
@@ -0,0 +1,6 @@
+pub use self::rfc3501::*;
+pub use self::rfc5464::*;
+
+mod rfc3501;
+mod rfc4551;
+mod rfc5464;
diff --git a/vendor/imap-proto-0.10.2/src/parser/rfc3501.rs b/vendor/imap-proto-0.10.2/src/parser/rfc3501.rs
new file mode 100644
index 000000000..0f5161927
--- /dev/null
+++ b/vendor/imap-proto-0.10.2/src/parser/rfc3501.rs
@@ -0,0 +1,871 @@
+//!
+//! https://tools.ietf.org/html/rfc3501
+//!
+//! INTERNET MESSAGE ACCESS PROTOCOL
+//!
+
+// rustfmt doesn't do a very good job on nom parser invocations.
+#![cfg_attr(rustfmt, rustfmt_skip)]
+
+use nom::IResult;
+
+use std::str;
+
+use crate::parser::rfc4551;
+use crate::parser::rfc5464::resp_metadata;
+use crate::types::*;
+use crate::core::*;
+use crate::body::*;
+use crate::body_structure::*;
+
+
+fn tag_char(c: u8) -> bool {
+    c != b'+' && astring_char(c)
+}
+
+named!(status_ok<Status>, map!(tag_no_case!("OK"),
+    |_s| Status::Ok
+));
+named!(status_no<Status>, map!(tag_no_case!("NO"),
+    |_s| Status::No
+));
+named!(status_bad<Status>, map!(tag_no_case!("BAD"),
+    |_s| Status::Bad
+));
+named!(status_preauth<Status>, map!(tag_no_case!("PREAUTH"),
+    |_s| Status::PreAuth
+));
+named!(status_bye<Status>, map!(tag_no_case!("BYE"),
+    |_s| Status::Bye
+));
+
+named!(status<Status>, alt!(
+    status_ok |
+    status_no |
+    status_bad |
+    status_preauth |
+    status_bye
+));
+
+named!(mailbox<&str>, map!(
+    astring_utf8,
+    |s| {
+        if s.eq_ignore_ascii_case("INBOX") {
+            "INBOX"
+        } else {
+            s
+        }
+    }
+));
+
+named!(flag_extension<&str>, map_res!(
+    recognize!(pair!(tag!("\\"), take_while!(atom_char))),
+    str::from_utf8
+));
+
+named!(flag<&str>, alt!(flag_extension | atom));
+
+named!(flag_list<Vec<&str>>, parenthesized_list!(flag));
+
+named!(flag_perm<&str>, alt!(
+    map_res!(tag!("\\*"), str::from_utf8) |
+    flag
+));
+
+named!(resp_text_code_alert<ResponseCode>, do_parse!(
+    tag_no_case!("ALERT") >>
+    (ResponseCode::Alert)
+));
+
+named!(resp_text_code_badcharset<ResponseCode>, do_parse!(
+    tag_no_case!("BADCHARSET") >>
+    ch: opt!(do_parse!(
+        tag!(" ") >>
+        charsets: parenthesized_nonempty_list!(astring_utf8) >>
+        (charsets)
+    )) >>
+    (ResponseCode::BadCharset(ch))
+));
+
+named!(resp_text_code_capability<ResponseCode>, map!(
+    capability_data,
+    |c| ResponseCode::Capabilities(c)
+));
+
+named!(resp_text_code_parse<ResponseCode>, do_parse!(
+    tag_no_case!("PARSE") >>
+    (ResponseCode::Parse)
+));
+
+named!(resp_text_code_permanent_flags<ResponseCode>, do_parse!(
+    tag_no_case!("PERMANENTFLAGS ") >>
+    flags: parenthesized_list!(flag_perm) >>
+    (ResponseCode::PermanentFlags(flags))
+));
+
+named!(resp_text_code_read_only<ResponseCode>, do_parse!(
+    tag_no_case!("READ-ONLY") >>
+    (ResponseCode::ReadOnly)
+));
+
+named!(resp_text_code_read_write<ResponseCode>, do_parse!(
+    tag_no_case!("READ-WRITE") >>
+    (ResponseCode::ReadWrite)
+));
+
+named!(resp_text_code_try_create<ResponseCode>, do_parse!(
+    tag_no_case!("TRYCREATE") >>
+    (ResponseCode::TryCreate)
+));
+
+named!(resp_text_code_uid_validity<ResponseCode>, do_parse!(
+    tag_no_case!("UIDVALIDITY ") >>
+    num: number >>
+    (ResponseCode::UidValidity(num))
+));
+
+named!(resp_text_code_uid_next<ResponseCode>, do_parse!(
+    tag_no_case!("UIDNEXT ") >>
+    num: number >>
+    (ResponseCode::UidNext(num))
+));
+
+named!(resp_text_code_unseen<ResponseCode>, do_parse!(
+    tag_no_case!("UNSEEN ") >>
+    num: number >>
+    (ResponseCode::Unseen(num))
+));
+
+named!(resp_text_code<ResponseCode>, do_parse!(
+    tag!("[") >>
+    coded: alt!(
+        resp_text_code_alert |
+        resp_text_code_badcharset |
+        resp_text_code_capability |
+        resp_text_code_parse |
+        resp_text_code_permanent_flags |
+        resp_text_code_uid_validity |
+        resp_text_code_uid_next |
+        resp_text_code_unseen |
+        resp_text_code_read_only |
+        resp_text_code_read_write |
+        resp_text_code_try_create |
+        rfc4551::resp_text_code_highest_mod_seq
+    ) >>
+    // Per the spec, the closing tag should be "] ".
+    // See `resp_text` for more on why this is done differently.
+    tag!("]") >>
+    (coded)
+));
+
+named!(capability<Capability>, alt!(
+    map!(tag_no_case!("IMAP4rev1"), |_| Capability::Imap4rev1) |
+    map!(preceded!(tag_no_case!("AUTH="), atom), |a| Capability::Auth(a)) |
+    map!(atom, |a| Capability::Atom(a))
+));
+
+fn ensure_capabilities_contains_imap4rev<'a>(capabilities: Vec<Capability<'a>>) -> Result<Vec<Capability<'a>>, ()> {
+    if capabilities.contains(&Capability::Imap4rev1) {
+        Ok(capabilities)
+    } else {
+        Err(())
+    }
+}
+
+named!(capability_data<Vec<Capability>>, map_res!(
+    do_parse!(
+        tag_no_case!("CAPABILITY") >>
+        capabilities: many0!(preceded!(char!(' '), capability)) >>
+        (capabilities)
+    ),
+    ensure_capabilities_contains_imap4rev
+));
+
+named!(resp_capability<Response>, map!(
+    capability_data,
+    |c| Response::Capabilities(c)
+));
+
+named!(mailbox_data_search<Response>, do_parse!(
+    tag_no_case!("SEARCH") >>
+    ids: many0!(do_parse!(
+        tag!(" ") >>
+        id: number >>
+        (id)
+    )) >>
+    (Response::IDs(ids))
+));
+
+named!(mailbox_data_flags<Response>, do_parse!(
+    tag_no_case!("FLAGS ") >>
+    flags: flag_list >>
+    (Response::MailboxData(MailboxDatum::Flags(flags)))
+));
+
+named!(mailbox_data_exists<Response>, do_parse!(
+    num: number >>
+    tag_no_case!(" EXISTS") >>
+    (Response::MailboxData(MailboxDatum::Exists(num)))
+));
+
+named!(mailbox_list<(Vec<&str>, Option<&str>, &str)>, do_parse!(
+    flags: flag_list >>
+    tag!(" ") >>
+    delimiter: alt!(
+        map!(quoted_utf8, |v| Some(v)) |
+        map!(nil, |_| None)
+    ) >>
+    tag!(" ") >>
+    name: mailbox >>
+    ((flags, delimiter, name))
+));
+
+named!(mailbox_data_list<Response>, do_parse!(
+    tag_no_case!("LIST ") >>
+    data: mailbox_list >>
+    (Response::MailboxData(MailboxDatum::List {
+        flags: data.0,
+        delimiter: data.1,
+        name: data.2,
+    }))
+));
+
+named!(mailbox_data_lsub<Response>, do_parse!(
+    tag_no_case!("LSUB ") >>
+    data: mailbox_list >>
+    (Response::MailboxData(MailboxDatum::List {
+        flags: data.0,
+        delimiter: data.1,
+        name: data.2,
+    }))
+));
+
+// Unlike `status_att` in the RFC syntax, this includes the value,
+// so that it can return a valid enum object instead of just a key.
+named!(status_att<StatusAttribute>, alt!(
+    rfc4551::status_att_val_highest_mod_seq |
+    do_parse!(
+        tag_no_case!("MESSAGES ") >>
+        val: number >>
+        (StatusAttribute::Messages(val))
+    ) |
+    do_parse!(
+        tag_no_case!("RECENT ") >>
+        val: number >>
+        (StatusAttribute::Recent(val))
+    ) |
+    do_parse!(
+        tag_no_case!("UIDNEXT ") >>
+        val: number >>
+        (StatusAttribute::UidNext(val))
+    ) |
+    do_parse!(
+        tag_no_case!("UIDVALIDITY ") >>
+        val: number >>
+        (StatusAttribute::UidValidity(val))
+    ) |
+    do_parse!(
+        tag_no_case!("UNSEEN ") >>
+        val: number >>
+        (StatusAttribute::Unseen(val))
+    )
+));
+
+named!(status_att_list<Vec<StatusAttribute>>, parenthesized_nonempty_list!(status_att));
+
+named!(mailbox_data_status<Response>, do_parse!(
+    tag_no_case!("STATUS ") >>
+    mailbox: mailbox >>
+    tag!(" ") >>
+    status: status_att_list >>
+    (Response::MailboxData(MailboxDatum::Status {
+        mailbox,
+        status,
+    }))
+));
+
+named!(mailbox_data_recent<Response>, do_parse!(
+    num: number >>
+    tag_no_case!(" RECENT") >>
+    (Response::MailboxData(MailboxDatum::Recent(num)))
+));
+
+named!(mailbox_data<Response>, alt!(
+    mailbox_data_flags |
+    mailbox_data_exists |
+    mailbox_data_list |
+    mailbox_data_lsub |
+    mailbox_data_status |
+    mailbox_data_recent |
+    mailbox_data_search
+));
+
+// An address structure is a parenthesized list that describes an
+// electronic mail address.
+named!(address<Address>, paren_delimited!(
+    do_parse!(
+        name: nstring >>
+        tag!(" ") >>
+        adl: nstring >>
+        tag!(" ") >>
+        mailbox: nstring >>
+        tag!(" ") >>
+        host: nstring >>
+        (Address {
+            name,
+            adl,
+            mailbox,
+            host,
+        })
+    )
+));
+
+named!(opt_addresses<Option<Vec<Address>>>, alt!(
+    map!(nil, |_s| None) |
+    map!(paren_delimited!(
+        many1!(do_parse!(
+            addr: address >>
+            opt!(char!(' ')) >>
+            (addr)
+        ))
+    ), |v| Some(v))
+));
+
+named!(pub(crate) envelope<Envelope>, paren_delimited!(
+    do_parse!(
+        date: nstring >>
+        tag!(" ") >>
+        subject: nstring >>
+        tag!(" ") >>
+        from: opt_addresses >>
+        tag!(" ") >>
+        sender: opt_addresses >>
+        tag!(" ") >>
+        reply_to: opt_addresses >>
+        tag!(" ") >>
+        to: opt_addresses >>
+        tag!(" ") >>
+        cc: opt_addresses >>
+        tag!(" ") >>
+        bcc: opt_addresses >>
+        tag!(" ") >>
+        in_reply_to: nstring >>
+        tag!(" ") >>
+        message_id: nstring >>
+        (Envelope {
+            date,
+            subject,
+            from,
+            sender,
+            reply_to,
+            to,
+            cc,
+            bcc,
+            in_reply_to,
+            message_id,
+        })
+    )
+));
+
+named!(msg_att_envelope<AttributeValue>, do_parse!(
+    tag_no_case!("ENVELOPE ") >>
+    envelope: envelope >>
+    (AttributeValue::Envelope(Box::new(envelope)))
+));
+
+named!(msg_att_internal_date<AttributeValue>, do_parse!(
+    tag_no_case!("INTERNALDATE ") >>
+    date: nstring_utf8 >>
+    (AttributeValue::InternalDate(date.unwrap()))
+));
+
+named!(msg_att_flags<AttributeValue>, do_parse!(
+    tag_no_case!("FLAGS ") >>
+    flags: flag_list >>
+    (AttributeValue::Flags(flags))
+));
+
+named!(msg_att_rfc822<AttributeValue>, do_parse!(
+    tag_no_case!("RFC822 ") >>
+    raw: nstring >>
+    (AttributeValue::Rfc822(raw))
+));
+
+named!(msg_att_rfc822_header<AttributeValue>, do_parse!(
+    tag_no_case!("RFC822.HEADER ") >>
+    opt!(tag!(" ")) >> // extra space workaround for DavMail
+    raw: nstring >>
+    (AttributeValue::Rfc822Header(raw))
+));
+
+named!(msg_att_rfc822_size<AttributeValue>, do_parse!(
+    tag_no_case!("RFC822.SIZE ") >>
+    num: number >>
+    (AttributeValue::Rfc822Size(num))
+));
+
+named!(msg_att_rfc822_text<AttributeValue>, do_parse!(
+    tag_no_case!("RFC822.TEXT ") >>
+    raw: nstring >>
+    (AttributeValue::Rfc822Text(raw))
+));
+
+named!(msg_att_uid<AttributeValue>, do_parse!(
+    tag_no_case!("UID ") >>
+    num: number >>
+    (AttributeValue::Uid(num))
+));
+
+named!(msg_att<AttributeValue>, alt!(
+    msg_att_body_section |
+    msg_att_body_structure |
+    msg_att_envelope |
+    msg_att_internal_date |
+    msg_att_flags |
+    rfc4551::msg_att_mod_seq |
+    msg_att_rfc822 |
+    msg_att_rfc822_header |
+    msg_att_rfc822_size |
+    msg_att_rfc822_text |
+    msg_att_uid
+));
+
+named!(msg_att_list<Vec<AttributeValue>>, parenthesized_nonempty_list!(msg_att));
+
+named!(message_data_fetch<Response>, do_parse!(
+    num: number >>
+    tag_no_case!(" FETCH ") >>
+    attrs: msg_att_list >>
+    (Response::Fetch(num, attrs))
+));
+
+named!(message_data_expunge<Response>, do_parse!(
+    num: number >>
+    tag_no_case!(" EXPUNGE") >>
+    (Response::Expunge(num))
+));
+
+named!(tag<RequestId>, map!(
+    map_res!(take_while1!(tag_char), str::from_utf8),
+    |s| RequestId(s.to_string())
+));
+
+// This is not quite according to spec, which mandates the following:
+//     ["[" resp-text-code "]" SP] text
+// However, examples in RFC 4551 (Conditional STORE) counteract this by giving
+// examples of `resp-text` that do not include the trailing space and text.
+named!(resp_text<(Option<ResponseCode>, Option<&str>)>, do_parse!(
+    code: opt!(resp_text_code) >>
+    text: text >>
+    ({
+        let res = if text.is_empty() {
+            None
+        } else if code.is_some() {
+            Some(&text[1..])
+        } else {
+            Some(text)
+        };
+        (code, res)
+    })
+));
+
+named!(continue_req<Response>, do_parse!(
+    tag!("+") >>
+    opt!(tag!(" ")) >> // Some servers do not send the space :/
+    text: resp_text >> // TODO: base64
+    tag!("\r\n") >>
+    (Response::Continue {
+        code: text.0,
+        information: text.1,
+    })
+));
+
+named!(response_tagged<Response>, do_parse!(
+    tag: tag >>
+    tag!(" ") >>
+    status: status >>
+    tag!(" ") >>
+    text: resp_text >>
+    tag!("\r\n") >>
+    (Response::Done {
+        tag,
+        status,
+        code: text.0,
+        information: text.1,
+    })
+));
+
+named!(resp_cond<Response>, do_parse!(
+    status: status >>
+    tag!(" ") >>
+    text: resp_text >>
+    (Response::Data {
+        status,
+        code: text.0,
+        information: text.1,
+    })
+));
+
+named!(response_data<Response>, do_parse!(
+    tag!("* ") >>
+    contents: alt!(
+        resp_cond |
+        mailbox_data |
+        message_data_expunge |
+        message_data_fetch |
+        resp_capability |
+        resp_metadata
+    ) >>
+    tag!("\r\n") >>
+    (contents)
+));
+
+named!(response<Response>, alt!(
+    continue_req |
+    response_data |
+    response_tagged
+));
+
+pub type ParseResult<'a> = IResult<&'a [u8], Response<'a>>;
+
+pub fn parse_response(msg: &[u8]) -> ParseResult<'_> {
+    response(msg)
+}
+
+
+#[cfg(test)]
+mod tests {
+    use nom;
+    use super::parse_response;
+    use crate::types::*;
+
+    #[test]
+    fn test_number_overflow() {
+        match parse_response(b"* 2222222222222222222222222222222222222222222C\r\n") {
+            Err(_) => {},
+            _ => panic!("error required for integer overflow"),
+        }
+    }
+
+    #[test]
+    fn test_unseen() {
+        match parse_response(b"* OK [UNSEEN 3] Message 3 is first unseen\r\n").unwrap() {
+            (_, Response::Data {
+                status: Status::Ok,
+                code: Some(ResponseCode::Unseen(3)),
+                information: Some("Message 3 is first unseen"),
+            }) => {},
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+    }
+
+    #[test]
+    fn test_body_text() {
+        match parse_response(b"* 2 FETCH (BODY[TEXT] {3}\r\nfoo)\r\n") {
+            Ok((_, Response::Fetch(_, attrs))) => {
+                let body = &attrs[0];
+                assert_eq!(body, &AttributeValue::BodySection {
+                    section: Some(SectionPath::Full(MessageSection::Text)),
+                    index: None,
+                    data: Some(b"foo"),
+                }, "body = {:?}", body);
+            },
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+    }
+
+    #[test]
+    fn test_body_structure() {
+        const RESPONSE: &[u8] = b"* 15 FETCH (BODYSTRUCTURE (\"TEXT\" \"PLAIN\" (\"CHARSET\" \"iso-8859-1\") NIL NIL \"QUOTED-PRINTABLE\" 1315 42 NIL NIL NIL NIL))\r\n";
+        match parse_response(RESPONSE) {
+            Ok((_, Response::Fetch(_, attrs))) => {
+                let body = &attrs[0];
+                assert!(if let AttributeValue::BodyStructure(_) = *body { true } else { false }, "body = {:?}", body);
+            },
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+    }
+
+    #[test]
+    fn test_status() {
+        match parse_response(b"* STATUS blurdybloop (MESSAGES 231 UIDNEXT 44292)\r\n") {
+            Ok((_, Response::MailboxData(MailboxDatum::Status { mailbox, status }))) => {
+                assert_eq!(mailbox, "blurdybloop");
+                assert_eq!(status, [
+                    StatusAttribute::Messages(231),
+                    StatusAttribute::UidNext(44292),
+                ]);
+            },
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+    }
+
+    #[test]
+    fn test_notify() {
+        match parse_response(b"* 3501 EXPUNGE\r\n") {
+            Ok((_, Response::Expunge(3501))) => {},
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+        match parse_response(b"* 3501 EXISTS\r\n") {
+            Ok((_, Response::MailboxData(MailboxDatum::Exists(3501)))) => {},
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+        match parse_response(b"+ idling\r\n") {
+            Ok((_, Response::Continue { code: None, information: Some("idling") })) => {},
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+    }
+
+    #[test]
+    fn test_search() {
+        match parse_response(b"* SEARCH\r\n") {
+            Ok((_, Response::IDs(ids))) => {
+                assert!(ids.is_empty());
+            },
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+        match parse_response(b"* SEARCH 12345 67890\r\n") {
+            Ok((_, Response::IDs(ids))) => {
+                assert_eq!(ids[0], 12345);
+                assert_eq!(ids[1], 67890);
+            },
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+    }
+
+    #[test]
+    fn test_uid_fetch() {
+        match parse_response(b"* 4 FETCH (UID 71372 RFC822.HEADER {10275}\r\n") {
+            Err(nom::Err::Incomplete(nom::Needed::Size(10275))) => {},
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+    }
+
+    #[test]
+    fn test_list() {
+        match crate::parser::rfc3501::mailbox(b"iNboX ") {
+            Ok((_, mb)) => {
+                assert_eq!(mb, "INBOX");
+            },
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+
+        match parse_response(b"* LIST (\\HasNoChildren) \".\" INBOX.Tests\r\n") {
+            Ok((_, Response::MailboxData(_))) => {},
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+    }
+
+    #[test]
+    fn test_uid_fetch_extra_space() {
+        // DavMail inserts an extra space after RFC822.HEADER
+        match parse_response(b"* 4 FETCH (UID 71372 RFC822.HEADER  {10275}\r\n") {
+            Err(nom::Err::Incomplete(nom::Needed::Size(10275))) => {},
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+    }
+
+    #[test]
+    fn test_envelope() {
+        let env = br#"ENVELOPE ("Wed, 17 Jul 1996 02:23:25 -0700 (PDT)" "IMAP4rev1 WG mtg summary and minutes" (("Terry Gray" NIL "gray" "cac.washington.edu")) (("Terry Gray" NIL "gray" "cac.washington.edu")) (("Terry Gray" NIL "gray" "cac.washington.edu")) ((NIL NIL "imap" "cac.washington.edu")) ((NIL NIL "minutes" "CNRI.Reston.VA.US") ("John Klensin" NIL "KLENSIN" "MIT.EDU")) NIL NIL "<B27397-0100000@cac.washington.edu>") "#;
+        match crate::parser::rfc3501::msg_att_envelope(env) {
+            Ok((_, AttributeValue::Envelope(_))) => {},
+            rsp => panic!("unexpected response {:?}", rsp)
+        }
+    }
+
+    #[test]
+    fn test_header_fields() {
+        const RESPONSE: &[u8] = b"* 1 FETCH (UID 1 BODY[HEADER.FIELDS (CHAT-VERSION)] {21}\r\nChat-Version: 1.0\r\n\r\n)\r\n";
+
+        match parse_response(RESPONSE) {
+            Ok((_, Response::Fetch(_, _))) => {},
+            rsp => panic!("unexpected response {:?}", rsp),
+        }
+    }
+
+    #[test]
+    fn test_opt_addresses() {
+        let addr = b"((NIL NIL \"minutes\" \"CNRI.Reston.VA.US\") (\"John Klensin\" NIL \"KLENSIN\" \"MIT.EDU\")) ";
+            match crate::parser::rfc3501::opt_addresses(addr) {
+            Ok((_, _addresses)) => {},
+            rsp => panic!("unexpected response {:?}", rsp)
+        }
+    }
+
+    #[test]
+    fn test_opt_addresses_no_space() {
+        let addr = br#"((NIL NIL "test" "example@example.com")(NIL NIL "test" "example@example.com"))"#;
+            match super::opt_addresses(addr) {
+            Ok((_, _addresses)) => {},
+            rsp => panic!("unexpected response {:?}", rsp)
+        }
+    }
+
+    #[test]
+    fn test_addresses() {
+        match crate::parser::rfc3501::address(b"(\"John Klensin\" NIL \"KLENSIN\" \"MIT.EDU\") ") {
+            Ok((_, _address)) => {},
+            rsp => panic!("unexpected response {:?}", rsp)
+        }
+
+        // Literal non-UTF8 address
+        match crate::parser::rfc3501::address(b"({12}\r\nJoh\xff Klensin NIL \"KLENSIN\" \"MIT.EDU\") ") {
+            Ok((_, _address)) => {},
+            rsp => panic!("unexpected response {:?}", rsp)
+        }
+    }
+
+    #[test]
+    fn test_response_codes() {
+        match parse_response(b"* OK [ALERT] Alert!\r\n") {
+            Ok((_, Response::Data { status: Status::Ok, code: Some(ResponseCode::Alert), information: Some("Alert!") })) => {}
+            rsp => panic!("unexpected response {:?}", rsp)
+        }
+
+        match parse_response(b"* NO [PARSE] Something\r\n") {
+            Ok((_, Response::Data { status: Status::No, code: Some(ResponseCode::Parse), information: Some("Something") })) => {}
+            rsp => panic!("unexpected response {:?}", rsp)
+        }
+
+        match parse_response(b"* OK [CAPABILITY IMAP4rev1 IDLE] Logged in\r\n") {
+            Ok((_, Response::Data {
+                status: Status::Ok,
+                code: Some(ResponseCode::Capabilities(c)),
+                information: Some("Logged in")
+            })) => {
+                assert_eq!(c.len(), 2);
+                assert_eq!(c[0], Capability::Imap4rev1);
+                assert_eq!(c[1], Capability::Atom("IDLE"));
+            }
+            rsp => panic!("unexpected response {:?}", rsp)
+        }
+
+        match parse_response(b"* OK [CAPABILITY UIDPLUS IMAP4rev1 IDLE] Logged in\r\n") {
+            Ok((_, Response::Data {
+                status: Status::Ok,
+                code: Some(ResponseCode::Capabilities(c)),
+                information: Some("Logged in")
+            })) => {
+                assert_eq!(c.len(), 3);
+                assert_eq!(c[0], Capability::Atom("UIDPLUS"));
+                assert_eq!(c[1], Capability::Imap4rev1);
+                assert_eq!(c[2], Capability::Atom("IDLE"));
+            }
+            rsp => panic!("unexpected response {:?}", rsp)
+        }
+
+        // Missing IMAP4rev1
+        match parse_response(b"* OK [CAPABILITY UIDPLUS IDLE] Logged in\r\n") {
+            Ok((_, Response::Data {
+                status: Status::Ok,
+                code: None,
+                information: Some("[CAPABILITY UIDPLUS IDLE] Logged in")
+            })) => {}
+            rsp => panic!("unexpected response {:?}", rsp)
+        }
+
+        match parse_response(b"* NO [BADCHARSET] error\r\n") {
+            Ok((_, Response::Data {
+                status: Status::No,
+                code: Some(ResponseCode::BadCharset(None)),
+                information: Some("error")
+            })) => {},
+            rsp => panic!("unexpected response {:?}", rsp)
+        }
+
+        match parse_response(b"* NO [BADCHARSET (utf-8 latin1)] error\r\n") {
+            Ok((_, Response::Data {
+                status: Status::No,
+                code: Some(ResponseCode::BadCharset(Some(v))),
+                information: Some("error")
+            })) => {
+                assert_eq!(v.len(), 2);
+                assert_eq!(v[0], "utf-8");
+                assert_eq!(v[1], "latin1");
+            },
+            rsp => panic!("unexpected response {:?}", rsp)
+        }
+
+        match parse_response(b"* NO [BADCHARSET ()] error\r\n") {
+            Ok((_, Response::Data {
+                status: Status::No,
+                code: None,
+                information: Some("[BADCHARSET ()] error")
+            })) => {}
+            rsp => panic!("unexpected response {:?}", rsp)
+        }
+    }
+
+    #[test]
+    fn test_capability_data() {
+        // Minimal capabilities
+        assert_matches!(
+            super::capability_data(b"CAPABILITY IMAP4rev1\r\n"),
+            Ok((_, capabilities)) => {
+                assert_eq!(capabilities, vec![Capability::Imap4rev1])
+            }
+        );
+
+        assert_matches!(
+            super::capability_data(b"CAPABILITY IMAP4REV1\r\n"),
+            Ok((_, capabilities)) => {
+                assert_eq!(capabilities, vec![Capability::Imap4rev1])
+            }
+        );
+
+        assert_matches!(
+            super::capability_data(b"CAPABILITY XPIG-LATIN IMAP4rev1 STARTTLS AUTH=GSSAPI\r\n"),
+            Ok((_, capabilities)) => {
+                assert_eq!(capabilities, vec![
+                    Capability::Atom("XPIG-LATIN"), Capability::Imap4rev1,
+                    Capability::Atom("STARTTLS"), Capability::Auth("GSSAPI")
+                ])
+            }
+        );
+
+        assert_matches!(
+            super::capability_data(b"CAPABILITY IMAP4rev1 AUTH=GSSAPI AUTH=PLAIN\r\n"),
+            Ok((_, capabilities)) => {
+                assert_eq!(capabilities, vec![
+                    Capability::Imap4rev1, Capability::Auth("GSSAPI"),  Capability::Auth("PLAIN")
+                ])
+            }
+        );
+
+        // Capability command must contain IMAP4rev1
+        assert_matches!(
+            super::capability_data(b"CAPABILITY AUTH=GSSAPI AUTH=PLAIN\r\n"),
+            Err(_)
+        );
+    }
+
+    #[test]
+    fn test_incomplete_fetch() {
+        match parse_response(b"* 4644 FETCH (UID ") {
+            Err(nom::Err::Incomplete(_)) => {},
+            rsp => panic!("should be incomplete: {:?}", rsp),
+        }
+    }
+
+    #[test]
+    fn test_continuation() {
+        // regular RFC compliant
+        match parse_response(b"+ \r\n") {
+            Ok((_, Response::Continue {
+                code: None,
+                information: None,
+            })) => {}
+            rsp => panic!("unexpected response {:?}", rsp)
+        }
+
+        // short version, sent by yandex
+        match parse_response(b"+\r\n") {
+            Ok((_, Response::Continue {
+                code: None,
+                information: None,
+            })) => {}
+            rsp => panic!("unexpected response {:?}", rsp)
+        }
+    }
+}
diff --git a/vendor/imap-proto-0.10.2/src/parser/rfc4551.rs b/vendor/imap-proto-0.10.2/src/parser/rfc4551.rs
new file mode 100644
index 000000000..8be595fa2
--- /dev/null
+++ b/vendor/imap-proto-0.10.2/src/parser/rfc4551.rs
@@ -0,0 +1,38 @@
+//!
+//! https://tools.ietf.org/html/rfc4551
+//!
+//! IMAP Extension for Conditional STORE Operation
+//! or Quick Flag Changes Resynchronization
+//!
+
+// rustfmt doesn't do a very good job on nom parser invocations.
+#![cfg_attr(rustfmt, rustfmt_skip)]
+
+use crate::core::number_64;
+use crate::types::*;
+
+// The highest mod-sequence value of all messages in the mailbox.
+// Extends resp-test-code defined in rfc3501.
+// [RFC4551 - 3.6 HIGHESTMODSEQ Status Data Items](https://tools.ietf.org/html/rfc4551#section-3.6)
+// [RFC4551 - 4. Formal Syntax - resp-text-code](https://tools.ietf.org/html/rfc4551#section-4)
+named!(pub (crate) resp_text_code_highest_mod_seq<ResponseCode>, do_parse!(
+    tag_no_case!("HIGHESTMODSEQ ") >>
+    num: number_64 >>
+    (ResponseCode::HighestModSeq(num))
+));
+
+// Extends status-att/status-att-list defined in rfc3501
+// [RFC4551 - 3.6 - HIGHESTMODSEQ Status Data Items](https://tools.ietf.org/html/rfc4551#section-3.6)
+// [RFC4551 - 4. Formal Syntax - status-att-val](https://tools.ietf.org/html/rfc4551#section-4)
+named!(pub (crate) status_att_val_highest_mod_seq<StatusAttribute>, do_parse!(
+    tag_no_case!("HIGHESTMODSEQ ") >>
+    mod_sequence_valzer: number_64 >>
+    (StatusAttribute::HighestModSeq(mod_sequence_valzer))
+));
+
+// [RFC4551 - 4. Formal Syntax - fetch-mod-resp](https://tools.ietf.org/html/rfc4551#section-4)
+named!(pub (crate) msg_att_mod_seq<AttributeValue>, do_parse!(
+    tag_no_case!("MODSEQ ") >>
+    num: paren_delimited!(number_64) >>
+    (AttributeValue::ModSeq(num))
+));
diff --git a/vendor/imap-proto-0.10.2/src/parser/rfc5464.rs b/vendor/imap-proto-0.10.2/src/parser/rfc5464.rs
new file mode 100644
index 000000000..dccb5fd9a
--- /dev/null
+++ b/vendor/imap-proto-0.10.2/src/parser/rfc5464.rs
@@ -0,0 +1,293 @@
+//!
+//! https://tools.ietf.org/html/rfc5464
+//!
+//! IMAP METADATA extension
+//!
+
+// rustfmt doesn't do a very good job on nom parser invocations.
+#![cfg_attr(rustfmt, rustfmt_skip)]
+
+use nom::IResult;
+
+use crate::core::*;
+use crate::types::*;
+use std::str;
+
+fn is_entry_component_char(c: u8) -> bool {
+    c < 0x80 && c > 0x19 && c != b'*' && c != b'%' && c != b'/'
+}
+
+enum EntryParseStage<'a> {
+    PrivateShared,
+    Admin(usize),
+    VendorComment(usize),
+    Path(usize),
+    Done(usize),
+    Fail(nom::Err<&'a [u8]>),
+}
+
+fn check_private_shared(i: &[u8]) -> EntryParseStage<'_> {
+    if i.starts_with(b"/private") {
+        EntryParseStage::VendorComment(8)
+    } else if i.starts_with(b"/shared") {
+        EntryParseStage::Admin(7)
+    } else {
+        EntryParseStage::Fail(nom::Err::Error(
+            b"Entry Name doesn't start with /private or /shared",
+        ))
+    }
+}
+
+fn check_admin(i: &[u8], l: usize) -> EntryParseStage<'_> {
+    if i[l..].starts_with(b"/admin") {
+        EntryParseStage::Path(l + 6)
+    } else {
+        EntryParseStage::VendorComment(l)
+    }
+}
+
+fn check_vendor_comment(i: &[u8], l: usize) -> EntryParseStage<'_> {
+    if i[l..].starts_with(b"/comment") {
+        EntryParseStage::Path(l + 8)
+    } else if i[l..].starts_with(b"/vendor") {
+        //make sure vendor name is present
+        if i.len() < l + 9 || i[l + 7] != b'/' || !is_entry_component_char(i[l + 8]) {
+            EntryParseStage::Fail(nom::Err::Incomplete(nom::Needed::Unknown))
+        } else {
+            EntryParseStage::Path(l + 7)
+        }
+    } else {
+        EntryParseStage::Fail(nom::Err::Error(
+            b"Entry name is not continued with /admin, /vendor or /comment",
+        ))
+    }
+}
+
+fn check_path(i: &[u8], l: usize) -> EntryParseStage<'_> {
+    if i.len() == l || i[l] == b' ' || i[l] == b'\r' {
+        return EntryParseStage::Done(l);
+    } else if i[l] != b'/' {
+        return EntryParseStage::Fail(nom::Err::Error(b"Entry name path is corrupted"));
+    }
+    for j in 1..(i.len() - l) {
+        if !is_entry_component_char(i[l + j]) {
+            return EntryParseStage::Path(l + j);
+        }
+    }
+    EntryParseStage::Done(i.len())
+}
+
+fn check_entry_name(i: &[u8]) -> IResult<&[u8], &[u8]> {
+    let mut stage = EntryParseStage::PrivateShared;
+    loop {
+        match stage {
+            EntryParseStage::PrivateShared => {
+                stage = check_private_shared(i);
+            }
+            EntryParseStage::Admin(l) => {
+                stage = check_admin(i, l);
+            }
+            EntryParseStage::VendorComment(l) => {
+                stage = check_vendor_comment(i, l);
+            }
+            EntryParseStage::Path(l) => {
+                stage = check_path(i, l);
+            }
+            EntryParseStage::Done(l) => {
+                return Ok((&i[l..], &i[..l]));
+            }
+            EntryParseStage::Fail(nom::Err::Error(err_msg)) => {
+                return std::result::Result::Err(nom::Err::Error((
+                    err_msg,
+                    nom::error::ErrorKind::Verify,
+                )));
+            }
+            EntryParseStage::Fail(nom::Err::Incomplete(reason)) => {
+                return std::result::Result::Err(nom::Err::Incomplete(reason));
+            }
+            _ => panic!("Entry name verification failure"),
+        }
+    }
+}
+
+fn entry_name(i: &[u8]) -> IResult<&[u8], &[u8]> {
+    let astring_res = astring(i)?;
+    check_entry_name(astring_res.1)?;
+    Ok(astring_res)
+}
+
+fn slice_to_str(i: &[u8]) -> &str {
+    str::from_utf8(i).unwrap()
+}
+
+named!(nil_value<Option<String>>, do_parse!(
+    tag_no_case!("NIL") >>
+        (None)
+));
+
+named!(string_value<Option<String>>, do_parse!(
+    value: map!(alt!(quoted | literal), slice_to_str) >>
+        (Some(value.to_string()))
+));
+
+named!(keyval_list<Vec<Metadata>>, do_parse!(
+    list: parenthesized_nonempty_list!(do_parse!(
+        key: map!(entry_name, slice_to_str) >>
+            tag!(" ") >>
+            value: alt!(nil_value | string_value) >>
+            (Metadata{entry: key.to_string(), value})
+    )) >>
+        (list)
+));
+
+named!(entry_list<Vec<&str>>, do_parse!(
+    list: separated_list!(tag!(" "), map!(entry_name, slice_to_str)) >>
+        (list)
+));
+
+named!(metadata_common<&[u8]>, do_parse!(
+    tag_no_case!("METADATA ") >>
+        mbox: quoted >>
+        tag!(" ") >>
+        (mbox)
+));
+
+// [RFC5464 - 4.4.1 METADATA Response with values]
+named!(metadata_solicited<Response>, do_parse!(
+    mbox: metadata_common >>
+    tail: keyval_list >>
+        (Response::MailboxData(MailboxDatum::MetadataSolicited {
+            mailbox:slice_to_str(mbox), values:tail
+        }))
+));
+
+// [RFC5464 - 4.4.2 Unsolicited METADATA Response without values]
+named!(metadata_unsolicited<Response>, do_parse!(
+    mbox: metadata_common >>
+        tail: entry_list >>
+        (Response::MailboxData(MailboxDatum::MetadataUnsolicited {
+            mailbox:slice_to_str(mbox), values:tail
+        }))
+));
+
+// Parse solicited or unsolicited METADATA response.
+named!(pub resp_metadata<Response>, do_parse!(
+    r: alt!(metadata_solicited |
+            metadata_unsolicited) >>
+        (r)
+));
+
+#[cfg(test)]
+mod tests {
+    use super::{metadata_solicited, metadata_unsolicited};
+    use crate::types::*;
+
+    #[test]
+    fn test_solicited_fail_1() {
+        match metadata_solicited(b"METADATA \"\" (/asdfg \"asdf\")\r\n") {
+            Err(_) => {}
+            _ => panic!("Error required when entry name is not starting with /private or /shared"),
+        }
+    }
+
+    #[test]
+    fn test_solicited_fail_2() {
+        match metadata_solicited(b"METADATA \"\" (/shared/asdfg \"asdf\")\r\n") {
+            Err(_) => {}
+            _ => panic!(
+                "Error required when in entry name /shared \
+                 is not continued with /admin, /comment or /vendor"
+            ),
+        }
+    }
+
+    #[test]
+    fn test_solicited_fail_3() {
+        match metadata_solicited(b"METADATA \"\" (/private/admin \"asdf\")\r\n") {
+            Err(_) => {}
+            _ => panic!(
+                "Error required when in entry name /private \
+                 is not continued with /comment or /vendor"
+            ),
+        }
+    }
+
+    #[test]
+    fn test_solicited_fail_4() {
+        match metadata_solicited(b"METADATA \"\" (/shared/vendor \"asdf\")\r\n") {
+            Err(_) => {}
+            _ => panic!("Error required when vendor name is not provided."),
+        }
+    }
+
+    #[test]
+    fn test_solicited_success() {
+        match metadata_solicited(
+            b"METADATA \"mbox\" (/shared/vendor/vendorname \"asdf\" \
+              /private/comment/a \"bbb\")\r\n",
+        ) {
+            Ok((i, Response::MailboxData(MailboxDatum::MetadataSolicited { mailbox, values }))) => {
+                assert_eq!(mailbox, "mbox");
+                assert_eq!(i, b"\r\n");
+                assert_eq!(values.len(), 2);
+                assert_eq!(values[0].entry, "/shared/vendor/vendorname");
+                assert_eq!(
+                    values[0]
+                        .value
+                        .as_ref()
+                        .expect("None value is not expected"),
+                    "asdf"
+                );
+                assert_eq!(values[1].entry, "/private/comment/a");
+                assert_eq!(
+                    values[1]
+                        .value
+                        .as_ref()
+                        .expect("None value is not expected"),
+                    "bbb"
+                );
+            }
+            _ => panic!("Correct METADATA response is not parsed properly."),
+        }
+    }
+
+    #[test]
+    fn test_literal_success() {
+        // match metadata_solicited(b"METADATA \"\" (/shared/vendor/vendor.coi/a \"AAA\")\r\n")
+        match metadata_solicited(b"METADATA \"\" (/shared/vendor/vendor.coi/a {3}\r\nAAA)\r\n") {
+            Ok((i, Response::MailboxData(MailboxDatum::MetadataSolicited { mailbox, values }))) => {
+                assert_eq!(mailbox, "");
+                assert_eq!(i, b"\r\n");
+                assert_eq!(values.len(), 1);
+                assert_eq!(values[0].entry, "/shared/vendor/vendor.coi/a");
+                assert_eq!(
+                    values[0]
+                        .value
+                        .as_ref()
+                        .expect("None value is not expected"),
+                    "AAA"
+                );
+            }
+            Err(e) => panic!("ERR: {:?}", e),
+            _ => panic!("Strange failure"),
+        }
+    }
+
+    #[test]
+    fn test_unsolicited_success() {
+        match metadata_unsolicited(b"METADATA \"theBox\" /shared/admin/qwe /private/comment/a\r\n")
+        {
+            Ok((
+                i,
+                Response::MailboxData(MailboxDatum::MetadataUnsolicited { mailbox, values }),
+            )) => {
+                assert_eq!(i, b"\r\n");
+                assert_eq!(mailbox, "theBox");
+                assert_eq!(values.len(), 2);
+                assert_eq!(values[0], "/shared/admin/qwe");
+                assert_eq!(values[1], "/private/comment/a");
+            }
+            _ => panic!("Correct METADATA response is not parsed properly."),
+        }
+    }
+}
diff --git a/vendor/imap-proto-0.10.2/src/types.rs b/vendor/imap-proto-0.10.2/src/types.rs
new file mode 100644
index 000000000..6ca930b24
--- /dev/null
+++ b/vendor/imap-proto-0.10.2/src/types.rs
@@ -0,0 +1,270 @@
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Request(pub RequestId, pub Vec<u8>);
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum AttrMacro {
+    All,
+    Fast,
+    Full,
+}
+
+impl Copy for AttrMacro {}
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum Response<'a> {
+    Capabilities(Vec<Capability<'a>>),
+    Continue {
+        code: Option<ResponseCode<'a>>,
+        information: Option<&'a str>,
+    },
+    Done {
+        tag: RequestId,
+        status: Status,
+        code: Option<ResponseCode<'a>>,
+        information: Option<&'a str>,
+    },
+    Data {
+        status: Status,
+        code: Option<ResponseCode<'a>>,
+        information: Option<&'a str>,
+    },
+    Expunge(u32),
+    Fetch(u32, Vec<AttributeValue<'a>>),
+    MailboxData(MailboxDatum<'a>),
+    IDs(Vec<u32>),
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum Status {
+    Ok,
+    No,
+    Bad,
+    PreAuth,
+    Bye,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum ResponseCode<'a> {
+    Alert,
+    BadCharset(Option<Vec<&'a str>>),
+    Capabilities(Vec<Capability<'a>>),
+    HighestModSeq(u64), // RFC 4551, section 3.1.1
+    Parse,
+    PermanentFlags(Vec<&'a str>),
+    ReadOnly,
+    ReadWrite,
+    TryCreate,
+    UidNext(u32),
+    UidValidity(u32),
+    Unseen(u32),
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum StatusAttribute {
+    HighestModSeq(u64), // RFC 4551
+    Messages(u32),
+    Recent(u32),
+    UidNext(u32),
+    UidValidity(u32),
+    Unseen(u32),
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct Metadata {
+    pub entry: String,
+    pub value: Option<String>,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum MailboxDatum<'a> {
+    Exists(u32),
+    Flags(Vec<&'a str>),
+    List {
+        flags: Vec<&'a str>,
+        delimiter: Option<&'a str>,
+        name: &'a str,
+    },
+    Status {
+        mailbox: &'a str,
+        status: Vec<StatusAttribute>,
+    },
+    Recent(u32),
+    MetadataSolicited {
+        mailbox: &'a str,
+        values: Vec<Metadata>,
+    },
+    MetadataUnsolicited {
+        mailbox: &'a str,
+        values: Vec<&'a str>,
+    },
+}
+
+#[derive(Debug, Eq, PartialEq, Hash)]
+pub enum Capability<'a> {
+    Imap4rev1,
+    Auth(&'a str),
+    Atom(&'a str),
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum Attribute {
+    Body,
+    Envelope,
+    Flags,
+    InternalDate,
+    ModSeq, // RFC 4551, section 3.3.2
+    Rfc822,
+    Rfc822Size,
+    Rfc822Text,
+    Uid,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum MessageSection {
+    Header,
+    Mime,
+    Text,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum SectionPath {
+    Full(MessageSection),
+    Part(Vec<u32>, Option<MessageSection>),
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Debug, Eq, PartialEq)]
+pub enum AttributeValue<'a> {
+    BodySection {
+        section: Option<SectionPath>,
+        index: Option<u32>,
+        data: Option<&'a [u8]>,
+    },
+    BodyStructure(BodyStructure<'a>),
+    Envelope(Box<Envelope<'a>>),
+    Flags(Vec<&'a str>),
+    InternalDate(&'a str),
+    ModSeq(u64), // RFC 4551, section 3.3.2
+    Rfc822(Option<&'a [u8]>),
+    Rfc822Header(Option<&'a [u8]>),
+    Rfc822Size(u32),
+    Rfc822Text(Option<&'a [u8]>),
+    Uid(u32),
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Debug, Eq, PartialEq)]
+pub enum BodyStructure<'a> {
+    Basic {
+        common: BodyContentCommon<'a>,
+        other: BodyContentSinglePart<'a>,
+        extension: Option<BodyExtension<'a>>,
+    },
+    Text {
+        common: BodyContentCommon<'a>,
+        other: BodyContentSinglePart<'a>,
+        lines: u32,
+        extension: Option<BodyExtension<'a>>,
+    },
+    Message {
+        common: BodyContentCommon<'a>,
+        other: BodyContentSinglePart<'a>,
+        envelope: Envelope<'a>,
+        body: Box<BodyStructure<'a>>,
+        lines: u32,
+        extension: Option<BodyExtension<'a>>,
+    },
+    Multipart {
+        common: BodyContentCommon<'a>,
+        bodies: Vec<BodyStructure<'a>>,
+        extension: Option<BodyExtension<'a>>,
+    },
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct BodyContentCommon<'a> {
+    pub ty: ContentType<'a>,
+    pub disposition: Option<ContentDisposition<'a>>,
+    pub language: Option<Vec<&'a str>>,
+    pub location: Option<&'a str>,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct BodyContentSinglePart<'a> {
+    pub id: Option<&'a str>,
+    pub md5: Option<&'a str>,
+    pub description: Option<&'a str>,
+    pub transfer_encoding: ContentEncoding<'a>,
+    pub octets: u32,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct ContentType<'a> {
+    pub ty: &'a str,
+    pub subtype: &'a str,
+    pub params: BodyParams<'a>,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct ContentDisposition<'a> {
+    pub ty: &'a str,
+    pub params: BodyParams<'a>,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum ContentEncoding<'a> {
+    SevenBit,
+    EightBit,
+    Binary,
+    Base64,
+    QuotedPrintable,
+    Other(&'a str),
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum BodyExtension<'a> {
+    Num(u32),
+    Str(Option<&'a str>),
+    List(Vec<BodyExtension<'a>>),
+}
+
+pub type BodyParams<'a> = Option<Vec<(&'a str, &'a str)>>;
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct Envelope<'a> {
+    pub date: Option<&'a [u8]>,
+    pub subject: Option<&'a [u8]>,
+    pub from: Option<Vec<Address<'a>>>,
+    pub sender: Option<Vec<Address<'a>>>,
+    pub reply_to: Option<Vec<Address<'a>>>,
+    pub to: Option<Vec<Address<'a>>>,
+    pub cc: Option<Vec<Address<'a>>>,
+    pub bcc: Option<Vec<Address<'a>>>,
+    pub in_reply_to: Option<&'a [u8]>,
+    pub message_id: Option<&'a [u8]>,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct Address<'a> {
+    pub name: Option<&'a [u8]>,
+    pub adl: Option<&'a [u8]>,
+    pub mailbox: Option<&'a [u8]>,
+    pub host: Option<&'a [u8]>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RequestId(pub String);
+
+impl RequestId {
+    pub fn as_bytes(&self) -> &[u8] {
+        self.0.as_bytes()
+    }
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum State {
+    NotAuthenticated,
+    Authenticated,
+    Selected,
+    Logout,
+}