@chatpanel/gateway 0.6.3 → 0.6.5

package/README.md

@@ -43,9 +43,14 @@ You need the [ChatPanel bridge](https://github.com/chatpanel/chatpanel-bridge)
 running and logged into codex/claude (the same bridge the extension uses).
 
 ```bash
+# Standalone binary — no Node.js required:
+curl -fsSL https://dl.chatpanel.net/gateway/install.sh | bash   # macOS / Linux
+#   Windows (PowerShell):  irm https://dl.chatpanel.net/gateway/install.ps1 | iex
+
+# Or via npm (needs Node):
 npm install -g @chatpanel/gateway
 chatpanel-gateway
-# → ChatPanel Privacy Gateway v0.1.0 on http://127.0.0.1:4320
+# → ChatPanel Privacy Gateway on http://127.0.0.1:4320
 #     backend  : bridge (agent: codex, via http://127.0.0.1:4319)
 ```
 
@@ -68,16 +73,42 @@ before codex sees it, and the reply is restored before opencode renders it. The
 request's `model` (`codex`/`claude`/`opencode`/`pi`) picks which agent the bridge
 drives; otherwise the configured default (`codex`) is used.
 
-### Using the api backend instead (local models / BYO keys)
+### Quick start (api backend — no bridge)
 
-Set `backend: "api"` (see config) and the gateway forwards redacted traffic to a
-real provider endpoint, passing your `Authorization` / `x-api-key` through:
+If all you want is the gateway as a **redacting proxy in front of an API model**,
+you do **not** need the bridge. Set `backend: "api"` and (optionally) point the
+gateway's upstream at your provider — in `~/.chatpanel/gateway.config.json`:
+
+```json
+{
+  "backend": "api",
+  "upstreams": {
+    "openai":    { "baseUrl": "https://api.openai.com" },
+    "anthropic": { "baseUrl": "https://api.anthropic.com" }
+  }
+}
+```
+
+Then point your **client** at the gateway and send your **own** API key — the
+gateway redacts, forwards to the provider with your key (it stores none), and
+restores the reply:
 
 ```bash
-export OPENAI_BASE_URL=http://127.0.0.1:4320/v1     # OpenAI / codex / aider / cursor
+# In your CLIENT's environment (NOT the gateway's — see the footgun below):
+export OPENAI_BASE_URL=http://127.0.0.1:4320/v1     # OpenAI-compatible: codex / aider / cursor / SDKs
 export ANTHROPIC_BASE_URL=http://127.0.0.1:4320     # Claude Code / Anthropic SDK
 ```
 
+To target a non-OpenAI provider (a local model, OpenRouter, Azure, …) change the
+**gateway's** `upstreams.*.baseUrl` in the config above — that's where the gateway
+forwards to. Flow: `client → gateway (redact) → provider (your key) → gateway (restore) → client`.
+
+> ⚠️ **Footgun:** `OPENAI_BASE_URL` means two different things — for your *client*
+> it's "where the gateway is", for the *gateway* it's "where my upstream is". Don't
+> set `OPENAI_BASE_URL=…:4320` in the **gateway's own** environment, or it forwards
+> to itself (the loop guard returns 508). Set the gateway's upstream in the config
+> file; use the env var only in the client's shell.
+
 ## Name/org redaction is built in (in-process NER, no Python)
 
 Deterministic redaction (emails, phones, cards, SSNs, API keys, IPs) needs no

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/gateway",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "Local privacy gateway — redacts PII out of OpenAI/Anthropic API traffic before it reaches a model, then restores it in the reply. Point opencode, codex, aider, Claude Code, etc. at it.",
   "type": "module",
   "bin": {

package/src/config.js

@@ -96,6 +96,14 @@ const DEFAULTS = {
 
   // Log one line per request (method, tokens redacted) without any raw values.
   logRequests: true,
+
+  // Optional per-request redaction breakdown attached to each log entry (shown
+  // expandable in the extension). Memory-only — never persisted to disk with the
+  // captured values; only the MODE is saved.
+  //   'off'    — counts only (default; the privacy-safe baseline)
+  //   'types'  — entity types + placeholder tokens (e.g. PERSON_1), no real values
+  //   'values' — real → placeholder mapping (the actual PII; opt-in, debugging)
+  logDetail: 'off',
 };
 
 function deepMerge(base, over) {

package/src/configstore.js

@@ -22,7 +22,7 @@ export function persistConfig(cfg, path = configPath()) {
     destinations: cfg.destinations,
     bridge: cfg.bridge, upstreams: cfg.upstreams, redaction: cfg.redaction,
     ner: cfg.ner, allowedOrigins: cfg.allowedOrigins, maxBodyBytes: cfg.maxBodyBytes,
-    pro: cfg.pro, logRequests: cfg.logRequests, tools: cfg.tools,
+    pro: cfg.pro, logRequests: cfg.logRequests, logDetail: cfg.logDetail, tools: cfg.tools,
   };
   writeFileSync(path, JSON.stringify(out, null, 2));
 }
@@ -47,6 +47,7 @@ export function publicConfig(cfg, { proUnlocked = false } = {}) {
     allowedOrigins: Array.isArray(cfg.allowedOrigins) ? cfg.allowedOrigins : [],
     pro: { unlocked: proUnlocked, hasToken: !!cfg.pro?.entitlementToken, free: cfg.pro?.free },
     logRequests: !!cfg.logRequests,
+    logDetail: ['types', 'values'].includes(cfg.logDetail) ? cfg.logDetail : 'off',
     tools: {
       autoNarrow: cfg.tools?.autoNarrow !== false,
       maxPerTurn: Number(cfg.tools?.maxPerTurn) > 0 ? Number(cfg.tools.maxPerTurn) : 8,
@@ -105,6 +106,7 @@ export function applyConfigPatch(cfg, patch = {}) {
     if (Number.isFinite(cap) && cap >= 0) cfg.pro.free.maxRequestsPerDay = cap;
   }
   if (typeof patch.logRequests === 'boolean') cfg.logRequests = patch.logRequests;
+  if (['off', 'types', 'values'].includes(patch.logDetail)) cfg.logDetail = patch.logDetail;
   if (patch.tools && typeof patch.tools === 'object') {
     cfg.tools = cfg.tools || {};
     if ('autoNarrow' in patch.tools) cfg.tools.autoNarrow = !!patch.tools.autoNarrow;

package/src/server.js

@@ -35,7 +35,7 @@ import * as openai from './openai.js';
 import * as responses from './responses.js';
 import * as anthropic from './anthropic.js';
 
-export const VERSION = '0.6.3';
+export const VERSION = '0.6.5';
 
 const KNOWN_AGENTS = new Set(['codex', 'claude', 'opencode', 'pi', 'kiro', 'antigravity']);
 
@@ -100,12 +100,62 @@ function setCors(res, origin) {
 
 const STARTED_AT = Date.now();
 
-// In-memory ring of recent request SUMMARIES for the extension's monitoring view.
-// Counts only — never any prompt/response text or values.
-const recentRequests = [];
-function recordRequest(entry) {
-  recentRequests.push(entry);
-  if (recentRequests.length > 50) recentRequests.shift();
+// Render a timings map as a compact one-liner for the console log.
+function fmtTimings(t) {
+  if (!t) return '';
+  const label = { redact: 'redact', upstream: 'model', stream: 'stream', restore: 'restore', total: 'total' };
+  return Object.keys(t).map((k) => `${label[k] || k} ${t[k]}ms`).join(' · ');
+}
+
+// Per-request timing + summary. Created ONLY when logging is on — when it's off
+// the handler passes a null trace and every `trace?.…` call short-circuits, so we
+// don't even read the clock: logging then adds zero latency. The committed entry
+// is flushed to the in-memory ring via setImmediate, i.e. AFTER the response has
+// been handed back, so recording (and the console line) never sits on the request
+// path. `timings` are wall-clock ms per stage of the flow:
+//   redact   prompt → harness[redact] → model input
+//   upstream model input → model output. Non-stream: full call. Stream: time to
+//            first token (model/connection latency). Shown as "model".
+//   stream   first token → last token (generation), streaming responses only
+//   restore  model output → harness[restore] → user response (non-stream; for
+//            streams restore is inline per chunk, so it's folded into stream)
+//   total    end-to-end through the gateway
+function mkTrace(sink) {
+  const start = performance.now();
+  const timings = {};
+  let done = false;
+  const mark = (name, ms) => { timings[name] = Math.round(ms * 10) / 10; };
+  return {
+    meta: {}, timings, mark,
+    // Stamp the duration of an already-completed stage (`t0` from clock()).
+    lap(name, t0) { mark(name, performance.now() - t0); },
+    clock() { return performance.now(); },
+    commit() {
+      if (done) return; done = true;
+      mark('total', performance.now() - start);
+      const entry = /** @type {any} */ ({ ...this.meta, timings });
+      setImmediate(() => {
+        sink(entry);
+        console.log(`[gateway] model=${entry.model || '-'} → ${entry.dest ? `${entry.dest}(${entry.type})` : 'none'} · redacted ${entry.redacted || 0}${entry.narrowed ? ` · narrowed -${entry.narrowed}` : ''} · ${fmtTimings(timings)}`);
+      });
+    },
+  };
+}
+
+// Build the optional per-request redaction breakdown from the request's vault.
+// 'types'  → [{ token:'PERSON_1', type:'PERSON' }]            (no real values)
+// 'values' → [{ token:'PERSON_1', type:'PERSON', value:'…' }] (the real PII; opt-in)
+// Lives only in the in-memory ring — never written to disk by persistConfig.
+function redactionDetail(vault, mode) {
+  if (!vault || !vault.byToken || (mode !== 'types' && mode !== 'values')) return undefined;
+  const out = [];
+  for (const [token, value] of vault.byToken) {
+    const m = /^\[\[([A-Z][A-Z0-9]*)_\d+\]\]$/.exec(token);
+    const t = m ? m[1] : 'PII';
+    const bare = token.replace(/^\[\[|\]\]$/g, '');
+    out.push(mode === 'values' ? { token: bare, type: t, value } : { token: bare, type: t });
+  }
+  return out;
 }
 
 // Classify a request: which protocol kind + adapter, whether it's a redactable
@@ -213,23 +263,32 @@ function forwardHeaders(headers, base) {
 // ---- backend: bridge -------------------------------------------------------
 
 // Stream the bridge SSE through the OpenAI shaper, parking on a tool call.
-async function pumpRelay(res, s, shaper) {
+// `trace` (when present) times the agent turn: 'upstream' = time to first token,
+// 'stream' = first token → park/done. The turn ends at a tool-call (parked, the
+// client runs the tool and POSTs back, resuming a fresh trace) or at onDone.
+async function pumpRelay(res, s, shaper, trace) {
   const restorer = makeTokenRestorer(s.vault);
+  const t0 = trace ? trace.clock() : 0;
+  let sStart = t0;
+  let first = true;
+  const tick = () => { if (trace && first) { trace.lap('upstream', t0); sStart = trace.clock(); first = false; } };
   await pumpBridgeStream(s, {
-    onText: (text) => { const r = restorer.push(text); if (r) res.write(shaper.sseDelta(r)); },
+    onText: (text) => { tick(); const r = restorer.push(text); if (r) res.write(shaper.sseDelta(r)); },
     onToolRequest: ({ name, restoredArgs, toolId }) => {
+      tick();
       const tail = restorer.flush(); if (tail) res.write(shaper.sseDelta(tail));
       res.write(shaper.sseToolCalls([{ id: toolId, name, arguments: JSON.stringify(restoredArgs) }]));
       res.write(shaper.sseToolFinish());
-      res.end(); // park: turn ends with tool_calls; the session stays alive for the follow-up
+      if (trace) trace.lap('stream', sStart);
+      res.end(); trace?.commit(); // park: turn ends with tool_calls; the session stays alive for the follow-up
     },
-    onDone: () => { const tail = restorer.flush(); if (tail) res.write(shaper.sseDelta(tail)); res.write(shaper.sseTail()); res.end(); endRelaySession(s.id); },
-    onError: (e) => { res.write(`data: ${JSON.stringify({ error: { message: e.message, type: 'bridge_error' } })}\n\n`); res.end(); endRelaySession(s.id); },
+    onDone: () => { const tail = restorer.flush(); if (tail) res.write(shaper.sseDelta(tail)); res.write(shaper.sseTail()); if (trace) trace.lap('stream', sStart); res.end(); endRelaySession(s.id); trace?.commit(); },
+    onError: (e) => { res.write(`data: ${JSON.stringify({ error: { message: e.message, type: 'bridge_error' } })}\n\n`); res.end(); endRelaySession(s.id); trace?.commit(); },
   });
 }
 
 // New tool-enabled turn: open the bridge with the client's tools as MCP specs.
-async function startRelay(req, res, { kind, adapter, agent }, body, vault, cfg, isPro, tools, harness = null) {
+async function startRelay(req, res, { kind, adapter, agent }, body, vault, cfg, isPro, tools, harness = null, trace = null) {
   const { messages, system } = adapter.toTurn(body);
   const token = readBridgeToken(cfg.bridge.token);
   const shaper = shaperFor(kind, body?.model || agent);
@@ -241,40 +300,48 @@ async function startRelay(req, res, { kind, adapter, agent }, body, vault, cfg,
   let resp;
   try {
     resp = await openBridgeChat({ bridgeUrl: cfg.bridge.url, agent, token, messages, system, specs: toolsToSpecs(tools), options: {}, signal: undefined });
-  } catch (e) { clearTimeout(ttl); endRelaySession(s.id); return sendJson(res, 502, { error: { message: `bridge: ${e.message}`, type: 'bridge_error' } }); }
+  } catch (e) { clearTimeout(ttl); endRelaySession(s.id); trace?.commit(); return sendJson(res, 502, { error: { message: `bridge: ${e.message}`, type: 'bridge_error' } }); }
   s.reader = resp.body.getReader();
   res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache', connection: 'keep-alive' });
   res.write(shaper.sseHead());
-  return pumpRelay(res, s, shaper);
+  return pumpRelay(res, s, shaper, trace);
 }
 
 // Follow-up turn carrying a tool result: feed it to the parked agent + resume.
-async function resumeRelay(res, s, toolContent, model) {
-  try { await deliverToolResult(s, toolContent); }
-  catch (e) { endRelaySession(s.id); return sendJson(res, 502, { error: { message: `tool-result: ${e.message}`, type: 'bridge_error' } }); }
+// The relay redacts the tool result with ITS vault (the main handler skips
+// redaction for a relay-resume), so time that here as the 'redact' leg.
+async function resumeRelay(res, s, toolContent, model, trace = null) {
+  try {
+    const rd0 = trace ? trace.clock() : 0;
+    await deliverToolResult(s, toolContent);
+    if (trace) trace.lap('redact', rd0);
+  } catch (e) { endRelaySession(s.id); trace?.commit(); return sendJson(res, 502, { error: { message: `tool-result: ${e.message}`, type: 'bridge_error' } }); }
   const shaper = shaperFor('openai', model || 'codex');
   res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache', connection: 'keep-alive' });
   res.write(shaper.sseHead());
-  return pumpRelay(res, s, shaper);
+  return pumpRelay(res, s, shaper, trace);
 }
 
-async function handleBridge(req, res, { kind, adapter, redactable, pathname, agentOverride, harness }, body, vault, cfg, isPro) {
+async function handleBridge(req, res, { kind, adapter, redactable, pathname, agentOverride, harness, trace }, body, vault, cfg, isPro) {
   if (!redactable) {
+    trace?.commit();
     return sendJson(res, 404, { error: `endpoint ${pathname} not supported by the bridge backend` });
   }
 
   // Tool relay (OpenAI protocol + agent destinations). A follow-up request carries
   // a tool result for a parked session; a new request with `tools` starts one.
+  // The relay streams its own multi-turn flow and commits the trace when its turn
+  // ends (parked on a tool call, or done).
   if (kind === 'openai') {
     const toolResult = adapter.extractLatestToolResult(body);
     if (toolResult) {
       const parsed = parseToolCallId(toolResult.tool_call_id);
       const s = parsed && getRelaySession(parsed.gwId);
-      if (s) return resumeRelay(res, s, toolResult.content, body?.model);
+      if (s) return resumeRelay(res, s, toolResult.content, body?.model, trace);
     }
     const tools = adapter.extractTools(body);
     if (tools.length && body?.stream === true) {
-      return startRelay(req, res, { kind, adapter, agent: agentOverride || pickAgent(body?.model, cfg) }, body, vault, cfg, isPro, tools, harness);
+      return startRelay(req, res, { kind, adapter, agent: agentOverride || pickAgent(body?.model, cfg) }, body, vault, cfg, isPro, tools, harness, trace);
     }
   }
 
@@ -291,10 +358,17 @@ async function handleBridge(req, res, { kind, adapter, redactable, pathname, age
   if (!wantStream) {
     try {
       let full = '';
+      const up0 = trace ? trace.clock() : 0;
       await streamBridgeChat(turn, (t) => { full += t; });
+      if (trace) trace.lap('upstream', up0);
+      const rs0 = trace ? trace.clock() : 0;
+      const out = shaper.full(restoreText(full, vault));
+      if (trace) trace.lap('restore', rs0);
       res.writeHead(200, { 'content-type': shaper.contentType });
-      return res.end(shaper.full(restoreText(full, vault)));
+      res.end(out);
+      return trace?.commit();
     } catch (e) {
+      trace?.commit();
       return sendJson(res, 502, { error: { message: `bridge backend failed: ${e.message}`, type: 'bridge_error' } });
     }
   }
@@ -302,8 +376,12 @@ async function handleBridge(req, res, { kind, adapter, redactable, pathname, age
   res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache', connection: 'keep-alive' });
   res.write(shaper.sseHead());
   const restorer = makeTokenRestorer(vault);
+  const up0 = trace ? trace.clock() : 0;
+  let sStart = up0;
   try {
+    let first = true;
     await streamBridgeChat(turn, (chunk) => {
+      if (trace && first) { trace.lap('upstream', up0); sStart = trace.clock(); first = false; } // time-to-first-token
       const restored = restorer.push(chunk);
       if (restored) res.write(shaper.sseDelta(restored));
     });
@@ -313,13 +391,16 @@ async function handleBridge(req, res, { kind, adapter, redactable, pathname, age
   } catch (e) {
     res.write(`data: ${JSON.stringify({ error: { message: e.message, type: 'bridge_error' } })}\n\n`);
   }
+  if (trace) trace.lap('stream', sStart);
   res.end();
+  trace?.commit();
 }
 
 // ---- backend: api ----------------------------------------------------------
 
-async function handleApi(req, res, { adapter, kind, pathname, search, base, destKey, destProtocol, harness }, outBody, vault) {
+async function handleApi(req, res, { adapter, kind, pathname, search, base, destKey, destProtocol, harness, trace }, outBody, vault) {
   let upstream;
+  const up0 = trace ? trace.clock() : 0;
   try {
     const headers = forwardHeaders(req.headers, base);
     // If the destination carries its own key (imported from a configured API),
@@ -334,6 +415,7 @@ async function handleApi(req, res, { adapter, kind, pathname, search, base, dest
       body: ['GET', 'HEAD'].includes(req.method) ? undefined : outBody,
     });
   } catch (e) {
+    trace?.commit();
     return sendJson(res, 502, { error: `upstream fetch failed: ${e.message}` });
   }
 
@@ -342,29 +424,47 @@ async function handleApi(req, res, { adapter, kind, pathname, search, base, dest
   upstream.headers.forEach((v, k) => { if (!HOP_BY_HOP.has(k.toLowerCase())) resHeaders[k] = v; });
 
   if (ct.includes('text/event-stream') && upstream.body) {
+    if (trace) trace.lap('upstream', up0); // model latency to response headers
+    const sStart = trace ? trace.clock() : 0;
     res.writeHead(upstream.status, resHeaders);
     // OpenAI streaming: restore tool-call args via the harness (real, or kept
     // redacted for remote MCP under redactRemote) while keeping visible text
-    // pseudonymized. Other protocols: generic restore.
-    if (kind === 'openai') return pipeRestoredOpenAIStream(upstream.body, res, vault, harness);
-    return pipeRestoredStream(upstream.body, res, vault);
+    // pseudonymized. Other protocols: generic restore. The 'stream' leg spans
+    // the body; commit once it finishes (total then covers the whole response).
+    const piped = kind === 'openai'
+      ? pipeRestoredOpenAIStream(upstream.body, res, vault, harness)
+      : pipeRestoredStream(upstream.body, res, vault);
+    return Promise.resolve(piped).finally(() => { if (trace) trace.lap('stream', sStart); trace?.commit(); });
   }
 
   const buf = Buffer.from(await upstream.arrayBuffer());
+  if (trace) trace.lap('upstream', up0);
   if (vault && ct.includes('application/json')) {
     try {
+      const rs0 = trace ? trace.clock() : 0;
       const json = adapter.restoreResponse(JSON.parse(buf.toString('utf8')), vault, harness);
+      if (trace) trace.lap('restore', rs0);
       res.writeHead(upstream.status, { ...resHeaders, 'content-type': 'application/json' });
-      return res.end(Buffer.from(JSON.stringify(json), 'utf8'));
+      res.end(Buffer.from(JSON.stringify(json), 'utf8'));
+      return trace?.commit();
     } catch { /* fall through */ }
   }
   res.writeHead(upstream.status, resHeaders);
   res.end(buf);
+  trace?.commit();
 }
 
 // ---- server ----------------------------------------------------------------
 
 export function createGateway(cfg = loadConfig()) {
+  // Per-gateway ring of recent request summaries for the extension's monitoring
+  // view (newest last). Counts + optional redaction detail + per-stage timings —
+  // see mkTrace. Lives only here, never persisted to disk.
+  const recentRequests = [];
+  const recordRequest = (entry) => {
+    recentRequests.push(entry);
+    if (recentRequests.length > 50) recentRequests.shift();
+  };
   return createServer(async (req, res) => {
     const url = new URL(req.url, 'http://127.0.0.1');
     const pathname = url.pathname;
@@ -461,7 +561,7 @@ export function createGateway(cfg = loadConfig()) {
       }
     }
     if (pathname === '/logs' && req.method === 'GET') {
-      return sendJson(res, 200, { entries: [...recentRequests].reverse() }); // newest first; counts only
+      return sendJson(res, 200, { entries: [...recentRequests].reverse() }); // newest first; counts only, unless logDetail enriches each entry
     }
     if (pathname === '/config' && req.method === 'GET') {
       const proUnlocked = await resolvePro(cfg.pro?.entitlementToken);
@@ -473,6 +573,18 @@ export function createGateway(cfg = loadConfig()) {
       if (!patch || typeof patch !== 'object') return sendJson(res, 400, { error: 'invalid config patch' });
       applyConfigPatch(cfg, patch);
       try { persistConfig(cfg, configPath()); } catch (e) { return sendJson(res, 500, { error: `could not persist config: ${e.message}` }); }
+      // The bundled NER engine only auto-loads at startup. If the user just switched
+      // detection BACK to the bundled engine (or it never loaded because an external
+      // detector was configured at boot), load it now so it doesn't stay "not running"
+      // until a restart. (An external detector needs no engine.) Fire-and-forget.
+      const det = cfg.redaction?.detection;
+      const usingBundled = !det || !det.backend || det.backend === 'off';
+      const st = nerEngine.state();
+      if (cfg.ner?.autostart && usingBundled && st !== 'ready' && st !== 'loading' && st !== 'downloading') {
+        nerEngine.setModel(cfg.ner.model, { onLog: (m) => console.log(m) }).then((ok) => {
+          if (ok && cfg.ner?.enableFullTier && cfg.redaction.tier !== 'full') cfg.redaction.tier = 'full';
+        });
+      }
       const proUnlocked = await resolvePro(cfg.pro?.entitlementToken);
       return sendJson(res, 200, publicConfig(cfg, { proUnlocked }));
     }
@@ -499,6 +611,9 @@ export function createGateway(cfg = loadConfig()) {
     let redactedCount = 0;
     let narrowedTools = 0;
     let isPro = true;
+    // Off the hot path: only build a trace when logging is on, so it adds nothing
+    // when off (no clock reads, no record, no console line).
+    const trace = (cfg.logRequests && r.redactable && req.method === 'POST') ? mkTrace(recordRequest) : null;
     if (r.redactable && req.method === 'POST' && raw.length) {
       try { body = JSON.parse(raw.toString('utf8')); } catch { body = null; }
       if (body && isRelayResume(body, r.kind)) {
@@ -531,7 +646,9 @@ export function createGateway(cfg = loadConfig()) {
         const segs = r.adapter.collectSegments(body, cfg.redaction);
         const ac = new AbortController();
         req.on('close', () => ac.abort());
+        const rd0 = trace ? trace.clock() : 0;
         const { vault: v, count } = await redactSegments(segs, cfg.redaction, { signal: ac.signal, isPro });
+        if (trace) trace.lap('redact', rd0);
         vault = v;
         redactedCount = count;
         // When tools are armed, tell the model placeholders are auto-restored for
@@ -554,18 +671,18 @@ export function createGateway(cfg = loadConfig()) {
     // Route by the requested model → a destination (agent via the bridge, or an
     // API we forward to). Falls back to the legacy backend when none configured.
     const dest = resolveDestination(body?.model, cfg, r.kind);
-    if (cfg.logRequests && r.redactable) {
-      recordRequest({ t: Date.now(), model: body?.model || null, dest: dest ? dest.id : null, type: dest ? dest.type : null, redacted: redactedCount, narrowed: narrowedTools });
-      console.log(`[gateway] ${req.method} ${pathname} · model=${body?.model || '-'} → ${dest ? `${dest.id}(${dest.type})` : 'none'} · redacted ${redactedCount}${narrowedTools ? ` · narrowed -${narrowedTools} tools` : ''}`);
+    if (trace) {
+      trace.meta = { t: Date.now(), model: body?.model || null, dest: dest ? dest.id : null, type: dest ? dest.type : null, redacted: redactedCount, narrowed: narrowedTools, detail: redactionDetail(vault, cfg.logDetail) };
     }
     if (dest && dest.type === 'api') {
-      if (!dest.baseUrl) return sendJson(res, 502, { error: `destination "${dest.id}" has no baseUrl` });
+      if (!dest.baseUrl) { trace?.commit(); return sendJson(res, 502, { error: `destination "${dest.id}" has no baseUrl` }); }
       if (isSelfUrl(dest.baseUrl, cfg)) {
+        trace?.commit();
         return sendJson(res, 508, { error: { message: `destination "${dest.id}" points back at the gateway (${dest.baseUrl}) — refusing to forward (would loop).`, type: 'loop_detected' } });
       }
-      return handleApi(req, res, { ...r, pathname, search: url.search, base: dest.baseUrl, destKey: dest.apiKey, destProtocol: dest.protocol, harness }, outBody, vault);
+      return handleApi(req, res, { ...r, pathname, search: url.search, base: dest.baseUrl, destKey: dest.apiKey, destProtocol: dest.protocol, harness, trace }, outBody, vault);
     }
-    return handleBridge(req, res, { ...r, pathname, agentOverride: dest?.agent, harness }, body, vault, cfg, isPro);
+    return handleBridge(req, res, { ...r, pathname, agentOverride: dest?.agent, harness, trace }, body, vault, cfg, isPro);
   });
 }