feat: parallel KB queries, morning brief, self-assessment, cross-KB synthesis, autonomy config

Performance: kb query-all queries all registered KBs concurrently via
asyncio.gather(), reducing pulse time from ~7 min to ~80s with 6 KBs.
Pulse prompt updated to use kb query-all instead of sequential iteration.

Proactive: morning brief (adjutant brief) compiles daily summary with
deadlines, priorities, and KB status into a phone-readable notification.
Self-assessment (adjutant self-assess) weekly introspection evaluating
notification effectiveness and proposing priority/behaviour changes to
insights/pending/ for user review.

Cross-KB: kb cross-query queries multiple KBs in parallel then synthesizes
a unified cross-domain answer via a synthesis prompt.

Autonomy: graduated autonomy config (levels 1-4) with auto_approve and
require_approval lists for fine-grained control over autonomous actions.

16 new tests, all 1358 existing tests still passing.

Author: eddiman

CHANGELOG.md

@@ -7,12 +7,17 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ---
 
-## [Unreleased] — Post-0.1.0 Hardening
+## [0.2.0] — Unreleased — Post-0.1.0 Hardening
 
 Comprehensive code quality, type safety, and security hardening pass driven by full deployment readiness audit.
 
 ### Added
 
+- **Parallel KB queries** — `adjutant kb query-all` queries all registered KBs concurrently via `asyncio.gather()`, reducing pulse time from ~7 min to ~80s with 6 KBs. Uses each KB's `query_hint` for targeted questions. (`capabilities/kb/query.py`, `cli.py`)
+- **Cross-KB synthesis** — `adjutant kb cross-query "question" --kbs a,b` queries multiple KBs in parallel, then synthesizes a unified cross-domain answer via a synthesis prompt. (`capabilities/kb/query.py`, `cli.py`)
+- **Morning brief** — `adjutant brief` proactive daily summary combining KB status, deadlines, pending insights, and priority alignment. Designed for phone readability (<800 chars). (`prompts/morning_brief.md`, `lifecycle/cron.py`, `cli.py`)
+- **Self-assessment** — `adjutant self-assess` weekly introspection evaluating notification effectiveness, priority alignment, and KB health. Proposes changes to `insights/pending/` for user review — never modifies identity files directly. (`prompts/self_assess.md`, `lifecycle/cron.py`, `cli.py`)
+- **Graduated autonomy config** — `autonomy` section in `adjutant.yaml` with levels 1-4 (notify-only → fully autonomous), `auto_approve` and `require_approval` lists. (`core/config.py`)
 - **Active operation tracking** — pulse and review write `state/active_operation.json` while running, allowing external clients to observe operation state without holding open connections. Staleness detection auto-cleans markers older than 30 minutes with dead PIDs. (`core/lockfiles.py`, `lifecycle/cron.py`)
 - **Post-completion notifications** — after a successful pulse or review, a Telegram notification is sent with a summary of KBs checked, issues found, and escalation status. Budget-guarded, best-effort. (`lifecycle/cron.py`)
 - Active operation markers for Telegram `/pulse` and `/reflect` → `/confirm` paths (`messaging/telegram/commands.py`)
@@ -143,7 +148,7 @@ Complete rewrite from bash to Python. New architecture, new capabilities, compre
 
 - `.github/workflows/release.yml` — tag-triggered release workflow with tarball + checksum
 - `VERSION` file as source of truth
-- Docusaurus documentation site (`adjutant-docs`)
+- Docusaurus documentation site (`site/`)
 
 ---
 

docs/guides/commands.md

@@ -94,6 +94,15 @@ adjutant startup      # Full startup, or recovery from KILLED state
 adjutant update       # Self-update to the latest release
 ```
 
+### Autonomous cycles
+
+```bash
+adjutant pulse        # Run the quick autonomous pulse (queries all KBs)
+adjutant review       # Run the deep autonomous review
+adjutant brief        # Run the proactive morning brief (daily summary + deadlines)
+adjutant self-assess  # Run the weekly self-assessment (evaluate + propose improvements)
+```
+
 See [Lifecycle](lifecycle.md) for when to use each of these.
 
 ### Sending messages
@@ -117,6 +126,10 @@ adjutant kb create --quick \
   --desc "What this KB is about"      # Quick non-interactive create (--desc, not --description)
 adjutant kb info <name>               # Show details about a KB
 adjutant kb query <name> "question"   # Query a KB
+adjutant kb query-all                 # Query ALL KBs in parallel (uses each KB's query_hint)
+adjutant kb query-all -q "question"   # Query ALL KBs with a custom question
+adjutant kb cross-query "question" \
+  --kbs ixda,fagkomite                # Query multiple KBs and synthesize a cross-domain answer
 adjutant kb run <name> <operation>    # Run a KB-local operation by convention
 adjutant kb remove <name>             # Unregister a KB (files are NOT deleted)
 ```
@@ -176,15 +189,16 @@ Run `adjutant doctor` to see the health of your installation:
 Adjutant Health Check
 =====================
 
-Installation: /Users/you/.adjutant
+Installation: /Users/you/adjutant
 OS:           Darwin
 
 Dependencies:
   bash         OK (GNU bash, version 5.2.15)
   curl         OK (curl 8.4.0)
   jq           OK (jq-1.7)
   python3      OK (Python 3.12.0)
-  opencode     OK (opencode 0.3.1)
+  claude       OK (/opt/homebrew/bin/claude)    # or opencode, depending on llm.backend
+  cloudcli     OK (/opt/homebrew/bin/cloudcli)  # claude-cli backend only
 
 Optional:
   playwright   not installed (needed for screenshot)
@@ -203,4 +217,6 @@ State:
   Listener: Running (PID 12345)
 ```
 
+The backend-specific binaries shown depend on `llm.backend` in `adjutant.yaml`. With `opencode`, doctor checks for the `opencode` binary. With `claude-cli`, it checks for `claude` and `cloudcli`.
+
 If `adjutant doctor` reports missing dependencies or configuration, run `adjutant setup --repair` to fix them interactively.

docs/guides/lifecycle.md

@@ -140,13 +140,13 @@ To start Adjutant automatically when you log in to your Mac:
 adjutant startup
 ```
 
-This installs a LaunchAgent plist at `~/Library/LaunchAgents/adjutant.telegram.plist`. The listener will start on every login without manual intervention.
+This installs a LaunchAgent plist at `~/Library/LaunchAgents/com.adjutant.telegram.plist`. The listener will start on every login without manual intervention.
 
 To remove the LaunchAgent:
 
 ```bash
-launchctl unload ~/Library/LaunchAgents/adjutant.telegram.plist
-rm ~/Library/LaunchAgents/adjutant.telegram.plist
+launchctl unload ~/Library/LaunchAgents/com.adjutant.telegram.plist
+rm ~/Library/LaunchAgents/com.adjutant.telegram.plist
 ```
 
 ---
@@ -180,7 +180,7 @@ adjutant restart
 adjutant doctor
 ```
 
-Checks that all required tools are installed (`bash`, `curl`, `jq`, `python3`, `opencode`), credentials are present in `.env`, identity files exist, and the listener state. Does not modify anything — read-only diagnostic.
+Checks that required tools are installed (`bash`, `curl`, `python3`, and your configured LLM backend binary), credentials are present in `.env`, identity files exist, and the listener state. Does not modify anything — read-only diagnostic.
 
 ---
 
@@ -254,3 +254,120 @@ The notification includes:
 Notifications use the daily budget system (`notifications.max_per_day` in `adjutant.yaml`, default 3). If the budget is exhausted, the notification is silently skipped. The pulse/review itself still completes normally.
 
 Note: when triggered from Telegram via `/pulse`, the notification is redundant since the results are already sent as a chat reply. Both are sent, but the daily budget prevents excess.
+
+---
+
+## Morning Brief
+
+The morning brief is a proactive daily summary designed for the user, not for system health. It combines:
+
+- Current priorities from `heart.md` with KB status updates
+- Deadlines in the next 7 days from all KBs
+- Unprocessed insights from `insights/pending/`
+- Overnight changes since the last pulse
+
+```bash
+# Run manually
+adjutant brief
+
+# Schedule via crontab (e.g., every weekday at 07:30)
+# In adjutant.yaml schedules:
+# - name: morning-brief
+#   schedule: "30 7 * * 1-5"
+#   script: "adjutant brief"
+#   enabled: true
+```
+
+The brief uses `kb query-all` internally to query all KBs in parallel, making it significantly faster than a sequential pulse. Output is sent as a single Telegram notification, kept under 800 characters for phone readability.
+
+The brief differs from pulse in purpose: pulse is a system-level health check that writes to journal and escalates issues. The brief is a user-facing daily planner that tells you what to focus on today.
+
+---
+
+## Self-Assessment
+
+The self-assessment is a weekly introspection cycle where Adjutant evaluates its own effectiveness and proposes improvements. It runs through `prompts/self_assess.md` and:
+
+1. Reviews the past week's journal entries
+2. Analyzes notification outcomes (which were useful, which were noise)
+3. Compares `heart.md` priorities against actual activity
+4. Evaluates signal-to-noise ratio, coverage, and timing
+5. Proposes specific changes to priorities, notification frequency, and KB query patterns
+
+```bash
+# Run manually
+adjutant self-assess
+
+# Schedule via crontab (e.g., every Sunday at 20:00)
+# In adjutant.yaml schedules:
+# - name: weekly-self-assess
+#   schedule: "0 20 * * 0"
+#   script: "adjutant self-assess"
+#   enabled: true
+```
+
+**Safety:** The self-assessment never modifies `identity/soul.md` or `identity/heart.md` directly. All proposed changes are written to `insights/pending/self-assessment-YYYY-WNN.md` for the user to review and approve. This keeps the human in the loop for any behavioural changes.
+
+---
+
+## Autonomy Configuration
+
+Adjutant supports graduated autonomy levels via the `autonomy` section in `adjutant.yaml`:
+
+```yaml
+autonomy:
+  level: 2                    # 1=notify-only, 2=suggest+approve, 3=act+notify, 4=autonomous
+  auto_approve:
+    - kb_data_refresh         # Actions that don't need approval at level 3+
+    - memory_digest
+  require_approval:
+    - heart_update            # Actions that always need approval, regardless of level
+    - notification_rule
+```
+
+| Level | Behaviour |
+|-------|-----------|
+| 1 | Notify-only — never act without explicit instruction |
+| 2 | Suggest and act on approval (default) — proposes changes, waits for confirmation |
+| 3 | Act and notify — performs actions autonomously, then tells you what it did |
+| 4 | Fully autonomous — acts silently, logs only |
+
+The `auto_approve` list specifies actions that can proceed without user approval at level 3 and above. The `require_approval` list specifies actions that always need explicit approval, regardless of autonomy level.
+
+---
+
+## Parallel KB Queries
+
+Pulse now uses `kb query-all` to query all registered KBs concurrently instead of sequentially. With 6 KBs at ~70 seconds each, this reduces pulse wall time from ~7 minutes to ~80 seconds.
+
+The `kb query-all` command:
+- Reads all KB entries from `knowledge_bases/registry.yaml`
+- Uses each KB's `query_hint` field for targeted questions
+- Falls back to a generic status query if no hint is set
+- Runs all queries via `asyncio.gather()` for maximum concurrency
+- Returns a combined result with one section per KB
+
+```bash
+# Query all KBs with default hints
+adjutant kb query-all
+
+# Override with a custom question for all KBs
+adjutant kb query-all -q "What deadlines are in the next 7 days?"
+```
+
+---
+
+## Cross-KB Intelligence
+
+The `kb cross-query` command enables multi-domain synthesis — asking questions that span multiple KBs:
+
+```bash
+adjutant kb cross-query "Do I have any scheduling conflicts?" --kbs ixda,fagkomite
+```
+
+This:
+1. Queries the specified KBs in parallel
+2. Feeds all responses into a synthesis prompt
+3. Returns a unified answer that identifies cross-domain connections and conflicts
+
+Use this when you need insights that no single KB can provide alone.

docs/reference/2026-04-06-performance-autonomy-plan.md

@@ -0,0 +1,141 @@
+# Performance, Autonomy & Proactive Features Plan
+
+**Date:** 2026-04-06
+**Status:** In progress
+
+## Problem
+
+Adjutant's pulse/review cycle queries all 6 KBs sequentially via LLM tool calls. Each KB query takes 60-80s, making a full pulse take 6-8 minutes. There is no cross-KB intelligence, no proactive daily briefing, no self-assessment loop, and no graduated autonomy control.
+
+## Goals
+
+- Reduce pulse wall time from ~7 min to ~90s via parallel KB queries
+- Add a morning brief prompt for daily proactive value
+- Add a self-assessment prompt for weekly introspection
+- Add cross-KB query capability for multi-domain synthesis
+- Add graduated autonomy configuration
+- Keep all changes generic and KB-agnostic
+
+## Non-goals
+
+- Embedding/vector store integration (future work)
+- Webhook triggers (future work)
+- Multi-channel messaging (future work)
+
+## Issues
+
+### Issue 1: Parallel KB queries — `kb query-all` command
+
+**Status:** Done
+
+**Problem:** Pulse prompt instructs the LLM agent to call `adjutant kb query` per KB sequentially. With 6 KBs at ~70s each, pulse takes ~7 minutes.
+
+**Solution:** Add `kb_query_all()` async function that queries all registered KBs in parallel via `asyncio.gather()`, and a `kb query-all` CLI command. Update pulse prompt to call this once instead of iterating.
+
+**Files changed:**
+
+| File | Change |
+|------|--------|
+| `src/adjutant/capabilities/kb/query.py` | Add `kb_query_all()` — parallel query across all KBs |
+| `src/adjutant/cli.py` | Add `kb query-all` CLI command |
+| `prompts/pulse.md` | Use `kb query-all` instead of per-KB iteration |
+| `tests/unit/test_kb_query.py` | Tests for `kb_query_all()` |
+
+**What was done:** Added `kb_query_all()` function that loads the KB registry, builds per-KB query strings (using `query_hint` if set), and runs all queries concurrently with `asyncio.gather()`. Returns a formatted multi-KB result string. Added `kb query-all` CLI command with `--query` option for custom query text. Updated `prompts/pulse.md` step 3 to call `adjutant kb query-all` once. Added 4 unit tests covering parallel dispatch, partial failure, empty registry, and custom query text.
+
+### Issue 2: Morning brief prompt
+
+**Status:** Done
+
+**Problem:** Adjutant has no proactive daily communication. Pulse is a system-level health check, not a user-facing daily planner.
+
+**Solution:** Add `prompts/morning_brief.md` — a user-facing daily brief combining deadlines, overnight KB changes, unread insights, and priority suggestions. Add `brief` CLI command and `brief_cron()` entry point.
+
+**Files changed:**
+
+| File | Change |
+|------|--------|
+| `prompts/morning_brief.md` | New prompt — daily brief for the user |
+| `src/adjutant/lifecycle/cron.py` | Add `brief_cron()` entry point |
+| `src/adjutant/cli.py` | Add `brief` CLI command |
+| `tests/unit/test_cron.py` | Tests for `brief_cron()` |
+
+**What was done:** Created `morning_brief.md` prompt that queries all KBs via `kb query-all`, reads recent journal + insights, compiles deadlines, and produces a scannable Telegram-ready brief. Added `brief_cron()` and `brief` CLI command following the same pattern as pulse/review. Added test for `brief_cron()`.
+
+### Issue 3: Self-assessment prompt
+
+**Status:** Done
+
+**Problem:** No feedback loop — adjutant never evaluates whether its own notifications were useful, its priorities are still accurate, or its behaviour should change.
+
+**Solution:** Add `prompts/self_assess.md` — a weekly introspection prompt that reviews journal, notification outcomes, and memory, then proposes priority and behaviour adjustments.
+
+**Files changed:**
+
+| File | Change |
+|------|--------|
+| `prompts/self_assess.md` | New prompt — weekly self-assessment |
+| `src/adjutant/lifecycle/cron.py` | Add `self_assess_cron()` entry point |
+| `src/adjutant/cli.py` | Add `self-assess` CLI command |
+| `tests/unit/test_cron.py` | Tests for `self_assess_cron()` |
+
+**What was done:** Created `self_assess.md` prompt that reviews past week's journal, notification outcomes from `state/actions.jsonl`, memory patterns, and heart.md alignment. Outputs proposed changes to `insights/pending/self-assessment-YYYY-WNN.md` for user review. Added `self_assess_cron()` and `self-assess` CLI command. Added test.
+
+### Issue 4: Autonomy configuration
+
+**Status:** Done
+
+**Problem:** No way to control what adjutant can do autonomously vs. what requires user approval. Binary choice between running and being paused.
+
+**Solution:** Add `autonomy` section to `adjutant.yaml` with a graduated level system and per-action overrides.
+
+**Files changed:**
+
+| File | Change |
+|------|--------|
+| `src/adjutant/core/config.py` | Add `AutonomyConfig` model |
+| `tests/unit/test_config.py` | Tests for new config section |
+
+**What was done:** Added `AutonomyConfig` with `level` (1-4), `auto_approve` list, and `require_approval` list. Level 1 = notify-only, 2 = suggest+act-on-approval, 3 = act+notify, 4 = fully autonomous. Added to `AdjutantConfig`. Added tests for defaults and custom values.
+
+### Issue 5: Cross-KB query command
+
+**Status:** Done
+
+**Problem:** KBs are isolated silos. No way to ask questions that span multiple domains (e.g., scheduling conflicts between IxDA events and Fagkomite conferences).
+
+**Solution:** Add `kb_cross_query()` function and `kb cross-query` CLI command that queries multiple KBs in parallel, then feeds combined results into a synthesis prompt.
+
+**Files changed:**
+
+| File | Change |
+|------|--------|
+| `src/adjutant/capabilities/kb/query.py` | Add `kb_cross_query()` |
+| `src/adjutant/cli.py` | Add `kb cross-query` CLI command |
+| `tests/unit/test_kb_query.py` | Tests for `kb_cross_query()` |
+
+**What was done:** Added `kb_cross_query()` that takes a list of KB names and a question, queries them in parallel, then runs a synthesis prompt through the backend to produce a unified answer. Added CLI command with `--kbs` option accepting comma-separated KB names. Added tests.
+
+### Issue 6: Update documentation
+
+**Status:** Done
+
+**Files changed:**
+
+| File | Change |
+|------|--------|
+| `docs/guides/commands.md` | Add new CLI commands |
+| `docs/guides/lifecycle.md` | Document morning brief and self-assessment cycles |
+| `CHANGELOG.md` | Add entries for all new features |
+
+**What was done:** Updated commands guide with `kb query-all`, `kb cross-query`, `brief`, and `self-assess` commands. Updated lifecycle guide with morning brief and self-assessment cycles. Added changelog entries.
+
+## Definition of done
+
+- `kb query-all` queries all KBs in parallel, returns combined result
+- `kb cross-query` synthesizes answers across selected KBs
+- Morning brief prompt provides daily proactive value
+- Self-assessment prompt enables weekly introspection
+- Autonomy config gives graduated control
+- All new code has unit tests
+- All docs updated