claudeck 1.3.1 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeck",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "type": "module",
   "description": "A browser-based UI for Claude Code — chat, run workflows, manage MCP servers, track costs, and orchestrate autonomous agents from a local web interface. Installable as a PWA.",
   "main": "server.js",
@@ -11,6 +11,7 @@
     "cli.js",
     "server.js",
     "db.js",
+    "db/",
     "server/",
     "public/",
     "config/",

package/plugins/tasks/server.js

@@ -3,63 +3,63 @@ import { listTodos, createTodo, updateTodo, archiveTodo, deleteTodo, createBrag,
 
 const router = Router();
 
-router.get("/", (req, res) => {
+router.get("/", async (req, res) => {
   try {
     const archived = req.query.archived === "1";
-    const todos = listTodos(archived);
+    const todos = await listTodos(archived);
     res.json(todos);
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
 });
 
-router.get("/counts", (req, res) => {
+router.get("/counts", async (req, res) => {
   try {
-    res.json(getTodoCounts());
+    res.json(await getTodoCounts());
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
 });
 
-router.post("/", (req, res) => {
+router.post("/", async (req, res) => {
   try {
     const { text } = req.body;
     if (!text || typeof text !== "string") {
       return res.status(400).json({ error: "text is required" });
     }
-    const info = createTodo(text.trim());
+    const info = await createTodo(text.trim());
     res.json({ id: info.lastInsertRowid });
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
 });
 
-router.put("/:id", (req, res) => {
+router.put("/:id", async (req, res) => {
   try {
     const id = Number(req.params.id);
     const { text, done, priority } = req.body;
-    updateTodo(id, text ?? null, done ?? null, priority ?? null);
+    await updateTodo(id, text ?? null, done ?? null, priority ?? null);
     res.json({ ok: true });
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
 });
 
-router.put("/:id/archive", (req, res) => {
+router.put("/:id/archive", async (req, res) => {
   try {
     const id = Number(req.params.id);
     const { archived } = req.body;
-    archiveTodo(id, archived ?? true);
+    await archiveTodo(id, archived ?? true);
     res.json({ ok: true });
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
 });
 
-router.delete("/:id", (req, res) => {
+router.delete("/:id", async (req, res) => {
   try {
     const id = Number(req.params.id);
-    deleteTodo(id);
+    await deleteTodo(id);
     res.json({ ok: true });
   } catch (err) {
     res.status(500).json({ error: err.message });
@@ -67,15 +67,15 @@ router.delete("/:id", (req, res) => {
 });
 
 // ── Brags ──────────────────────────────────────────────
-router.get("/brags", (req, res) => {
+router.get("/brags", async (req, res) => {
   try {
-    res.json(listBrags());
+    res.json(await listBrags());
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
 });
 
-router.post("/:id/brag", (req, res) => {
+router.post("/:id/brag", async (req, res) => {
   try {
     const todoId = Number(req.params.id);
     const { summary } = req.body;
@@ -86,27 +86,27 @@ router.post("/:id/brag", (req, res) => {
       return res.status(400).json({ error: "summary must be 500 chars or less" });
     }
     // Get the todo text before archiving
-    const todos = listTodos(false);
+    const todos = await listTodos(false);
     const todo = todos.find(t => t.id === todoId);
-    const archivedTodos = listTodos(true);
+    const archivedTodos = await listTodos(true);
     const archivedTodo = archivedTodos.find(t => t.id === todoId);
     const foundTodo = todo || archivedTodo;
     if (!foundTodo) {
       return res.status(404).json({ error: "Todo not found" });
     }
-    const info = createBrag(todoId, foundTodo.text, summary.trim());
+    const info = await createBrag(todoId, foundTodo.text, summary.trim());
     // Archive the todo
-    archiveTodo(todoId, true);
+    await archiveTodo(todoId, true);
     res.json({ id: info.lastInsertRowid });
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
 });
 
-router.delete("/brags/:id", (req, res) => {
+router.delete("/brags/:id", async (req, res) => {
   try {
     const id = Number(req.params.id);
-    deleteBrag(id);
+    await deleteBrag(id);
     res.json({ ok: true });
   } catch (err) {
     res.status(500).json({ error: err.message });

package/public/css/ui/messages.css

@@ -25,6 +25,31 @@
   gap: 18px;
 }
 
+/* ── Load-more indicator (lazy loading) ─────────────── */
+.load-more-indicator {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  padding: 10px 0;
+  color: var(--text-muted);
+  font-size: 0.8rem;
+}
+
+.load-more-spinner {
+  display: inline-block;
+  width: 14px;
+  height: 14px;
+  border: 2px solid var(--border);
+  border-top-color: var(--accent);
+  border-radius: 50%;
+  animation: load-more-spin 0.6s linear infinite;
+}
+
+@keyframes load-more-spin {
+  to { transform: rotate(360deg); }
+}
+
 .messages:empty::after {
   content: "";
   display: none;

package/public/js/core/api.js

@@ -36,18 +36,35 @@ export async function fetchActiveSessionIds() {
   return data.activeSessionIds || [];
 }
 
-export async function fetchMessages(sessionId) {
-  const res = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}/messages`);
+function _appendPaginationParams(url, { limit, before } = {}) {
+  const params = new URLSearchParams();
+  if (limit) params.set("limit", limit);
+  if (before) params.set("before", before);
+  const qs = params.toString();
+  return qs ? `${url}?${qs}` : url;
+}
+
+export async function fetchMessages(sessionId, opts) {
+  const url = _appendPaginationParams(
+    `/api/sessions/${encodeURIComponent(sessionId)}/messages`, opts
+  );
+  const res = await fetch(url);
   return res.json();
 }
 
-export async function fetchMessagesByChatId(sessionId, chatId) {
-  const res = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}/messages/${encodeURIComponent(chatId)}`);
+export async function fetchMessagesByChatId(sessionId, chatId, opts) {
+  const url = _appendPaginationParams(
+    `/api/sessions/${encodeURIComponent(sessionId)}/messages/${encodeURIComponent(chatId)}`, opts
+  );
+  const res = await fetch(url);
   return res.json();
 }
 
-export async function fetchSingleMessages(sessionId) {
-  const res = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}/messages-single`);
+export async function fetchSingleMessages(sessionId, opts) {
+  const url = _appendPaginationParams(
+    `/api/sessions/${encodeURIComponent(sessionId)}/messages-single`, opts
+  );
+  const res = await fetch(url);
   return res.json();
 }
 

package/public/js/core/ws.js

@@ -3,6 +3,12 @@ import { $ } from './dom.js';
 import { getState, setState } from './store.js';
 import { emit } from './events.js';
 
+export function subscribeToSession(sessionId) {
+  const ws = getState("ws");
+  if (!ws || ws.readyState !== 1 || !sessionId) return;
+  ws.send(JSON.stringify({ type: "subscribe", sessionId }));
+}
+
 let backoffAttempt = 0;
 let hasConnectedBefore = false;
 
@@ -37,6 +43,12 @@ export function connectWebSocket() {
       hasConnectedBefore = true;
       emit("ws:connected");
     }
+
+    // Subscribe to current session for multi-client broadcast
+    const currentSession = getState("sessionId");
+    if (currentSession) {
+      ws.send(JSON.stringify({ type: "subscribe", sessionId: currentSession }));
+    }
   };
 
   ws.onmessage = (event) => {

package/public/js/features/chat.js

@@ -399,6 +399,10 @@ function handleServerMessage(msg) {
       showThinking("Thinking...", pane);
       break;
 
+    case "user_message":
+      addUserMessage(msg.text, pane);
+      break;
+
     case "text":
       appendAssistantText(msg.text, pane);
       break;

package/public/js/features/sessions.js

@@ -5,8 +5,12 @@ import { CHAT_IDS } from '../core/constants.js';
 import { escapeHtml } from '../core/utils.js';
 import * as api from '../core/api.js';
 import { panes, enterParallelMode, exitParallelMode } from '../ui/parallel.js';
-import { renderMessagesIntoPane, showWhalyPlaceholder } from '../ui/messages.js';
+import { renderMessagesIntoPane, prependOlderMessages, showWhalyPlaceholder, showLoadingIndicator, hideLoadingIndicator } from '../ui/messages.js';
 import { loadContextGauge } from '../ui/context-gauge.js';
+import { subscribeToSession } from '../core/ws.js';
+
+const MESSAGE_PAGE_SIZE = 30;
+const SCROLL_LOAD_THRESHOLD = 150; // px from top to trigger load more
 
 const SESSION_STORAGE_KEY = "claudeck-session-id";
 
@@ -14,6 +18,7 @@ const SESSION_STORAGE_KEY = "claudeck-session-id";
 onState("sessionId", (val) => {
   if (val) {
     localStorage.setItem(SESSION_STORAGE_KEY, val);
+    subscribeToSession(val);
   } else {
     localStorage.removeItem(SESSION_STORAGE_KEY);
   }
@@ -228,16 +233,16 @@ export async function deleteSession(id) {
 
 export async function loadMessages(sid) {
   if (getState("parallelMode")) {
-    for (const chatId of CHAT_IDS) {
-      loadPaneMessages(sid, chatId);
-    }
+    // Load all panes concurrently instead of sequentially
+    await Promise.all(CHAT_IDS.map(chatId => loadPaneMessages(sid, chatId)));
     return;
   }
 
   const pane = panes.get(null);
   try {
-    const messages = await api.fetchSingleMessages(sid);
+    const messages = await api.fetchSingleMessages(sid, { limit: MESSAGE_PAGE_SIZE });
     renderMessagesIntoPane(messages, pane);
+    _initPanePagination(pane, messages, "single");
     loadContextGauge(sid);
   } catch (err) {
     console.error("Failed to load messages:", err);
@@ -248,22 +253,109 @@ export async function loadPaneMessages(sid, chatId) {
   const pane = panes.get(chatId);
   if (!pane) return;
   try {
-    let messages = await api.fetchMessagesByChatId(sid, chatId);
-
+    let messages;
     // For Chat 1 (chat-0): also load single-mode messages as fallback
     if (chatId === CHAT_IDS[0]) {
-      const singleMessages = await api.fetchSingleMessages(sid);
-      if (singleMessages.length > 0) {
-        messages = [...singleMessages, ...messages].sort((a, b) => a.id - b.id);
+      const [chatMsgs, singleMsgs] = await Promise.all([
+        api.fetchMessagesByChatId(sid, chatId, { limit: MESSAGE_PAGE_SIZE }),
+        api.fetchSingleMessages(sid, { limit: MESSAGE_PAGE_SIZE }),
+      ]);
+      if (singleMsgs.length > 0) {
+        messages = [...singleMsgs, ...chatMsgs].sort((a, b) => a.id - b.id);
+      } else {
+        messages = chatMsgs;
       }
+    } else {
+      messages = await api.fetchMessagesByChatId(sid, chatId, { limit: MESSAGE_PAGE_SIZE });
     }
 
     renderMessagesIntoPane(messages, pane);
+    _initPanePagination(pane, messages, chatId === CHAT_IDS[0] ? "chat0" : "chat");
   } catch (err) {
     console.error(`Failed to load messages for ${chatId}:`, err);
   }
 }
 
+// ── Lazy-load pagination ────────────────────────────────
+
+function _initPanePagination(pane, messages, mode) {
+  pane._hasMore = messages.length >= MESSAGE_PAGE_SIZE;
+  pane._oldestMessageId = messages.length > 0 ? messages[0].id : null;
+  pane._loadingMore = false;
+  pane._paginationMode = mode; // "single" | "chat" | "chat0"
+
+  // Remove any existing scroll listener
+  if (pane._scrollHandler) {
+    pane.messagesDiv.removeEventListener("scroll", pane._scrollHandler);
+  }
+
+  if (pane._hasMore) {
+    pane._scrollHandler = () => _onPaneScroll(pane);
+    pane.messagesDiv.addEventListener("scroll", pane._scrollHandler, { passive: true });
+  }
+}
+
+function _onPaneScroll(pane) {
+  if (
+    pane.messagesDiv.scrollTop < SCROLL_LOAD_THRESHOLD &&
+    pane._hasMore &&
+    !pane._loadingMore
+  ) {
+    _loadMoreMessages(pane);
+  }
+}
+
+async function _loadMoreMessages(pane) {
+  pane._loadingMore = true;
+  showLoadingIndicator(pane);
+
+  const sid = getState("sessionId");
+  const before = pane._oldestMessageId;
+  const opts = { limit: MESSAGE_PAGE_SIZE, before };
+
+  try {
+    let olderMessages;
+
+    switch (pane._paginationMode) {
+      case "single":
+        olderMessages = await api.fetchSingleMessages(sid, opts);
+        break;
+      case "chat0": {
+        // Chat 1 merges chatId + single messages
+        const [chatMsgs, singleMsgs] = await Promise.all([
+          api.fetchMessagesByChatId(sid, pane.chatId, opts),
+          api.fetchSingleMessages(sid, opts),
+        ]);
+        olderMessages = singleMsgs.length > 0
+          ? [...singleMsgs, ...chatMsgs].sort((a, b) => a.id - b.id)
+          : chatMsgs;
+        break;
+      }
+      default:
+        olderMessages = await api.fetchMessagesByChatId(sid, pane.chatId, opts);
+    }
+
+    if (olderMessages.length === 0) {
+      pane._hasMore = false;
+    } else {
+      pane._oldestMessageId = olderMessages[0].id;
+      pane._hasMore = olderMessages.length >= MESSAGE_PAGE_SIZE;
+      prependOlderMessages(olderMessages, pane);
+    }
+  } catch (err) {
+    console.error("Failed to load more messages:", err);
+  } finally {
+    hideLoadingIndicator(pane);
+    pane._loadingMore = false;
+
+    // Detach scroll listener if no more messages
+    if (!pane._hasMore && pane._scrollHandler) {
+      pane.messagesDiv.removeEventListener("scroll", pane._scrollHandler);
+      pane._scrollHandler = null;
+    }
+  }
+}
+
 // ── Session Context Menu ────────────────────────────────
 let sessionCtxMenu = null;
 

package/public/js/ui/messages.js

@@ -443,3 +443,45 @@ function addForkButton(msgEl, messageId) {
   btn.innerHTML = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="6" y1="3" x2="6" y2="15"/><circle cx="18" cy="6" r="3"/><circle cx="6" cy="18" r="3"/><path d="M18 9a9 9 0 0 1-9 9"/></svg>`;
   msgEl.appendChild(btn);
 }
+
+// ── Lazy-loading helpers ────────────────────────────────
+
+export function prependOlderMessages(messages, pane) {
+  if (!messages || messages.length === 0) return;
+
+  // Render older messages into a detached container using the same rendering logic
+  const tempContainer = document.createElement("div");
+  const tempPane = { messagesDiv: tempContainer, currentAssistantMsg: null };
+  renderMessagesIntoPane(messages, tempPane);
+
+  // Capture scroll position before DOM mutation
+  const scrollHeightBefore = pane.messagesDiv.scrollHeight;
+
+  // Move all rendered nodes into the real pane
+  const fragment = document.createDocumentFragment();
+  while (tempContainer.firstChild) {
+    fragment.appendChild(tempContainer.firstChild);
+  }
+
+  // Insert after loading indicator (if present) or at the top
+  const indicator = pane.messagesDiv.querySelector(".load-more-indicator");
+  const insertRef = indicator ? indicator.nextSibling : pane.messagesDiv.firstChild;
+  pane.messagesDiv.insertBefore(fragment, insertRef);
+
+  // Restore scroll position so the user's view doesn't jump
+  const scrollHeightAfter = pane.messagesDiv.scrollHeight;
+  pane.messagesDiv.scrollTop += (scrollHeightAfter - scrollHeightBefore);
+}
+
+export function showLoadingIndicator(pane) {
+  if (pane.messagesDiv.querySelector(".load-more-indicator")) return;
+  const el = document.createElement("div");
+  el.className = "load-more-indicator";
+  el.innerHTML = '<span class="load-more-spinner"></span> Loading older messages\u2026';
+  pane.messagesDiv.prepend(el);
+}
+
+export function hideLoadingIndicator(pane) {
+  const el = pane.messagesDiv.querySelector(".load-more-indicator");
+  if (el) el.remove();
+}

package/public/js/ui/parallel.js

@@ -138,11 +138,9 @@ export function enterParallelMode() {
 
   const sessionId = getState("sessionId");
   if (sessionId) {
-    // Lazy import to avoid circular dependency
+    // Lazy import to avoid circular dependency — load all panes concurrently
     import('../features/sessions.js').then(({ loadPaneMessages }) => {
-      for (const chatId of CHAT_IDS) {
-        loadPaneMessages(sessionId, chatId);
-      }
+      Promise.all(CHAT_IDS.map(chatId => loadPaneMessages(sessionId, chatId)));
     });
   }
 }

package/server/agent-loop.js

@@ -40,7 +40,7 @@ import { logNotification } from "./notification-logger.js";
  * Build the agent system prompt that instructs Claude to work autonomously
  * toward the given goal.
  */
-function buildAgentPrompt(agentDef, userContext, sharedContext, cwd) {
+async function buildAgentPrompt(agentDef, userContext, sharedContext, cwd) {
   let prompt = `You are an autonomous AI agent. Work toward the following goal step by step, using any tools available to you.\n\n`;
   prompt += `## Goal\n${agentDef.goal}\n\n`;
   if (userContext) {
@@ -48,7 +48,7 @@ function buildAgentPrompt(agentDef, userContext, sharedContext, cwd) {
   }
   // Inject persistent memories from previous sessions
   if (cwd) {
-    const memoryPrompt = buildAgentMemoryPrompt(cwd, 8);
+    const memoryPrompt = await buildAgentMemoryPrompt(cwd, 8);
     if (memoryPrompt) {
       prompt += memoryPrompt + '\n\n';
       console.log(`\n══════ AGENT MEMORY INJECTION ══════`);
@@ -105,7 +105,7 @@ export async function runAgent({
   const monitorRunId = runId || `single-${Date.now()}`;
   const effectiveRunType = runType || 'single';
   try {
-    recordAgentRunStart(monitorRunId, agentId, agentDef.title, effectiveRunType, parentRunId);
+    await recordAgentRunStart(monitorRunId, agentId, agentDef.title, effectiveRunType, parentRunId);
   } catch (e) { /* ignore duplicates */ }
 
   function agentSend(payload) {
@@ -161,8 +161,8 @@ export async function runAgent({
   if (resumeId) opts.resume = resumeId;
 
   // Load shared context from previous agents in this run
-  const sharedContext = runId ? getAllAgentContext(runId) : [];
-  const prompt = buildAgentPrompt(agentDef, userContext, sharedContext, cwd);
+  const sharedContext = runId ? await getAllAgentContext(runId) : [];
+  const prompt = await buildAgentPrompt(agentDef, userContext, sharedContext, cwd);
   let resolvedSid = clientSid;
   let claudeSessionId = null;
   let sessionModel = null;
@@ -185,15 +185,15 @@ export async function runAgent({
 
         sessionIds.set(ourSid, claudeSessionId);
 
-        if (!getSession(ourSid)) {
-          createSession(ourSid, claudeSessionId, projectName || "Agent Session", cwd || "");
-          updateSessionTitle(ourSid, `Agent: ${agentDef.title}`);
+        if (!await getSession(ourSid)) {
+          await createSession(ourSid, claudeSessionId, projectName || "Agent Session", cwd || "");
+          await updateSessionTitle(ourSid, `Agent: ${agentDef.title}`);
         } else {
-          updateClaudeSessionId(ourSid, claudeSessionId);
+          await updateClaudeSessionId(ourSid, claudeSessionId);
         }
 
         agentSend({ type: "session", sessionId: ourSid });
-        addMessage(resolvedSid, "user", JSON.stringify({ text: `[Agent: ${agentDef.title}] ${agentDef.goal}` }), null);
+        await addMessage(resolvedSid, "user", JSON.stringify({ text: `[Agent: ${agentDef.title}] ${agentDef.goal}` }), null);
         continue;
       }
 
@@ -204,7 +204,7 @@ export async function runAgent({
             lastAssistantText += (lastAssistantText ? "\n\n" : "") + block.text;
             agentSend({ type: "text", text: block.text });
             if (resolvedSid) {
-              addMessage(resolvedSid, "assistant", JSON.stringify({ text: block.text }), null);
+              await addMessage(resolvedSid, "assistant", JSON.stringify({ text: block.text }), null);
             }
           } else if (block.type === "tool_use") {
             turnCount++;
@@ -220,7 +220,7 @@ export async function runAgent({
                 : "",
             });
             if (resolvedSid) {
-              addMessage(resolvedSid, "tool", JSON.stringify({ id: block.id, name: block.name, input: block.input }), null);
+              await addMessage(resolvedSid, "tool", JSON.stringify({ id: block.id, name: block.name, input: block.input }), null);
             }
           }
         }
@@ -242,7 +242,7 @@ export async function runAgent({
               isError: block.is_error || false,
             });
             if (resolvedSid) {
-              addMessage(resolvedSid, "tool_result", JSON.stringify({
+              await addMessage(resolvedSid, "tool_result", JSON.stringify({
                 toolUseId: block.tool_use_id,
                 content: text.slice(0, 10000),
                 isError: block.is_error || false,
@@ -266,7 +266,7 @@ export async function runAgent({
           const resultModel = Object.keys(sdkMsg.modelUsage || {})[0] || sessionModel;
 
           if (resolvedSid) {
-            addCost(resolvedSid, costUsd, durationMs, numTurns, inputTokens, outputTokens, {
+            await addCost(resolvedSid, costUsd, durationMs, numTurns, inputTokens, outputTokens, {
               model: resultModel,
               stopReason: sdkMsg.subtype,
               isError: 0,
@@ -280,7 +280,7 @@ export async function runAgent({
             duration_ms: durationMs,
             num_turns: numTurns,
             cost_usd: costUsd,
-            totalCost: getTotalCost(),
+            totalCost: await getTotalCost(),
             input_tokens: inputTokens,
             output_tokens: outputTokens,
             cache_read_tokens: cacheReadTokens,
@@ -301,11 +301,11 @@ export async function runAgent({
 
           // Record completion for monitoring
           try {
-            recordAgentRunComplete(monitorRunId, agentId, 'completed', numTurns, costUsd, durationMs, inputTokens, outputTokens);
+            await recordAgentRunComplete(monitorRunId, agentId, 'completed', numTurns, costUsd, durationMs, inputTokens, outputTokens);
           } catch (e) { /* ignore */ }
 
           // Log notification
-          logNotification('agent', `Agent "${agentDef.title}" completed`,
+          await logNotification('agent', `Agent "${agentDef.title}" completed`,
             `${numTurns} turns · $${costUsd.toFixed(4)} · ${(durationMs / 1000).toFixed(1)}s`,
             JSON.stringify({ costUsd, durationMs, inputTokens, outputTokens, turns: numTurns }),
             resolvedSid, agentId);
@@ -315,7 +315,7 @@ export async function runAgent({
             const summary = lastAssistantText.length > 4000
               ? lastAssistantText.slice(0, 4000) + "\n\n[truncated]"
               : lastAssistantText;
-            setAgentContext(runId, agentId, "output", summary);
+            await setAgentContext(runId, agentId, "output", summary);
           }
         } else if (sdkMsg.subtype?.startsWith("error")) {
           const errMsg = sdkMsg.errors?.join(", ") || "Unknown error";
@@ -329,14 +329,14 @@ export async function runAgent({
           const resultModel = Object.keys(sdkMsg.modelUsage || {})[0] || sessionModel;
 
           if (resolvedSid) {
-            addCost(resolvedSid, costUsd, durationMs, numTurns, inputTokens, outputTokens, {
+            await addCost(resolvedSid, costUsd, durationMs, numTurns, inputTokens, outputTokens, {
               model: resultModel,
               stopReason: sdkMsg.subtype,
               isError: 1,
               cacheReadTokens,
               cacheCreationTokens,
             });
-            addMessage(resolvedSid, "error", JSON.stringify({ error: errMsg, subtype: sdkMsg.subtype }), null);
+            await addMessage(resolvedSid, "error", JSON.stringify({ error: errMsg, subtype: sdkMsg.subtype }), null);
           }
 
           lastAgentMetrics = { durationMs, costUsd, inputTokens, outputTokens, model: resultModel, turns: numTurns, isError: true, error: errMsg };
@@ -345,11 +345,11 @@ export async function runAgent({
 
           // Record error for monitoring
           try {
-            recordAgentRunComplete(monitorRunId, agentId, 'error', numTurns, costUsd, durationMs, inputTokens, outputTokens, errMsg);
+            await recordAgentRunComplete(monitorRunId, agentId, 'error', numTurns, costUsd, durationMs, inputTokens, outputTokens, errMsg);
           } catch (e) { /* ignore */ }
 
           // Log error notification
-          logNotification('error', `Agent "${agentDef.title}" failed`,
+          await logNotification('error', `Agent "${agentDef.title}" failed`,
             errMsg.slice(0, 200),
             JSON.stringify({ costUsd, durationMs, error: errMsg }),
             resolvedSid, agentId);
@@ -361,11 +361,11 @@ export async function runAgent({
     if (err.name === "AbortError") {
       agentSend({ type: "agent_aborted", agentId, turn: turnCount });
       agentSend({ type: "aborted" });
-      try { recordAgentRunComplete(monitorRunId, agentId, 'aborted', turnCount, 0, 0, 0, 0, 'Aborted'); } catch (e) { /* ignore */ }
+      try { await recordAgentRunComplete(monitorRunId, agentId, 'aborted', turnCount, 0, 0, 0, 0, 'Aborted'); } catch (e) { /* ignore */ }
     } else {
       agentSend({ type: "agent_error", agentId, error: err.message, turn: turnCount });
       agentSend({ type: "error", error: err.message });
-      try { recordAgentRunComplete(monitorRunId, agentId, 'error', turnCount, 0, 0, 0, 0, err.message); } catch (e) { /* ignore */ }
+      try { await recordAgentRunComplete(monitorRunId, agentId, 'error', turnCount, 0, 0, 0, 0, err.message); } catch (e) { /* ignore */ }
     }
     throw err; // Re-throw so callers (chains, DAGs) know the agent failed
   } finally {
@@ -413,8 +413,8 @@ export async function runAgent({
     // Auto-capture memories from agent output
     if (cwd && lastAssistantText) {
       try {
-        const explicitCount = saveExplicitMemories(cwd, lastAssistantText, resolvedSid);
-        const autoCount = captureMemories(cwd, lastAssistantText, resolvedSid, agentId);
+        const explicitCount = await saveExplicitMemories(cwd, lastAssistantText, resolvedSid);
+        const autoCount = await captureMemories(cwd, lastAssistantText, resolvedSid, agentId);
         const totalCaptured = explicitCount + autoCount;
         if (totalCaptured > 0) {
           console.log(`Captured ${totalCaptured} memories (${explicitCount} explicit, ${autoCount} auto) from agent ${agentId}`);