From 7b1d12a07c0faf351ef7de2240165dbb4a6e7be4 Mon Sep 17 00:00:00 2001
From: SiNaPsEr0x <5438823+SiNaPsEr0x@users.noreply.github.com>
Date: Mon, 20 Jul 2026 17:54:29 +0200
Subject: [PATCH] feat: SOCKS5 egress proxy + harden local-model path (#79)

Integrate SOCKS5 attack-traffic proxying, egress leak visibility, and local-model hardening. Preserve direct local/LAN model traffic while the proxy is active and reconcile the branch with current upstream.
---
 docs/index.html                          | 1021 +++++++++++++++++++---
 package-lock.json                        |   35 +
 package.json                             |    2 +
 src/__tests__/proxy-local-bypass.test.ts |   33 +
 src/agent/local-agents.ts                |    7 +-
 src/config/index.ts                      |   33 +-
 src/llm/index.ts                         |  123 ++-
 src/net/proxy.ts                         |  345 ++++++++
 src/server.ts                            |  247 +++++-
 9 files changed, 1708 insertions(+), 138 deletions(-)
 create mode 100644 src/__tests__/proxy-local-bypass.test.ts
 create mode 100644 src/net/proxy.ts

diff --git a/docs/index.html b/docs/index.html
index 7322aed..481dc21 100755
--- a/docs/index.html
+++ b/docs/index.html
@@ -345,7 +345,31 @@
 
         .header-title { font-size: 18px; font-weight: 600; }
 
-        .header-actions { display: flex; gap: 10px; }
+        .header-actions { display: flex; gap: 10px; align-items: center; }
+
+        /* Egress IP badge — shows the IP the world sees for test traffic. Colour encodes
+           state: green = proxied (safe), red = real IP exposed (leak), grey = unknown. */
+        .egress-badge {
+            display: inline-flex; align-items: center; gap: 6px;
+            padding: 5px 10px; border-radius: 6px; cursor: pointer; user-select: none;
+            font-size: 11px; font-family: 'JetBrains Mono', ui-monospace, monospace;
+            border: 1px solid rgba(255,255,255,0.14); background: rgba(255,255,255,0.04);
+            transition: background .15s, border-color .15s;
+        }
+        .egress-badge:hover { background: rgba(255,255,255,0.08); }
+        .egress-badge .egress-dot { width: 8px; height: 8px; border-radius: 50%; background: #888; flex: 0 0 auto; }
+        .egress-badge .egress-label { color: #9aa; font-weight: 600; letter-spacing: .5px; }
+        .egress-badge .egress-ip { color: #cfd; font-weight: 700; }
+        .egress-loading .egress-dot { background: #888; animation: egressPulse 1s ease-in-out infinite; }
+        .egress-proxied { border-color: rgba(0,255,136,0.4); background: rgba(0,255,136,0.08); }
+        .egress-proxied .egress-dot { background: #00ff88; box-shadow: 0 0 6px rgba(0,255,136,0.7); }
+        .egress-proxied .egress-ip { color: #7CFFC4; }
+        .egress-leak { border-color: rgba(255,64,64,0.55); background: rgba(255,64,64,0.12); }
+        .egress-leak .egress-dot { background: #ff4040; box-shadow: 0 0 8px rgba(255,64,64,0.8); animation: egressPulse .8s ease-in-out infinite; }
+        .egress-leak .egress-label, .egress-leak .egress-ip { color: #ff8080; }
+        .egress-error { border-color: rgba(255,176,32,0.4); }
+        .egress-error .egress-dot { background: #ffb020; }
+        @keyframes egressPulse { 0%,100% { opacity: 1; } 50% { opacity: .35; } }
 
         .btn {
             padding: 8px 16px;
@@ -868,7 +892,7 @@
         .modal-body { padding: 16px; }
 
         /* Toast */
-        .toast-container { position: fixed; bottom: 20px; right: 20px; z-index: 2000; }
+        .toast-container { position: fixed; bottom: 20px; right: 20px; z-index: 2000; transition: bottom 0.2s ease; }
 
         .toast {
             background: var(--bg-secondary);
@@ -893,6 +917,72 @@
         .toast.error { border-left: 3px solid var(--danger); }
         .toast.warning { border-left: 3px solid var(--warning); }
 
+        /* LLM Call Queue popup — live feed of queued/running LLM calls, bottom-right, above toasts */
+        .llm-queue-popup {
+            position: fixed; bottom: 20px; right: 20px; z-index: 2100;
+            width: 960px; max-width: calc(100vw - 40px);
+            background: var(--bg-secondary); border: 1px solid var(--border-color); border-radius: 8px;
+            box-shadow: 0 8px 24px rgba(0,0,0,0.4); font-size: 12px; overflow: hidden;
+            animation: slideIn 0.25s ease;
+        }
+        .llm-queue-popup.minimized .llm-queue-body { display: none; }
+        .llm-queue-header {
+            display: flex; align-items: center; justify-content: space-between;
+            padding: 8px 10px; cursor: pointer; user-select: none;
+            background: var(--bg-tertiary); border-bottom: 1px solid var(--border-color);
+        }
+        .llm-queue-popup.minimized .llm-queue-header { border-bottom: none; }
+        .llm-queue-title { color: var(--accent); font-weight: 700; font-size: 11px; letter-spacing: 0.3px; }
+        .llm-queue-title span { color: var(--text-muted); font-weight: 400; }
+        .llm-queue-min-btn {
+            background: none; border: 1px solid var(--border-color); color: var(--text-secondary);
+            width: 20px; height: 18px; line-height: 14px; border-radius: 3px; cursor: pointer; font-size: 12px;
+        }
+        .llm-queue-min-btn:hover { color: var(--accent); border-color: var(--accent); }
+        .llm-queue-body { max-height: 260px; overflow-y: auto; }
+        .llm-queue-item {
+            display: flex; align-items: center; gap: 8px; padding: 8px 10px;
+            border-bottom: 1px solid var(--border-color);
+        }
+        .llm-queue-item:last-child { border-bottom: none; }
+        .llm-queue-item-dot { width: 7px; height: 7px; border-radius: 50%; flex-shrink: 0; }
+        .llm-queue-item.running .llm-queue-item-dot { background: var(--cyan); box-shadow: 0 0 6px var(--cyan); animation: llmQueuePulse 1.2s infinite; }
+        .llm-queue-item.queued .llm-queue-item-dot { background: var(--text-muted); }
+        .llm-queue-item.done .llm-queue-item-dot { background: var(--accent); }
+        .llm-queue-item.error .llm-queue-item-dot { background: var(--danger); }
+        .llm-queue-item.cancelled .llm-queue-item-dot { background: var(--warning); }
+        @keyframes llmQueuePulse { 0%,100% { opacity: 1; } 50% { opacity: 0.35; } }
+        .llm-queue-item-info { flex: 1; min-width: 0; }
+        .llm-queue-item-label { color: var(--text-primary); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+        .llm-queue-item-status { color: var(--text-muted); font-size: 10px; }
+        .llm-queue-item-stop {
+            background: none; border: 1px solid var(--border-color); color: var(--text-muted);
+            width: 20px; height: 20px; border-radius: 3px; cursor: pointer; font-size: 11px; flex-shrink: 0; line-height: 1;
+        }
+        .llm-queue-item-stop:hover { color: var(--danger); border-color: var(--danger); }
+        /* Live log panel inside the queue popup — a real-time feed of what the harness
+           is launching (benchmarks, API calls, fallbacks, pass/fail). */
+        .llm-queue-header-btns { display: flex; gap: 4px; align-items: center; }
+        .llm-queue-log {
+            max-height: 190px; overflow-y: auto; border-top: 1px solid var(--border-color);
+            background: var(--bg-primary); font-size: 10px; padding: 3px 0; display: none;
+        }
+        .llm-queue-log.show { display: block; }
+        .llm-queue-popup.minimized .llm-queue-log { display: none !important; }
+        .llm-queue-log-entry {
+            display: flex; gap: 6px; padding: 2px 10px; line-height: 1.35;
+            border-left: 2px solid transparent; word-break: break-word;
+        }
+        .llm-queue-log-time { color: var(--text-muted); flex-shrink: 0; font-size: 9px; }
+        .llm-queue-log-src { color: var(--text-secondary); font-weight: 700; flex-shrink: 0; font-size: 9px; letter-spacing: 0.3px; }
+        .llm-queue-log-msg { color: var(--text-primary); flex: 1; min-width: 0; }
+        .llm-queue-log-entry.info { border-left-color: var(--cyan, #0088ff); }
+        .llm-queue-log-entry.success { border-left-color: var(--accent, #00ff88); }
+        .llm-queue-log-entry.warning { border-left-color: var(--warning, #ffaa00); }
+        .llm-queue-log-entry.error, .llm-queue-log-entry.danger { border-left-color: var(--danger, #ff4444); }
+        .llm-queue-log-entry.error .llm-queue-log-msg, .llm-queue-log-entry.danger .llm-queue-log-msg { color: var(--danger, #ff4444); }
+        .llm-queue-log-empty { color: var(--text-muted); padding: 8px 10px; font-style: italic; font-size: 10px; }
+
         /* Scrollbar */
         ::-webkit-scrollbar { width: 6px; height: 6px; }
         ::-webkit-scrollbar-track { background: var(--bg-primary); }
@@ -939,6 +1029,7 @@
         .bench-result.pass { color: var(--accent); }
         .bench-result.fail { color: var(--danger); }
         .bench-result.partial { color: var(--warning); }
+        .bench-result.cancelled { color: var(--warning); opacity: 0.8; }
 
         .perf-bar {
             width: 100%;
@@ -3457,6 +3548,11 @@
                 <button class="mobile-toggle" onclick="toggleSidebar()">☰</button>
                 <h1 class="header-title" id="pageTitle">War Room</h1>
                 <div class="header-actions">
+                    <span id="egressIpBadge" class="egress-badge egress-loading" onclick="refreshEgressIp(true)" title="Egress IP for test traffic — click to re-check">
+                        <span class="egress-dot"></span>
+                        <span class="egress-label">IP:</span>
+                        <span class="egress-ip" id="egressIpValue">…</span>
+                    </span>
                     <button class="btn btn-secondary" onclick="if(window.t3mpTour)t3mpTour.start()" title="Take the guided tour" aria-label="Guided tour" style="font-weight:700;">?</button>
                     <button class="btn btn-secondary" onclick="openQuickActions()">⌘ Actions</button>
                     <button class="btn btn-primary" onclick="navigateTo('warroom')">⚔️ War Room</button>
@@ -5609,6 +5705,78 @@
                         </div>
                     </div>
 
+                    <div class="settings-section">
+                        <h2 class="settings-title">🖥️ Local Model (llama.cpp / Ollama / OpenAI-compatible)</h2>
+                        <p style="color: var(--text-muted); font-size: 12px; margin-bottom: 12px;">
+                            Point the War Room at a model running on your own host — <b style="color:#bcd;">no cloud, no OpenRouter</b>.
+                            Requires <code>npm run server</code>. When enabled, BOTH server-dispatched missions/General AND the
+                            browser "AI" features route through your local model.
+                        </p>
+                        <div class="card">
+                            <label style="display:flex; align-items:center; gap:8px; cursor:pointer; margin-bottom:14px; font-size:14px; font-weight:700; color:#2fd6ff;">
+                                <input type="checkbox" id="useLocalToggle" style="accent-color:#2fd6ff; width:16px; height:16px;">
+                                Use the local model for all LLM calls
+                            </label>
+                            <div style="display:grid; grid-template-columns: 2fr 1fr 1fr; gap:10px;">
+                                <div class="form-group">
+                                    <label style="font-size:12px; color:var(--text-muted);">Host / IP</label>
+                                    <input type="text" class="form-input" id="localHost" placeholder="127.0.0.1">
+                                </div>
+                                <div class="form-group">
+                                    <label style="font-size:12px; color:var(--text-muted);">Port</label>
+                                    <input type="text" class="form-input" id="localPort" placeholder="8080">
+                                </div>
+                                <div class="form-group">
+                                    <label style="font-size:12px; color:var(--text-muted);">API path</label>
+                                    <input type="text" class="form-input" id="localPath" placeholder="/v1">
+                                </div>
+                            </div>
+                            <div class="form-hint" style="margin:-6px 0 12px;">
+                                llama.cpp (OpenAI-compatible server): path <code>/v1</code> · Ollama native: path <code>/api</code> (port <code>11434</code>) · LM Studio: <code>/v1</code> (port <code>1234</code>)
+                            </div>
+                            <div class="form-group">
+                                <label style="font-size:12px; color:var(--text-muted);">Model tag</label>
+                                <input type="text" class="form-input" id="localModel" placeholder="e.g. qwen2.5-coder / llama3 / the loaded gguf name">
+                            </div>
+                            <div class="form-group">
+                                <label style="font-size:12px; color:var(--text-muted);">API key (optional — llama.cpp <code>--api-key</code>)</label>
+                                <div class="api-key-input">
+                                    <input type="password" class="form-input" id="localApiKey" placeholder="leave empty if the server needs none">
+                                    <button class="api-key-toggle" onclick="toggleApiKey('localApiKey')">Show</button>
+                                </div>
+                            </div>
+                            <div style="display:flex; gap:10px; flex-wrap:wrap;">
+                                <button class="btn btn-primary btn-sm" onclick="saveLocalConfig()">Save</button>
+                                <button class="btn btn-sm" onclick="testLocalConfig()" style="background:rgba(255,255,255,0.05);border:1px solid rgba(0,200,255,0.3);color:#bcd;">Test connection</button>
+                            </div>
+                            <div id="localTestResult" style="font-size:12px; margin-top:10px; color:var(--text-muted);"></div>
+                        </div>
+                    </div>
+
+                    <div class="settings-section">
+                        <h2 class="settings-title">🧅 Egress Proxy (SOCKS5)</h2>
+                        <p style="color: var(--text-muted); font-size: 12px; margin-bottom: 12px;">
+                            Route all probe/attack <code>fetch()</code> traffic through a <b style="color:#bcd;">SOCKS5 proxy</b> so tests
+                            don't leave from your own IP (Tor, an SSH <code>-D</code> tunnel, a VPS, etc.). Loopback (the local model &amp; this
+                            server) is always bypassed. Requires <code>npm run server</code>; also settable via <code>TEMPEST_PROXY_URL</code>.
+                        </p>
+                        <div class="card">
+                            <div class="form-group">
+                                <label style="font-size:12px; color:var(--text-muted);">SOCKS5 URL — <code>socks5://[user:pass@]host:port</code></label>
+                                <input type="text" class="form-input" id="proxyUrl" placeholder="socks5://127.0.0.1:9050  (empty = direct / your own IP)">
+                            </div>
+                            <div class="form-hint" style="margin:-6px 0 12px;">
+                                Tor: <code>socks5://127.0.0.1:9050</code> · SSH tunnel: <code>ssh -D 1080 host</code> → <code>socks5://127.0.0.1:1080</code>. Use <code>socks5h://</code> to resolve DNS at the proxy.
+                            </div>
+                            <div style="display:flex; gap:10px; flex-wrap:wrap;">
+                                <button class="btn btn-primary btn-sm" onclick="saveProxyConfig()">Save &amp; apply</button>
+                                <button class="btn btn-sm" onclick="saveProxyConfig('')" style="background:rgba(255,255,255,0.05);border:1px solid rgba(255,255,255,0.2);color:#bcd;">Disable (direct)</button>
+                                <button class="btn btn-sm" onclick="checkProxyIp()" style="background:rgba(255,255,255,0.05);border:1px solid rgba(0,200,255,0.3);color:#bcd;">Check IP now</button>
+                            </div>
+                            <div id="proxyTestResult" style="font-size:12px; margin-top:10px; color:var(--text-muted);"></div>
+                        </div>
+                    </div>
+
                     <div class="settings-section">
                         <h2 class="settings-title">🔌 Local Agents</h2>
                         <p style="color: var(--text-muted); font-size: 12px; margin-bottom: 12px;">Enlist agents you've already authed on this machine — <b style="color:#bcd;">no API keys needed</b>. T3MP3ST detects each CLI and can drive it as an operator. Tick several and connect them all at once.</p>
@@ -5888,6 +6056,20 @@ tempest.operators.<span class="function">spawn</span>(<span class="string">'scan
     <!-- Toast Container -->
     <div class="toast-container" id="toastContainer"></div>
 
+    <!-- LLM Call Queue — live Q&A feed for sequential (single-slot) LLM calls, e.g. local models -->
+    <div class="llm-queue-popup" id="llmQueuePopup" style="display:none;">
+        <div class="llm-queue-header" onclick="toggleLLMQueueMinimize()">
+            <span class="llm-queue-title">⚡ LLM Queue <span id="llmQueueCount">0</span></span>
+            <div class="llm-queue-header-btns">
+                <button class="llm-queue-min-btn" onclick="event.stopPropagation(); toggleLLMQueueLog()" title="Mostra/nascondi log live">▤</button>
+                <button class="llm-queue-min-btn" onclick="event.stopPropagation(); toggleLLMQueueMinimize()" title="Minimizza">_</button>
+                <button class="llm-queue-min-btn" onclick="event.stopPropagation(); closeLLMQueuePopup()" title="Chiudi">✕</button>
+            </div>
+        </div>
+        <div class="llm-queue-body" id="llmQueueBody"></div>
+        <div class="llm-queue-log show" id="llmQueueLog"><div class="llm-queue-log-empty">In attesa di attività…</div></div>
+    </div>
+
     <script>
         // State
         const state = {
@@ -5896,7 +6078,7 @@ tempest.operators.<span class="function">spawn</span>(<span class="string">'scan
             findings: [],
             credentials: [],
             activities: [],
-            settings: { openrouterKey: '', anthropicKey: '', openaiKey: '', selectedModel: 'anthropic/claude-opus-4.6', fallbackModel: 'nousresearch/hermes-3-llama-3.1-405b' },
+            settings: { openrouterKey: '', anthropicKey: '', openaiKey: '', selectedModel: 'anthropic/claude-opus-4.6', fallbackModel: 'nousresearch/hermes-3-llama-3.1-405b', localHost: '127.0.0.1', localPort: '8080', localPath: '/v1', localModel: '', localApiKey: '', useLocal: false },
             connected: false
         };
 
@@ -6377,6 +6559,11 @@ tempest.operators.<span class="function">spawn</span>(<span class="string">'scan
              * Start a mission via the backend
              */
             async startMission(missionName, targets, operators, apiKey, provider, model, approvalId) {
+                // For a local provider, carry the operator's llama.cpp / Ollama base URL and
+                // (optional) key from Settings so the server dispatches the mission to it.
+                const localExtras = (provider === 'local' && typeof buildLocalBaseUrl === 'function')
+                    ? { baseUrl: buildLocalBaseUrl(), apiKey: state.settings?.localApiKey || undefined }
+                    : {};
                 const result = await T3MP3ST_API.post('/api/mission/start', {
                     name: missionName,
                     targets: targets.map(t => ({ host: t.host || t })),
@@ -6384,6 +6571,7 @@ tempest.operators.<span class="function">spawn</span>(<span class="string">'scan
                     apiKey,
                     provider,
                     model,
+                    ...localExtras, // local: overrides apiKey with the Settings key + adds baseUrl
                     ...(approvalId ? { approvalId } : {}),
                 });
                 if (result.success) {
@@ -7114,6 +7302,19 @@ Correlating findings across agents, identifying patterns, producing actionable i
             if (veKey) veKey.value = state.settings.veniceKey || '';
             if (anKey) anKey.value = state.settings.anthropicKey || '';
             if (oaKey) oaKey.value = state.settings.openaiKey || '';
+            // Local model (llama.cpp / Ollama / OpenAI-compatible)
+            const setV = (id, v) => { const n = document.getElementById(id); if (n) n.value = v; };
+            setV('localHost', state.settings.localHost || '127.0.0.1');
+            setV('localPort', state.settings.localPort || '8080');
+            setV('localPath', state.settings.localPath || '/v1');
+            setV('localModel', state.settings.localModel || '');
+            setV('localApiKey', state.settings.localApiKey || '');
+            const ult = document.getElementById('useLocalToggle');
+            if (ult) ult.checked = !!state.settings.useLocal;
+            // Egress SOCKS5 proxy — the field holds the full URL (with creds) the operator
+            // typed; the server only ever returns a redacted form, so we repopulate from the
+            // local cache. If the server has one set via TEMPEST_PROXY_URL, the badge shows it.
+            setV('proxyUrl', localStorage.getItem('t3mp3st_proxy_url') || '');
         }
 
         function saveState() {
@@ -8520,6 +8721,19 @@ o.id === 'coordinator' ? `1. MISSION_STATUS: Progress assessment
             return div.innerHTML;
         }
 
+        // escapeHtml (the textContent/innerHTML trick) only escapes & < > — it does NOT escape quotes,
+        // because that's only applied when serializing an actual attribute, not a text node. Any string
+        // interpolated into an HTML attribute value (title="...", etc.) must use this instead, or a
+        // literal " in the source string breaks out of the attribute (e.g. remote-sourced benchmark names).
+        function escapeAttr(text) {
+            return String(text)
+                .replace(/&/g, '&amp;')
+                .replace(/"/g, '&quot;')
+                .replace(/'/g, '&#39;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;');
+        }
+
 
 
         function filterArsenalByCat(cat) {
@@ -8817,6 +9031,123 @@ o.id === 'coordinator' ? `1. MISSION_STATUS: Progress assessment
             toast(`${provider} key saved`, 'success');
         }
 
+        // ── Local model (llama.cpp / Ollama / OpenAI-compatible) ───────────────
+        // Compose host + port + path into the base URL the LocalAdapter expects.
+        // A base URL ending in /vN (e.g. llama.cpp's /v1) routes over the OpenAI wire;
+        // /api routes over Ollama's native wire.
+        function buildLocalBaseUrl() {
+            const host = (state.settings.localHost || '127.0.0.1').trim().replace(/^https?:\/\//, '').replace(/\/$/, '');
+            const port = (state.settings.localPort || '').trim();
+            let path = (state.settings.localPath || '/v1').trim();
+            if (!path.startsWith('/')) path = '/' + path;
+            path = path.replace(/\/$/, '');
+            return `http://${host}${port ? ':' + port : ''}${path}`;
+        }
+
+        function readLocalInputsIntoState() {
+            state.settings.localHost = document.getElementById('localHost').value.trim() || '127.0.0.1';
+            state.settings.localPort = document.getElementById('localPort').value.trim();
+            state.settings.localPath = document.getElementById('localPath').value.trim() || '/v1';
+            state.settings.localModel = document.getElementById('localModel').value.trim();
+            state.settings.localApiKey = document.getElementById('localApiKey').value.trim();
+            state.settings.useLocal = document.getElementById('useLocalToggle').checked;
+        }
+
+        function saveLocalConfig() {
+            readLocalInputsIntoState();
+            saveState();
+            const url = buildLocalBaseUrl();
+            if (typeof updatePreflightChecklist === 'function') updatePreflightChecklist();
+            addActivity('success', `Local model ${state.settings.useLocal ? 'ENABLED' : 'config saved'} (${state.settings.localModel || 'default'})`, 'Settings');
+            toast(`Local model ${state.settings.useLocal ? 'enabled' : 'saved'} → ${url}`, 'success');
+        }
+
+        // ── Egress SOCKS5 proxy (Settings → Egress Proxy) ──
+        // Persists on the server (drives the global fetch dispatcher) AND caches locally
+        // so the field repopulates. Pass '' to disable. `override` lets the "Disable" button
+        // clear it regardless of the field's current text.
+        async function saveProxyConfig(override) {
+            const el = document.getElementById('proxyTestResult');
+            const input = document.getElementById('proxyUrl');
+            const url = (typeof override === 'string') ? override : (input ? input.value.trim() : '');
+            if (el) { el.style.color = 'var(--text-muted)'; el.textContent = '⏳ Applying proxy …'; }
+            try {
+                const r = await fetch(`${getApiBase()}/api/net/proxy`, {
+                    method: 'POST', headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ url }),
+                });
+                const d = await r.json();
+                if (!r.ok) throw new Error(d.error || ('HTTP ' + r.status));
+                if (input && typeof override === 'string') input.value = override;
+                localStorage.setItem('t3mp3st_proxy_url', url);
+                if (el) {
+                    el.style.color = d.enabled ? '#7CFFC4' : 'var(--text-muted)';
+                    el.textContent = d.enabled ? `✅ Proxy active → ${d.url} (loopback bypassed). Verifying egress IP…` : '✅ Proxy disabled — egress is direct (your own IP).';
+                }
+                toast(d.enabled ? `Egress proxy enabled → ${d.url}` : 'Egress proxy disabled', d.enabled ? 'success' : 'info');
+                addActivity('success', d.enabled ? `Egress proxy ENABLED (${d.url})` : 'Egress proxy disabled', 'Settings');
+                // Re-check the badge/IP right away (force = skip the server cache).
+                setTimeout(() => { refreshEgressIp(true); checkProxyIp(); }, 400);
+            } catch (e) {
+                if (el) { el.style.color = '#ff8080'; el.textContent = '❌ ' + (e.message || e); }
+                toast('Proxy config failed: ' + (e.message || e), 'error');
+            }
+        }
+
+        async function checkProxyIp() {
+            const el = document.getElementById('proxyTestResult');
+            if (el) { el.style.color = 'var(--text-muted)'; el.textContent = '⏳ Checking egress IP via ifconfig.co …'; }
+            try {
+                const r = await fetch(`${getApiBase()}/api/net/ip?force=1`);
+                const d = await r.json();
+                if (!r.ok) throw new Error(d.error || ('HTTP ' + r.status));
+                const exit = (d.exit && d.exit.ip) || '—';
+                const real = (d.direct && d.direct.ip) || '—';
+                const cc = (d.exit && d.exit.country) ? ` (${d.exit.country})` : '';
+                if (el) {
+                    if (d.leak) {
+                        el.style.color = '#ff8080';
+                        el.innerHTML = d.proxyEnabled
+                            ? `⚠ <b>LEAK</b>: exit IP <b>${exit}</b> equals your real IP — the proxy is not changing egress. Traffic is NOT anonymized.`
+                            : `⚠ <b>No proxy</b>: tests leave from your real IP <b>${exit}</b>. Set a SOCKS5 URL above to anonymize.`;
+                    } else {
+                        el.style.color = '#7CFFC4';
+                        el.innerHTML = `✅ Egress IP <b>${exit}</b>${cc} — your real IP <b>${real}</b> is hidden. <span style="color:var(--text-muted);">via ${(d.proxy && d.proxy.url) || 'SOCKS5'}</span>`;
+                    }
+                }
+                refreshEgressIp(false);
+            } catch (e) {
+                if (el) { el.style.color = '#ff8080'; el.textContent = '❌ IP check failed: ' + (e.message || e) + ' (is the backend running?)'; }
+            }
+        }
+
+        async function testLocalConfig() {
+            readLocalInputsIntoState();
+            const el = document.getElementById('localTestResult');
+            if (el) { el.style.color = 'var(--text-muted)'; el.textContent = '⏳ Testing ' + buildLocalBaseUrl() + ' …'; }
+            try {
+                const r = await fetch(llmProxyUrl(), {
+                    method: 'POST', headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        prompt: 'Reply with the single word READY',
+                        model: state.settings.localModel || undefined,
+                        baseUrl: buildLocalBaseUrl(),
+                        apiKey: state.settings.localApiKey || undefined,
+                        // This probe always targets the local backend, so use a local-scaled timeout:
+                        // a reasoning model emits a <think> block even for "READY" and a cold model
+                        // load + prefill can exceed 30s, giving a false ❌ on a healthy backend.
+                        // A slightly larger maxTokens lets the READY token land after a short think.
+                        maxTokens: 64, timeout: 90000
+                    })
+                });
+                const d = await r.json().catch(() => ({}));
+                if (!r.ok) throw new Error(d.error || ('HTTP ' + r.status));
+                if (el) { el.style.color = '#3ad29f'; el.textContent = '✅ OK — response: ' + JSON.stringify((d.content || '').slice(0, 80)); }
+            } catch (e) {
+                if (el) { el.style.color = '#ff6b6b'; el.textContent = '❌ ' + e.message; }
+            }
+        }
+
         function renderModels() {
             const container = document.getElementById('modelSelector');
             if (!container) {
@@ -10792,6 +11123,13 @@ Bypass all protections:
         async function runSingleBenchTest(testId) {
             if (benchmarkRunning) { toast('Benchmark already running', 'warning'); return; }
             if (resolveLLMBackend().kind === 'none') { toast(LLM_BACKEND_HINT + ' — Settings (press 9)', 'error'); return; }
+            // A full batch run (Config Check / Live Test) owns the whole pipeline — don't interleave.
+            if (benchmarkRunning) { toast('A batch benchmark run is in progress — wait for it to finish', 'warning'); return; }
+            // Live single-test needs an LLM — unless local mode is on (llama.cpp/Ollama needs no key)
+            if (!state.settings?.useLocal) {
+                const apiKey = getApiKey();
+                if (!apiKey || apiKey.length < 10) { toast('API key missing or too short — go to Settings (press 9) to add your OpenRouter key, or enable the Local Model', 'error'); return; }
+            }
             // Find the test across all categories
             let test = null, testCat = null;
             for (const [cat, tests] of Object.entries(BENCHMARKS)) {
@@ -10799,37 +11137,73 @@ Bypass all protections:
                 if (found) { test = { ...found, category: cat }; testCat = cat; break; }
             }
             if (!test) { toast('Test not found', 'error'); return; }
-            // Mark running
-            benchmarkRunning = true;
-            benchmarkMode = 'live';
+
             const testEl = document.querySelector(`[data-test="${testId}"] .bench-result`);
-            if (testEl) { testEl.textContent = '...'; testEl.className = 'bench-result'; }
+
+            // Queue instead of rejecting — a local model typically serves one call at a time.
+            // Live status shows in the bottom-right popup; the operator can cancel from there.
+            // dedupeKey=testId: a 2nd click on an already queued/running test must NOT spawn a second
+            // run — that would race two invocations over the same testEl/benchmarkResults slot.
+            const qItem = llmQueuePush(test.name, testId);
+            if (qItem.isDuplicate) { toast(`${test.name} is already queued/running`, 'warning'); return; }
+            if (testEl) { testEl.textContent = '⏳'; testEl.className = 'bench-result'; testEl.title = 'Queued'; }
+            const started = await llmQueueWaitTurn(qItem);
+            if (!started) {
+                if (testEl) { testEl.textContent = '--'; testEl.className = 'bench-result'; testEl.title = ''; }
+                return; // cancelled while still waiting in the queue
+            }
+
+            benchmarkMode = 'live';
+            if (testEl) { testEl.textContent = '...'; testEl.className = 'bench-result'; testEl.title = ''; }
             toast(`Running: ${test.name}...`, 'info');
             try {
                 const startTime = performance.now();
                 const result = test.configCheck
                     ? (test.async ? await test.configCheck() : test.configCheck())
-                    : await runLiveBenchmark(test);
+                    : await runLiveBenchmark(test, qItem);
                 if (test.configCheck) result.score = result.passed ? 100 : 0;
                 const elapsed = Math.round(performance.now() - startTime);
                 benchmarkResults[testCat].tests[testId] = {
                     score: result.score, time: elapsed, passed: result.passed,
+                    error: result.error || false,
                     details: result.details, response: result.response,
                     evaluation: result.evaluation || null,
                     foundKeywords: result.foundKeywords || [],
                     missingRequired: result.missingRequired || []
                 };
                 if (testEl) {
-                    testEl.textContent = result.passed ? `✓ ${result.score}%` : `✗ ${result.score}%`;
-                    testEl.className = `bench-result ${result.passed ? 'pass' : result.score >= 50 ? 'partial' : 'fail'}`;
-                    testEl.title = result.details || '';
+                    if (result.cancelled) {
+                        testEl.textContent = 'CANC';
+                        testEl.className = 'bench-result cancelled';
+                        testEl.title = 'Cancelled by operator';
+                    } else if (result.error) {
+                        // LLM call failed (unreachable model / timeout) — distinct from a wrong answer.
+                        testEl.textContent = 'ERR';
+                        testEl.className = 'bench-result fail';
+                        testEl.title = result.details || 'LLM call failed';
+                    } else {
+                        testEl.textContent = result.passed ? `✓ ${result.score}%` : `✗ ${result.score}%`;
+                        testEl.className = `bench-result ${result.passed ? 'pass' : result.score >= 50 ? 'partial' : 'fail'}`;
+                        testEl.title = result.details || '';
+                    }
                 }
-                toast(`${test.name}: ${result.score}% ${result.passed ? '(PASS)' : '(FAIL)'}`, result.passed ? 'success' : 'warning');
+                if (result.cancelled) {
+                    // llmQueueCancel already toasted "Cancelled: <name>"
+                } else if (result.error) {
+                    toast(`${test.name}: ERROR — ${result.details}`, 'error');
+                } else {
+                    toast(`${test.name}: ${result.score}% ${result.passed ? '(PASS)' : '(FAIL)'}`, result.passed ? 'success' : 'warning');
+                }
+                llmQueueFinish(qItem, result.cancelled ? 'cancelled' : (result.error ? 'error' : 'done'));
             } catch (err) {
-                if (testEl) { testEl.textContent = 'ERR'; testEl.className = 'bench-result fail'; }
-                toast(`${test.name}: ${err.message}`, 'error');
+                const cancelled = qItem.status === 'cancelled';
+                if (testEl) {
+                    testEl.textContent = cancelled ? 'CANC' : 'ERR';
+                    testEl.className = cancelled ? 'bench-result cancelled' : 'bench-result fail';
+                }
+                if (!cancelled) toast(`${test.name}: ${err.message}`, 'error');
+                llmQueueFinish(qItem, cancelled ? 'cancelled' : 'error');
             }
-            benchmarkRunning = false;
         }
 
         // Auto-improve toggle shows/hides iterations input + bench-test click delegation
@@ -10925,6 +11299,212 @@ Bypass all protections:
                 models = options._noFallback ? [primaryModel]
                     : (primaryModel === fallbackModel ? [primaryModel] : [primaryModel, fallbackModel]);
             }
+        // Same-origin proxy the browser "AI" features POST to when local mode is on.
+        // The server (npm run server) serves this page, so /api/llm/chat is same-origin
+        // (no CORS) and reuses LLMBackbone -> LocalAdapter to reach llama.cpp/Ollama.
+        function llmProxyUrl() {
+            const custom = localStorage.getItem('t3mp3st_api_url');
+            return (custom ? custom.replace(/\/$/, '') : '') + '/api/llm/local';
+        }
+
+        // Local CPU/GPU inference is far slower than cloud APIs — a 30s timeout tuned for
+        // OpenRouter cuts off llama.cpp mid-generation. Scale call timeouts up when local mode is on.
+        function llmTimeoutFor(baseMs) {
+            return state.settings?.useLocal ? Math.max(baseMs, 120000) : baseMs;
+        }
+
+        // ═══════════ LLM CALL QUEUE — live bottom-right popup for sequential (single-slot) LLM calls ═══════════
+        // Local backends (llama.cpp/Ollama) typically serve one inference at a time. Rather than reject a
+        // benchmark click while one is running, queue it and show live status; let the operator cancel
+        // any queued or in-flight call (important given how slow big local models can be).
+        const llmQueue = []; // { id, label, status: 'queued'|'running'|'done'|'error'|'cancelled', startedAt, controller }
+        let llmQueueSeq = 0;
+        let llmQueueActiveId = null;
+        let llmQueueMinimized = false;
+        let llmQueueHideTimer = null;
+
+        // dedupeKey (e.g. the benchmark testId) prevents two independent runs of the SAME test from
+        // both being queued — without this, a double-click on a still-'...' cell spawns a second
+        // qItem that stomps the first one's live DOM/result state (confirmed bug from code review).
+        // Returns the existing item if one is already queued/running for that key, and null-safe callers
+        // should check `item.isDuplicate` to decide whether to bail out instead of running again.
+        function llmQueuePush(label, dedupeKey) {
+            if (dedupeKey) {
+                const existing = llmQueue.find(q => q.dedupeKey === dedupeKey && (q.status === 'queued' || q.status === 'running'));
+                if (existing) { existing.isDuplicate = true; return existing; }
+            }
+            const item = { id: ++llmQueueSeq, label, dedupeKey, status: 'queued', startedAt: null, controller: null };
+            llmQueue.push(item);
+            if (llmQueueHideTimer) { clearTimeout(llmQueueHideTimer); llmQueueHideTimer = null; }
+            renderLLMQueue();
+            return item;
+        }
+
+        // Resolves once `item` is allowed to run (FIFO among queued items, one active slot).
+        // Resolves false if the item was cancelled while still waiting.
+        function llmQueueWaitTurn(item) {
+            return new Promise(resolve => {
+                (function tick() {
+                    if (item.status === 'cancelled') { resolve(false); return; }
+                    const nextQueued = llmQueue.find(q => q.status === 'queued');
+                    if (llmQueueActiveId === null && nextQueued && nextQueued.id === item.id) {
+                        llmQueueActiveId = item.id;
+                        item.status = 'running';
+                        item.startedAt = Date.now();
+                        renderLLMQueue();
+                        resolve(true);
+                        return;
+                    }
+                    setTimeout(tick, 150);
+                })();
+            });
+        }
+
+        function llmQueueFinish(item, status) {
+            item.status = status; // 'done' | 'error' | 'cancelled'
+            if (llmQueueActiveId === item.id) llmQueueActiveId = null; // free the slot for the next queued item
+            renderLLMQueue();
+            // keep the finished item visible briefly (live feed), then drop it
+            setTimeout(() => {
+                const idx = llmQueue.indexOf(item);
+                if (idx >= 0) llmQueue.splice(idx, 1);
+                renderLLMQueue();
+                scheduleLLMQueueAutoHide();
+            }, 4000);
+        }
+
+        window.llmQueueCancel = function(id) {
+            const item = llmQueue.find(q => q.id === id);
+            if (!item) return;
+            const wasRunning = item.status === 'running';
+            item.status = 'cancelled';
+            if (wasRunning) {
+                if (item.controller) { try { item.controller.abort(); } catch (_) {} }
+                if (llmQueueActiveId === item.id) llmQueueActiveId = null; // free the slot immediately
+            }
+            renderLLMQueue();
+            if (window.toast) toast(`Cancelled: ${item.label}`, 'warning');
+            setTimeout(() => {
+                const idx = llmQueue.indexOf(item);
+                if (idx >= 0) llmQueue.splice(idx, 1);
+                renderLLMQueue();
+                scheduleLLMQueueAutoHide();
+            }, wasRunning ? 2000 : 0);
+        };
+
+        window.toggleLLMQueueMinimize = function() {
+            llmQueueMinimized = !llmQueueMinimized;
+            const el = document.getElementById('llmQueuePopup');
+            if (el) el.classList.toggle('minimized', llmQueueMinimized);
+            updateToastOffset();
+        };
+
+        // Auto-hide DISABLED by request: once open, the popup stays open so its live log
+        // remains readable during AND after a benchmark run. It's dismissed only manually
+        // via the ✕ button (closeLLMQueuePopup). Kept as a no-op so existing callers work
+        // and never leave a stale hide timer armed.
+        function scheduleLLMQueueAutoHide() {
+            if (llmQueueHideTimer) { clearTimeout(llmQueueHideTimer); llmQueueHideTimer = null; }
+        }
+
+        // Manual close — the only way the popup goes away now that auto-hide is off.
+        window.closeLLMQueuePopup = function() {
+            const el = document.getElementById('llmQueuePopup');
+            if (el) el.style.display = 'none';
+            updateToastOffset();
+        };
+
+        // Show/hide the live log panel (kept visible by default during activity).
+        window.toggleLLMQueueLog = function() {
+            const log = document.getElementById('llmQueueLog');
+            if (!log) return;
+            log.classList.toggle('show');
+            if (log.classList.contains('show')) log.scrollTop = log.scrollHeight;
+            updateToastOffset();
+        };
+
+        // Live log inside the popup — mirrors every addIntel event so the operator can
+        // watch, in real time, exactly what the harness is launching (benchmarks, API
+        // calls, model fallbacks, pass/fail) without leaving the War Room. Capped to the
+        // last LLM_QUEUE_LOG_MAX lines; autoscrolls only when already pinned to bottom so
+        // scrolling back to read history isn't yanked away by new entries.
+        const LLM_QUEUE_LOG_MAX = 200;
+        let llmQueueLogPrimed = false;
+        function pushLLMLog(source, message, type = 'info') {
+            const log = document.getElementById('llmQueueLog');
+            if (!log) return;
+            if (!llmQueueLogPrimed) { log.innerHTML = ''; llmQueueLogPrimed = true; } // clear the placeholder
+            const time = new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' });
+            const atBottom = log.scrollHeight - log.scrollTop - log.clientHeight < 24;
+            const entry = document.createElement('div');
+            entry.className = 'llm-queue-log-entry ' + type;
+            entry.innerHTML = `<span class="llm-queue-log-time">${time}</span>`
+                + `<span class="llm-queue-log-src">${escapeHtml(String(source).toUpperCase())}</span>`
+                + `<span class="llm-queue-log-msg">${escapeHtml(String(message))}</span>`;
+            log.appendChild(entry);
+            while (log.childElementCount > LLM_QUEUE_LOG_MAX) log.removeChild(log.firstChild);
+            if (atBottom) log.scrollTop = log.scrollHeight;
+        }
+
+        // Both the queue popup and the toast container are anchored bottom-right — push toasts up
+        // above the popup while it's showing so notifications (pass/fail/cancelled) stay visible
+        // instead of rendering underneath the opaque, higher-z-index popup.
+        function updateToastOffset() {
+            const tc = document.getElementById('toastContainer');
+            if (!tc) return;
+            const popup = document.getElementById('llmQueuePopup');
+            // The popup now stays open (no auto-hide) even with an empty queue, and its
+            // height varies with the live log — so measure it instead of assuming 320px,
+            // and don't gate visibility on queue length.
+            const popupVisible = !!(popup && popup.style.display !== 'none');
+            if (!popupVisible) { tc.style.bottom = '20px'; return; }
+            if (llmQueueMinimized) { tc.style.bottom = '60px'; return; }
+            const h = popup.getBoundingClientRect().height || 300;
+            tc.style.bottom = Math.round(h + 30) + 'px';
+        }
+
+        const LLM_QUEUE_STATUS_LABEL = { queued: 'queued…', running: 'running…', done: '✓ done', error: '✗ error', cancelled: 'cancelled' };
+        function renderLLMQueue() {
+            const popup = document.getElementById('llmQueuePopup');
+            const body = document.getElementById('llmQueueBody');
+            const countEl = document.getElementById('llmQueueCount');
+            if (!popup || !body) return;
+            if (llmQueue.length === 0) { return; } // let scheduleLLMQueueAutoHide handle hiding
+            popup.style.display = 'block';
+            const activeCount = llmQueue.filter(q => q.status === 'queued' || q.status === 'running').length;
+            if (countEl) countEl.textContent = activeCount || llmQueue.length;
+            body.innerHTML = llmQueue.map(item => {
+                const elapsed = item.startedAt ? Math.round((Date.now() - item.startedAt) / 1000) + 's' : '';
+                const canStop = item.status === 'queued' || item.status === 'running';
+                const safeLabel = escapeAttr(item.label);
+                return `<div class="llm-queue-item ${item.status}">
+                    <span class="llm-queue-item-dot"></span>
+                    <span class="llm-queue-item-info">
+                        <div class="llm-queue-item-label" title="${safeLabel}">${escapeHtml(item.label)}</div>
+                        <div class="llm-queue-item-status">${LLM_QUEUE_STATUS_LABEL[item.status] || item.status}${elapsed ? ' · ' + elapsed : ''}</div>
+                    </span>
+                    ${canStop ? `<button class="llm-queue-item-stop" onclick="llmQueueCancel(${item.id})" title="Stop">✕</button>` : ''}
+                </div>`;
+            }).join('');
+            updateToastOffset();
+        }
+        // Live-refresh elapsed timers on the running item while the popup is open
+        setInterval(() => { if (llmQueue.some(q => q.status === 'running') && !llmQueueMinimized) renderLLMQueue(); }, 1000);
+
+        // Shared safe LLM call — handles response.ok, JSON parsing, timeouts, model fallback
+        async function safeLLMCall(prompt, options = {}) {
+            const localMode = !!state.settings?.useLocal;
+            const apiKey = localMode ? 'local' : getApiKey();
+            if (!localMode && !apiKey) throw new Error('No API key configured');
+            const primaryModel = localMode
+                ? (state.settings?.localModel || 'local')
+                : (options.model || state.settings?.selectedModel || 'anthropic/claude-opus-4.6');
+            const fallbackModel = state.settings?.fallbackModel || 'nousresearch/hermes-3-llama-3.1-405b';
+            // Build model chain: local mode is single-model (no cloud fallback); otherwise
+            // primary then fallback (skip fallback if same as primary or caller pinned model).
+            const models = localMode ? [primaryModel]
+                : (options._noFallback ? [primaryModel]
+                : (primaryModel === fallbackModel ? [primaryModel] : [primaryModel, fallbackModel]));
 
             let lastError = null;
             for (const model of models) {
@@ -11008,6 +11588,83 @@ Bypass all protections:
                 }),
                 signal: AbortSignal.timeout(options.timeout || 120000)
             });
+
+            // LOCAL MODE: route through the same-origin server proxy (reuses
+            // LLMBackbone -> LocalAdapter; avoids browser CORS against llama.cpp/localhost).
+            if (state.settings?.useLocal) {
+                const localModel = state.settings.localModel || undefined;
+                addIntel('API', `→ local:${localModel || '(default)'}`, 'info');
+                const timeoutMs = options.timeout || 120000;
+                // Own AbortController (not AbortSignal.timeout) so a caller-supplied hook
+                // (e.g. the LLM queue's Stop button) can cancel this specific call mid-flight —
+                // the abort propagates through the server proxy to the local model itself.
+                const controller = new AbortController();
+                if (typeof options.onAbortController === 'function') { try { options.onAbortController(controller); } catch (_) {} }
+                const timer = setTimeout(() => controller.abort(), timeoutMs);
+                let response;
+                try {
+                    response = await fetch(llmProxyUrl(), {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            messages: Array.isArray(prompt) ? prompt : [{ role: 'user', content: prompt }],
+                            model: localModel,
+                            baseUrl: buildLocalBaseUrl(),
+                            apiKey: state.settings.localApiKey || undefined,
+                            maxTokens: options.maxTokens || 4096,
+                            temperature: options.temperature ?? 0.3,
+                            timeout: timeoutMs
+                        }),
+                        signal: controller.signal
+                    });
+                } catch (err) {
+                    if (controller.signal.aborted) throw new Error('Cancelled or timed out');
+                    throw err;
+                } finally {
+                    clearTimeout(timer);
+                }
+                if (!response.ok) {
+                    const errText = await response.text().catch(() => '');
+                    throw new Error(`Local LLM ${response.status}: ${errText.substring(0, 200)}`);
+                }
+                const data = await response.json();
+                return data.content || data.choices?.[0]?.message?.content || '';
+            }
+
+            addIntel('API', `→ ${model}`, 'info');
+            // Own AbortController here too (not a bare AbortSignal.timeout) so the queue's Stop
+            // button can actually cancel a cloud call, not just abandon it while it keeps running
+            // (and billing) in the background — same reasoning as the local-mode branch above.
+            const cloudTimeoutMs = options.timeout || 120000;
+            const cloudController = new AbortController();
+            if (typeof options.onAbortController === 'function') { try { options.onAbortController(cloudController); } catch (_) {} }
+            const cloudTimer = setTimeout(() => cloudController.abort(), cloudTimeoutMs);
+            let response;
+            try {
+                response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json',
+                        'HTTP-Referer': window.location.href,
+                        'X-Title': options.title || 'T3MP3ST'
+                    },
+                    body: JSON.stringify({
+                        model,
+                        messages: Array.isArray(prompt)
+                            ? prompt
+                            : [{ role: 'user', content: prompt }],
+                        max_tokens: options.maxTokens || 4096,
+                        temperature: options.temperature ?? 0.3
+                    }),
+                    signal: cloudController.signal
+                });
+            } catch (err) {
+                if (cloudController.signal.aborted) throw new Error('Cancelled or timed out');
+                throw err;
+            } finally {
+                clearTimeout(cloudTimer);
+            }
             if (!response.ok) {
                 const errText = await response.text().catch(() => '');
                 throw new Error(`API ${response.status}: ${errText.substring(0, 200)}`);
@@ -11018,6 +11675,7 @@ Bypass all protections:
 
         async function runBenchmarks(mode) {
             if (benchmarkRunning) return;
+            if (llmQueue.length > 0) { toast('Single test(s) still queued/running — wait for them to finish first', 'warning'); return; }
 
             if (state.operators.length === 0) {
                 toast('Spawn at least one operator first', 'error');
@@ -11035,6 +11693,11 @@ Bypass all protections:
             if (mode === 'live') {
                 if (resolveLLMBackend().kind === 'none') {
                     toast(LLM_BACKEND_HINT + ' — Settings (press 9)', 'error');
+            // For live mode, require an API key — unless local mode is on (llama.cpp/Ollama needs none)
+            if (mode === 'live' && !state.settings?.useLocal) {
+                const apiKey = getApiKey();
+                if (!apiKey || apiKey.length < 10) {
+                    toast('OpenRouter API key required for benchmarks — go to Settings (press 9) to configure, or enable the Local Model', 'error');
                     return;
                 }
             }
@@ -11097,6 +11760,7 @@ Bypass all protections:
                     score: result.score,
                     time: elapsed,
                     passed: result.passed,
+                    error: result.error || false,
                     details: result.details,
                     response: result.response,
                     // Rigorous evaluation data
@@ -11108,13 +11772,20 @@ Bypass all protections:
                 // Update UI with result
                 const testEl = document.querySelector(`[data-test="${test.id}"] .bench-result`);
                 if (testEl) {
-                    if (benchmarkMode === 'live') {
-                        testEl.textContent = result.passed ? `✓ ${result.score}%` : `✗ ${result.score}%`;
+                    if (result.error) {
+                        // LLM call failed — show ERR, never a misleading 0% score.
+                        testEl.textContent = 'ERR';
+                        testEl.className = 'bench-result fail';
+                        testEl.title = result.details || 'LLM call failed';
                     } else {
-                        testEl.textContent = result.passed ? '✓ READY' : '✗ MISSING';
+                        if (benchmarkMode === 'live') {
+                            testEl.textContent = result.passed ? `✓ ${result.score}%` : `✗ ${result.score}%`;
+                        } else {
+                            testEl.textContent = result.passed ? '✓ READY' : '✗ MISSING';
+                        }
+                        testEl.className = `bench-result ${result.passed ? 'pass' : result.score >= 50 ? 'partial' : 'fail'}`;
+                        testEl.title = result.details;
                     }
-                    testEl.className = `bench-result ${result.passed ? 'pass' : result.score >= 50 ? 'partial' : 'fail'}`;
-                    testEl.title = result.details;
                 }
 
                 completed++;
@@ -11138,7 +11809,9 @@ Bypass all protections:
                 let totalWeight = 0, weightedScore = 0;
                 tests.forEach(t => {
                     const result = benchmarkResults[cat].tests[t.id];
-                    if (result) {
+                    // Skip tests whose LLM call errored — a connection failure is not a
+                    // 0% capability result and must not drag the category average down.
+                    if (result && !result.error) {
                         weightedScore += result.score * t.weight;
                         totalWeight += t.weight;
                     }
@@ -11159,13 +11832,18 @@ Bypass all protections:
 
             // Calculate overall stats
             const allResults = Object.values(benchmarkResults).flatMap(c => Object.values(c.tests));
-            const overallScore = allResults.length > 0 ? Math.round(allResults.reduce((a, r) => a + r.score, 0) / allResults.length) : 0;
-            const passedCount = allResults.filter(r => r.passed).length;
-            const avgTime = allResults.length > 0 ? Math.round(allResults.reduce((a, r) => a + r.time, 0) / allResults.length) : 0;
-            const accuracy = allResults.length > 0 ? Math.round((passedCount / allResults.length) * 100) : 0;
+            // Errored tests (failed LLM call) are excluded from all aggregates — a
+            // connection failure is not a 0% capability result. They're surfaced via the
+            // ERR badge on the card and the (N ERR) counter below.
+            const scored = allResults.filter(r => !r.error);
+            const errCount = allResults.length - scored.length;
+            const overallScore = scored.length > 0 ? Math.round(scored.reduce((a, r) => a + r.score, 0) / scored.length) : 0;
+            const passedCount = scored.filter(r => r.passed).length;
+            const avgTime = scored.length > 0 ? Math.round(scored.reduce((a, r) => a + r.time, 0) / scored.length) : 0;
+            const accuracy = scored.length > 0 ? Math.round((passedCount / scored.length) * 100) : 0;
 
             document.getElementById('overallScore').textContent = `${overallScore}%`;
-            document.getElementById('passedTests').textContent = `${passedCount}/${allResults.length}`;
+            document.getElementById('passedTests').textContent = `${passedCount}/${scored.length}${errCount ? ` (${errCount} ERR)` : ''}`;
             document.getElementById('avgTime').textContent = benchmarkMode === 'live' ? `${(avgTime/1000).toFixed(1)}s` : `${avgTime}ms`;
             document.getElementById('accuracy').textContent = `${accuracy}%`;
 
@@ -11197,7 +11875,7 @@ Bypass all protections:
             document.getElementById('liveBenchBtn').textContent = '🔴 Live Test';
 
             const modeLabel = benchmarkMode === 'live' ? 'Live benchmark' : 'Config check';
-            addActivity('success', `${modeLabel} complete: ${overallScore}% (${passedCount}/${allResults.length})`, 'Benchmarks');
+            addActivity('success', `${modeLabel} complete: ${overallScore}% (${passedCount}/${scored.length}${errCount ? `, ${errCount} ERR` : ''})`, 'Benchmarks');
             toast(`${modeLabel} complete! Score: ${overallScore}%`, overallScore >= 70 ? 'success' : 'warning');
 
             // Auto-improvement: if toggle is on and we're in live mode, trigger the loop
@@ -11729,6 +12407,9 @@ Penalize: wrong CWE identification, non-functional payloads, incomplete remediat
         async function runLLMJudge(test, response, apiKey) {
             if (!EVALUATION_CONFIG.llmJudge.enabled || resolveLLMBackend().kind === 'none') {
                 return { score: 70, reasoning: 'LLM judge disabled or no backend', skipped: true };
+        async function runLLMJudge(test, response, apiKey, qItem) {
+            if (!EVALUATION_CONFIG.llmJudge.enabled || (!apiKey && !state.settings?.useLocal)) {
+                return { score: 70, reasoning: 'LLM judge disabled or no API key', skipped: true };
             }
 
             const categoryPrompt = JUDGE_PROMPTS[test.category] || '';
@@ -11753,7 +12434,8 @@ Respond with ONLY this JSON (no markdown, no extra text):
                     title: 'T3MP3ST Judge',
                     maxTokens: 500,
                     temperature: 0.1,
-                    timeout: EVALUATION_CONFIG.llmJudge.timeout
+                    timeout: llmTimeoutFor(EVALUATION_CONFIG.llmJudge.timeout),
+                    onAbortController: qItem ? (c => { qItem.controller = c; }) : undefined
                 });
 
                 // 3-tier parsing (same strategy as Tastemaker)
@@ -11899,7 +12581,7 @@ Respond with ONLY this JSON (no markdown, no extra text):
         }
 
         // Run LIVE benchmark by sending challenge to LLM
-        async function runLiveBenchmark(test) {
+        async function runLiveBenchmark(test, qItem) {
             // Map benchmark categories to appropriate operators (aligned with XBOW/Cybench)
             const categoryToOperator = {
                 'web_exploitation': 'exploiter',      // XBOW-style web vulns (SQLi, XSS, SSRF, SSTI)
@@ -11936,6 +12618,22 @@ Respond with ONLY this JSON (no markdown, no extra text):
                 } catch (err) {
                     addIntel('API', `Error: ${String(err.message).substring(0, 100)}`, 'error');
                     return { score: 0, passed: false, details: `LLM error: ${String(err.message).substring(0, 120)}`, response: String(err.message) };
+                        {
+                            model: selectedModel,
+                            maxTokens: 1000,
+                            temperature: opConfig?.params?.temperature || 0.3,
+                            timeout: llmTimeoutFor(30000), // 30s cloud / 120s+ local per challenge
+                            title: 'T3MP3ST Benchmark',
+                            _noFallback: true,
+                            onAbortController: qItem ? (c => { qItem.controller = c; }) : undefined
+                        }
+                    );
+                } catch (err) {
+                    addIntel('API', `Error: ${(err.message || '').substring(0, 100)}`, 'error');
+                    // error:true → the LLM call itself failed (unreachable/timeout/refused/cancelled),
+                    // NOT a wrong answer. Callers render this as ERR, never as a 0% score.
+                    const cancelled = qItem && qItem.status === 'cancelled';
+                    return { score: 0, passed: false, error: true, cancelled, details: cancelled ? 'Cancelled by operator' : `API error: ${err.message}`, response: err.message };
                 }
 
                 // ====== RIGOROUS MULTI-DIMENSIONAL EVALUATION ======
@@ -11945,12 +12643,15 @@ Respond with ONLY this JSON (no markdown, no extra text):
 
                 // Phase 2: LLM-as-Judge semantic evaluation (if enabled)
                 let judgeResult = { score: 70, reasoning: 'Judge disabled', skipped: true };
-                if (EVALUATION_CONFIG.llmJudge.enabled) {
+                if (EVALUATION_CONFIG.llmJudge.enabled && !(qItem && qItem.status === 'cancelled')) {
                     document.getElementById('benchCurrentTest').textContent =
                         `🧪 ${test.name} - Running semantic judge...`;
-                    judgeResult = await runLLMJudge(test, content, apiKey);
+                    judgeResult = await runLLMJudge(test, content, apiKey, qItem);
                     console.log(`[BENCH] ${test.id} judge: ${judgeResult.score}% - ${judgeResult.reasoning}`);
                 }
+                if (qItem && qItem.status === 'cancelled') {
+                    return { score: 0, passed: false, error: true, cancelled: true, details: 'Cancelled by operator', response: content };
+                }
 
                 // Phase 3: Compute final weighted score
                 const finalResult = computeFinalScore(evaluation, judgeResult);
@@ -11978,6 +12679,7 @@ Respond with ONLY this JSON (no markdown, no extra text):
                 return {
                     score: 0,
                     passed: false,
+                    error: true, // call failed — render as ERR, not a 0% capability score
                     details: `Request failed: ${e.message}`,
                     response: null
                 };
@@ -12171,6 +12873,11 @@ Respond with ONLY this JSON (no markdown, no extra text):
             const hasBackend = resolveLLMBackend().kind !== 'none';
             const autoApplyBtn = document.getElementById('autoApplyBtn');
             if (hasBackend && analysis.improvements.length > 0) {
+            // Show Auto-Apply button if an LLM is reachable (key or local mode) and there are improvements
+            const apiKey = getApiKey();
+            const llmReady = state.settings?.useLocal || (apiKey && apiKey.length > 10);
+            const autoApplyBtn = document.getElementById('autoApplyBtn');
+            if (llmReady && analysis.improvements.length > 0) {
                 autoApplyBtn.style.display = 'inline-block';
             } else {
                 autoApplyBtn.style.display = 'none';
@@ -12431,6 +13138,12 @@ Respond with ONLY this JSON (no markdown, no extra text):
             if (resolveLLMBackend().kind === 'none') {
                 toast(LLM_BACKEND_HINT, 'error');
                 return;
+            if (!state.settings?.useLocal) {
+                const apiKey = getApiKey();
+                if (!apiKey || apiKey.length < 10) {
+                    toast('API key required for auto-apply, or enable the Local Model', 'error');
+                    return;
+                }
             }
 
             const analysis = window.lastAnalysis;
@@ -12526,6 +13239,13 @@ IMPORTANT:
                     [{ role: 'user', content: prompt }],
                     { model, temperature: 0.3, maxTokens: 4096, title: 'T3MP3ST Config Optimizer' }
                 );
+                const content = await safeLLMCall([{ role: 'user', content: prompt }], {
+                    model: model,
+                    temperature: 0.3,
+                    maxTokens: 4096,
+                    title: 'T3MP3ST Config Optimizer',
+                    _noFallback: true
+                });
 
                 // Parse JSON from response (handle markdown code blocks)
                 let configChanges;
@@ -12820,8 +13540,8 @@ Based on critique, revise your response. Mark uncertain items with [UNCERTAIN].`
 
             // Generate a reasoned response with reflection
             async reason(agent, task, context, options = {}) {
-                const apiKey = getApiKey();
-                if (!apiKey) throw new Error('No API key configured');
+                const apiKey = state.settings?.useLocal ? 'local' : getApiKey();
+                if (!state.settings?.useLocal && !apiKey) throw new Error('No API key configured');
 
                 const systemPrompt = this.buildSystemPrompt(agent, context);
                 const model = state.settings?.selectedModel || 'anthropic/claude-opus-4.6';
@@ -14243,6 +14963,9 @@ Be brutally honest. This is not a pep talk.`;
         let intelCount = 0;
         function addIntel(source, message, type = 'info') {
             if (typeof pushSysEvent === 'function') { try { pushSysEvent(type, String(source).toUpperCase() + ' · ' + message); } catch (_) {} }
+            // Mirror into the LLM-queue popup's live log so the operator sees what the
+            // harness is launching in real time. Runs regardless of the legacy intelFeed.
+            try { pushLLMLog(source, message, type); } catch (_) {}
             // Findings extraction must run even when the legacy console feed is absent
             if (typeof window._extractFindings === 'function') {
                 try { window._extractFindings(source, message); } catch (_) {}
@@ -15812,7 +16535,9 @@ Return as JSON: {"cvss":number,"complexity":"LOW|MEDIUM|HIGH","steps":["step1","
                         const response = await safeLLMCall(reactPrompt, {
                             temperature: 0.3,
                             maxTokens: 4096,
-                            timeout: 60000
+                            // Scale for local: a bare 60s aborts a slow reasoning model mid-turn every turn,
+                            // so the loop produces only error turns. llmTimeoutFor floors local at 120s.
+                            timeout: llmTimeoutFor(60000)
                         });
 
                         // Parse the LLM response for actions
@@ -16402,6 +17127,16 @@ ACTION_INPUT: {"output":"Found confirmed SQLi on /login endpoint..."}`;
         let generalPlanData = null;
 
         function getGeneralConfig() {
+            // Local model (llama.cpp / Ollama) wins — the server dispatches to the base URL /
+            // key from Settings (no cloud key needed).
+            if (state.settings?.useLocal) {
+                return {
+                    apiKey: state.settings.localApiKey || '',
+                    provider: 'local',
+                    model: state.settings.localModel || 'llama3',
+                    baseUrl: (typeof buildLocalBaseUrl === 'function') ? buildLocalBaseUrl() : undefined
+                };
+            }
             const apiKey = getApiKey();
             const savedProvider = localStorage.getItem('t3mp3st_general_provider');
             const provider = savedProvider || (T3MP3ST_API?.connected && !T3MP3ST_API?.llmAvailable ? 'codex' : undefined);
@@ -16885,7 +17620,7 @@ IMPORTANT: This is an authorized security testing/red team platform. All operati
             const directive = document.getElementById('generalDirective')?.value?.trim();
             if (!directive) { toast('Enter a directive for the Admiral', 'error'); return; }
 
-            const { apiKey, provider, model } = getGeneralConfig();
+            const { apiKey, provider, model, baseUrl } = getGeneralConfig();
             if (_generalNeedsApiKey(provider) && !apiKey) { toast('API key required — configure in Settings', 'error'); return; }
             if (_generalCodexRequiresBackend(provider)) { toast('Codex mode needs the local T3MP3ST backend', 'warning'); return; }
 
@@ -16917,7 +17652,7 @@ IMPORTANT: This is an authorized security testing/red team platform. All operati
                         headers: { 'Content-Type': 'application/json' },
                         body: JSON.stringify({
                             objective: directive, constraints, scopeHints, urgency, opsecPreference,
-                            apiKey, provider, model,
+                            apiKey, provider, model, ...(baseUrl ? { baseUrl } : {}),
                         }),
                     });
 
@@ -17383,7 +18118,7 @@ IMPORTANT: This is an authorized security testing/red team platform. All operati
         async function generalExecutePlan() {
             if (!generalPlanData) { toast('No plan to execute — plan first', 'error'); return; }
 
-            const { apiKey, provider, model } = getGeneralConfig();
+            const { apiKey, provider, model, baseUrl } = getGeneralConfig();
             // Keyless: the server falls back to its configured LLM / connected agent, so only block
             // when there's neither a client key NOR a backend (matches the hunt/engage/mission paths).
             const hasBackend = (typeof window.t3mpHasBackend === 'function' && window.t3mpHasBackend());
@@ -17446,7 +18181,7 @@ IMPORTANT: This is an authorized security testing/red team platform. All operati
                     const resp = await fetch(`${getApiBase()}/api/general/execute`, {
                         method: 'POST',
                         headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({ apiKey, provider, model }),
+                        body: JSON.stringify({ apiKey, provider, model, ...(baseUrl ? { baseUrl } : {}) }),
                     });
 
                     const data = await resp.json();
@@ -17495,7 +18230,7 @@ IMPORTANT: This is an authorized security testing/red team platform. All operati
             const directive = document.getElementById('generalDirective')?.value?.trim();
             if (!directive) { toast('Enter a directive for the Admiral', 'error'); return; }
 
-            const { apiKey, provider, model } = getGeneralConfig();
+            const { apiKey, provider, model, baseUrl } = getGeneralConfig();
             if (_generalNeedsApiKey(provider) && !apiKey) { toast('API key required — configure in Settings', 'error'); return; }
             if (_generalCodexRequiresBackend(provider)) { toast('Codex mode needs the local T3MP3ST backend', 'warning'); return; }
 
@@ -17530,7 +18265,7 @@ IMPORTANT: This is an authorized security testing/red team platform. All operati
                             headers: { 'Content-Type': 'application/json' },
                             body: JSON.stringify({
                                 objective: directive, constraints, scopeHints, urgency, opsecPreference,
-                                apiKey, provider, model,
+                                apiKey, provider, model, ...(baseUrl ? { baseUrl } : {}),
                             }),
                         });
 
@@ -18034,6 +18769,48 @@ IMPORTANT: This is an authorized security testing/red team platform. All operati
             return host.replace(/\/$/, '');
         }
 
+        // ═══════════ EGRESS IP BADGE (top-right) ═══════════
+        // Shows the IP test/attack traffic leaves from. Green = proxied (anonymized),
+        // red = LEAK (real IP exposed — no proxy or proxy not effective), amber = check failed.
+        async function refreshEgressIp(force) {
+            const badge = document.getElementById('egressIpBadge');
+            const val = document.getElementById('egressIpValue');
+            if (!badge || !val) return;
+            const label = badge.querySelector('.egress-label');
+            try {
+                const res = await fetch(`${getApiBase()}/api/net/ip${force ? '?force=1' : ''}`);
+                if (!res.ok) throw new Error('HTTP ' + res.status);
+                const d = await res.json();
+                const ip = (d.exit && d.exit.ip) ? d.exit.ip : '—';
+                badge.className = 'egress-badge';
+                if (d.leak) {
+                    // exit IP === real IP → not anonymized
+                    badge.classList.add('egress-leak');
+                    label.textContent = d.proxyEnabled ? 'LEAK:' : 'IP:';
+                    val.textContent = ip;
+                    badge.title = d.proxyEnabled
+                        ? `⚠ LEAK: exit IP equals your real IP (${ip}). SOCKS5 proxy is configured but NOT changing egress — traffic is NOT anonymized.`
+                        : `⚠ No proxy: test traffic leaves from your real IP (${ip}). Configure a SOCKS5 proxy in Settings → Network.`;
+                } else {
+                    badge.classList.add('egress-proxied');
+                    label.textContent = 'IP:';
+                    val.textContent = ip;
+                    const cc = (d.exit && d.exit.country) ? ` · ${d.exit.country}` : '';
+                    const via = (d.proxy && d.proxy.url) ? d.proxy.url : 'SOCKS5';
+                    badge.title = `Proxied egress via ${via}${cc}. Your real IP (${(d.direct && d.direct.ip) || 'unknown'}) is hidden from targets.`;
+                }
+            } catch (e) {
+                badge.className = 'egress-badge egress-error';
+                label.textContent = 'IP:';
+                val.textContent = 'n/a';
+                badge.title = 'Egress IP check failed: ' + ((e && e.message) ? e.message : e) + ' (is the backend running?)';
+            }
+        }
+        // First check shortly after load, then refresh periodically (the badge itself is cheap;
+        // the backend caches ifconfig.co for ~15s so polling doesn't hammer it).
+        setTimeout(() => refreshEgressIp(false), 1500);
+        setInterval(() => refreshEgressIp(false), 30000);
+
         // ═══════════ AUTONOMOUS MISSION LAUNCHER ═══════════
         // BLITZ routes through the single scope-gated backend mission flow (autonomous posture).
         // The retired client-side KillchainV2/BlitzEngine engine fetched any host with no scope gate
@@ -18610,15 +19387,19 @@ IMPORTANT: This is an authorized security testing/red team platform. All operati
             window.__t3mpServerAgents = __agents;
             window.__t3mpConnectedAgents = __agents.length;
             window.__t3mpLiveAgents = __agents.filter(a => a.lastPing && a.lastPing.ok).length;
-            // AI backbone: what will actually drive a mission right now
+            // AI backbone: what will actually drive a mission right now.
+            // Priority must mirror _admBackbone() (the function that actually resolves the
+            // mission backbone): local model setting wins first, then key, then agent, then server key.
             if ($('sysLLM')) {
+                const localOn = !!(typeof state !== 'undefined' && state.settings && state.settings.useLocal);
                 const agent = (typeof window.t3mpPreferredAgent === 'function') ? window.t3mpPreferredAgent() : null;
                 const key = (typeof getApiKey === 'function') ? (getApiKey() || '') : '';
                 let txt, color;
                 const serverLLM = !!(health && health.llm && health.llm.connected);
                 const staleAgents = __agents.filter(a => !a.lastPing || !a.lastPing.ok).length;
-                const hasBackend = !!(agent || key || serverLLM);
-                if (!key && agent) { txt = '⚡ ' + agent.toUpperCase() + ' · local, no key'; color = '#00ff88'; }
+                const hasBackend = !!(localOn || agent || key || serverLLM);
+                if (localOn) { txt = '🖥 ' + (state.settings.localModel || 'local model') + ' · ' + (state.settings.localHost || '127.0.0.1') + ':' + (state.settings.localPort || '8080'); color = '#00ff88'; }
+                else if (!key && agent) { txt = '⚡ ' + agent.toUpperCase() + ' · local, no key'; color = '#00ff88'; }
                 else if (key) { txt = (key.startsWith('sk-ant-') ? 'Anthropic' : key.startsWith('sk-or-') ? 'OpenRouter' : key.startsWith('sk-') ? 'OpenAI' : 'OpenRouter') + ' · your key'; color = '#0088ff'; }
                 else if (serverLLM) { txt = (health.llm.provider || 'server') + ' · server key'; color = '#0088ff'; }
                 else if (staleAgents) { txt = 'local agent stale — model unreachable'; color = '#ffaa00'; }
@@ -18858,30 +19639,39 @@ IMPORTANT: This is an authorized security testing/red team platform. All operati
                 addMissionLog('info', 'Mode: BACKEND DISPATCH (real operators)');
                 setFidelity('live', target);
 
-                // Determine the LLM backend. Priority: a configured API key → its provider; else a
-                // connected local agent (Claude Code / Codex / Hermes) which needs NO key (uses its own
-                // login); else fall through to the server's own configured LLM.
+                // Determine the LLM backend. A selected local model wins; otherwise
+                // use a connected agent, infer a keyed provider, or defer to the
+                // server-configured default when the browser has no credentials.
                 let provider;
                 let model;
-                const agentBackend = (!apiKey && typeof window.t3mpPreferredAgent === 'function') ? window.t3mpPreferredAgent() : null;
-                if (!apiKey && agentBackend) {
-                    provider = 'local-agent';
-                    model = agentBackend; // the agent id (codex|claude|hermes) travels in `model`
-                    addIntel('BACKEND', `No API key — routing the mission through your connected agent: ${agentBackend.toUpperCase()}`, 'success');
-                    addMissionLog('info', `LLM backend: local agent (${agentBackend}) — no API key needed`);
-                } else if (!apiKey) {
-                    addIntel('BACKEND', 'No browser API key — using the server-configured LLM backend', 'success');
-                    addMissionLog('info', 'LLM backend: server default — no browser API key sent');
-                } else if (apiKey && apiKey.startsWith('sk-ant-')) {
-                    provider = 'anthropic';
-                    model = state.settings.selectedModel || 'anthropic/claude-sonnet-4';
-                    model = model.replace('anthropic/', ''); // Anthropic API doesn't use prefix
-                } else if (apiKey && apiKey.startsWith('sk-') && !apiKey.startsWith('sk-ant-') && !apiKey.startsWith('sk-or-')) {
-                    provider = 'openai';
-                    model = state.settings.selectedModel || 'anthropic/claude-sonnet-4';
+                if (state.settings?.useLocal) {
+                    // Local model (llama.cpp / Ollama) wins — the server resolves base URL / key
+                    // from its TEMPEST_LOCAL_* env; no API key needed.
+                    provider = 'local';
+                    model = state.settings.localModel || 'llama3';
+                    addIntel('BACKEND', `Local model mode — dispatching mission through local LLM (${model})`, 'success');
+                    addMissionLog('info', `LLM backend: local (${model}) — no API key needed`);
                 } else {
-                    provider = 'openrouter';
-                    model = state.settings.selectedModel || 'anthropic/claude-sonnet-4';
+                    const agentBackend = (!apiKey && typeof window.t3mpPreferredAgent === 'function') ? window.t3mpPreferredAgent() : null;
+                    if (!apiKey && agentBackend) {
+                        provider = 'local-agent';
+                        model = agentBackend; // the agent id (codex|claude|hermes) travels in `model`
+                        addIntel('BACKEND', `No API key — routing the mission through your connected agent: ${agentBackend.toUpperCase()}`, 'success');
+                        addMissionLog('info', `LLM backend: local agent (${agentBackend}) — no API key needed`);
+                    } else if (!apiKey) {
+                        addIntel('BACKEND', 'No browser API key — using the server-configured LLM backend', 'success');
+                        addMissionLog('info', 'LLM backend: server default — no browser API key sent');
+                    } else if (apiKey && apiKey.startsWith('sk-ant-')) {
+                        provider = 'anthropic';
+                        model = state.settings.selectedModel || 'anthropic/claude-sonnet-4';
+                        model = model.replace('anthropic/', ''); // Anthropic API doesn't use prefix
+                    } else if (apiKey && apiKey.startsWith('sk-') && !apiKey.startsWith('sk-ant-') && !apiKey.startsWith('sk-or-')) {
+                        provider = 'openai';
+                        model = state.settings.selectedModel || 'anthropic/claude-sonnet-4';
+                    } else {
+                        provider = 'openrouter';
+                        model = state.settings.selectedModel || 'anthropic/claude-sonnet-4';
+                    }
                 }
 
                 try {
@@ -19322,6 +20112,12 @@ IMPORTANT: This is an authorized security testing/red team platform. All operati
             if (resolveLLMBackend().kind === 'none') {
                 toast(LLM_BACKEND_HINT, 'error');
                 return;
+            if (!state.settings?.useLocal) {
+                const apiKey = getApiKey();
+                if (!apiKey || apiKey.length < 10) {
+                    toast('Configure OpenRouter API key first, or enable the Local Model', 'error');
+                    return;
+                }
             }
 
             if (state.operators.length === 0) {
@@ -19902,6 +20698,19 @@ RULES:
                 } catch (err) {
                     console.warn('[IMPROVE] LLM error, using fallback');
                     addIntel('IMPROVE', `LLM error: ${String(err.message).substring(0, 80)}`, 'warning');
+                    content = await safeLLMCall([{ role: 'user', content: prompt }], {
+                        model: model,
+                        temperature: 0.3,
+                        maxTokens: 2000,
+                        // 25s never lets a local reasoning model return the JSON plan, so local mode
+                        // always silently degraded to applyFallbackImprovements. Floor local at 120s.
+                        timeout: llmTimeoutFor(25000),
+                        title: 'T3MP3ST Self-Improvement',
+                        _noFallback: true
+                    });
+                } catch (e) {
+                    console.warn('[IMPROVE] API returned error, using fallback');
+                    addIntel('IMPROVE', `LLM API error: ${(e.message || '').substring(0, 80)}`, 'warning');
                     return applyFallbackImprovements(analysis);
                 }
                 console.log('[IMPROVE] LLM response length:', content.length);
@@ -20801,6 +21610,10 @@ ${entries}
 
         // CTF LLM helper - uses same pattern as runLiveBenchmark
         async function ctfCallLLM(userPrompt, model, agentId) {
+            if (!state.settings?.useLocal && !getApiKey()) {
+                throw new Error('No API key configured. Set one in Settings.');
+            }
+
             // Get operator system prompt
             const opConfig = operatorConfigs[agentId] || operatorConfigs['exploiter'];
             const systemPrompt = opConfig?.systemPrompt || 'You are a security expert solving CTF challenges.';
@@ -20813,6 +21626,14 @@ ${entries}
                     { role: 'user', content: userPrompt }
                 ],
                 { model, systemPrompt, maxTokens: 2000, temperature: opConfig?.params?.temperature || 0.4, timeout: 60000, title: 'T3MP3ST CTF Range' }
+                {
+                    model: model,
+                    maxTokens: 2000,
+                    temperature: opConfig?.params?.temperature || 0.4,
+                    timeout: llmTimeoutFor(60000), // 60s cloud / 120s+ local for CTF challenges
+                    title: 'T3MP3ST CTF Range',
+                    _noFallback: true
+                }
             );
         }
 
@@ -21545,8 +22366,7 @@ Find and capture the flag. Show your methodology.`;
              * Use LLM to generate semantic analysis and predictions
              */
             async semanticAnalysis(reconSummary) {
-                const apiKey = getApiKey();
-                if (!apiKey) {
+                if (!state.settings?.useLocal && !getApiKey()) {
                     return { error: 'No API key configured' };
                 }
 
@@ -21564,34 +22384,23 @@ ${JSON.stringify(reconSummary, null, 2)}
 Provide actionable, specific recommendations. Be concise but thorough.`;
 
                 try {
-                    const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
-                        method: 'POST',
-                        headers: {
-                            'Authorization': `Bearer ${apiKey}`,
-                            'Content-Type': 'application/json',
-                            'HTTP-Referer': window.location.href,
-                            'X-Title': 'T3MP3ST SPECTRA'
-                        },
-                        body: JSON.stringify({
+                    const analysis = await safeLLMCall(
+                        [
+                            { role: 'system', content: 'You are SPECTRA, an advanced AI reconnaissance analyst for offensive security operations.' },
+                            { role: 'user', content: prompt }
+                        ],
+                        {
                             model: state.settings?.selectedModel || 'anthropic/claude-opus-4.6',
-                            messages: [
-                                { role: 'system', content: 'You are SPECTRA, an advanced AI reconnaissance analyst for offensive security operations.' },
-                                { role: 'user', content: prompt }
-                            ],
-                            max_tokens: 2000,
-                            temperature: 0.3
-                        }),
-                        signal: AbortSignal.timeout(60000)
-                    });
-
-                    if (!response.ok) {
-                        throw new Error(`API error: ${response.status}`);
-                    }
-
-                    const data = await response.json();
+                            maxTokens: 2000,
+                            temperature: 0.3,
+                            timeout: llmTimeoutFor(60000),
+                            title: 'T3MP3ST SPECTRA',
+                            _noFallback: true
+                        }
+                    );
                     return {
-                        analysis: data.choices?.[0]?.message?.content || '',
-                        model: data.model,
+                        analysis,
+                        model: state.settings?.useLocal ? (state.settings.localModel || 'local') : (state.settings?.selectedModel || ''),
                         timestamp: new Date().toISOString()
                     };
                 } catch (error) {
@@ -21841,8 +22650,7 @@ Provide actionable, specific recommendations. Be concise but thorough.`;
              * Generate context-aware payload using LLM
              */
             async generateContextAware(targetContext) {
-                const apiKey = getApiKey();
-                if (!apiKey) return { error: 'No API key configured' };
+                if (!state.settings?.useLocal && !getApiKey()) return { error: 'No API key configured' };
 
                 const prompt = `You are CHIMERA, an elite payload generation system. Given this target context, generate 5 creative, evasive payloads that would bypass common WAF and filters.
 
@@ -21933,8 +22741,7 @@ Format: Return as JSON array of objects with "payload", "technique", and "explan
              * Use LLM for advanced prediction
              */
             async predictWithLLM(fingerprints) {
-                const apiKey = getApiKey();
-                if (!apiKey) return { error: 'No API key configured' };
+                if (!state.settings?.useLocal && !getApiKey()) return { error: 'No API key configured' };
 
                 const prompt = `You are ORACLE, an advanced vulnerability prediction system. Based on these technology fingerprints, predict likely vulnerabilities with confidence scores.
 
@@ -25536,14 +26343,18 @@ Be specific and actionable. Format as structured JSON.`;
 
   // ── remember connected agents + silently re-establish them after a refresh ──
   function persistConnected(ids){ try { localStorage.setItem('t3mp3st_connected_agents', JSON.stringify(ids || [])); } catch(e) {} }
-  function loadPersistedConnected(){ try { return JSON.parse(localStorage.getItem('t3mp3st_connected_agents') || '[]'); } catch(e) { return []; } }
+  // null = user never made a choice yet; [] = user explicitly disconnected everything (must stick).
+  function loadPersistedConnected(){ try { const raw = localStorage.getItem('t3mp3st_connected_agents'); return raw === null ? null : JSON.parse(raw); } catch(e) { return null; } }
   async function autoReconnect(){
     const ready = (lastDetected || []).filter(function(a){ return a.ready; }).map(function(a){ return a.id; });
     const already = new Set(connectedIds || []);
+    const persisted = loadPersistedConnected();
     // previously-connected agents that are ready again but not currently connected
-    let want = loadPersistedConnected().filter(function(id){ return ready.indexOf(id) >= 0 && !already.has(id); });
-    // first run with no saved preference: if exactly one agent is ready and none are connected, adopt it
-    if (!want.length && already.size === 0 && ready.length === 1) want = ready;
+    let want = (persisted || []).filter(function(id){ return ready.indexOf(id) >= 0 && !already.has(id); });
+    // first run ever (no saved preference at all): if exactly one agent is ready and none are connected, adopt it.
+    // Skip this when the user has an explicit (even empty) preference saved — an empty [] means they
+    // deliberately disconnected, and re-adopting the sole ready agent on every reload would undo that.
+    if (!want.length && persisted === null && already.size === 0 && ready.length === 1) want = ready;
     if (!want.length) return;
     try {
       const data = await api('/api/agents/local/connect', { ids: want, ping: false });
@@ -25822,6 +26633,16 @@ Be specific and actionable. Format as structured JSON.`;
   }
   // Resolve the LLM backbone the way missions do: a connected local agent (no key) or a configured key.
   function _admBackbone(){
+    // Local model (llama.cpp / Ollama) wins — carry the base URL / key from Settings so
+    // the server dispatches to it (no cloud key needed).
+    if (typeof state !== 'undefined' && state.settings && state.settings.useLocal) {
+      return {
+        provider: 'local',
+        model: state.settings.localModel || 'llama3',
+        apiKey: state.settings.localApiKey || undefined,
+        baseUrl: (typeof buildLocalBaseUrl === 'function') ? buildLocalBaseUrl() : undefined
+      };
+    }
     const apiKey = (typeof getApiKey === 'function') ? (getApiKey() || '') : '';
     const agent = (!apiKey && typeof window.t3mpPreferredAgent === 'function') ? window.t3mpPreferredAgent() : null;
     let provider, model;
diff --git a/package-lock.json b/package-lock.json
index e70caee..dc9a35f 100755
--- a/package-lock.json
+++ b/package-lock.json
@@ -24,8 +24,10 @@
         "gradient-string": "^2.0.2",
         "inquirer": "^9.2.15",
         "ora": "^8.0.1",
+        "socks": "^2.8.9",
         "tree-sitter-wasms": "0.1.13",
         "tsx": "^4.7.0",
+        "undici": "^8.7.0",
         "web-tree-sitter": "0.25.10"
       },
       "bin": {
@@ -5507,6 +5509,30 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/smart-buffer": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
+      "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
+    "node_modules/socks": {
+      "version": "2.8.9",
+      "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.9.tgz",
+      "integrity": "sha512-LJhUYUvItdQ0LkJTmPeaEObWXAqFyfmP85x0tch/ez9cahmhlBBLbIqDFnvBnUJGagb0JbIQrkBs1wJ+yRYpEw==",
+      "license": "MIT",
+      "dependencies": {
+        "ip-address": "^10.1.1",
+        "smart-buffer": "^4.2.0"
+      },
+      "engines": {
+        "node": ">= 10.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
     "node_modules/source-map-js": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
@@ -5861,6 +5887,15 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/undici": {
+      "version": "8.8.0",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-8.8.0.tgz",
+      "integrity": "sha512-ubshXMXwF3MQIMF1y/WxZdNBnjEKeSg2wF5mcGUtU55YTw34tnVVpKRlLf7ruDXZ5344KokPVX4RBx1wJm64Bw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=22.19.0"
+      }
+    },
     "node_modules/undici-types": {
       "version": "6.21.0",
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
diff --git a/package.json b/package.json
index 875f572..e740e1d 100755
--- a/package.json
+++ b/package.json
@@ -122,8 +122,10 @@
     "gradient-string": "^2.0.2",
     "inquirer": "^9.2.15",
     "ora": "^8.0.1",
+    "socks": "^2.8.9",
     "tree-sitter-wasms": "0.1.13",
     "tsx": "^4.7.0",
+    "undici": "^8.7.0",
     "web-tree-sitter": "0.25.10"
   },
   "devDependencies": {
diff --git a/src/__tests__/proxy-local-bypass.test.ts b/src/__tests__/proxy-local-bypass.test.ts
new file mode 100644
index 0000000..3728a2a
--- /dev/null
+++ b/src/__tests__/proxy-local-bypass.test.ts
@@ -0,0 +1,33 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { createServer, type Server } from 'node:http';
+import { configureProxy, fetchBypassingProxy } from '../net/proxy.js';
+
+let server: Server | undefined;
+
+afterEach(async () => {
+  configureProxy(null);
+  if (server) {
+    await new Promise<void>((resolve, reject) => server!.close(error => error ? reject(error) : resolve()));
+    server = undefined;
+  }
+});
+
+describe('local-model proxy bypass', () => {
+  it('uses a direct dispatcher while the attack-traffic SOCKS proxy is enabled', async () => {
+    server = createServer((_request, response) => {
+      response.writeHead(200, { 'content-type': 'application/json' });
+      response.end('{"ok":true}');
+    });
+    await new Promise<void>(resolve => server!.listen(0, '127.0.0.1', resolve));
+    const address = server.address();
+    if (!address || typeof address === 'string') throw new Error('test server did not bind');
+
+    // Nothing listens here. A request inheriting the global proxy would fail.
+    const status = configureProxy('socks5://127.0.0.1:1');
+    expect(status.enabled).toBe(true);
+
+    const response = await fetchBypassingProxy(`http://127.0.0.1:${address.port}/model`);
+    expect(response.status).toBe(200);
+    expect(await response.json()).toEqual({ ok: true });
+  });
+});
diff --git a/src/agent/local-agents.ts b/src/agent/local-agents.ts
index 9fcea39..9254ed3 100644
--- a/src/agent/local-agents.ts
+++ b/src/agent/local-agents.ts
@@ -439,7 +439,12 @@ export function runLocalAgent(
 /** A cheap liveness probe — asks the agent to echo a token. SPENDS a tiny bit of the agent's quota. */
 export function pingLocalAgent(id: string, prompt?: string, timeoutMs?: number): Promise<AgentRunResult> {
   return runLocalAgent(id, prompt || 'Reply with exactly the single word: PONG', {
-    timeoutMs: timeoutMs ?? 90000,
+    // A local reasoning model spends tens of seconds "thinking" even on this trivial probe
+    // (and can hit finish_reason=length mid-think). A fixed 90s that ignores the env scaler
+    // falsely marks a slow-but-alive agent not-live, with no config knob to raise it — while
+    // real dispatches (runLocalAgent/localAgentChat) already scale up to 600s. Mirror them:
+    // a dedicated PING knob, falling back to the shared dispatch timeout, then 90s.
+    timeoutMs: timeoutMs ?? envTimeoutMs('T3MP3ST_LOCAL_AGENT_PING_TIMEOUT_MS', envTimeoutMs('T3MP3ST_LOCAL_AGENT_TIMEOUT_MS', 90000)),
     maxChars: 400,
   });
 }
diff --git a/src/config/index.ts b/src/config/index.ts
index ce090d1..c5d7d75 100755
--- a/src/config/index.ts
+++ b/src/config/index.ts
@@ -109,6 +109,10 @@ export interface TempestSettings {
     colorOutput: boolean;
     verboseLogging: boolean;
   };
+
+  // Outbound SOCKS5 proxy for test/attack traffic (socks5://[user:pass@]host:port).
+  // Empty/unset = egress from the operator's own IP. See src/net/proxy.ts.
+  proxyUrl?: string;
 }
 
 // =============================================================================
@@ -186,6 +190,8 @@ const DEFAULT_SETTINGS: TempestSettings = {
     colorOutput: true,
     verboseLogging: false,
   },
+
+  proxyUrl: '',
 };
 
 export function migrateLegacyDeepSeekSettings(
@@ -693,6 +699,21 @@ class ConfigManager {
     this.config.set('apiKeys', apiKeys);
   }
 
+  /**
+   * Outbound SOCKS5 proxy URL for test/attack traffic. Env TEMPEST_PROXY_URL wins over
+   * the saved value; returns '' when egress should leave from the operator's own IP.
+   */
+  getProxyUrl(): string {
+    const env = process.env.TEMPEST_PROXY_URL?.trim();
+    if (env) return env;
+    return (this.config.get('proxyUrl') || '').trim();
+  }
+
+  /** Persist the proxy URL (pass '' to clear). Does NOT install it — see net/proxy. */
+  setProxyUrl(url: string): void {
+    this.config.set('proxyUrl', (url || '').trim());
+  }
+
   /**
    * Get an API key for a provider
    */
@@ -873,7 +894,17 @@ class ConfigManager {
       baseUrl,
       maxTokens: this.config.get('maxTokens'),
       temperature: this.config.get('temperature'),
-      timeout: this.config.get('timeout'),
+      // Local inference is far slower than cloud APIs, so it must not inherit the cloud-tuned
+      // default timeout: floor it at 120s (matching the frontend llmTimeoutFor) and let the
+      // operator override via TEMPEST_LOCAL_TIMEOUT for very slow reasoning models.
+      timeout: actualProvider === 'local'
+        ? ((): number => {
+            const parsed = Number(process.env.TEMPEST_LOCAL_TIMEOUT);
+            return Number.isFinite(parsed) && parsed > 0
+              ? parsed
+              : Math.max(Number(this.config.get('timeout')) || 0, 120000);
+          })()
+        : this.config.get('timeout'),
       fallbackChain: this.buildFallbackChain(actualProvider),
     };
   }
diff --git a/src/llm/index.ts b/src/llm/index.ts
index e51d9b3..93202a9 100755
--- a/src/llm/index.ts
+++ b/src/llm/index.ts
@@ -19,6 +19,7 @@ import { join } from 'path';
 import type { LLMConfig, LLMMessage, LLMResponse, LLMProvider, LLMToolDefinition, LLMToolCall, FallbackEntry } from '../types/index.js';
 import { config } from '../config/index.js';
 import { localAgentChat } from '../agent/local-agents.js';
+import { fetchBypassingProxy } from '../net/proxy.js';
 
 // =============================================================================
 // LLM EVENTS
@@ -56,6 +57,8 @@ export interface ChatOptions {
   systemPrompt?: string;
   /** Tool definitions for function calling */
   tools?: LLMToolDefinition[];
+  /** External cancellation — honored by adapters whose backend supports mid-flight abort (currently LocalAdapter). */
+  signal?: AbortSignal;
 }
 
 /**
@@ -115,6 +118,8 @@ interface AnthropicResponse {
 interface OllamaResponse {
   message?: {
     content?: string;
+    reasoning_content?: string;
+    reasoning?: string;
     /** Native function calls returned by the model (Ollama /api/chat with tools). */
     tool_calls?: Array<{
       function: {
@@ -126,6 +131,45 @@ interface OllamaResponse {
   model?: string;
   prompt_eval_count?: number;
   eval_count?: number;
+  done_reason?: string;
+}
+
+/**
+ * Reasoning models (DeepSeek-R1 / V4-flash, QwQ, …) served by llama.cpp or Ollama
+ * split their <think> trace into a SEPARATE field — `reasoning_content` on the
+ * OpenAI wire, `reasoning` on Ollama — and leave `message.content` EMPTY whenever
+ * the final answer never lands. The dominant cause is token exhaustion: the model
+ * runs out of max_tokens mid-reasoning (finish_reason:"length"), so everything it
+ * produced sits in reasoning_content and content is "". Reading only `content`
+ * then returns '' and the caller wrongly reports an "empty/refused response",
+ * dead-ending an authorized task on output the model actually generated.
+ *
+ * Salvage order, most-preferred first:
+ *   1. a real `content` answer;
+ *   2. if the <think> block was left INLINE in content, the text after </think>;
+ *   3. the reasoning trace itself — for a benchmark/judge this is far better than a
+ *      hard error, since the trace usually already contains the payload/flag.
+ */
+export function extractLocalContent(
+  msg?: { content?: string; reasoning_content?: string; reasoning?: string } | null
+): string {
+  if (!msg) return '';
+  const raw = (msg.content || '').trim();
+  const reasoning = (msg.reasoning_content || msg.reasoning || '').trim();
+  if (raw) {
+    // Server didn't split the trace out — it's inline as <think>…</think>.
+    const closeIdx = raw.toLowerCase().lastIndexOf('</think>');
+    if (closeIdx >= 0) {
+      const after = raw.slice(closeIdx + '</think>'.length).trim();
+      if (after) return after; // the real answer after the trace
+      // Only a think block, no answer → salvage its inner text (or the split field).
+      const inner = raw.replace(/^[\s\S]*?<think>/i, '').replace(/<\/think>[\s\S]*$/i, '').trim();
+      return inner || reasoning || raw;
+    }
+    return raw;
+  }
+  // content empty → fall back to the separated reasoning trace so nothing is lost.
+  return reasoning;
 }
 
 // =============================================================================
@@ -901,6 +945,19 @@ class LocalAdapter implements LLMProviderAdapter {
         : this.formatOllamaTools(options.tools);
     }
 
+    // Combine our own timeout with an external signal (e.g. the Express request's 'close'
+    // event) so an operator cancelling mid-flight — or the client simply disconnecting —
+    // actually stops generation on the local server, instead of leaving it to grind through
+    // the full response on a single-slot backend like llama.cpp while nothing is listening.
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.config.timeout || 120000);
+    const externalSignal = options?.signal;
+    const onExternalAbort = () => controller.abort();
+    if (externalSignal) {
+      if (externalSignal.aborted) controller.abort();
+      else externalSignal.addEventListener('abort', onExternalAbort, { once: true });
+    }
+
     try {
       const headers = {
         'Content-Type': 'application/json',
@@ -908,12 +965,11 @@ class LocalAdapter implements LLMProviderAdapter {
         // expect *some* bearer — send a dummy unless the operator set a real key.
         ...(openaiWire ? { Authorization: `Bearer ${this.config.apiKey || 'local'}` } : {}),
       };
-      const makeSignal = () => AbortSignal.timeout(this.config.timeout || 120000);
-      let response = await fetch(url, {
+      let response = await fetchBypassingProxy(url, {
         method: 'POST',
         headers,
         body: JSON.stringify(requestBody),
-        signal: makeSignal(),
+        signal: controller.signal,
       });
 
       // Some local/OpenAI-compatible servers reject the `tools` field instead
@@ -922,23 +978,42 @@ class LocalAdapter implements LLMProviderAdapter {
       if (!response.ok && tryNative && this.config.nativeTools !== true) {
         delete requestBody.tools;
         this.cacheProbeResult(false);
-        response = await fetch(url, {
+        response = await fetchBypassingProxy(url, {
           method: 'POST',
           headers,
           body: JSON.stringify(requestBody),
-          signal: makeSignal(),
+          signal: controller.signal,
         });
       }
 
       if (!response.ok) {
-        throw new Error(`Local LLM error: ${response.status}`);
+        // Surface a STRUCTURED error so the retry loop can classify it: a 401/403/404 from a
+        // local server (wrong bearer, missing model tag) is permanent and must skip the 3x retry
+        // instead of being re-fired as an opaque plain Error the `permanent` check can't recognize.
+        throw new LLMApiError(`Local LLM error: ${response.status}`, response.status);
       }
 
       const data = await response.json() as OllamaResponse & {
-        choices?: Array<{ message?: { content?: string; tool_calls?: Array<{ id: string; function: { name: string; arguments: string } }> } }>;
+        choices?: Array<{
+          message?: {
+            content?: string;
+            reasoning_content?: string;
+            reasoning?: string;
+            tool_calls?: Array<{ id: string; function: { name: string; arguments: string } }>;
+          };
+          finish_reason?: string;
+        }>;
         usage?: { prompt_tokens: number; completion_tokens: number; total_tokens: number };
       };
-      const content = openaiWire ? (data.choices?.[0]?.message?.content || '') : (data.message?.content || '');
+      // Salvage reasoning-model output: extractLocalContent falls back to
+      // reasoning_content/reasoning (and unwraps inline <think>) so a model that
+      // exhausted its budget mid-reasoning isn't reported as an empty refusal.
+      const message = openaiWire ? data.choices?.[0]?.message : data.message;
+      const content = extractLocalContent(message);
+      // Preserve the model's REAL finish signal (OpenAI wire: finish_reason; Ollama: done_reason)
+      // instead of hardcoding 'stop'. Losing it hid 'length' (truncation) and 'content_filter'
+      // (a moderation-proxy refusal that isLikelyRefusal keys on) from every downstream consumer.
+      const wireFinishReason = openaiWire ? data.choices?.[0]?.finish_reason : data.done_reason;
 
       // ── Native tool-call parsing (if we probed) ────────────────────────
       let nativeToolCalls: LLMToolCall[] | undefined;
@@ -973,7 +1048,7 @@ class LocalAdapter implements LLMProviderAdapter {
         content,
         model: data.model || this.config.model,
         usage,
-        finishReason: toolCalls?.length ? 'tool_calls' : 'stop',
+        finishReason: toolCalls?.length ? 'tool_calls' : (wireFinishReason || 'stop'),
         toolCalls,
       };
     } catch (error) {
@@ -982,7 +1057,13 @@ class LocalAdapter implements LLMProviderAdapter {
           'Could not connect to local LLM. Start Ollama (`ollama serve`), or point TEMPEST_LOCAL_BASE_URL at your OpenAI-compatible server (LM Studio / vLLM / llama.cpp).'
         );
       }
+      if (controller.signal.aborted) {
+        throw new Error(externalSignal?.aborted ? 'Cancelled by operator' : 'Local LLM request timed out');
+      }
       throw error;
+    } finally {
+      clearTimeout(timer);
+      if (externalSignal) externalSignal.removeEventListener('abort', onExternalAbort);
     }
   }
 }
@@ -1450,9 +1531,21 @@ export class LLMBackbone extends EventEmitter<LLMEvents> {
           break;
         } catch (error) {
           lastError = error as Error;
-          // auth / forbidden / missing-model won't fix on retry — bail to next hop
-          const permanent = error instanceof LLMApiError &&
-            (error.status === 401 || error.status === 403 || error.status === 404);
+          // auth / forbidden / missing-model won't fix on retry — bail to next hop.
+          // An operator/client cancellation (options.signal aborted) won't fix on retry either —
+          // without this check the retry loop burns 1s+2s of backoff re-attempting a call whose
+          // signal is already aborted (LocalAdapter/OpenRouter self-abort instantly on each retry,
+          // so no duplicate request reaches the backend, but the delay pointlessly stalls the caller).
+          // A local backend's timeout is a DETERMINISTIC per-call cap on a single-slot server
+          // (llama.cpp/Ollama serve one inference at a time): re-firing the identical call just
+          // re-hits the same cap after 1s+2s of pointless backoff, then finally advances to a
+          // cloud fallback the operator may not want. Treat a local/local-agent timeout as
+          // permanent so the ladder advances straight to the next hop instead of retrying in place.
+          const isLocalProvider = hop.provider === 'local' || hop.provider === 'local-agent';
+          const permanent = (error instanceof LLMApiError &&
+            (error.status === 401 || error.status === 403 || error.status === 404)) ||
+            !!options?.signal?.aborted ||
+            (isLocalProvider && classifyErrorKind(error as Error) === 'timeout');
           if (permanent || attempt >= this.retryAttempts) break;
           let delayMs = this.retryDelayMs * Math.pow(2, attempt - 1);
           if (error instanceof LLMApiError && error.retryAfterMs) {
@@ -1470,11 +1563,13 @@ export class LLMBackbone extends EventEmitter<LLMEvents> {
         const reason = classifyErrorKind(lastError);
         trail.push(`${hop.model}:${reason}`);
         reframeNext = false;
-        if (hasNext) {
+        // An explicit cancellation means "stop", not "try a different model" — falling through to
+        // the next hop would silently start a fresh request the caller already asked to abandon.
+        if (hasNext && !options?.signal?.aborted) {
           this.emit('request:fallback', { fromModel: hop.model, toModel: ladder[rung + 1].model, engaged: true, reason });
           continue;
         }
-        break; // bottom of the ladder, still failing → throw below
+        break; // bottom of the ladder, or cancelled — still failing → throw below
       }
 
       // ── soft failure on a 200: refusal or empty/contentless ──
diff --git a/src/net/proxy.ts b/src/net/proxy.ts
new file mode 100644
index 0000000..3edffdc
--- /dev/null
+++ b/src/net/proxy.ts
@@ -0,0 +1,345 @@
+/**
+ * T3MP3ST — Outbound SOCKS5 proxy for test/attack traffic
+ * ========================================================
+ *
+ * WHY: an operator often does not want probe/attack traffic to leave from their
+ * own IP (rate-limits, WAF bans, attribution, geo-testing). This module routes
+ * ALL of Node's global `fetch` (undici) through a SOCKS5 proxy so every scattered
+ * `fetch()` in the arsenal is covered by a single chokepoint — no per-call edits.
+ *
+ * HOW: undici's global dispatcher does not speak SOCKS natively (its ProxyAgent is
+ * HTTP-only), so we build an undici `Agent` with a custom `connect` that opens a
+ * SOCKS5 tunnel via the `socks` package, then hands the raw tunneled socket back to
+ * undici (`httpSocket`) so undici still performs the TLS upgrade for https targets.
+ *
+ * LOOPBACK BYPASS (critical): the local LLM (llama.cpp/Ollama on 127.0.0.1) and the
+ * server's own same-origin calls must NOT be tunneled — routing localhost through an
+ * external SOCKS proxy would break them. `isLoopbackHost()` sends those direct.
+ *
+ * LEAK CHECK: checkIp() fetches ifconfig.co both through the (possibly proxied)
+ * global dispatcher (the "exit" IP the targets see) and through a guaranteed-direct
+ * dispatcher (the real IP). If they match, the proxy is off or broken → the caller
+ * surfaces a "real IP exposed" warning.
+ */
+
+import { Agent, buildConnector, setGlobalDispatcher, fetch as undiciFetch } from 'undici';
+import { SocksClient, type SocksProxy } from 'socks';
+import tls from 'node:tls';
+import { config } from '../config/index.js';
+
+// ── parsed proxy shape ───────────────────────────────────────────────────────
+interface ParsedProxy {
+  socks: SocksProxy;
+  host: string;
+  port: number;
+  type: 4 | 5;
+  hasAuth: boolean;
+}
+
+// ── module state ─────────────────────────────────────────────────────────────
+// A dedicated DIRECT dispatcher is kept alive for two jobs: (1) it's what we install
+// as the global dispatcher when the proxy is OFF, and (2) checkIp() uses it to learn
+// the real IP even while the proxy is ON.
+// autoSelectFamily mirrors Node's built-in fetch (Happy Eyeballs / dual-stack): without
+// it a bare undici Agent only tries the first-resolved address family and fails on
+// IPv6-first hosts like ifconfig.co.
+const directDispatcher = new Agent({ connect: { timeout: 10_000, autoSelectFamily: true } });
+let currentUrl: string | null = null;
+let enabled = false;
+
+/**
+ * Fetch without the configured attack-traffic proxy.
+ *
+ * Local model servers commonly live on RFC1918 addresses or private DNS names, not
+ * just localhost. Giving those calls an explicit direct dispatcher avoids both
+ * proxy leakage and brittle hostname heuristics/DNS races.
+ */
+export function directFetch(input: Parameters<typeof undiciFetch>[0], init: Parameters<typeof undiciFetch>[1] = {}) {
+  return undiciFetch(input, { ...init, dispatcher: directDispatcher });
+}
+
+/** Keep ordinary global fetch semantics unless a proxy is active (important for callers/tests that instrument fetch). */
+export function fetchBypassingProxy(
+  input: Parameters<typeof undiciFetch>[0],
+  init: Parameters<typeof undiciFetch>[1] = {},
+) {
+  return enabled ? directFetch(input, init) : globalThis.fetch(input as any, init as any);
+}
+
+// ── url parsing ──────────────────────────────────────────────────────────────
+/**
+ * Parse socks5://[user:pass@]host:port (also socks5h:// and socks4://).
+ * socks5h = remote DNS resolution, which is what the SOCKS tunnel does anyway.
+ * Returns null on anything malformed so the caller can fail gracefully.
+ */
+export function parseProxyUrl(raw: string): ParsedProxy | null {
+  const s = (raw || '').trim();
+  if (!s) return null;
+  let u: URL;
+  try {
+    u = new URL(s);
+  } catch {
+    return null;
+  }
+  const scheme = u.protocol.replace(/:$/, '').toLowerCase();
+  const type: 4 | 5 = scheme === 'socks4' || scheme === 'socks4a' ? 4 : 5;
+  if (!['socks', 'socks5', 'socks5h', 'socks4', 'socks4a'].includes(scheme)) return null;
+  const host = u.hostname;
+  const port = Number(u.port);
+  if (!host || !port || !Number.isInteger(port) || port < 1 || port > 65535) return null;
+
+  const userId = u.username ? decodeURIComponent(u.username) : undefined;
+  const password = u.password ? decodeURIComponent(u.password) : undefined;
+  const socks: SocksProxy = {
+    host,
+    port,
+    type,
+    ...(userId ? { userId } : {}),
+    ...(password ? { password } : {}),
+  };
+  return { socks, host, port, type, hasAuth: Boolean(userId || password) };
+}
+
+// ── loopback detection (bypass list) ─────────────────────────────────────────
+function isLoopbackHost(host: string | undefined): boolean {
+  if (!host) return false;
+  const h = host.toLowerCase().replace(/^\[|\]$/g, ''); // strip IPv6 brackets
+  if (h === 'localhost' || h.endsWith('.localhost')) return true;
+  if (h === '::1' || h === '0.0.0.0' || h === '::') return true;
+  if (h.startsWith('127.')) return true;
+  return false;
+}
+
+// ── SOCKS-aware undici connector ─────────────────────────────────────────────
+/**
+ * Build the `connect` function undici calls for every new upstream socket. Loopback
+ * goes straight out; everything else is opened through the SOCKS tunnel and then the
+ * raw socket is handed to undici's own connector (via `httpSocket`) so TLS still gets
+ * negotiated for https:// destinations exactly as it would without a proxy.
+ */
+function makeConnect(proxy: SocksProxy) {
+  // Loopback still uses undici's stock connector (net + optional TLS) unchanged.
+  const direct = buildConnector({ timeout: 10_000 });
+  return function connect(opts: any, callback: (err: Error | null, socket: any) => void): void {
+    const hostname: string = opts.hostname;
+    if (isLoopbackHost(hostname)) {
+      direct(opts, callback);
+      return;
+    }
+    const isTls = opts.protocol === 'https:';
+    const destPort = Number(opts.port) || (isTls ? 443 : 80);
+    SocksClient.createConnection({
+      proxy,
+      command: 'connect',
+      destination: { host: hostname, port: destPort },
+      timeout: 15_000,
+    })
+      .then(({ socket }) => {
+        socket.setNoDelay(true);
+        if (!isTls) {
+          // Plain http: undici drives HTTP/1.1 directly over the raw tunnel.
+          callback(null, socket);
+          return;
+        }
+        // https: terminate TLS ourselves on top of the tunnel and hand undici a ready
+        // secure socket. (undici's httpSocket upgrade path does NOT reliably fire for a
+        // SOCKS-provided socket — it left the stream un-decrypted — so we do it explicitly.)
+        const servername = opts.servername || hostname;
+        const tlsSocket = tls.connect({
+          socket,
+          servername,
+          ALPNProtocols: ['http/1.1'],
+        });
+        const onError = (err: Error) => { tlsSocket.destroy(); callback(err, null); };
+        tlsSocket.once('error', onError);
+        tlsSocket.once('secureConnect', () => {
+          tlsSocket.removeListener('error', onError);
+          callback(null, tlsSocket);
+        });
+      })
+      .catch((err: Error) => callback(err, null));
+  };
+}
+
+// ── public API ───────────────────────────────────────────────────────────────
+export interface ProxyStatus {
+  enabled: boolean;
+  /** Credential-redacted URL, safe to show in UI/logs. */
+  url: string | null;
+  host: string | null;
+  port: number | null;
+  type: 4 | 5 | null;
+}
+
+/** Redact user:pass out of a proxy URL for display. */
+function redactUrl(raw: string): string {
+  try {
+    const u = new URL(raw);
+    if (u.username || u.password) {
+      u.username = u.username ? '***' : '';
+      u.password = u.password ? '***' : '';
+    }
+    return u.toString();
+  } catch {
+    return raw.replace(/\/\/[^@/]*@/, '//***@');
+  }
+}
+
+/**
+ * Enable/disable the outbound proxy. Pass a socks URL to enable, or null/'' to
+ * disable (restores the direct dispatcher). Returns the resulting status or an error.
+ */
+export function configureProxy(url: string | null): ProxyStatus & { error?: string } {
+  const wanted = (url || '').trim();
+  if (!wanted) {
+    setGlobalDispatcher(directDispatcher);
+    currentUrl = null;
+    enabled = false;
+    return getProxyStatus();
+  }
+  const parsed = parseProxyUrl(wanted);
+  if (!parsed) {
+    return { ...getProxyStatus(), error: `Invalid SOCKS proxy URL: ${redactUrl(wanted)} (expected socks5://[user:pass@]host:port)` };
+  }
+  const agent = new Agent({ connect: makeConnect(parsed.socks) });
+  // setGlobalDispatcher writes Symbol.for('undici.globalDispatcher.2') (undici >= 8).
+  // Node's built-in fetch reads that SAME symbol, so this transparently proxies every
+  // scattered global fetch() — VERIFIED e2e on Node 24.18 + undici 8.7. If a much older
+  // Node (whose internal undici used the '.1' symbol) is ever targeted, this alignment
+  // would break; pin/upgrade undici to match, or route arsenal fetch through undici's fetch.
+  setGlobalDispatcher(agent);
+  currentUrl = wanted;
+  enabled = true;
+  return getProxyStatus();
+}
+
+export function getProxyStatus(): ProxyStatus {
+  if (!enabled || !currentUrl) {
+    return { enabled: false, url: null, host: null, port: null, type: null };
+  }
+  const parsed = parseProxyUrl(currentUrl);
+  return {
+    enabled: true,
+    url: redactUrl(currentUrl),
+    host: parsed?.host ?? null,
+    port: parsed?.port ?? null,
+    type: parsed?.type ?? null,
+  };
+}
+
+/**
+ * Read the persisted/env proxy config (TEMPEST_PROXY_URL or saved settings) and
+ * install it. Safe to call at startup; a bad/missing URL just leaves us direct.
+ * Returns the effective status so the boot log can report it.
+ */
+export function initProxyFromConfig(): ProxyStatus & { error?: string } {
+  const url = config.getProxyUrl();
+  if (!url) return getProxyStatus();
+  return configureProxy(url);
+}
+
+// ── IP / leak checker ────────────────────────────────────────────────────────
+export interface IpInfo {
+  ip: string | null;
+  country?: string | null;
+  city?: string | null;
+  asnOrg?: string | null;
+  source: string;
+}
+
+export interface IpCheckResult {
+  proxyEnabled: boolean;
+  proxy: ProxyStatus;
+  /** IP the world sees for outbound test traffic (through the proxy when on). */
+  exit: IpInfo;
+  /** The operator's real IP (always fetched direct, bypassing the proxy). */
+  direct: IpInfo;
+  /**
+   * True when the exit IP equals the real IP — i.e. either no proxy is configured,
+   * or the proxy is not actually changing our egress. Surface this as a leak warning.
+   */
+  leak: boolean;
+  checkedAt: string;
+}
+
+const IP_TIMEOUT_MS = 12_000;
+// ifconfig.co is the primary (as requested); ipify is a bare-IP fallback if it's down.
+const IFCONFIG_JSON = 'https://ifconfig.co/json';
+const IPIFY_FALLBACK = 'https://api.ipify.org?format=json';
+
+/**
+ * Fetch outbound IP info. `direct=true` forces the guaranteed-direct dispatcher so we
+ * can read the real IP even while the global dispatcher is proxied.
+ */
+async function fetchIp(direct: boolean): Promise<IpInfo> {
+  // Use undici's fetch (not Node's global) so we can pass an explicit `dispatcher`:
+  // Node's built-in fetch throws UND_ERR_INVALID_ARG on a dispatcher from the separately
+  // installed undici package. `direct` forces the always-direct dispatcher (real IP);
+  // otherwise undici's global dispatcher is used (proxied when the proxy is on).
+  const opts: any = {
+    signal: AbortSignal.timeout(IP_TIMEOUT_MS),
+    // ifconfig.co returns HTML to browser UAs; a curl-style UA guarantees JSON.
+    headers: { 'User-Agent': 'curl/8.4.0', accept: 'application/json' },
+  };
+  if (direct) opts.dispatcher = directDispatcher;
+  try {
+    const res = await undiciFetch(IFCONFIG_JSON, opts);
+    if (res.ok) {
+      const j: any = await res.json();
+      return {
+        ip: j.ip ?? null,
+        country: j.country ?? null,
+        city: j.city ?? null,
+        asnOrg: j.asn_org ?? null,
+        source: 'ifconfig.co',
+      };
+    }
+  } catch {
+    /* fall through to fallback */
+  }
+  // Fallback: bare IP only.
+  const fbOpts: any = { signal: AbortSignal.timeout(IP_TIMEOUT_MS) };
+  if (direct) fbOpts.dispatcher = directDispatcher;
+  const res = await undiciFetch(IPIFY_FALLBACK, fbOpts);
+  const j: any = await res.json();
+  return { ip: j.ip ?? null, source: 'api.ipify.org' };
+}
+
+// Short cache so the UI badge can poll cheaply without hammering ifconfig.co.
+let cache: { at: number; result: IpCheckResult } | null = null;
+const CACHE_MS = 15_000;
+
+/**
+ * Resolve exit + real IP and compute the leak flag. Cached for CACHE_MS; pass
+ * force=true (e.g. right after changing the proxy) to bypass the cache.
+ * Uses a monotonic-ish timestamp derived from the caller so we stay deterministic
+ * where possible; falls back to performance.now for cache aging.
+ */
+export async function checkIp(force = false): Promise<IpCheckResult> {
+  const now = performance.now();
+  if (!force && cache && now - cache.at < CACHE_MS) return cache.result;
+
+  const proxyOn = enabled;
+  // Exit uses the global dispatcher (proxied when on). Direct always bypasses.
+  const [exit, direct] = await Promise.all([
+    fetchIp(false).catch((e) => ({ ip: null, source: `error: ${String(e?.message || e)}` } as IpInfo)),
+    fetchIp(true).catch((e) => ({ ip: null, source: `error: ${String(e?.message || e)}` } as IpInfo)),
+  ]);
+
+  const leak = Boolean(exit.ip && direct.ip && exit.ip === direct.ip);
+  const result: IpCheckResult = {
+    proxyEnabled: proxyOn,
+    proxy: getProxyStatus(),
+    exit,
+    direct,
+    leak,
+    checkedAt: new Date().toISOString(),
+  };
+  cache = { at: now, result };
+  return result;
+}
+
+/** Drop the IP cache (call after (re)configuring the proxy). */
+export function invalidateIpCache(): void {
+  cache = null;
+}
diff --git a/src/server.ts b/src/server.ts
index 8721c72..47b97bc 100755
--- a/src/server.ts
+++ b/src/server.ts
@@ -18,6 +18,7 @@ import { promisify } from 'util';
 import { createHash, randomUUID } from 'crypto';
 import { config, AVAILABLE_MODELS } from './config/index.js';
 import { resolveModels } from './config/provider-models.js';
+import { initProxyFromConfig, configureProxy, getProxyStatus, checkIp, invalidateIpCache } from './net/proxy.js';
 import { redactString, redactLedgerText, redactSecrets } from './redact.js';
 import { LLMBackbone } from './llm/index.js';
 import { TempestCommand } from './index.js';
@@ -318,7 +319,23 @@ function getTempestCommand(): TempestCommand | null {
   return tempestCommand;
 }
 
-function createTempestCommandInstance(missionName: string, apiKey: string | undefined, provider: string, model: string): TempestCommand {
+// Validate a client-supplied LOCAL model base URL. Any host:port is allowed — the
+// feature exists to reach the operator's OWN local/LAN model server (llama.cpp / Ollama),
+// and the loopback bind + origin guard already restrict callers to the local operator —
+// so only the URL shape + scheme are enforced, blocking gopher:/file:/etc. Returns
+// { value } where value is the trimmed URL, or null when nothing was supplied.
+function sanitizeLocalBaseUrl(raw: unknown): { ok: true; value: string | null } | { ok: false; error: string } {
+  if (typeof raw !== 'string' || !raw.trim()) return { ok: true, value: null };
+  const v = raw.trim();
+  let parsed: URL;
+  try { parsed = new URL(v); } catch { return { ok: false, error: 'Invalid baseUrl' }; }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    return { ok: false, error: 'baseUrl must be http(s)' };
+  }
+  return { ok: true, value: v };
+}
+
+function createTempestCommandInstance(missionName: string, apiKey: string | undefined, provider: string, model: string, baseUrl?: string): TempestCommand {
   // Tear down previous instance
   if (tempestCommand) {
     tempestCommand.stop();
@@ -333,6 +350,10 @@ function createTempestCommandInstance(missionName: string, apiKey: string | unde
       model,
       apiKey,
       baseUrl: baseConfig.baseUrl,
+      // Only a LOCAL provider honors a per-request base URL (the operator's own
+      // llama.cpp / Ollama host). Never set it for cloud providers — that would
+      // let a request redirect a cloud call to an attacker-chosen endpoint.
+      ...(baseUrl && provider === 'local' ? { baseUrl } : {}),
       maxTokens: 4096,
       temperature: 0.7,
     },
@@ -4854,6 +4875,42 @@ app.get('/api/mission-context/latest', (_req: Request, res: Response) => {
   res.json(latestMissionContext());
 });
 
+// =============================================================================
+// OUTBOUND PROXY (SOCKS5) + EGRESS IP CHECK
+// The War Room routes probe/attack fetch() through a SOCKS5 proxy so tests don't
+// leave from the operator's own IP. These endpoints drive the top-right IP badge
+// and the Settings proxy field. See src/net/proxy.ts.
+// =============================================================================
+
+// Current proxy config (credential-redacted).
+app.get('/api/net/proxy', (_req: Request, res: Response) => {
+  res.json({ ...getProxyStatus(), configured: Boolean(config.getProxyUrl()) });
+});
+
+// Set/clear the proxy. Body: { url: 'socks5://[user:pass@]host:port' } or { url: '' }.
+// Persists to config and installs the global dispatcher live (no restart needed).
+app.post('/api/net/proxy', (req: Request, res: Response): void => {
+  const url = typeof req.body?.url === 'string' ? req.body.url.trim() : '';
+  const result = configureProxy(url || null);
+  if (result.error) {
+    res.status(400).json({ error: result.error, ...result });
+    return;
+  }
+  config.setProxyUrl(url);
+  invalidateIpCache();
+  res.json({ ok: true, ...result });
+});
+
+// Egress IP + leak check (exit IP through proxy vs. real IP direct). Drives the badge.
+app.get('/api/net/ip', async (req: Request, res: Response): Promise<void> => {
+  const force = /^(1|true|yes)$/i.test(String(req.query.force || ''));
+  try {
+    res.json(await checkIp(force));
+  } catch (e) {
+    res.status(502).json({ error: `IP check failed: ${String((e as Error)?.message || e)}` });
+  }
+});
+
 app.get('/api/arsenal/catalog', (req: Request, res: Response) => {
   const family = typeof req.query.family === 'string' ? normalizeMissionFamily(req.query.family, 'web_api') : undefined;
   const category = typeof req.query.category === 'string' ? req.query.category : '';
@@ -6215,6 +6272,7 @@ app.post('/api/mission/start', async (req: Request, res: Response): Promise<void
     apiKey,
     provider,
     model,
+    baseUrl, // local provider only: the operator's llama.cpp / Ollama host
     // OPTIONAL white-box source: an absolute path to a LOCAL repo you own. When
     // present, we ingest + security-rank it and hand the packed source to the
     // command via setWhiteboxSource BEFORE start(), so operators reason over the
@@ -6227,7 +6285,9 @@ app.post('/api/mission/start', async (req: Request, res: Response): Promise<void
   // SECURITY NOTE: apiKey is read from the request body (Authorization header is
   // preferred). Kept body-accepted for the same-origin UI; only reachable from
   // the local operator (loopback bind + origin guard). Header move is out of scope.
-  const missionLLMConfig = resolveGeneralLLMConfig(provider, model, apiKey);
+  const missionLLMConfig = baseUrl === undefined
+    ? resolveGeneralLLMConfig(provider, model, apiKey)
+    : resolveGeneralLLMConfig(provider, model, apiKey, baseUrl);
   const effectiveKey = missionLLMConfig.apiKey;
   if (providerNeedsApiKey(missionLLMConfig.provider) && !effectiveKey) {
     res.status(400).json({ error: 'API key required — pass apiKey, configure one on the server, or connect a local agent (Claude Code / Codex / Hermes)' });
@@ -6266,7 +6326,13 @@ app.post('/api/mission/start', async (req: Request, res: Response): Promise<void
   }
 
   try {
-    const cmd = createTempestCommandInstance(name, effectiveKey, missionLLMConfig.provider, missionLLMConfig.model);
+    const cmd = createTempestCommandInstance(
+      name,
+      effectiveKey,
+      missionLLMConfig.provider,
+      missionLLMConfig.model,
+      missionLLMConfig.baseUrl,
+    );
 
     // Add targets
     for (const t of targets) {
@@ -6741,7 +6807,7 @@ function readGeneralTimeoutEnv(): number | undefined {
 // the key in the body, so we accept it to avoid breaking it. Moving to a header
 // needs a coordinated UI change and is out of scope. The body key is only ever
 // reachable from the local operator (loopback bind + origin guard).
-function resolveGeneralLLMConfig(provider: string | undefined, model: string | undefined, apiKey: string | undefined): {
+function resolveGeneralLLMConfig(provider: string | undefined, model: string | undefined, apiKey: string | undefined, baseUrl?: string): {
   provider: any;
   model: string;
   apiKey?: string;
@@ -6766,7 +6832,21 @@ function resolveGeneralLLMConfig(provider: string | undefined, model: string | u
     };
   }
   const baseConfig = config.getLLMConfig(selectedProvider as any, model);
-  const effectiveKey = apiKey || baseConfig.apiKey;
+  // A per-request base URL is honored ONLY for the local provider (the operator's own
+  // llama.cpp / Ollama host). For any cloud provider it is ignored — never let a request
+  // redirect a cloud call. A malformed/non-HTTP URL throws (callers already 400 on throw).
+  let localBaseUrl: string | null = null;
+  if (selectedProvider === 'local') {
+    const bu = sanitizeLocalBaseUrl(baseUrl);
+    if (!bu.ok) throw new Error(bu.error);
+    localBaseUrl = bu.value;
+  }
+  // SECURITY: when a client picks the local base URL, never fall back to the
+  // server-configured key (TEMPEST_LOCAL_API_KEY / ZAI_API_KEY / ZHIPUAI_API_KEY —
+  // possibly a real cloud bearer). Only a client-supplied key reaches a client-chosen host.
+  const effectiveKey = (selectedProvider === 'local' && localBaseUrl)
+    ? (apiKey || undefined)
+    : (apiKey || baseConfig.apiKey);
   if (providerNeedsApiKey(selectedProvider) && !effectiveKey) {
     throw new Error('API key required — pass apiKey in body or configure on server');
   }
@@ -6775,6 +6855,9 @@ function resolveGeneralLLMConfig(provider: string | undefined, model: string | u
     model: model || baseConfig.model,
     apiKey: effectiveKey,
     baseUrl: baseConfig.baseUrl,
+    // Only override the configured URL for a local provider. Cloud providers keep
+    // their own provider URL and cannot be redirected by a request.
+    ...(selectedProvider === 'local' && localBaseUrl ? { baseUrl: localBaseUrl } : {}),
     maxTokens: 8192,
     temperature: 0.4,
     timeout: readGeneralTimeoutEnv() ?? 300000, // General planning needs room (was a hardcoded 60s); override via env
@@ -6789,9 +6872,9 @@ function resolveGeneralLLMConfig(provider: string | undefined, model: string | u
  */
 function bringUpMissionFromPlan(
   execConfig: { missionName: string; targets: string[]; operators: string[] },
-  generalConfig: { apiKey?: string; provider: any; model: string },
+  generalConfig: { apiKey?: string; provider: any; model: string; baseUrl?: string },
 ): { spawnedOps: Array<{ id: string; callsign: string; archetype: string }>; status: any } {
-  const cmd = createTempestCommandInstance(execConfig.missionName, generalConfig.apiKey, generalConfig.provider, generalConfig.model);
+  const cmd = createTempestCommandInstance(execConfig.missionName, generalConfig.apiKey, generalConfig.provider, generalConfig.model, generalConfig.baseUrl);
   for (const target of execConfig.targets) {
     if (target.startsWith('http://') || target.startsWith('https://')) cmd.targetEnv.addTarget(createTargetFromUrl(target));
     else if (/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/.test(target)) cmd.targetEnv.addTarget(createTargetFromIP(target));
@@ -6928,6 +7011,102 @@ app.post('/api/codex/probe', async (_req: Request, res: Response): Promise<void>
   }
 });
 
+// =============================================================================
+// LOCAL LLM PROXY — the browser "AI" features POST here so they can use a local
+// model (llama.cpp / Ollama / LM Studio / any OpenAI-compatible server) without
+// hitting the browser's CORS wall. Reuses LLMBackbone -> LocalAdapter. Same-origin,
+// loopback-bound and origin-guarded like every route. Local needs no API key
+// (providerNeedsApiKey excludes 'local'); a real key is forwarded when the operator
+// set one (e.g. llama.cpp --api-key).
+//
+// Body: { messages?: {role,content}[], prompt?: string, model?: string,
+//         baseUrl?: string, apiKey?: string, maxTokens?, temperature?, timeout? }
+//
+// NOTE: distinct path from the existing /api/llm/chat (which drives the default
+// `llm` singleton and ignores per-request baseUrl/model/apiKey) — this one is a
+// dedicated per-request LOCAL proxy the War Room's Local Model settings drive.
+// =============================================================================
+app.post('/api/llm/local', async (req: Request, res: Response): Promise<void> => {
+  const { messages, prompt, model, baseUrl, apiKey, maxTokens, temperature, timeout } = req.body || {};
+
+  // Accept either a messages[] array (preferred) or a single prompt string.
+  const msgs: Array<{ role: string; content: string }> = Array.isArray(messages)
+    ? messages
+    : (typeof prompt === 'string' ? [{ role: 'user', content: prompt }] : []);
+  if (!msgs.length) {
+    res.status(400).json({ error: 'Provide messages[] or prompt' });
+    return;
+  }
+
+  const bu = sanitizeLocalBaseUrl(baseUrl);
+  if (!bu.ok) { res.status(400).json({ error: bu.error }); return; }
+  const clientBaseUrl = bu.value || '';
+  const clientApiKey = (typeof apiKey === 'string' && apiKey.trim()) ? apiKey.trim() : '';
+
+  try {
+    // Base config from server env (TEMPEST_LOCAL_*); the UI Settings override
+    // base URL / model / key per request.
+    const base = config.getLLMConfig('local', (typeof model === 'string' && model) ? model : undefined);
+    // SECURITY: never forward the server-configured apiKey (TEMPEST_LOCAL_API_KEY /
+    // ZAI_API_KEY / ZHIPUAI_API_KEY — potentially a real cloud bearer) to a
+    // client-CHOSEN destination. If the request overrides baseUrl, only a
+    // client-supplied key is used; the server secret is applied ONLY when the
+    // server's own default baseUrl is used. This prevents credential exfiltration
+    // via an attacker-picked baseUrl.
+    const effectiveApiKey = clientBaseUrl ? (clientApiKey || undefined) : (clientApiKey || base.apiKey);
+    const llmConfig = {
+      ...base,
+      provider: 'local' as const,
+      model: (typeof model === 'string' && model) ? model : base.model,
+      baseUrl: clientBaseUrl || base.baseUrl,
+      apiKey: effectiveApiKey,
+      maxTokens: Number(maxTokens) > 0 ? Number(maxTokens) : 4096,
+      temperature: typeof temperature === 'number' ? temperature : 0.3,
+      timeout: Number(timeout) > 0 ? Number(timeout) : 120000,
+    };
+
+    // Propagate a client disconnect (browser abort / operator "stop") to the upstream
+    // local model call. Without this, the Node fetch to llama.cpp/Ollama keeps running
+    // to its own full timeout regardless of what the browser did, wasting the single
+    // inference slot local backends typically serve.
+    //
+    // Must listen on `res`, not `req`: the request stream ends (and auto-destroys,
+    // emitting 'close') as soon as express.json() finishes consuming the body — which
+    // happens before this handler even runs — so `req.on('close')` fired on every
+    // single call, aborting it instantly regardless of whether the client stayed
+    // connected. `res`'s 'close' event fires on both normal completion and premature
+    // disconnect; `writableEnded` disambiguates (false only means the client actually
+    // went away before we could respond).
+    const controller = new AbortController();
+    const onClose = () => { if (!res.writableEnded) controller.abort(); };
+    res.on('close', onClose);
+
+    const backbone = new LLMBackbone(llmConfig as any);
+    let result;
+    try {
+      result = await backbone.chat(msgs as any, {
+        maxTokens: llmConfig.maxTokens,
+        temperature: llmConfig.temperature,
+        signal: controller.signal,
+      });
+    } finally {
+      res.off('close', onClose);
+    }
+
+    // Return BOTH a bare `content` and an OpenRouter-shaped `choices[]`, so callers
+    // reading either shape keep working with no further change.
+    res.json({
+      content: result.content,
+      model: result.model,
+      usage: result.usage,
+      choices: [{ message: { role: 'assistant', content: result.content } }],
+    });
+  } catch (error: any) {
+    console.error('[T3MP3ST] /api/llm/chat failed:', error);
+    if (!res.headersSent) res.status(502).json({ error: error?.message || 'Local LLM request failed' });
+  }
+});
+
 /**
  * POST /api/general/plan — Give the General a directive, get back an OpPlan
  *
@@ -6945,6 +7124,7 @@ app.post('/api/general/plan', async (req: Request, res: Response): Promise<void>
     apiKey,
     provider,
     model,
+    baseUrl, // local provider only: the operator's llama.cpp / Ollama host
   } = req.body;
 
   if (!objective) {
@@ -6953,7 +7133,7 @@ app.post('/api/general/plan', async (req: Request, res: Response): Promise<void>
   }
 
   try {
-    const generalConfig = resolveGeneralLLMConfig(provider, model, apiKey);
+    const generalConfig = resolveGeneralLLMConfig(provider, model, apiKey, baseUrl);
     // Create a dedicated LLM backbone for the General
     const generalLLM = new LLMBackbone(generalConfig);
 
@@ -7019,11 +7199,12 @@ app.post('/api/general/execute', async (req: Request, res: Response): Promise<vo
     apiKey,
     provider,
     model,
+    baseUrl, // local provider only: the operator's llama.cpp / Ollama host
   } = req.body;
 
   let generalConfig;
   try {
-    generalConfig = resolveGeneralLLMConfig(provider, model, apiKey);
+    generalConfig = resolveGeneralLLMConfig(provider, model, apiKey, baseUrl);
   } catch (error: any) {
     res.status(400).json({ error: error.message || 'API key required' });
     return;
@@ -7051,7 +7232,8 @@ app.post('/api/general/execute', async (req: Request, res: Response): Promise<vo
       execConfig.missionName,
       generalConfig.apiKey,
       generalConfig.provider,
-      generalConfig.model
+      generalConfig.model,
+      generalConfig.baseUrl
     );
 
     // Add targets from the plan
@@ -7132,6 +7314,7 @@ app.post('/api/general/auto', async (req: Request, res: Response): Promise<void>
     apiKey,
     provider,
     model,
+    baseUrl, // local provider only: the operator's llama.cpp / Ollama host
   } = req.body;
 
   if (!objective) {
@@ -7141,7 +7324,7 @@ app.post('/api/general/auto', async (req: Request, res: Response): Promise<void>
 
   let generalConfig;
   try {
-    generalConfig = resolveGeneralLLMConfig(provider, model, apiKey);
+    generalConfig = resolveGeneralLLMConfig(provider, model, apiKey, baseUrl);
   } catch (error: any) {
     res.status(400).json({ error: error.message || 'API key required' });
     return;
@@ -7196,7 +7379,8 @@ app.post('/api/general/auto', async (req: Request, res: Response): Promise<void>
       execConfig.missionName,
       generalConfig.apiKey,
       generalConfig.provider,
-      generalConfig.model
+      generalConfig.model,
+      generalConfig.baseUrl
     );
 
     for (const target of execConfig.targets) {
@@ -7389,8 +7573,8 @@ import { Admiral, briefToDirective, type ChatMsg, type MissionBrief } from './ad
  */
 app.post('/api/admiral/converse', async (req: Request, res: Response): Promise<void> => {
   try {
-    const { messages, provider, model, apiKey } = req.body as {
-      messages: ChatMsg[]; provider?: string; model?: string; apiKey?: string;
+    const { messages, provider = 'openrouter', model, apiKey, baseUrl } = req.body as {
+      messages: ChatMsg[]; provider?: string; model?: string; apiKey?: string; baseUrl?: string;
     };
     if (!Array.isArray(messages) || messages.length === 0) {
       res.status(400).json({ error: 'messages[] required' });
@@ -7400,7 +7584,7 @@ app.post('/api/admiral/converse', async (req: Request, res: Response): Promise<v
     if (llm) {
       admiralLLM = llm;
     } else {
-      const cfg = resolveGeneralLLMConfig(provider, model, apiKey);
+      const cfg = resolveGeneralLLMConfig(provider, model, apiKey, baseUrl);
       admiralLLM = new LLMBackbone(cfg);
     }
     const admiral = new Admiral(admiralLLM);
@@ -7419,8 +7603,8 @@ app.post('/api/admiral/converse', async (req: Request, res: Response): Promise<v
  */
 app.post('/api/admiral/suggest', async (req: Request, res: Response): Promise<void> => {
   try {
-    const { operatorPrompt, archetype, failureSignal, provider, model, apiKey } = req.body as {
-      operatorPrompt?: string; archetype?: string; failureSignal?: string; provider?: string; model?: string; apiKey?: string;
+    const { operatorPrompt, archetype, failureSignal, provider = 'openrouter', model, apiKey, baseUrl } = req.body as {
+      operatorPrompt?: string; archetype?: string; failureSignal?: string; provider?: string; model?: string; apiKey?: string; baseUrl?: string;
     };
     let prompt = typeof operatorPrompt === 'string' ? operatorPrompt : '';
     if (!prompt && archetype) {
@@ -7434,7 +7618,7 @@ app.post('/api/admiral/suggest', async (req: Request, res: Response): Promise<vo
     let admiralLLM: LLMBackbone;
     if (llm) { admiralLLM = llm; }
     else {
-      const cfg = resolveGeneralLLMConfig(provider, model, apiKey);
+      const cfg = resolveGeneralLLMConfig(provider, model, apiKey, baseUrl);
       admiralLLM = new LLMBackbone(cfg);
     }
     const admiral = new Admiral(admiralLLM);
@@ -7454,8 +7638,8 @@ app.post('/api/admiral/suggest', async (req: Request, res: Response): Promise<vo
  */
 app.post('/api/admiral/launch', async (req: Request, res: Response): Promise<void> => {
   try {
-    const { brief, confirmed, provider, model, apiKey } = req.body as {
-      brief: MissionBrief; confirmed?: boolean; provider?: string; model?: string; apiKey?: string;
+    const { brief, confirmed, provider = 'openrouter', model, apiKey, baseUrl } = req.body as {
+      brief: MissionBrief; confirmed?: boolean; provider?: string; model?: string; apiKey?: string; baseUrl?: string;
     };
     if (!brief || !brief.objective || !brief.target) {
       res.status(400).json({ error: 'brief with objective + target required' });
@@ -7471,7 +7655,7 @@ app.post('/api/admiral/launch', async (req: Request, res: Response): Promise<voi
 
     let generalConfig;
     try {
-      generalConfig = resolveGeneralLLMConfig(provider, model, apiKey);
+      generalConfig = resolveGeneralLLMConfig(provider, model, apiKey, baseUrl);
     } catch (error: any) {
       res.status(400).json({ error: error.message || 'API key required' });
       return;
@@ -7637,7 +7821,14 @@ type ConnectedLocalAgent = {
 };
 const connectedLocalAgents = new Map<string, ConnectedLocalAgent>();
 const LOCAL_AGENT_HEALTH_TTL_MS = 30_000;
-const LOCAL_AGENT_HEALTH_TIMEOUT_MS = 45_000;
+// A 15s liveness probe SIGKILLs a slow-but-alive local reasoning agent (which spends tens of
+// seconds thinking even on the trivial PONG probe), making requireLiveLocalAgent falsely reject
+// a healthy backend. Default to 90s and let the operator raise it via env for very slow models.
+// Bounded (not the 600s dispatch timeout) so a genuinely hung agent can't stall a mission for minutes.
+const LOCAL_AGENT_HEALTH_TIMEOUT_MS = (() => {
+  const parsed = Number(process.env.T3MP3ST_LOCAL_AGENT_HEALTH_TIMEOUT_MS);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 90_000;
+})();
 
 async function refreshConnectedLocalAgentHealth(force = false): Promise<void> {
   const now = Date.now();
@@ -7788,6 +7979,18 @@ async function startServer() {
   console.log('');
 
   await loadPersistedState();
+
+  // Install the outbound SOCKS5 proxy (if TEMPEST_PROXY_URL / saved settings define one)
+  // BEFORE anything makes outbound calls, so all test/attack fetch() egress is covered.
+  const proxyStatus = initProxyFromConfig();
+  if (proxyStatus.enabled) {
+    console.log(`[T3MP3ST] Outbound proxy ENABLED → ${proxyStatus.url} (loopback bypassed)`);
+  } else if (proxyStatus.error) {
+    console.warn(`[T3MP3ST] Outbound proxy misconfigured, egress is DIRECT: ${proxyStatus.error}`);
+  } else {
+    console.log('[T3MP3ST] Outbound proxy disabled — egress from local IP.');
+  }
+
   llm = await initLLM();
 
   // Load multi-language grammars once, before any white-box ingest request.