@miller-tech/uap 1.137.2 → 1.137.3

package/docs/INDEX.md

@@ -20,7 +20,7 @@ UAP is organized like a delivery line. If you know which part of the pipeline yo
 | **Intake** — understand the work | Amnesiac sessions, invented scope | [Memory](guides/MEMORY.md) · [Reactor](design/UAP_REACTOR.md) |
 | **Prep / routing** — right job, right station | Wrong approach or wrong-sized model | [Multi-Model Routing](guides/MULTI_MODEL.md) · [Patterns](reference/PATTERNS.md) · [Droids & Skills](guides/DROIDS_AND_SKILLS.md) |
 | **Isolation** — a bench per job | Editing `main`, clobbering files | [Worktree Workflow](guides/WORKTREE_WORKFLOW.md) |
-| **Build** — make the thing | Plausible-but-wrong code, stubs, empty output | [`uap deliver`](guides/DELIVER.md) · [Local Models](guides/LOCAL_MODELS.md) |
+| **Build** — make the thing | Plausible-but-wrong code, stubs, empty output | [`uap deliver`](guides/DELIVER.md) · [Local Models](guides/LOCAL_MODELS.md) · [Inference Proxy](guides/PROXY.md) |
 | **QC / verify** — prove it runs | "Done" on code that never ran | [`uap deliver`](guides/DELIVER.md) · [Policies](guides/POLICIES.md) |
 | **Coordination** — many workers, one floor | Parallel agents colliding | [Coordination](guides/COORDINATION.md) · [Deploy Batching](guides/DEPLOY_BATCHING.md) |
 | **Shipping** — out the door safely | Regressions, red CI, skipped bumps | [Worktree Workflow](guides/WORKTREE_WORKFLOW.md) · [Policies](guides/POLICIES.md) |
@@ -60,6 +60,7 @@ Full map: **[The UAP Delivery Pipeline](guides/DELIVERY_PIPELINE.md)**.
 | [Deploy Batching](guides/DEPLOY_BATCHING.md) | Conflict-free batched git/deploy actions |
 | [Coordination](guides/COORDINATION.md) | Multi-agent overlap detection |
 | [Local Models](guides/LOCAL_MODELS.md) | Running agents against local llama.cpp / Qwen models |
+| [Inference Proxy](guides/PROXY.md) | The Anthropic↔local gateway: `uap proxy` lifecycle, reliability guardrails, security, serving recipes |
 | [Qwen3.6 on llama.cpp by VRAM](guides/QWEN36_LLAMACPP.md) | Tiered 8/12/16/24/32 GB setup; how `uap deliver` uplifts small local models |
 | [**LLM Self-Tuning**](guides/SELF_TUNING.md) | `uap tune` — raise a small model toward Opus by tuning UAP's flag surface with a benchmark-validated LLM/GP-BO loop; quality scoring, model profiles, auto-on real-time adaptation ⭐ |
 

package/docs/guides/DELIVER.md

@@ -51,6 +51,22 @@ local or frontier — runs the build to 100% without stopping. See
 
 ---
 
+## Big builds: decompose → orchestrate → epics → contracts-first
+
+For a mission too large to hold in one context, `deliver` scales down the context each turn actually needs — this is what lets a small-context local model compose a system it could never see all at once.
+
+- **`--decompose`** splits the mission into sequential phases, each converged by its own loop (auto for long, complex instructions; `--no-decompose` forbids it).
+- **`--orchestrate`** runs those phases through the **blackboard orchestrator** with *minimal* per-task context — each task sees only its goal + its direct-dependency outputs. Implies `--decompose`.
+- **`--epics`** runs a massive mission as a sequence of **epics, each a fresh session** — only prior epics' summaries are injected, never their full code — looped until each is accepted (auto for very long missions; `--no-epics` disables).
+
+**Contracts-first** (on by default inside epic/decompose runs; `UAP_DELIVER_CONTRACTS=0` disables): the first epic plans the shared types, interfaces, and registry APIs the rest build against. Once accepted, its files are **locked read-only** so later epics build against frozen signatures and can't drift them. The public surface is *extracted and verified against emitted source* — only names proven present are recorded — which is what makes cross-module composition reliable without holding every module in context.
+
+**Scaffold-then-fill** (on by default in phased runs; `UAP_DELIVER_SCAFFOLD=0` disables): a large phase is split into a **scaffold** phase that emits the compiling skeleton (complete public signatures, wired imports/exports, stub bodies — build/typecheck must pass) and a **fill** phase that implements the logic *without changing any signature*. The skeleton keeps the build green while the details land.
+
+Interrupted a long run? **`--resume <id|latest>`** picks up a durable run from `.uap/deliver-runs` where it left off.
+
+---
+
 ## Auto-optimization
 
 By default every task is **classified by complexity** and the matching convergence aids turn on automatically (`auto-optimizer.ts`). You don't have to tune anything for the common case. To control it explicitly:
@@ -103,41 +119,106 @@ uap deliver "add the orders endpoint" --until-deployed
 
 ---
 
+## Beyond build & test: proving it runs
+
+Green gates prove code *compiles and tests pass* — not that the artifact actually **runs**. `deliver` adds gates for that:
+
+- **Execution gate** — auto-synthesized as a ladder rung whenever a runnable artifact is detected: it actually *runs* the thing (headless browser / vm-dom / child-process) and fails the turn on a runtime error, a blank canvas, or a static frame. Catches "declared done but never ran."
+- **Acceptance judge** (`--acceptance`) — after the objective gates pass, an LLM judges the spec's *behavioral completeness* from the code + runtime evidence and feeds any unmet requirements back so the loop finishes the spec. Pair it with **`--evaluator-model <preset>`** to have a *different* model judge than the one that implemented (separate generator from evaluator — the "barbell" strategy).
+- **Self-gate** — when a project has **no** detectable gates, `deliver` authors a task-specific acceptance gate as a fallback so there is always something to converge against (on by default; `--no-self-gate` disables, `--force-self-gate` authors one even when project gates exist).
+
+## Resilience: baseline-delta, migrations & repair escalation
+
+Long autonomous runs fail in predictable ways; `deliver` has a guard for each:
+
+- **Baseline-delta gating** — the full ladder is run **once at mission start**. Any required gate that is *already red at baseline* (a pre-existing failure the mission didn't cause) is demoted to non-blocking and annotated; only **new** regressions (green→red) block delivery. So a pre-existing broken lint or flaky test can't consume every attempt. On by default (`UAP_DELIVER_BASELINE_DELTA=0` or `.uap.json` `deliver.baselineDelta:false` to disable).
+- **Migration-validation gate** — when a `migrations/` dir with `.sql` files exists, a ladder rung runs the migrations against an **ephemeral throwaway Postgres container** before they can ship broken. Skips cleanly (never fails) when Docker/`sqlx-cli` isn't available.
+- **Repair escalation** — a circuit breaker for the compile-error death spiral: when the compile-error count *grows* across consecutive turns, the loop stops mission work and runs **one narrow "make it compile, change nothing else" pass** — in a fresh focused session, on the `--escalate-model` when configured — then resumes.
+
 ## Options
 
+**Loop & termination**
+
 | Flag | Purpose |
 |---|---|
 | `--max-turns <n>` | Maximum execute→verify iterations before until-delivered extension (default `5`) |
 | `--no-until-delivered` | Disable loop-until-delivered (ON by default: extends past `--max-turns` to the ceiling, stopping on stagnation) |
 | `--ceiling <n>` | Hard turn ceiling for until-delivered (1–50, default `30`) |
+| `--no-lazy` | Skip the lazy bare first attempt (by default one bare turn runs before the convergence aids engage) |
+| `--resume <id>` | Resume an interrupted durable run: a run id or `latest` (`.uap/deliver-runs`) |
+
+**Executor**
+
+| Flag | Purpose |
+|---|---|
+| `--executor <mode>` | Per-turn executor: `blind` (one completion), `agentic` (tool-using read/list/bash/write loop), or `auto` (agentic when there's repo context/gates to inspect) — default `auto` |
+| `--allow-bash` | Permit the agentic executor's `run_bash` tool when NOT under `uap sandbox` (off by default; auto-enabled under sandbox) |
+
+**Models & routing**
+
+| Flag | Purpose |
+|---|---|
 | `-m, --model <preset>` | Model preset (default `$UAP_DELIVER_MODEL` or `qwen35-a3b`) |
+| `--routing <preset>` | Pick the executor per task complexity from a routing preset (e.g. `cost-tiered`, `speed-tiered`); ignored when `--model` is set (`$UAP_DELIVER_ROUTING`) |
 | `--endpoint <url>` | Override the model endpoint (OpenAI-compatible `/v1`) |
-| `--escalate-model <preset>` | Stronger model for escalation (default `$UAP_ESCALATE_MODEL`) |
+| `--escalate-model <preset>` | Stronger model for the escalation/repair ladder (default `$UAP_ESCALATE_MODEL`) |
 | `--temperature <t>` | Sampling temperature (default: execution-profile value) |
+
+**Gates & acceptance**
+
+| Flag | Purpose |
+|---|---|
 | `--gates <ids>` | Gate subset: `build,typecheck,test,lint` |
-| `--tiers <list>` | Explicit local tiers to run, e.g. `fast,integration,deploy-dev` (overrides auto-detection) |
+| `--acceptance` | After objective gates pass, judge spec behavioral completeness (LLM) and feed unmet requirements back |
+| `--evaluator-model <preset>` / `--evaluator-endpoint <url>` | Judge the acceptance gate with a DIFFERENT model than the implementer (generator≠evaluator) |
+| `--no-self-gate` | Disable the self-authored acceptance-gate fallback (on by default when no project gates are detected) |
+| `--force-self-gate` | Author a task-specific acceptance gate even when project gates exist |
+| `--keep-best` | Never regress: snapshot first, roll back if the run ends with a worse required-gate score |
+
+**Tiers & CI/deploy feedback**
+
+| Flag | Purpose |
+|---|---|
+| `--tiers <list>` | Explicit local tiers, e.g. `fast,integration,deploy-dev` (overrides auto-detection) |
 | `--integration` / `--no-integration` | Run the integration tier (on by default when a suite is detected) |
 | `--deploy-dev` / `--no-deploy-dev` | Run a local dev deploy + smoke tier (compose up → smoke → teardown) |
-| `--watch-ci` | After local-green, commit + push the worktree branch and watch CI; re-converge on failure |
+| `--watch-ci` | After local-green, commit + push the worktree branch and watch CI; re-converge on failure (never pushes master/main) |
 | `--until-deployed` | Imply `--watch-ci` and require CI + staging/prod deploy jobs green before exiting 0 |
 | `--ci-passes <n>` | Max CI re-converge passes on failure (1–10, default `2`) |
 | `--ci-timeout <minutes>` | CI watch budget in minutes (1–120, default `20`) |
+
+**Big builds (decompose → orchestrate → epics)**
+
+| Flag | Purpose |
+|---|---|
+| `--decompose` / `--no-decompose` | Split the mission into sequential phases, each converged by its own loop (auto for long complex tasks) |
+| `--orchestrate` / `--no-orchestrate` | Run decomposed tasks through the blackboard orchestrator with MINIMAL per-task context (implies `--decompose`) |
+| `--epics` / `--no-epics` | Run a massive mission as a sequence of fresh-session epics until each is accepted (auto for very long missions) |
+
+**Exploration & quality aids**
+
+| Flag | Purpose |
+|---|---|
 | `--candidates <n>` | Best-of-N exploration: candidates per turn (2–8) |
-| `--critic` | Structured critique of failed turns |
+| `--critic` | Structured critique of failed turns (extra model call per failure) |
 | `--practices` / `--no-semantic` | Inject/record best-practice cards (keyword retrieval with `--no-semantic`) |
-| `--escalate` | Escalation ladder on stagnation |
+| `--escalate` | Escalation ladder on stagnation (widen exploration → critic → stronger model) |
 | `--ideate` / `--ideate-project <name>` | Divergent ideation strategy seeds |
-| `--halo` | Emit HALO spans (analyze with `uap harness analyze`) |
-| `--coordinate` | Register the run with the coordination layer |
-| `--deploy` | On success, queue a commit of applied files into the deploy batcher |
 | `--optimize` | Enable every convergence aid |
-| `--no-auto` | Disable dynamic optimization |
+| `--no-auto` | Disable dynamic optimization (aids are auto-selected by task complexity by default) |
+
+**Integration & run control**
+
+| Flag | Purpose |
+|---|---|
 | `--no-protect-tests` | Allow the model to modify pre-existing test files (protected by default) |
 | `--guidance-file <path>` | Poll a file each turn for live operator guidance |
+| `--halo` | Emit HALO spans (analyze with `uap harness analyze`) |
+| `--coordinate` | Register the run with the coordination layer (announce, heartbeat, overlap detection) |
+| `--deploy` | On success, queue a commit of applied files into the deploy batcher |
 | `--project-root <path>` | Project whose gates define delivery (default: cwd) |
 | `--dry-run` | Show detected gates and plan without calling the model |
 | `--json` | Emit a JSON result |
-| `--keep-best` | Never regress: snapshot the project first, roll back if the run ends with a worse required-gate score |
 
 ### `--keep-best` snapshots
 

package/docs/guides/LOCAL_MODELS.md

@@ -162,6 +162,10 @@ The client then talks the Anthropic protocol to the proxy, which forwards
 OpenAI requests to llama.cpp. The proxy supports streaming and tool-call
 translation.
 
+For the full picture — the `uap proxy` lifecycle, the reliability guardrails
+that keep a small model from wedging, security, and serving recipes — see the
+**[Inference Proxy guide](PROXY.md)**.
+
 ## Related
 
 - [Deploy Batching](./DEPLOY_BATCHING.md) — what `uap deliver --deploy` queues.

package/docs/guides/PROXY.md

@@ -0,0 +1,202 @@
+# The Inference Proxy
+
+UAP ships a local **inference proxy** — an Anthropic-Messages-compatible gateway
+that sits in front of a local llama.cpp/Qwen backend, translates between the
+Anthropic wire format and llama's OpenAI-compatible API, and applies a layer of
+**reliability guardrails** on the way through. It's what lets a Claude-native
+harness (Claude Code, Factory, …) drive a local model, and it's where most of
+the "keep a small model from wedging" logic lives.
+
+> Code: [`tools/agents/scripts/anthropic_proxy.py`](../../tools/agents/scripts/anthropic_proxy.py)
+> (the server), `tools/agents/scripts/confidence_escalation.py` (serving
+> recipes), and `src/cli/proxy.ts` / `src/cli/proxy-lifecycle.ts` (lifecycle).
+> Related: [Local Models](LOCAL_MODELS.md) · [Configuration Reference](../reference/CONFIGURATION_REFERENCE.md).
+
+---
+
+## What it does
+
+- **Protocol translation** — accepts Anthropic `POST /v1/messages` and forwards
+  OpenAI-style requests to the local rail (`LLAMA_CPP_BASE`, e.g.
+  `http://localhost:8080/v1`), streaming and tool-calls included.
+- **Reliability guardrails** — detects and breaks the failure modes a small
+  local model falls into (act/review loops, "I'm stuck" spirals, endless
+  exploration with no deliverable) so a run terminates instead of burning turns.
+- **Context management** — scales token counts so the client compacts *before*
+  the local rail overflows, and prunes as a backstop.
+- **Graceful degradation under load** — pool saturation returns a proper
+  Anthropic `529 overloaded_error` with `retry-after` rather than failing hard.
+- **Serving recipes** — optional confidence/fusion escalation to a stronger
+  judge model, plus per-request routing from the reactor and the self-tuning
+  real-time adaptor.
+
+### Endpoints
+
+| Route | Purpose |
+|---|---|
+| `POST /v1/messages` (+ `/anthropic/v1/messages`) | Main Anthropic Messages endpoint (local model + guardrails) |
+| `POST /v1/messages/count_tokens` | Token counting, scaled so the client compacts before the local rail overflows |
+| `POST /v1/chat/completions` | OpenAI-compatible surface |
+| `GET /v1/models` | Model list (honors the `__local_only__` passthrough sentinel) |
+| `GET /health` | Liveness (probes the upstream; stays unauthenticated) |
+| `GET /v1/context` | Per-session token-usage / utilization / guardrail telemetry (dashboards & debug) |
+
+---
+
+## Lifecycle: `uap proxy`
+
+The proxy is **reference-counted and session-scoped**. Hooks call `ensure` when a
+session starts and `release` when it ends, so it starts on demand and stops when
+the last session leaves — but it **never** kills a proxy that systemd manages or
+that other sessions are still using.
+
+```
+uap proxy [ensure | release | status | start | stop | restart | enable | disable]
+```
+
+| Subcommand | What it does |
+|---|---|
+| `ensure` | Start the proxy if none is running, or **adopt** a running one; register this session as a client |
+| `release` | Deregister this session; stop the proxy **only if** we spawned it as a plain process and no other client remains |
+| `status` | Report whether it's running, how (systemd vs spawned), the port, and client count (`--json` for machine-readable) |
+| `start` / `stop` / `restart` | Explicit control (e.g. `restart` after changing `PROXY_*` in `.uap/proxy.env`) |
+| `enable` / `disable` | Toggle `.uap.json` `proxy.autostart` so hooks auto-start it (or not) |
+
+| Flag | Purpose |
+|---|---|
+| `--client <id>` | Client/session id (defaults to the session env or parent pid) |
+| `--client-pid <n>` | Long-lived agent pid for liveness (hooks pass `$PPID`) |
+| `--port <n>` | Proxy port (default `4000` / `$PROXY_PORT`) |
+| `--if-enabled` | No-op unless `.uap.json` `proxy.autostart` is `true` (hook-safe) |
+| `--quiet` / `--json` | Suppress output (hooks) / machine-readable status |
+
+**How it's managed.** When available, the proxy runs as the systemd unit
+`uap-anthropic-proxy.service`, reading its environment from
+`~/.config/uap/anthropic-proxy.env`; a plain spawned proxy seeds the same file
+for parity. The proxy also loads project-local `.uap/proxy.env` at startup
+(real environment always wins). PID reuse is defended with a `/proc/<pid>`
+start-time token so `release` never kills an unrelated process that inherited an
+old pid. Everything hook-driven **fails open** — if the proxy won't start, the
+agent just runs without it.
+
+```bash
+uap proxy status --json
+uap proxy restart          # pick up new PROXY_* values from .uap/proxy.env
+uap proxy enable           # let session hooks autostart it
+```
+
+---
+
+## Security
+
+- **Loopback by default.** The proxy binds `127.0.0.1` (`PROXY_HOST`). This is
+  deliberate: an unauthenticated `0.0.0.0` listener would let any host on your
+  LAN drive the local model — and reach any cloud passthrough — so local-only is
+  the safe default.
+- **Shared-secret auth for LAN exposure.** To run it as a shared service, set
+  `PROXY_HOST=0.0.0.0` **and** a `PROXY_AUTH_TOKEN`. With a token set, every model
+  route requires `Authorization: Bearer <token>` (or `X-Uap-Proxy-Token`), checked
+  in constant time; `/health` stays open. Never expose it beyond loopback without
+  a token.
+- **Passthrough credentials.** For requests routed to the cloud, the proxy
+  forwards the client's OAuth `Authorization: Bearer` verbatim and does not also
+  attach an `x-api-key` (Anthropic rejects both).
+
+---
+
+## Reliability guardrails
+
+These are the heart of the proxy — the logic that keeps a weaker model from
+wedging. Most are **on by default** and tuned via `PROXY_*` env vars (persisted
+in `.uap/proxy.env` or the systemd EnvironmentFile). The high-signal knobs are in
+the [Configuration Reference](../reference/CONFIGURATION_REFERENCE.md); the full
+set is below.
+
+### Termination breakers (on by default)
+
+| Guardrail | Env (default) | Behavior |
+|---|---|---|
+| **Loop-breaker** | `PROXY_LOOP_BREAKER` (on) | Detects act/review cycles + no-progress streaks and releases `tool_choice` to `auto` so the model can actually terminate |
+| **Stuck-break** | `PROXY_STUCK_BREAK` (on) | When the model self-reports "stuck in a loop" or hammers a rate-limited host, forces a terminal turn |
+| **Deferral-break** | `PROXY_DEFERRAL_BREAK` (on) | The inverse: a no-tool turn that *defers* work ("I need more exploration cycles") is forced to act on the next turn |
+| **Recon-convergence** | `PROXY_RECON_CONVERGENCE_THRESHOLD` (40) | After N tool-using turns with **no** write/deliverable, inject "stop exploring, produce the deliverable"; escalates to stripping tools if it persists (0 disables) |
+| **Hard-finalize** | `PROXY_HARD_FINALIZE_TURNS` (40) | Absolute turn cap before a forced finalize |
+| **MANDATE-DELIVER** | `PROXY_MANDATE_DELIVER` (on) | On the delivery-enforcer block marker, pin `tool_choice` to `deliver` so the next turn *must* route through the gated path — makes routing binding for weak models |
+
+### Context & compaction
+
+| Env (default) | Behavior |
+|---|---|
+| `PROXY_CONTEXT_WINDOW` (0 = auto) | Explicit local context window; 0 derives it from the live rail |
+| `PROXY_COUNT_TOKENS_SCALE` (auto) | Scales the reported token count so the client auto-compacts before the local rail overflows |
+| `PROXY_CONTEXT_PRUNE_THRESHOLD` (0.85) / `PROXY_CONTEXT_PRUNE_TARGET_FRACTION` (0.50) | Backstop pruning: prune at 85% of the window, land the session at ~50% |
+
+### Connection health & backpressure
+
+| Env (default) | Behavior |
+|---|---|
+| `PROXY_MAX_CONNECTIONS` (20) | httpx pool size; a large pool + 529 backoff absorbs connection churn gracefully |
+| **529 backpressure** (no toggle) | A pool timeout returns HTTP **529 `overloaded_error`** with `retry-after` — pure graceful degradation, not a hard failure |
+| `PROXY_CLOSEWAIT_REAP_INTERVAL` (0 = **off**) | Opt-in CLOSE-WAIT reaper (pool self-heal); off by default because pool-swap churn can harm a saturated upstream |
+| `PROXY_TOOL_NARROWING` (**off**) | Opt-in: drop cycling/banned tools from the set on loops — always keeps the Bash/WebFetch/Agent escape hatch + write tools (a floor invariant that never strands the agent) |
+
+> **Off-by-default knobs to know:** `PROXY_TOOL_NARROWING`, the CLOSE-WAIT reaper
+> (`PROXY_CLOSEWAIT_REAP_INTERVAL=0`), `PROXY_POOL_SWAP_ON_SATURATION`, and the
+> serving recipes (`PROXY_CONFIDENCE_ESCALATE`). Everything else above is on.
+
+---
+
+## Serving recipes & escalation
+
+The proxy can run a bounded **micro-agent recipe** in front of the local model —
+escalating low-confidence or hard turns to a stronger **judge** model — behind
+the same single model API. It is **off by default and fails open**.
+
+| Env (default) | Meaning |
+|---|---|
+| `PROXY_CONFIDENCE_ESCALATE` (off) | Master switch for serving recipes |
+| `PROXY_RECIPE` (auto) | `single \| confidence \| fusion` (+ `ratings \| remom`); `auto` routes by signal |
+| `PROXY_CONFIDENCE_THRESHOLD` (0.5) | Below this confidence, escalate the turn to the judge |
+| `PROXY_FUSION_N` (3) | Candidates the fusion recipe samples before the judge picks/merges (2–6) |
+| `PROXY_ESCALATE_MODEL` / `PROXY_ESCALATE_ENDPOINT` / `PROXY_ESCALATE_API_KEY` | The stronger judge backend |
+
+A judge-dependent recipe requires a judge **distinct from** the primary model —
+a same-model "qwen judging qwen" setup downgrades to `single` unless
+`PROXY_ALLOW_SELF_JUDGE=1`. The judge model id is configured on the harness side
+via `recipes.judge.model` (see the [recipes settings](../reference/CONFIGURATION_REFERENCE.md));
+`uap setup` / `uap config` seed the `PROXY_ESCALATE_*` triple into the proxy env.
+
+### Cross-process signals
+
+Because the proxy freezes its `PROXY_*` env at startup and has no reload
+endpoint, two features steer it **per request** via small signal files (each a
+best-effort read, TTL ~180s, never fatal):
+
+- **Recipe signal** — the harness [Reactor](../design/UAP_REACTOR.md) writes its
+  per-prompt routing decision to `~/.cache/uap/recipe-signals/`; the proxy prefers
+  that fresh signal over re-deriving complexity itself.
+- **Adaptation signal** — the [LLM self-tuning](SELF_TUNING.md) real-time adaptor
+  writes per-session adjustments (escalate / recipe / recon threshold / force
+  synthesis) to `~/.cache/uap/adaptation-signals/`. Consumed when
+  `PROXY_REALTIME_ADAPT` is on (**auto-on**; opt out with `0`).
+
+---
+
+## Configuration
+
+Proxy settings are `PROXY_*` environment variables. Persist them with
+`uap config set` (which writes `.uap/proxy.env`) and `uap proxy restart` to apply:
+
+```bash
+uap config set PROXY_RECON_CONVERGENCE_THRESHOLD 30
+uap config set PROXY_AUTH_TOKEN "$(openssl rand -hex 16)"
+uap proxy restart
+```
+
+The curated high-impact subset is documented in the
+[Configuration Reference](../reference/CONFIGURATION_REFERENCE.md#proxy);
+the exhaustive list lives as module-level constants in `anthropic_proxy.py`.
+
+> **Note:** the upstream backend default in the checked-in scripts
+> (`LLAMA_CPP_BASE`) points at a specific host/port — always set it (or your
+> model's `endpoint`) to your own llama.cpp/Qwen server.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miller-tech/uap",
-  "version": "1.137.2",
+  "version": "1.137.3",
   "description": "Autonomous AI agent memory system with CLAUDE.md protocol enforcement",
   "type": "module",
   "main": "dist/index.js",