madarx 2.16.3 → 2.18.0

package/app/marketplace/marketplace-shell.jsx

@@ -7,7 +7,7 @@ import MarketplaceSearch from './marketplace-search.jsx';
 import MarketplaceRow from './marketplace-row.jsx';
 import ImportFromGithubModal from './import-from-github-modal.jsx';
 import ConnectionSetupModal from './connection-setup-modal.jsx';
-import InstallToast from './install-toast.jsx';
+import InstallToast, { describe } from './install-toast.jsx';
 
 const KIND_OPTIONS = ['all', 'connection', 'tool', 'skill', 'bundle', 'agent', 'workflow'];
 
@@ -95,6 +95,68 @@ export default function MarketplaceShell({
   const [bundleModal, setBundleModal] = useState({ open: false, slug: null });
   const [connectionModal, setConnectionModal] = useState({ open: false, item: null });
 
+  // Live copy of the server-rendered items so install toggles can update a card
+  // in place (no full-page navigation). Re-sync when the server re-renders.
+  const [liveItems, setLiveItems] = useState(items);
+  useEffect(() => { setLiveItems(items); }, [items]);
+
+  // Controlled toast for in-place installs (the query-param <InstallToast/>
+  // still handles the server-action / import redirect path).
+  const [toast, setToast] = useState(null);
+  useEffect(() => {
+    if (!toast) return undefined;
+    const t = setTimeout(() => setToast(null), 3800);
+    return () => clearTimeout(t);
+  }, [toast]);
+
+  function patchItem(id, patch) {
+    setLiveItems(prev => prev.map(it => (it.id === id ? { ...it, ...patch } : it)));
+  }
+
+  // In-place install/uninstall. Optimistically flips the card, calls the
+  // existing JSON route, reconciles with the authoritative item, and rolls back
+  // on failure. No router navigation → no scroll reset / full refresh.
+  async function installItem(item, nextInstalled) {
+    const id = item.id;
+    const prevInstalled = Boolean(item.installed);
+    patchItem(id, { installed: nextInstalled }); // optimistic
+    let toastKey = 0;
+    try {
+      const res = await fetch(`/api/marketplace/${encodeURIComponent(id)}`, {
+        method: 'PUT',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ installed: nextInstalled }),
+      });
+      const data = await res.json().catch(() => ({}));
+
+      if (!res.ok) {
+        patchItem(id, { installed: prevInstalled }); // rollback
+        setToast({ state: 'error', slug: item.slug, key: ++toastKey });
+        return;
+      }
+      if (data.deferred) {
+        patchItem(id, { installed: prevInstalled }); // bundle never actually installs
+        setToast({ state: 'deferred', slug: item.slug, key: ++toastKey });
+        return;
+      }
+      if (data.setup_required) {
+        patchItem(id, { installed: prevInstalled });
+        setToast({ state: 'setup_required', slug: item.slug, key: ++toastKey });
+        return;
+      }
+      // Reconcile with the server's authoritative item shape when provided.
+      if (data.item && typeof data.item === 'object') {
+        patchItem(id, data.item);
+      } else {
+        patchItem(id, { installed: nextInstalled });
+      }
+      setToast({ state: nextInstalled ? 'installed' : 'uninstalled', slug: item.slug, key: ++toastKey });
+    } catch {
+      patchItem(id, { installed: prevInstalled }); // rollback on network error
+      setToast({ state: 'error', slug: item.slug, key: ++toastKey });
+    }
+  }
+
   // Deep-link prefill for the connection modal. Read once on mount so the
   // user lands on the right card with the right scope preselected when
   // arriving from "/agents/[id] → Connect another service".
@@ -129,17 +191,17 @@ export default function MarketplaceShell({
   const categoryCounts = useMemo(() => {
     const counts = {};
     const scope = activeKind === 'all'
-      ? items
-      : items.filter(item => item.kind === activeKind);
+      ? liveItems
+      : liveItems.filter(item => item.kind === activeKind);
     for (const item of scope) {
       if (!item.category) continue;
       counts[item.category] = (counts[item.category] || 0) + 1;
     }
     return counts;
-  }, [items, activeKind]);
+  }, [liveItems, activeKind]);
 
   const filtered = useMemo(() => {
-    let list = items;
+    let list = liveItems;
     if (activeKind !== 'all') {
       list = list.filter(item => item.kind === activeKind);
     }
@@ -154,13 +216,21 @@ export default function MarketplaceShell({
         .sort((a, b) => rankItem(b, q) - rankItem(a, q));
     }
     return list;
-  }, [items, activeKind, activeCategory, query]);
+  }, [liveItems, activeKind, activeCategory, query]);
 
-  const installedCount = items.filter(item => item.installed).length;
+  const installedCount = liveItems.filter(item => item.installed).length;
+  const toastCopy = toast ? describe(toast.state, toast.slug) : null;
 
   return (
     <div className="mkt-page">
       <InstallToast />
+      {toastCopy ? (
+        <div className={`mkt-toast ${toastCopy.tone}`} role="status" aria-live="polite" key={toast.key}>
+          <span>{toastCopy.eyebrow}</span>
+          <p>{toastCopy.text}</p>
+          <button type="button" onClick={() => setToast(null)} aria-label="Dismiss notification">×</button>
+        </div>
+      ) : null}
       <section className="mkt-stats">
         <div className="mkt-stat">
           <b>{counts.all}</b>
@@ -225,6 +295,7 @@ export default function MarketplaceShell({
                 key={item.id}
                 item={item}
                 toggleAction={toggleAction}
+                installItem={installItem}
                 onBundleClick={() => setBundleModal({ open: true, slug: item.slug })}
                 onConnectionClick={() => setConnectionModal({ open: true, item })}
                 connectionStatus={item.kind === 'connection' ? summarizeConnectionClient(item) : null}

package/app/marketplace/workflow-card.jsx

@@ -33,7 +33,7 @@ function summarizeStages(stageKinds) {
  *   currentKind?: string,
  * }} props
  */
-export default function WorkflowCard({ item, toggleAction, currentKind }) {
+export default function WorkflowCard({ item, toggleAction, onToggle, currentKind }) {
   const installed = Boolean(item.installed);
   const workflow = item.workflow || {};
 
@@ -65,6 +65,7 @@ export default function WorkflowCard({ item, toggleAction, currentKind }) {
         </span>
         <InstallToggle
           action={toggleAction}
+          onToggle={onToggle}
           itemId={item.id}
           installed={installed}
           available={true}

package/lib/active-runs.js

@@ -0,0 +1,33 @@
+// In-process registry of agents with a LIVE manual/on-demand run.
+//
+// Manual runs triggered via POST /api/agents/[id]/run are fire-and-forget
+// promises inside the web process — they create NO `agent_runs` row (those are
+// for delegated/task runs), so there is no DB source of truth for "is this
+// agent running right now?". This module is that source for the current process.
+//
+// Scope + lifetime: process-local and best-effort. It answers the active-run
+// endpoint so the Run button can hydrate correct state after the user navigates
+// away and back within the same server process. It is intentionally NOT durable
+// (a restart clears it) — durable run tracking is the heartbeat-queue path.
+//
+// A ref count (not a boolean) tolerates overlapping ticks for the same agent.
+
+const counts = new Map();
+
+export function markRunActive(agentId) {
+  const id = String(agentId || '');
+  if (!id) return;
+  counts.set(id, (counts.get(id) || 0) + 1);
+}
+
+export function clearRunActive(agentId) {
+  const id = String(agentId || '');
+  if (!id) return;
+  const next = (counts.get(id) || 0) - 1;
+  if (next <= 0) counts.delete(id);
+  else counts.set(id, next);
+}
+
+export function isRunActive(agentId) {
+  return (counts.get(String(agentId || '')) || 0) > 0;
+}

package/lib/agent-config.js

@@ -1,6 +1,7 @@
 import { getDb } from './db.js';
 import { hasEnabledInternetTools } from './tools/registry.js';
 import { brandInstructionText, getBrandProfile } from './brand.js';
+import { commandExists } from './agent-engines.js';
 
 // Role description: user-editable identity/persona block. The dashboard's
 // InstructionsBuilder and /settings page both write to this. Replacing it
@@ -91,6 +92,13 @@ TOOL_SELF_MANAGEMENT
 - If the tool exists but is disabled, call install_tool to enable it. Tools rated irreversible_external will gate on operator approval — surface that to the principal.
 - After enabling a tool, immediately use it to complete the task.
 
+BROWSER_CONTROL
+- When asked to open, visit, or navigate a real web page and then read it, click, type, or search on it, drive a real browser — do NOT refuse and do NOT settle for web_fetch (which cannot click or run JavaScript-heavy pages).
+- Use browser_open to load the URL, browser_act to click/fill/type/press/scroll, browser_extract to read the rendered result, and browser_screenshot to capture it. The page persists across calls so you can chain open → act → extract.
+- These interactive browser tools start disabled. If a browser_* call is unavailable, call install_tool to enable it first, then proceed — exactly as TOOL_SELF_MANAGEMENT describes. Do not tell the principal you cannot browse; enable the tool and do it.
+- When the principal explicitly wants to WATCH the browser live (a visible window, "open the browser so I can see", "connect chrome"), use skill_bridge_run with skill="connect-chrome" or skill="browse" — it drives the real visible GStack browser. This tool ALWAYS asks for owner approval before each run (it crosses the local CLI boundary); surface that one approval, then proceed. For silent/background automation prefer the headless browser_* tools instead.
+- This applies identically whether the request arrives by voice or typed chat — voice runs through this same brain and toolset.
+
 ARTIFACT_LIFECYCLE
 - When asked to build a UI, page, interface, web component, landing page, dashboard, or any visual output — use generate_ui. Never use create_artifact for HTML or UI work.
 - When the principal refines, extends, or follows up on a previous artifact, use update_artifact with the existing artifact_id — do NOT create a new artifact.
@@ -232,14 +240,6 @@ export const MODELS = ANTHROPIC_MODELS;
 
 const OLLAMA_BASE_URL = process.env.OLLAMA_BASE_URL || 'http://127.0.0.1:11434';
 
-async function commandExists(command) {
-  const { spawn } = await import('node:child_process');
-  return new Promise(resolve => {
-    const child = spawn('sh', ['-lc', `command -v ${command}`], { shell: false });
-    child.on('error', () => resolve(false));
-    child.on('close', code => resolve(code === 0));
-  });
-}
 
 export async function getModels() {
   const [ollamaRes, claudeCodeOk, codexOk] = await Promise.all([

package/lib/agent-engines.js

@@ -7,18 +7,42 @@ import { chatWithClaude } from './claude.js';
 const ANTHROPIC_MODEL = 'claude-sonnet-4-6';
 import { publishLiveEvent } from './live-events.js';
 import { WORKSPACE, DATA_DIR, ensureDirs } from './paths.js';
+import { getStreamVerbosity, verbosityStreamsThinking, thinkingBudgetTokens } from './engine-verbosity.js';
 
 const PROJECT_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 
+// Extract a short, human-readable preview from a tool_result block's content.
+// Content can be a string or an array of {type:'text', text} / image parts.
+function previewToolResultContent(block) {
+  const c = block?.content;
+  let text = '';
+  if (typeof c === 'string') text = c;
+  else if (Array.isArray(c)) {
+    text = c.map(p => (typeof p === 'string' ? p : (p?.type === 'text' && typeof p.text === 'string' ? p.text : ''))).join('');
+  }
+  text = String(text || '');
+  return {
+    preview: text.slice(0, 200),
+    chars: text.length,
+    lines: text ? text.split('\n').length : 0,
+  };
+}
+
 // Parses Claude Code's `--output-format stream-json` stdout. Each line is a JSON
 // envelope. We care about:
 //   - assistant.message.content[].type === 'text'       → accumulate response text
+//   - assistant.message.content[].type === 'thinking'   → surface reasoning (onThinkingDelta)
 //   - assistant.message.content[].type === 'tool_use'   → emit agent_tool_start
 //   - user.message.content[].type      === 'tool_result' → emit agent_tool_result
-// Everything else (system, init, hooks, partials, result) is ignored.
-function makeStreamJsonParser({ agentId, agentName, onText, onToolStart, onToolResult, onResult }) {
+//   - stream_event (only with --include-partial-messages) → incremental text /
+//     thinking deltas for smooth token-by-token streaming.
+// `partial` tells us deltas are active: when true the live preview is driven by
+// stream_event deltas, and the complete assistant envelope is used ONLY to
+// accumulate the authoritative final answer (avoids double-counting).
+export function makeStreamJsonParser({ agentId, agentName, partial = false, onText, onTextDelta, onThinkingDelta, onToolStart, onToolResult, onResult, onStatus }) {
   let buffer = '';
   const toolNameById = new Map();
+  const toolStartedAt = new Map();
   return function handleChunk(chunk) {
     buffer += chunk;
     let nl;
@@ -29,6 +53,28 @@ function makeStreamJsonParser({ agentId, agentName, onText, onToolStart, onToolR
       let evt;
       try { evt = JSON.parse(raw); } catch { continue; }
       if (!evt || typeof evt !== 'object') continue;
+
+      // Partial-message deltas (present only with --include-partial-messages).
+      // These wrap the raw Anthropic SSE event under evt.event. They drive the
+      // live preview; the authoritative answer still comes from the complete
+      // `assistant` envelopes below.
+      if (evt.type === 'stream_event' && evt.event && typeof evt.event === 'object') {
+        const se = evt.event;
+        if (se.type === 'content_block_delta' && se.delta) {
+          const d = se.delta;
+          if (d.type === 'text_delta' && typeof d.text === 'string') {
+            onTextDelta?.(d.text);
+          } else if (d.type === 'thinking_delta' && typeof d.thinking === 'string') {
+            onThinkingDelta?.(d.thinking);
+          }
+        } else if (se.type === 'content_block_start' && se.content_block?.type === 'thinking') {
+          onStatus?.('thinking');
+        } else if (se.type === 'message_start') {
+          onStatus?.('generating');
+        }
+        continue;
+      }
+
       // Terminal result event carries the run's final text at top level
       // (`evt.result`), not inside message.content. Capture it as a last-resort
       // answer for turns that emitted only tool_use blocks and no clean text
@@ -52,6 +98,16 @@ function makeStreamJsonParser({ agentId, agentName, onText, onToolStart, onToolR
         // can keep it for the live chat preview but exclude it from the
         // final return value.
         const hasToolUse = content.some(b => b?.type === 'tool_use');
+        // Thinking blocks in a complete envelope: only surface here when partial
+        // streaming is OFF (otherwise the stream_event deltas already did, and
+        // re-emitting would duplicate the reasoning).
+        if (!partial) {
+          for (const b of content) {
+            if (b?.type === 'thinking' && typeof b.thinking === 'string' && b.thinking) {
+              onThinkingDelta?.(b.thinking);
+            }
+          }
+        }
         const messageText = content
           .filter(b => b?.type === 'text' && typeof b.text === 'string')
           .map(b => b.text)
@@ -59,7 +115,10 @@ function makeStreamJsonParser({ agentId, agentName, onText, onToolStart, onToolR
         if (messageText) onText?.(messageText, { isFinal: !hasToolUse });
         for (const block of content) {
           if (block?.type === 'tool_use') {
-            if (block.id) toolNameById.set(block.id, block.name || 'tool');
+            if (block.id) {
+              toolNameById.set(block.id, block.name || 'tool');
+              toolStartedAt.set(block.id, Date.now());
+            }
             onToolStart?.({ id: block.id, name: block.name || 'tool', input: block.input });
             if (agentId) {
               publishLiveEvent({
@@ -76,7 +135,18 @@ function makeStreamJsonParser({ agentId, agentName, onText, onToolStart, onToolR
         for (const block of content) {
           if (block?.type === 'tool_result') {
             const toolName = toolNameById.get(block.tool_use_id) || 'tool';
-            onToolResult?.({ tool_use_id: block.tool_use_id, name: toolName, isError: Boolean(block.is_error) });
+            const startedAt = toolStartedAt.get(block.tool_use_id);
+            const durationMs = startedAt ? Date.now() - startedAt : null;
+            const { preview, chars, lines } = previewToolResultContent(block);
+            onToolResult?.({
+              tool_use_id: block.tool_use_id,
+              name: toolName,
+              isError: Boolean(block.is_error),
+              durationMs,
+              preview,
+              chars,
+              lines,
+            });
             if (agentId) {
               publishLiveEvent({
                 type: 'agent_tool_result',
@@ -85,9 +155,11 @@ function makeStreamJsonParser({ agentId, agentName, onText, onToolStart, onToolR
                 tool: toolName,
                 status: block.is_error ? 'error' : 'done',
                 isError: Boolean(block.is_error),
+                duration_ms: durationMs,
               });
             }
             toolNameById.delete(block.tool_use_id);
+            toolStartedAt.delete(block.tool_use_id);
           }
         }
       }
@@ -271,7 +343,13 @@ function commandSpawnTarget(command) {
   return _commandPathCache.get(command) || resolveCommandPathSync(command) || command;
 }
 
-async function commandExists(command) {
+// Exported so other surfaces (e.g. the main-chat model feed in agent-config.js)
+// use the SAME robust detection as /settings/engines — absolute-path candidates
+// + MADARX_<CMD>_BIN override + login-shell fallback. A bare `sh -lc command -v`
+// alone misses CLIs installed outside the server's inherited/login PATH (common
+// on GUI- or daemon-launched servers), which made claude-code show available in
+// engine settings but absent from the main chat picker.
+export async function commandExists(command) {
   if (resolveCommandPathSync(command)) return true;
   return new Promise(resolve => {
     const child = spawn('sh', ['-lc', `command -v ${command}`], { shell: false });
@@ -286,6 +364,30 @@ async function commandExists(command) {
   });
 }
 
+// Whether the installed `claude` CLI understands --include-partial-messages
+// (needed for token-by-token streaming + thinking deltas). Older CLIs reject
+// unknown flags and fail the whole spawn, so we probe `claude --help` once and
+// cache the result, degrading gracefully to chunked streaming when absent.
+// Force with MADARX_CC_FORCE_PARTIAL=1, disable with =0.
+let _ccPartialSupport;
+async function claudeSupportsPartialMessages() {
+  if (process.env.MADARX_MOCK_CLAUDE_CODE_RESPONSE) return false;
+  if (process.env.MADARX_CC_FORCE_PARTIAL === '1') return true;
+  if (process.env.MADARX_CC_FORCE_PARTIAL === '0') return false;
+  if (_ccPartialSupport !== undefined) return _ccPartialSupport;
+  _ccPartialSupport = await new Promise(resolve => {
+    try {
+      const child = spawn(commandSpawnTarget('claude'), ['--help'], { shell: false });
+      let out = '';
+      child.stdout.on('data', c => { out += c.toString(); });
+      child.stderr.on('data', c => { out += c.toString(); });
+      child.on('error', () => resolve(false));
+      child.on('close', () => resolve(out.includes('include-partial-messages')));
+    } catch { resolve(false); }
+  });
+  return _ccPartialSupport;
+}
+
 async function listOllamaModels() {
   try {
     const response = await fetch(`${OLLAMA_BASE_URL}/api/tags`, { signal: AbortSignal.timeout(1500) });
@@ -378,32 +480,73 @@ function cliOutput(command, args, { cwd = process.cwd(), timeoutMs = 120000, clo
   });
 }
 
-export async function runOllamaAgent({ model, systemPrompt, userMessage, maxTokens = 2048 }) {
+export async function runOllamaAgent({ model, systemPrompt, userMessage, maxTokens = 2048, onChunk, onThinking } = {}) {
   if (process.env.MADARX_MOCK_OLLAMA_RESPONSE) return process.env.MADARX_MOCK_OLLAMA_RESPONSE;
+  // Stream only when a consumer wants live output. `think` surfaces reasoning on
+  // models that support it (deepseek-r1, qwen3, …) but errors on some Ollama
+  // versions/models, so it's opt-in via MADARX_OLLAMA_THINK=1.
+  const wantStream = Boolean(onChunk || onThinking);
+  const wantThink = wantStream && verbosityStreamsThinking() && process.env.MADARX_OLLAMA_THINK === '1';
+  const body = {
+    model: model || process.env.OLLAMA_MODEL,
+    stream: wantStream,
+    options: { num_predict: maxTokens },
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userMessage },
+    ],
+  };
+  if (wantThink) body.think = true;
   const response = await fetch(`${OLLAMA_BASE_URL}/api/chat`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      model: model || process.env.OLLAMA_MODEL,
-      stream: false,
-      options: { num_predict: maxTokens },
-      messages: [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userMessage },
-      ],
-    }),
+    body: JSON.stringify(body),
   });
   if (!response.ok) throw new Error(`Ollama chat failed: HTTP ${response.status}`);
-  const data = await response.json();
-  const content = data.message?.content || data.response || '';
+  if (!wantStream) {
+    const data = await response.json();
+    const content = data.message?.content || data.response || '';
+    if (!content.trim()) throw new Error('Ollama returned no text');
+    return content.trim();
+  }
+  // Streaming: Ollama emits newline-delimited JSON. Accumulate content + thinking
+  // and forward incremental pieces to the callbacks for a live chat preview.
+  let content = '';
+  let thinking = '';
+  const reader = response.body.getReader();
+  const dec = new TextDecoder();
+  let buf = '';
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += dec.decode(value, { stream: true });
+    let nl;
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      let evt;
+      try { evt = JSON.parse(line); } catch { continue; }
+      const piece = evt.message?.content || evt.response || '';
+      const think = evt.message?.thinking || '';
+      if (piece) { content += piece; onChunk?.(piece, content); }
+      if (think) { thinking += think; onThinking?.(thinking, think); }
+    }
+  }
   if (!content.trim()) throw new Error('Ollama returned no text');
   return content.trim();
 }
 
-export async function runClaudeCodeAgent({ model, systemPrompt, userMessage, maxTurns, allowedTools = [], timeoutMs, onChunk, onAssistantText, onToolStart, onToolResult, cwd, addDirs = [], agentId, agentName } = {}) {
+export async function runClaudeCodeAgent({ model, systemPrompt, userMessage, maxTurns, allowedTools = [], timeoutMs, onChunk, onAssistantText, onThinking, onStatus, onToolStart, onToolResult, cwd, addDirs = [], agentId, agentName, verbosity } = {}) {
   if (process.env.MADARX_MOCK_CLAUDE_CODE_RESPONSE) return process.env.MADARX_MOCK_CLAUDE_CODE_RESPONSE;
   const prompt = `${systemPrompt}\n\n${userMessage}`;
   const effectiveMaxTurns = Number(maxTurns || process.env.CLAUDE_CODE_MAX_TURNS || 30);
+  const v = verbosity || getStreamVerbosity();
+  const wantsThinking = verbosityStreamsThinking(v);
+  // Token-by-token streaming + reasoning need --include-partial-messages, which
+  // only newer CLIs support. Probe once; fall back to chunked complete-message
+  // streaming when unavailable so nothing breaks on older installs.
+  const partial = wantsThinking && await claudeSupportsPartialMessages();
   const args = [
     '-p', prompt,
     '--max-turns', String(effectiveMaxTurns),
@@ -412,12 +555,21 @@ export async function runClaudeCodeAgent({ model, systemPrompt, userMessage, max
     '--permission-mode', 'bypassPermissions',
     '--setting-sources', 'project,local,user',
   ];
+  if (partial) args.push('--include-partial-messages');
   for (const dir of addDirs) {
     if (dir) args.push('--add-dir', dir);
   }
   if (allowedTools.length) args.push('--allowedTools', allowedTools.join(','));
   if (model && model !== 'claude-code') args.splice(2, 0, '--model', model);
 
+  // Best-effort nudge for the spawned CLI to actually produce extended thinking.
+  // Harmless when unsupported (the env var is simply ignored).
+  const subEnv = claudeSubprocessEnv();
+  if (wantsThinking) {
+    const budget = thinkingBudgetTokens(v);
+    if (budget > 0) subEnv.MAX_THINKING_TOKENS = String(Math.max(1024, budget));
+  }
+
   // Two buffers: `narrationParts` keeps every assistant text block (used only
   // for the live chat preview), `finalParts` keeps text from messages that had
   // NO tool_use — i.e. the actual answer, not the "let me search next…" prose.
@@ -427,17 +579,32 @@ export async function runClaudeCodeAgent({ model, systemPrompt, userMessage, max
   const finalParts = [];
   let lastNarration = '';
   let resultText = '';
+  // Live preview accumulators for partial mode. `liveDelta` is the running
+  // answer text (token deltas); `liveThinking` is the running reasoning. They
+  // never feed the returned answer — only the live chat surface.
+  let liveDelta = '';
+  let liveThinking = '';
   const parse = makeStreamJsonParser({
     agentId,
     agentName,
+    partial,
     onText: (t, opts = {}) => {
       narrationParts.push(t);
       if (opts.isFinal) finalParts.push(t);
       else lastNarration = t;
-      // Snapshot of running assistant prose so the route can stream a clean
-      // preview to the chat without exposing raw stream-json envelopes.
-      onAssistantText?.(narrationParts.join('').trim());
+      // When partial deltas are streaming the preview, the complete envelope is
+      // authoritative-only — don't also drive the preview from it (would double).
+      if (!partial) onAssistantText?.(narrationParts.join('').trim());
+    },
+    onTextDelta: (delta) => {
+      liveDelta += delta;
+      onAssistantText?.(liveDelta.trim());
+    },
+    onThinkingDelta: (delta) => {
+      liveThinking += delta;
+      onThinking?.(liveThinking.trim(), delta);
     },
+    onStatus: (phase) => { onStatus?.(phase); },
     onResult: (t) => { resultText = t; },
     onToolStart,
     onToolResult,
@@ -455,7 +622,7 @@ export async function runClaudeCodeAgent({ model, systemPrompt, userMessage, max
     // local CLI engine. Strip them so CC uses the logged-in subscription.
     // Honor an explicit opt-out for users who genuinely want API-key billing
     // for the spawned CLI (MADARX_CLI_USE_API_KEY=1).
-    env: claudeSubprocessEnv(),
+    env: subEnv,
     onChunk: (chunk) => {
       parse(chunk);
       onChunk?.(chunk);

package/lib/agent-runner.js

@@ -10,6 +10,7 @@ import { executeRegistryTool, getEnabledToolSchemasForAgent } from './tools/regi
 import { assertRunnable } from './engine-capabilities.js';
 import { looksFabricatedToolTranscript } from './fabricated-tool-output.js';
 import { publishLiveEvent } from './live-events.js';
+import { markRunActive, clearRunActive } from './active-runs.js';
 import {
   addTaskComment,
   appendAgentRunEvent,
@@ -363,6 +364,11 @@ export async function runAgentTick(agentOrId, {
     updateTask(task_id, { status: 'in_progress', actor_type: 'agent', actor_id: agent.id });
   }
 
+  // Mark this agent as having a live run so GET /api/agents/[id]/active-run can
+  // report it — manual runs have no agent_runs row to read from. Cleared in the
+  // finally below regardless of outcome.
+  markRunActive(agent.id);
+
   publishLiveEvent({
     type: 'agent_run_start',
     agent_id: agent.id,
@@ -610,6 +616,34 @@ ${lastMemory.length ? lastMemory.map((entry, index) => `${index + 1}. ${entry}`)
       try {
         markAgentRunFinished(taskRun.id, { status: 'failed', error: message });
       } catch {}
+    } else {
+      // Manual / on-demand run (no taskRun). The success path persists a `runs`
+      // row + audit, but this failure path historically did neither — so a
+      // failed manual run vanished (console-only) and the agent's activity feed
+      // stayed empty ("nothing happened"). Persist a FAILED run + audit carrying
+      // the remediation message and the error code so the failure — and how to
+      // fix it (e.g. engine_cannot_run_tools → switch engine) — is visible.
+      try {
+        const { recordRun, appendAudit } = await import('./runtime.js');
+        recordRun({
+          kind: 'agent-tick',
+          title: `${agent.name} run failed`,
+          agent: agent.name,
+          agent_id: agent.id,
+          status: 'failed',
+          preview: message,
+          output: message,
+          triggered_by,
+        });
+        appendAudit({
+          type: 'agent.run.failed',
+          summary: `${agent.name} run failed: ${message}`,
+          status: 'error',
+          meta: { agent_id: agent.id, code: err?.code || null, triggered_by },
+        });
+      } catch {
+        // Failure recording is best-effort — never mask the original error.
+      }
     }
     // Always publish run_complete on the error path so the OCC entry clears,
     // regardless of whether a taskRun was attached (on-demand runs via the
@@ -626,5 +660,7 @@ ${lastMemory.length ? lastMemory.map((entry, index) => `${index + 1}. ${entry}`)
       error: message,
     });
     throw err;
+  } finally {
+    clearRunActive(agent.id);
   }
 }

package/lib/auth-config.js

@@ -74,26 +74,42 @@ export function verifyRecoveryToken(provided) {
 
 function envMode() {
   const raw = process.env.MADARX_AUTH_MODE;
-  if (raw && String(raw).trim()) return String(raw).trim().toLowerCase();
+  if (raw && String(raw).trim()) {
+    const m = String(raw).trim().toLowerCase();
+    if (VALID_MODES.has(m)) return m;
+  }
   return null;
 }
 
-/** True when MADARX_AUTH_MODE is explicitly set — the UI cannot override it. */
+/**
+ * True ONLY when the operator opts into a hard lock via MADARX_AUTH_MODE_LOCK=1
+ * (alongside a valid MADARX_AUTH_MODE). In that state the UI / recovery flow
+ * cannot change the mode — for multi-tenant deployments that must fail closed.
+ *
+ * A bare `MADARX_AUTH_MODE` is NOT a lock: it only seeds the initial default the
+ * UI can still override. This is deliberate — a stray `MADARX_AUTH_MODE=supabase`
+ * with no resolvable credentials must never strand the operator behind a login
+ * that can't initialise, because the config-table mode (written by the login
+ * screen and the recovery-token hatch) always wins over the env seed.
+ */
 export function isAuthModeEnvLocked() {
-  const m = envMode();
-  return Boolean(m && VALID_MODES.has(m));
+  const lock = String(process.env.MADARX_AUTH_MODE_LOCK || '').trim().toLowerCase();
+  return Boolean(envMode() && (lock === '1' || lock === 'true'));
 }
 
 export function getAuthMode() {
-  const override = envMode();
-  if (override && VALID_MODES.has(override)) return override;
+  // Hard lock (opt-in): env wins outright, UI cannot override.
+  if (isAuthModeEnvLocked()) return envMode();
+  // Normal precedence: the config table (UI/recovery-managed) wins, so the
+  // login screen and the recovery-token hatch can always change the mode.
   try {
     const stored = getConfig(AUTH_MODE_KEY, null);
     if (stored && VALID_MODES.has(stored)) return stored;
   } catch {
-    // DB not ready (very early boot) — fall through to the safe default.
+    // DB not ready (very early boot) — fall through to the env seed / default.
   }
-  return 'local';
+  // No stored mode yet → env acts as the initial default (seed), else local.
+  return envMode() || 'local';
 }
 
 export function getSupabaseAuthConfig() {