create-walle 0.9.21 → 0.9.23

package/template/claude-task-manager/lib/connection-health.js

@@ -0,0 +1,232 @@
+'use strict';
+
+/**
+ * Unified phone/remote-access connection health.
+ *
+ * Produces ONE normalized health record per method (Microsoft Dev Tunnel, Walle Remote
+ * relay, Tailscale) so the Access page can show a single status truth, detect
+ * expiry/offline, fire an action-required notification on the TRANSITION to broken, and
+ * auto-recover when the user fixes it.
+ *
+ * Probes are READ-ONLY (no recovery side-effects) — the existing Microsoft watchdog owns
+ * actually fixing the tunnel; this module reports state and offers `action` endpoints the
+ * client triggers. Cheap enough to poll (~20s) — no deep public-reachability probe here.
+ *
+ * Record shape:
+ *   { method, state, detail, origin, action, since, checked_at }
+ *   state: 'ok' | 'warning' | 'expired' | 'offline' | 'error' | 'not_configured'
+ *   action: null | { kind, endpoint, method }   // a one-click fix the client can POST/GET
+ */
+
+const fs = require('fs');
+const { X509Certificate } = require('crypto');
+
+const microsoft = require('./microsoft-dev-tunnel-setup');
+const tailscale = require('./tailscale-setup');
+const remoteRelay = require('./remote-relay-store');
+
+// Walle relay heartbeat: if not connected and last handshake older than this, treat as offline.
+const WALLE_STALE_MS = Number(process.env.CTM_WALLE_RELAY_STALE_MS) || 5 * 60 * 1000;
+const CERT_SOON_MS = 24 * 60 * 60 * 1000;
+
+// States that count as "broken" (drive the Reconnect badge + action-required notification).
+const BROKEN = new Set(['expired', 'offline', 'error']);
+
+// method -> { state, since } — transition cache (also keeps `since` accurate between polls).
+const _stateCache = new Map();
+
+function _rec(method, { state, detail, origin = '', action = null }) {
+  return { method, state, detail, origin, action };
+}
+
+// How far past its scheduled renewal the managed tunnel is (ms; 0 = on track).
+// Considers both the tunnel renewal and the anonymous-access renewal.
+function _renewalOverdueMs(managed, now = Date.now()) {
+  let worst = 0;
+  for (const key of ['next_tunnel_renewal_at', 'next_access_renewal_at']) {
+    const at = Date.parse(managed && managed[key] || '');
+    if (Number.isFinite(at) && now > at) worst = Math.max(worst, now - at);
+  }
+  return worst;
+}
+
+async function probeMicrosoftHealth(opts) {
+  try {
+    const d = await microsoft.detectMicrosoftDevTunnelSetup(opts);
+    const managed = d.managed_tunnel || {};
+    const configured = !!(managed.configured || managed.desired_running || managed.tunnel_id);
+    if (!d.installed) {
+      return _rec('microsoft', { state: 'not_configured', detail: 'devtunnel CLI is not installed.',
+        action: { kind: 'install', endpoint: '/api/setup/network/microsoft-dev-tunnel/install', method: 'POST' } });
+    }
+    if (!d.signed_in) {
+      // Signed out: if a tunnel was previously configured this is almost always an EXPIRED login.
+      return _rec('microsoft', configured
+        ? { state: 'expired', detail: 'Microsoft sign-in expired — reconnect.',
+            action: { kind: 'login', endpoint: '/api/setup/network/microsoft-dev-tunnel/login', method: 'POST' } }
+        : { state: 'not_configured', detail: 'Not signed in.',
+            action: { kind: 'login', endpoint: '/api/setup/network/microsoft-dev-tunnel/login', method: 'POST' } });
+    }
+    if (managed.desired_running && !managed.running) {
+      return _rec('microsoft', { state: 'offline', detail: 'Tunnel should be running but is not — reconnect.', origin: d.mobile_url,
+        action: { kind: 'recover', endpoint: '/api/setup/network/microsoft-dev-tunnel/recover', method: 'POST' } });
+    }
+    if (!configured || !managed.running) {
+      return _rec('microsoft', { state: 'not_configured', detail: 'Tunnel not started yet.', origin: d.mobile_url,
+        action: { kind: 'start', endpoint: '/api/setup/network/microsoft-dev-tunnel/start', method: 'POST' } });
+    }
+    if (managed.access && managed.access.status === 'error') {
+      return _rec('microsoft', { state: 'warning', detail: managed.access_error || 'Tunnel access needs attention.', origin: d.mobile_url,
+        action: { kind: 'recover', endpoint: '/api/setup/network/microsoft-dev-tunnel/recover', method: 'POST' } });
+    }
+    // Renewal runs at day 25 of the 30-day Dev Tunnels expiration. If it is
+    // overdue the tunnel is burning its ~5-day runway toward expiry — and an
+    // expired tunnel gets RECREATED with a NEW URL, which invalidates every
+    // paired phone (cookies + passkeys are hostname-bound). Escalate before that:
+    // >24h overdue = warning, >3 days = broken (fires the action-required alert).
+    const overdue = _renewalOverdueMs(managed);
+    if (overdue > 3 * 24 * 60 * 60 * 1000) {
+      return _rec('microsoft', { state: 'error', detail: 'Tunnel renewal has been failing for days — the URL will expire and rotate. Reconnect.', origin: d.mobile_url,
+        action: { kind: 'recover', endpoint: '/api/setup/network/microsoft-dev-tunnel/recover', method: 'POST' } });
+    }
+    if (overdue > 24 * 60 * 60 * 1000) {
+      return _rec('microsoft', { state: 'warning', detail: 'Tunnel renewal is overdue — reconnect before the URL expires and rotates.', origin: d.mobile_url,
+        action: { kind: 'recover', endpoint: '/api/setup/network/microsoft-dev-tunnel/recover', method: 'POST' } });
+    }
+    return _rec('microsoft', { state: 'ok', detail: 'Connected.', origin: d.mobile_url });
+  } catch (err) {
+    return _rec('microsoft', { state: 'error', detail: String(err?.message || err).slice(0, 200) });
+  }
+}
+
+async function probeWalleHealth(db) {
+  try {
+    if (!db) return _rec('walle', { state: 'not_configured', detail: 'Relay store unavailable.' });
+    remoteRelay.ensureRemoteRelaySchema(db);
+    const s = remoteRelay.buildRemoteStatus(db);
+    if (!s.configured) return _rec('walle', { state: 'not_configured', detail: 'Walle Remote is not set up.' });
+    if (s.connected) return _rec('walle', { state: 'ok', detail: 'Relay connected.', origin: s.relay && s.relay.mobile_url });
+    // Configured but not connected. Only treat as a BREAK if it was connected before
+    // (last_connected_at exists) — otherwise it's a default instance that was never used,
+    // which must NOT raise a false "offline — reconnect" alert.
+    const last = Number(s.instance && s.instance.last_connected_at) || 0;
+    if (!last) return _rec('walle', { state: 'not_configured', detail: 'Set up Walle Remote to pair a phone.', origin: s.relay && s.relay.mobile_url });
+    const stale = (Date.now() - last) > WALLE_STALE_MS;
+    return _rec('walle', {
+      state: 'offline',
+      detail: stale ? 'Relay is not connected.' : 'Relay reconnecting…',
+      origin: s.relay && s.relay.mobile_url,
+      action: null, // no programmatic re-dial yet (relay client auto-reconnects); surface guidance
+    });
+  } catch (err) {
+    return _rec('walle', { state: 'error', detail: String(err?.message || err).slice(0, 200) });
+  }
+}
+
+// Returns { expired, soon, notAfter } or null if cert can't be read/parsed.
+function _certStatus(certPath) {
+  try {
+    if (!certPath || !fs.existsSync(certPath)) return null;
+    const x = new X509Certificate(fs.readFileSync(certPath));
+    const notAfter = new Date(x.validTo).getTime();
+    if (!Number.isFinite(notAfter)) return null;
+    const now = Date.now();
+    return { expired: now > notAfter, soon: notAfter - now < CERT_SOON_MS, notAfter };
+  } catch {
+    return null;
+  }
+}
+
+async function probeTailscaleHealth(opts) {
+  try {
+    const t = await tailscale.detectTailscaleSetup(opts);
+    const tailscaleAuto = { kind: 'recover', endpoint: '/api/setup/network/tailscale-auto', method: 'POST' };
+    if (!t.installed) return _rec('tailscale', { state: 'not_configured', detail: 'Tailscale is not installed.' });
+    // "Set up for CTM phone access" = an HTTPS cert was generated. Without it, Tailscale
+    // may be installed/used for other things but isn't a CTM phone path — so a stopped/
+    // logged-out node must NOT raise a false "offline — reconnect" alert.
+    if (!t.cert_exists) {
+      return _rec('tailscale', {
+        state: 'not_configured',
+        detail: t.available ? 'Run auto setup to enable HTTPS for phones.' : 'Tailscale is not set up for phone access.',
+        origin: t.mobile_url, action: tailscaleAuto,
+      });
+    }
+    // Cert exists → the user set this up. Now report real liveness (authoritative
+    // BackendState + cert validity), so a genuine break surfaces as offline/expired.
+    const cert = _certStatus(t.cert_path);
+    if (cert && cert.expired) {
+      return _rec('tailscale', { state: 'expired', detail: 'HTTPS certificate expired — regenerate.', origin: t.mobile_url, action: tailscaleAuto });
+    }
+    const backend = String(t.backend_state || '');
+    if (backend === 'NeedsLogin') {
+      return _rec('tailscale', { state: 'expired', detail: 'Tailscale needs sign-in — run “tailscale up”.', origin: t.mobile_url, action: tailscaleAuto });
+    }
+    if (!t.available || (backend && backend !== 'Running')) {
+      const detail = backend === 'Stopped' ? 'Tailscale is stopped — run “tailscale up”.'
+        : backend === 'Starting' ? 'Tailscale is starting…'
+        : 'Tailscale is not connected — run “tailscale up”.';
+      return _rec('tailscale', { state: backend === 'Starting' ? 'warning' : 'offline', detail, origin: t.mobile_url, action: tailscaleAuto });
+    }
+    if (cert && cert.soon) {
+      return _rec('tailscale', { state: 'warning', detail: 'HTTPS certificate expires soon.', origin: t.mobile_url, action: tailscaleAuto });
+    }
+    return _rec('tailscale', { state: 'ok', detail: 'Reachable on your tailnet.', origin: t.mobile_url });
+  } catch (err) {
+    return _rec('tailscale', { state: 'error', detail: String(err?.message || err).slice(0, 200) });
+  }
+}
+
+// Update each record's `since`/`checked_at` from the cache and return broken-edge transitions.
+function _applyTransitions(records, nowIso) {
+  const transitions = [];
+  for (const r of records) {
+    const prev = _stateCache.get(r.method);
+    if (!prev || prev.state !== r.state) {
+      r.since = nowIso;
+      if (prev && !BROKEN.has(prev.state) && BROKEN.has(r.state)) {
+        transitions.push({ method: r.method, from: prev.state, to: r.state });
+      }
+      _stateCache.set(r.method, { state: r.state, since: nowIso });
+    } else {
+      r.since = prev.since;
+    }
+    r.checked_at = nowIso;
+  }
+  return transitions;
+}
+
+const _ORDER = { microsoft: 0, walle: 1, tailscale: 2 };
+function _pickRecommended(records) {
+  const oks = records.filter((r) => r.state === 'ok');
+  if (oks.length >= 1) {
+    return oks.sort((a, b) => _ORDER[a.method] - _ORDER[b.method])[0].method;
+  }
+  return 'microsoft'; // simplest to set up (no VPN app, no custom domain)
+}
+
+async function getConnectionHealth(deps = {}) {
+  const opts = { configDir: deps.configDir, port: deps.port };
+  const nowIso = new Date().toISOString();
+  const order = ['microsoft', 'walle', 'tailscale'];
+  const settled = await Promise.allSettled([
+    probeMicrosoftHealth(opts),
+    probeWalleHealth(deps.db),
+    probeTailscaleHealth(opts),
+  ]);
+  const records = settled.map((s, i) => (s.status === 'fulfilled'
+    ? s.value
+    : _rec(order[i], { state: 'error', detail: String(s.reason && s.reason.message || s.reason).slice(0, 200) })));
+  const transitions = _applyTransitions(records, nowIso);
+  return { ok: true, checked_at: nowIso, recommended: _pickRecommended(records), methods: records, transitions };
+}
+
+module.exports = {
+  getConnectionHealth,
+  probeMicrosoftHealth,
+  probeWalleHealth,
+  probeTailscaleHealth,
+  BROKEN,
+  _stateCache,
+  _internal: { _certStatus, _applyTransitions, _pickRecommended, _renewalOverdueMs },
+};

package/template/claude-task-manager/lib/conversation-blob-parser.js

@@ -0,0 +1,42 @@
+'use strict';
+
+// Shared parse of a session_conversations cache blob into a sorted message array.
+//
+// This is the heavy work behind `session-messages:parseCacheBlob`: JSON.parse of a
+// 0.5–2MB messages string (real Claude/Codex messages are deeply nested, so the parse
+// is 150–360ms on the main thread per the [freeze-probe] samples), a codex-synthetic
+// scan, and an in-place timeline sort. Extracted so it runs IDENTICALLY on the main
+// thread (cold/first-load + pool-failure fallback) and on a read-pool worker (the
+// off-thread re-parse for growing sessions) — parity by construction (same function).
+//
+// Deliberately dependency-light so a worker can require it without pulling in server.js:
+// only lib/timeline-order + lib/session-history (both already worker-safe).
+
+const { sortTimelineMessagesInPlace } = require('./timeline-order');
+
+// Lazy + defensive: if session-history can't load in a worker context, treat nothing as
+// synthetic (the main-thread path uses the real predicate; worst case a worker keeps a
+// synthetic codex context row that main would have dropped — corrected on the next
+// main-served parse). Mirrors lib/session-prompt-index.js's resolution.
+let _isCodexSyntheticUserText = null;
+function _codexSynthetic() {
+  if (_isCodexSyntheticUserText) return _isCodexSyntheticUserText;
+  try { _isCodexSyntheticUserText = require('./session-history').isCodexSyntheticUserText; }
+  catch { _isCodexSyntheticUserText = () => false; }
+  return _isCodexSyntheticUserText;
+}
+
+// Returns the parsed+sorted message array, or null when the blob is empty/invalid or the
+// conversation is entirely injected codex context (matches the server.js inline behavior
+// that this replaces). Throws only on malformed JSON — callers catch and fall back.
+function parseConversationBlob(messagesString) {
+  if (typeof messagesString !== 'string' || messagesString.length === 0) return null;
+  const messages = JSON.parse(messagesString);
+  if (!Array.isArray(messages) || messages.length === 0) return null;
+  const isSynthetic = _codexSynthetic();
+  if (messages.some((m) => m && m.role === 'user' && isSynthetic(m.text))) return null;
+  sortTimelineMessagesInPlace(messages);
+  return messages;
+}
+
+module.exports = { parseConversationBlob };

package/template/claude-task-manager/lib/conversation-tail-merge.js

@@ -1,9 +1,14 @@
 'use strict';
 
 const crypto = require('crypto');
+const { sortTimelineMessages, timelineTimestampMs } = require('./timeline-order');
 
 const MESSAGE_ROLES = new Set(['user', 'assistant']);
 
+// Below this length, identical text is too likely to be a legitimately-repeated short
+// turn (e.g. a user typing "yes" twice) to safely use as a cross-timestamp dedup key.
+const CONTENT_IDENTITY_MIN_LEN = 200;
+
 function textHash(text) {
   return crypto.createHash('sha1').update(String(text || '')).digest('hex').slice(0, 16);
 }
@@ -14,32 +19,65 @@ function messageText(message) {
 
 function timestampValue(timestamp) {
   if (timestamp == null || timestamp === '') return '';
-  if (typeof timestamp === 'number' && Number.isFinite(timestamp)) {
-    try { return new Date(timestamp).toISOString(); } catch { return String(timestamp); }
-  }
   const raw = String(timestamp || '');
-  const parsed = Date.parse(raw);
-  if (Number.isFinite(parsed)) return new Date(parsed).toISOString();
+  const parsed = timelineTimestampMs(timestamp);
+  if (parsed != null) {
+    try { return new Date(parsed).toISOString(); } catch {}
+  }
   return raw;
 }
 
-function timestampMs(timestamp) {
-  if (typeof timestamp === 'number' && Number.isFinite(timestamp)) return timestamp;
-  const parsed = Date.parse(String(timestamp || ''));
-  return Number.isFinite(parsed) ? parsed : null;
-}
-
-function messageKey(message) {
+function messageKey(message, textHashValue) {
   const role = String(message?.role || '').trim();
   const text = messageText(message);
   if (!role || !text) return '';
   return [
     role,
     timestampValue(message?.timestamp),
-    textHash(text),
+    textHashValue || textHash(text),
   ].join(':');
 }
 
+function messageIdentityKeys(message, textHashValue) {
+  const role = String(message?.role || '').trim();
+  if (!MESSAGE_ROLES.has(role)) return [];
+  const keys = [];
+  const parentUuid = String(
+    message?.parentUuid
+    || message?._parent
+    || message?.metadata?.parentUuid
+    || message?.metadata?.uuid
+    || ''
+  ).trim();
+  const ts = timestampValue(message?.timestamp);
+  if (parentUuid) keys.push(['provider', role, parentUuid].join(':'));
+  if (ts) keys.push(['timestamp', role, ts].join(':'));
+  // Content identity: collapses an exact-duplicate long turn that shares neither a
+  // parentUuid nor a timestamp with its twin — the provider-side hazards (stream-json
+  // duplicate rows, a non-streaming fallback re-bundling blocks, or a session resume
+  // rewriting history with fresh uuids/timestamps). Gated to long text so genuinely
+  // repeated short turns are never collapsed.
+  const text = messageText(message);
+  if (text.length >= CONTENT_IDENTITY_MIN_LEN) {
+    keys.push(['content', role, textHashValue || textHash(text)].join(':'));
+  }
+  return keys;
+}
+
+function messagesRepresentSameEvent(a, b) {
+  const aText = messageText(a);
+  const bText = messageText(b);
+  if (!aText || !bText) return false;
+  if (aText === bText) return true;
+  const shorter = aText.length <= bText.length ? aText : bText;
+  const longer = aText.length <= bText.length ? bText : aText;
+  // The conversation cache intentionally stores long rows as bounded visible
+  // text, while the live stream tail can still have the full JSONL row. Treat
+  // a long cached prefix and the full stream event as the same turn. Keep this
+  // bounded to long text so two short same-timestamp messages are not merged.
+  return shorter.length >= 512 && longer.startsWith(shorter);
+}
+
 function eventRole(event) {
   const type = String(event?.type || '').trim();
   if (MESSAGE_ROLES.has(type)) return type;
@@ -64,33 +102,32 @@ function streamEventToMessage(event) {
   };
   if (event?.eventId) message.streamEventId = event.eventId;
   if (Array.isArray(event?.data?.contentBlocks)) message.contentBlocks = event.data.contentBlocks;
+  if (event?.data?.parentUuid) message.parentUuid = event.data.parentUuid;
   return message;
 }
 
 function sortMessagesChronologically(messages) {
-  return messages
-    .slice()
-    .sort((a, b) => {
-      const ams = timestampMs(a.timestamp);
-      const bms = timestampMs(b.timestamp);
-      if (ams != null && bms != null && ams !== bms) return ams - bms;
-      if (ams != null && bms == null) return -1;
-      if (ams == null && bms != null) return 1;
-      if (a._mergeSourceOrder !== b._mergeSourceOrder) return a._mergeSourceOrder - b._mergeSourceOrder;
-      return a._mergeIndex - b._mergeIndex;
-    })
+  return sortTimelineMessages(messages)
     .map(({ _mergeSourceOrder, _mergeIndex, ...message }) => message);
 }
 
 function mergeMessagesWithStreamEvents(messages, events) {
   const merged = [];
   const seen = new Set();
+  const byIdentity = new Map();
   let added = 0;
+  let replaced = 0;
 
   const addMessage = (message, sourceOrder, index, fromStream = false) => {
     const text = messageText(message);
     const role = String(message?.role || '').trim();
-    if (!MESSAGE_ROLES.has(role) || !text) return;
+    if (!role || !text) return;
+    // Only user/assistant turns ever arrive via the live stream ring; durable
+    // base messages with other roles (tool-result rows, structured-capture
+    // system rows) must pass through, or a hot stream tail hides them. They
+    // get exact-key dedup below but no identity-key merging (identity keys
+    // are user/assistant-only).
+    if (fromStream && !MESSAGE_ROLES.has(role)) return;
     const normalized = {
       ...message,
       role,
@@ -99,9 +136,34 @@ function mergeMessagesWithStreamEvents(messages, events) {
       _mergeSourceOrder: sourceOrder,
       _mergeIndex: index,
     };
-    const key = messageKey(normalized);
+    const th = textHash(text);
+    const key = messageKey(normalized, th);
     if (!key || seen.has(key)) return;
+    const identityKeys = messageIdentityKeys(normalized, th);
+    for (const identityKey of identityKeys) {
+      if (!byIdentity.has(identityKey)) continue;
+      const existing = byIdentity.get(identityKey);
+      const existingMessage = merged[existing.index];
+      // A shared provider key (parentUuid) means the SAME provider row: a still-streaming
+      // partial in the live ring and its finalized copy in the cache. Collapse it
+      // unconditionally (keep the longer text) — the partial is not always a clean >=512
+      // prefix of the final, so messagesRepresentSameEvent's prefix gate can miss it.
+      // Weaker keys (timestamp / content-hash) still require a text match so two genuinely
+      // different turns that merely collide on one weak key are never merged.
+      const sameEvent = identityKey.startsWith('provider:')
+        || messagesRepresentSameEvent(existingMessage, normalized);
+      if (sameEvent) {
+        seen.add(key);
+        if (text.length > messageText(existingMessage).length) {
+          merged[existing.index] = normalized;
+          replaced++;
+        }
+        identityKeys.forEach(k => byIdentity.set(k, existing));
+        return;
+      }
+    }
     seen.add(key);
+    identityKeys.forEach(identityKey => byIdentity.set(identityKey, { index: merged.length, fromStream }));
     merged.push(normalized);
     if (fromStream) added++;
   };
@@ -117,6 +179,7 @@ function mergeMessagesWithStreamEvents(messages, events) {
   return {
     messages: sortMessagesChronologically(merged),
     added,
+    replaced,
   };
 }
 

package/template/claude-task-manager/lib/ctm-session-context-api.js

@@ -13,7 +13,7 @@ function loadCtmSessionContext() {
   return ctmSessionContext;
 }
 
-function handleCtmSessionContextApi(req, res, url, { db, dbModule } = {}) {
+function handleCtmSessionContextApi(req, res, url, { db, dbModule, runHeavy } = {}) {
   if (!url.pathname.startsWith('/api/ctm/session-memory')) return false;
 
   const context = loadCtmSessionContext();
@@ -26,19 +26,46 @@ function handleCtmSessionContextApi(req, res, url, { db, dbModule } = {}) {
     });
   }
 
+  // The search / context / context-pack reads are the heavy ones (FTS + LIKE scans over
+  // 220k+ message rows and a tens-of-MB conversation-blob column, plus full JSON.parse of
+  // matched conversations) — a single search was measured blocking the main loop 7.74s.
+  // When the server wires an off-thread runner, run them on the read-pool worker and reply
+  // when it resolves; `args` is the plain (clone-safe) input the worker re-runs with its own
+  // read-only connection, and `computeSync` is the main-thread fallback used when no runner
+  // is wired (tests / direct callers) or the pool is unavailable.
+  const serveHeavy = (op, args, computeSync) => {
+    if (typeof runHeavy !== 'function') {
+      return respondJson(res, 200, asApiResult(computeSync()));
+    }
+    Promise.resolve()
+      .then(() => runHeavy(op, args, computeSync))
+      .then((result) => respondJson(res, 200, asApiResult(result)))
+      .catch((err) => respondJson(res, 500, {
+        ok: false,
+        source: 'ctm-api',
+        authority: 'ctm',
+        reason: 'ctm_session_context_failed',
+        error: err.message,
+      }));
+    return true;
+  };
+
   try {
     if (url.pathname === '/api/ctm/session-memory/health' && req.method === 'GET') {
       return respondJson(res, 200, asApiResult(context.getCtmDbHealth({ db })));
     }
 
     if (url.pathname === '/api/ctm/session-memory/search' && req.method === 'GET') {
-      const query = url.searchParams.get('q') || url.searchParams.get('query') || '';
-      const limit = url.searchParams.get('limit') || undefined;
-      return respondJson(res, 200, asApiResult(context.searchCtmSessions({ query, limit, db })));
+      const args = {
+        query: url.searchParams.get('q') || url.searchParams.get('query') || '',
+        limit: url.searchParams.get('limit') || undefined,
+      };
+      return serveHeavy('ctmSessionMemorySearch', args,
+        () => context.searchCtmSessions({ ...args, db }));
     }
 
     if (url.pathname === '/api/ctm/session-memory/context' && req.method === 'GET') {
-      return respondJson(res, 200, asApiResult(context.getCtmSessionContext({
+      const args = {
         session_id: url.searchParams.get('session_id') || url.searchParams.get('id') || '',
         session_ids: parseListParams(url.searchParams, 'session_id', 'session_ids', 'ids'),
         limit: url.searchParams.get('limit') || undefined,
@@ -46,8 +73,9 @@ function handleCtmSessionContextApi(req, res, url, { db, dbModule } = {}) {
         include_raw: parseBool(url.searchParams.get('include_raw')),
         dedupe: !parseBool(url.searchParams.get('no_dedupe')),
         format: url.searchParams.get('format') || 'messages',
-        db,
-      })));
+      };
+      return serveHeavy('ctmSessionMemoryContext', args,
+        () => context.getCtmSessionContext({ ...args, db }));
     }
 
     if (
@@ -76,7 +104,7 @@ function handleCtmSessionContextApi(req, res, url, { db, dbModule } = {}) {
     if (url.pathname === '/api/ctm/session-memory/context-pack' && req.method === 'POST') {
       readJsonBody(req, 128 * 1024)
         .then((body) => {
-          respondJson(res, 200, asApiResult(context.buildContextPack({
+          const args = {
             task: body.task || '',
             query: body.query || '',
             session_ids: body.session_ids || body.ids,
@@ -84,8 +112,9 @@ function handleCtmSessionContextApi(req, res, url, { db, dbModule } = {}) {
             token_budget: body.token_budget,
             include_raw: Boolean(body.include_raw),
             mode: body.mode || 'auto',
-            db,
-          })));
+          };
+          serveHeavy('ctmSessionMemoryContextPack', args,
+            () => context.buildContextPack({ ...args, db }));
         })
         .catch((err) => respondJson(res, 400, {
           ok: false,