claudeck 1.3.1 → 1.4.0

package/server/memory-extractor.js

@@ -107,7 +107,7 @@ export function extractMemories(text) {
  * @param {string|null} agentId - Source agent ID (for agent runs)
  * @returns {number} Number of new memories saved
  */
-export function captureMemories(projectPath, assistantText, sessionId = null, agentId = null) {
+export async function captureMemories(projectPath, assistantText, sessionId = null, agentId = null) {
   if (!projectPath || !assistantText) return 0;
 
   const extracted = extractMemories(assistantText);
@@ -115,7 +115,7 @@ export function captureMemories(projectPath, assistantText, sessionId = null, ag
 
   for (const { category, content } of extracted) {
     try {
-      const result = createMemory(projectPath, category, content, sessionId, agentId);
+      const result = await createMemory(projectPath, category, content, sessionId, agentId);
       if (!result.isDuplicate) saved++;
     } catch {
       // Ignore individual save errors
@@ -129,10 +129,10 @@ export function captureMemories(projectPath, assistantText, sessionId = null, ag
  * Run memory maintenance for a project.
  * Call this on session start to decay stale memories and clean expired ones.
  */
-export function runMaintenance(projectPath) {
+export async function runMaintenance(projectPath) {
   if (!projectPath) return;
   try {
-    maintainMemories(projectPath);
+    await maintainMemories(projectPath);
   } catch {
     // Non-critical — don't break session startup
   }

package/server/memory-injector.js

@@ -36,11 +36,11 @@ function dedup(memories) {
  * @param {string|null} userMessage - Current user message for relevance matching
  * @returns {{ prompt: string|null, count: number }}
  */
-export function buildMemoryPrompt(projectPath, limit = 10, userMessage = null) {
+export async function buildMemoryPrompt(projectPath, limit = 10, userMessage = null) {
   if (!projectPath) return { prompt: null, count: 0 };
 
   // Get top memories by relevance score
-  let memories = getTopMemories(projectPath, limit);
+  let memories = await getTopMemories(projectPath, limit);
 
   // If we have a user message, also search for query-relevant memories
   if (userMessage && userMessage.length > 10) {
@@ -53,7 +53,7 @@ export function buildMemoryPrompt(projectPath, limit = 10, userMessage = null) {
         .filter(w => w.length > 2 && !stopWords.has(w));
 
       if (keywords.length > 0) {
-        const queryRelevant = searchMemories(projectPath, keywords.join(' '), limit);
+        const queryRelevant = await searchMemories(projectPath, keywords.join(' '), limit);
         memories = dedup([...memories, ...queryRelevant]);
       }
     } catch {
@@ -68,7 +68,7 @@ export function buildMemoryPrompt(projectPath, limit = 10, userMessage = null) {
 
   // Touch each memory to boost relevance on access
   for (const m of memories) {
-    touchMemory(m.id);
+    await touchMemory(m.id);
   }
 
   let prompt = `## Project Memory (persistent knowledge from previous sessions)\n`;
@@ -100,14 +100,14 @@ export function buildMemoryPrompt(projectPath, limit = 10, userMessage = null) {
 /**
  * Build a shorter memory section for agent prompts (tighter budget).
  */
-export function buildAgentMemoryPrompt(projectPath, limit = 8) {
+export async function buildAgentMemoryPrompt(projectPath, limit = 8) {
   if (!projectPath) return null;
 
-  const memories = getTopMemories(projectPath, limit);
+  const memories = await getTopMemories(projectPath, limit);
   if (!memories || memories.length === 0) return null;
 
   for (const m of memories) {
-    touchMemory(m.id);
+    await touchMemory(m.id);
   }
 
   let prompt = `## Prior Knowledge\n`;
@@ -157,7 +157,7 @@ export function parseMemoryBlocks(text) {
  * @param {string|null} sessionId
  * @returns {number} count of saved memories
  */
-export function saveExplicitMemories(projectPath, assistantText, sessionId = null) {
+export async function saveExplicitMemories(projectPath, assistantText, sessionId = null) {
   if (!projectPath || !assistantText) return 0;
 
   const blocks = parseMemoryBlocks(assistantText);
@@ -165,7 +165,7 @@ export function saveExplicitMemories(projectPath, assistantText, sessionId = nul
 
   for (const { category, content } of blocks) {
     try {
-      const result = createMemory(projectPath, category, content, sessionId, null);
+      const result = await createMemory(projectPath, category, content, sessionId, null);
       if (!result.isDuplicate) saved++;
     } catch {
       // Ignore individual save errors
@@ -188,7 +188,7 @@ export function saveExplicitMemories(projectPath, assistantText, sessionId = nul
  * @param {string|null} sessionId
  * @returns {{ saved: boolean, content: string, category: string }|null}
  */
-export function parseRememberCommand(message, projectPath, sessionId = null) {
+export async function parseRememberCommand(message, projectPath, sessionId = null) {
   if (!message || !projectPath) return null;
 
   const trimmed = message.trim();
@@ -213,7 +213,7 @@ export function parseRememberCommand(message, projectPath, sessionId = null) {
   const content = text.slice(0, 300);
 
   try {
-    const result = createMemory(projectPath, category, content, sessionId, null);
+    const result = await createMemory(projectPath, category, content, sessionId, null);
     return { saved: !result.isDuplicate, content, category };
   } catch {
     return null;

package/server/memory-optimizer.js

@@ -163,7 +163,7 @@ function parseOptimizerOutput(text) {
  */
 export async function optimizeMemories(projectPath, onProgress = () => {}) {
   // 1. Load all memories
-  const allMemories = listMemories(projectPath);
+  const allMemories = await listMemories(projectPath);
   if (!allMemories.length) {
     return { preview: { before: 0, after: 0, summary: "No memories to optimize." } };
   }
@@ -251,7 +251,7 @@ export async function optimizeMemories(projectPath, onProgress = () => {}) {
  * @param {Array<{category: string, content: string}>} optimized
  * @returns {{ deleted: number, created: number }}
  */
-export function applyOptimization(projectPath, optimized) {
+export async function applyOptimization(projectPath, optimized) {
   const db = getDb();
 
   // Run in a transaction for atomicity

package/server/notification-logger.js

@@ -14,14 +14,14 @@ function broadcast(payload) {
   }
 }
 
-export function logNotification(type, title, body = null, metadata = null, sourceSessionId = null, sourceAgentId = null) {
-  const notification = createNotification(type, title, body, metadata, sourceSessionId, sourceAgentId);
-  const unreadCount = getUnreadNotificationCount();
+export async function logNotification(type, title, body = null, metadata = null, sourceSessionId = null, sourceAgentId = null) {
+  const notification = await createNotification(type, title, body, metadata, sourceSessionId, sourceAgentId);
+  const unreadCount = await getUnreadNotificationCount();
   broadcast({ type: "notification:new", notification, unreadCount });
   return notification;
 }
 
-export function broadcastReadUpdate(ids) {
-  const unreadCount = getUnreadNotificationCount();
+export async function broadcastReadUpdate(ids) {
+  const unreadCount = await getUnreadNotificationCount();
   broadcast({ type: "notification:read", ids, unreadCount });
 }

package/server/orchestrator.js

@@ -68,10 +68,10 @@ For each sub-task you want to delegate, output a fenced code block with the lang
 ${task}`;
 }
 
-function buildOrchestratorPromptWithMemory(task, agents, cwd) {
+async function buildOrchestratorPromptWithMemory(task, agents, cwd) {
   let prompt = buildOrchestratorPrompt(task, agents);
   if (cwd) {
-    const memPrompt = buildAgentMemoryPrompt(cwd, 6);
+    const memPrompt = await buildAgentMemoryPrompt(cwd, 6);
     if (memPrompt) {
       prompt += '\n\n' + memPrompt;
     }
@@ -186,7 +186,7 @@ export async function runOrchestrator({
   orchSend({ type: "orchestrator_phase", phase: "planning" });
 
   try {
-    const prompt = buildOrchestratorPromptWithMemory(task, agents, cwd);
+    const prompt = await buildOrchestratorPromptWithMemory(task, agents, cwd);
     const q = query({ prompt, options: plannerOpts });
 
     for await (const sdkMsg of q) {
@@ -198,20 +198,20 @@ export async function runOrchestrator({
         resolvedSid = ourSid;
         sessionIds.set(ourSid, claudeSessionId);
 
-        if (!getSession(ourSid)) {
-          createSession(
+        if (!await getSession(ourSid)) {
+          await createSession(
             ourSid,
             claudeSessionId,
             projectName || "Orchestrator",
             cwd || "",
           );
-          updateSessionTitle(ourSid, `Orchestrator: ${task.slice(0, 60)}`);
+          await updateSessionTitle(ourSid, `Orchestrator: ${task.slice(0, 60)}`);
         } else {
-          updateClaudeSessionId(ourSid, claudeSessionId);
+          await updateClaudeSessionId(ourSid, claudeSessionId);
         }
 
         orchSend({ type: "session", sessionId: ourSid });
-        addMessage(
+        await addMessage(
           resolvedSid,
           "user",
           JSON.stringify({ text: `[Orchestrator] ${task}` }),
@@ -226,7 +226,7 @@ export async function runOrchestrator({
             plannerText += block.text;
             orchSend({ type: "text", text: block.text });
             if (resolvedSid) {
-              addMessage(
+              await addMessage(
                 resolvedSid,
                 "assistant",
                 JSON.stringify({ text: block.text }),
@@ -252,7 +252,7 @@ export async function runOrchestrator({
           Object.keys(sdkMsg.modelUsage || {})[0] || null;
 
         if (resolvedSid) {
-          addCost(
+          await addCost(
             resolvedSid,
             costUsd,
             durationMs,
@@ -274,7 +274,7 @@ export async function runOrchestrator({
           duration_ms: durationMs,
           num_turns: numTurns,
           cost_usd: costUsd,
-          totalCost: getTotalCost(),
+          totalCost: await getTotalCost(),
           input_tokens: inputTokens,
           output_tokens: outputTokens,
           model: resultModel,
@@ -375,7 +375,7 @@ export async function runOrchestrator({
       if (result?.claudeSessionId) chainResumeId = result.claudeSessionId;
 
       // Read context that the agent stored
-      const ctx = getAllAgentContext(runId).find(
+      const ctx = (await getAllAgentContext(runId)).find(
         (c) => c.agent_id === agentDef.id,
       );
 
@@ -439,7 +439,7 @@ export async function runOrchestrator({
             if (block.type === "text" && block.text) {
               orchSend({ type: "text", text: block.text });
               if (resolvedSid) {
-                addMessage(
+                await addMessage(
                   resolvedSid,
                   "assistant",
                   JSON.stringify({ text: block.text }),
@@ -465,7 +465,7 @@ export async function runOrchestrator({
             Object.keys(sdkMsg.modelUsage || {})[0] || null;
 
           if (resolvedSid) {
-            addCost(
+            await addCost(
               resolvedSid,
               costUsd,
               durationMs,
@@ -487,7 +487,7 @@ export async function runOrchestrator({
             duration_ms: durationMs,
             num_turns: numTurns,
             cost_usd: costUsd,
-            totalCost: getTotalCost(),
+            totalCost: await getTotalCost(),
             input_tokens: inputTokens,
             output_tokens: outputTokens,
             model: resultModel,

package/server/push-sender.js

@@ -9,7 +9,7 @@ export function initPushSender(webpush) {
 export async function sendPushNotification(title, body, tag) {
   if (!webpushInstance) return;
 
-  const subs = getAllPushSubscriptions();
+  const subs = await getAllPushSubscriptions();
   if (!subs.length) return;
 
   const payload = JSON.stringify({ title, body, tag });
@@ -23,7 +23,7 @@ export async function sendPushNotification(title, body, tag) {
         );
       } catch (err) {
         if (err.statusCode === 404 || err.statusCode === 410) {
-          deletePushSubscription(sub.endpoint);
+          await deletePushSubscription(sub.endpoint);
         }
       }
     })

package/server/routes/agents.js

@@ -46,9 +46,9 @@ function slugify(text) {
 
 // ── Agent Context (shared memory) ──
 
-router.get("/context/:runId", (req, res) => {
+router.get("/context/:runId", async (req, res) => {
   try {
-    const rows = getAllAgentContext(req.params.runId);
+    const rows = await getAllAgentContext(req.params.runId);
     res.json(rows);
   } catch (err) {
     res.status(500).json({ error: err.message });

package/server/routes/memory.js

@@ -11,11 +11,11 @@ const router = Router();
 const CATEGORIES = ["convention", "decision", "discovery", "warning"];
 
 // List memories for a project
-router.get("/", (req, res) => {
+router.get("/", async (req, res) => {
   try {
     const { project, category } = req.query;
     if (!project) return res.status(400).json({ error: "project query param required" });
-    const memories = listMemories(project, category || null);
+    const memories = await listMemories(project, category || null);
     res.json(memories);
   } catch (err) {
     res.status(500).json({ error: err.message });
@@ -23,11 +23,11 @@ router.get("/", (req, res) => {
 });
 
 // Search memories
-router.get("/search", (req, res) => {
+router.get("/search", async (req, res) => {
   try {
     const { project, q, limit } = req.query;
     if (!project || !q) return res.status(400).json({ error: "project and q required" });
-    const results = searchMemories(project, q, Number(limit) || 20);
+    const results = await searchMemories(project, q, Number(limit) || 20);
     res.json(results);
   } catch (err) {
     res.status(500).json({ error: err.message });
@@ -35,13 +35,13 @@ router.get("/search", (req, res) => {
 });
 
 // Get top relevant memories (used for prompt injection)
-router.get("/top", (req, res) => {
+router.get("/top", async (req, res) => {
   try {
     const { project, limit } = req.query;
     if (!project) return res.status(400).json({ error: "project required" });
-    const memories = getTopMemories(project, Number(limit) || 10);
+    const memories = await getTopMemories(project, Number(limit) || 10);
     // Touch each memory to boost relevance
-    for (const m of memories) touchMemory(m.id);
+    for (const m of memories) await touchMemory(m.id);
     res.json(memories);
   } catch (err) {
     res.status(500).json({ error: err.message });
@@ -49,12 +49,12 @@ router.get("/top", (req, res) => {
 });
 
 // Get stats
-router.get("/stats", (req, res) => {
+router.get("/stats", async (req, res) => {
   try {
     const { project } = req.query;
     if (!project) return res.status(400).json({ error: "project required" });
-    const stats = getMemoryStats(project);
-    const counts = getMemoryCounts(project);
+    const stats = await getMemoryStats(project);
+    const counts = await getMemoryCounts(project);
     res.json({ ...stats, categories: counts });
   } catch (err) {
     res.status(500).json({ error: err.message });
@@ -62,14 +62,14 @@ router.get("/stats", (req, res) => {
 });
 
 // Create a memory
-router.post("/", (req, res) => {
+router.post("/", async (req, res) => {
   try {
     const { project, category, content, sessionId, agentId } = req.body;
     if (!project || !content) {
       return res.status(400).json({ error: "project and content required" });
     }
     const cat = CATEGORIES.includes(category) ? category : "discovery";
-    const info = createMemory(project, cat, content.trim(), sessionId || null, agentId || null);
+    const info = await createMemory(project, cat, content.trim(), sessionId || null, agentId || null);
     res.json({ id: info.lastInsertRowid });
   } catch (err) {
     res.status(500).json({ error: err.message });
@@ -77,13 +77,13 @@ router.post("/", (req, res) => {
 });
 
 // Update a memory
-router.put("/:id", (req, res) => {
+router.put("/:id", async (req, res) => {
   try {
     const id = Number(req.params.id);
     const { content, category } = req.body;
     if (!content) return res.status(400).json({ error: "content required" });
     const cat = CATEGORIES.includes(category) ? category : "discovery";
-    updateMemory(id, content.trim(), cat);
+    await updateMemory(id, content.trim(), cat);
     res.json({ ok: true });
   } catch (err) {
     res.status(500).json({ error: err.message });
@@ -91,10 +91,10 @@ router.put("/:id", (req, res) => {
 });
 
 // Delete a memory
-router.delete("/:id", (req, res) => {
+router.delete("/:id", async (req, res) => {
   try {
     const id = Number(req.params.id);
-    deleteMemory(id);
+    await deleteMemory(id);
     res.json({ ok: true });
   } catch (err) {
     res.status(500).json({ error: err.message });
@@ -102,11 +102,11 @@ router.delete("/:id", (req, res) => {
 });
 
 // Decay old memories and clean expired
-router.post("/maintain", (req, res) => {
+router.post("/maintain", async (req, res) => {
   try {
     const { project } = req.body;
     if (!project) return res.status(400).json({ error: "project required" });
-    maintainMemories(project);
+    await maintainMemories(project);
     res.json({ ok: true });
   } catch (err) {
     res.status(500).json({ error: err.message });
@@ -129,13 +129,13 @@ router.post("/optimize", async (req, res) => {
 });
 
 // Apply optimization — replace memories with optimized set
-router.post("/optimize/apply", (req, res) => {
+router.post("/optimize/apply", async (req, res) => {
   try {
     const { project, optimized } = req.body;
     if (!project || !Array.isArray(optimized)) {
       return res.status(400).json({ error: "project and optimized array required" });
     }
-    const result = applyOptimization(project, optimized);
+    const result = await applyOptimization(project, optimized);
     res.json(result);
   } catch (err) {
     console.error("Apply optimization error:", err);

package/server/routes/messages.js

@@ -1,32 +1,63 @@
 import { Router } from "express";
-import { getMessages, getMessagesByChatId, getMessagesNoChatId } from "../../db.js";
+import {
+  getMessages, getMessagesByChatId, getMessagesNoChatId,
+  getRecentMessages, getRecentMessagesByChatId, getRecentMessagesNoChatId,
+  getOlderMessages, getOlderMessagesByChatId, getOlderMessagesNoChatId,
+} from "../../db.js";
 
 const router = Router();
 
-// Get all messages for a session
-router.get("/:id/messages", (req, res) => {
+// Get all messages for a session (supports ?limit=N&before=ID)
+router.get("/:id/messages", async (req, res) => {
   try {
-    const messages = getMessages(req.params.id);
+    const limit = req.query.limit ? parseInt(req.query.limit, 10) : 0;
+    const before = req.query.before ? parseInt(req.query.before, 10) : 0;
+    let messages;
+    if (limit > 0 && before > 0) {
+      messages = await getOlderMessages(req.params.id, before, limit);
+    } else if (limit > 0) {
+      messages = await getRecentMessages(req.params.id, limit);
+    } else {
+      messages = await getMessages(req.params.id);
+    }
     res.json(messages);
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
 });
 
-// Get messages filtered by chatId
-router.get("/:id/messages/:chatId", (req, res) => {
+// Get messages filtered by chatId (supports ?limit=N&before=ID)
+router.get("/:id/messages/:chatId", async (req, res) => {
   try {
-    const messages = getMessagesByChatId(req.params.id, req.params.chatId);
+    const limit = req.query.limit ? parseInt(req.query.limit, 10) : 0;
+    const before = req.query.before ? parseInt(req.query.before, 10) : 0;
+    let messages;
+    if (limit > 0 && before > 0) {
+      messages = await getOlderMessagesByChatId(req.params.id, req.params.chatId, before, limit);
+    } else if (limit > 0) {
+      messages = await getRecentMessagesByChatId(req.params.id, req.params.chatId, limit);
+    } else {
+      messages = await getMessagesByChatId(req.params.id, req.params.chatId);
+    }
     res.json(messages);
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
 });
 
-// Get messages where chat_id IS NULL (single-mode)
-router.get("/:id/messages-single", (req, res) => {
+// Get messages where chat_id IS NULL (supports ?limit=N&before=ID)
+router.get("/:id/messages-single", async (req, res) => {
   try {
-    const messages = getMessagesNoChatId(req.params.id);
+    const limit = req.query.limit ? parseInt(req.query.limit, 10) : 0;
+    const before = req.query.before ? parseInt(req.query.before, 10) : 0;
+    let messages;
+    if (limit > 0 && before > 0) {
+      messages = await getOlderMessagesNoChatId(req.params.id, before, limit);
+    } else if (limit > 0) {
+      messages = await getRecentMessagesNoChatId(req.params.id, limit);
+    } else {
+      messages = await getMessagesNoChatId(req.params.id);
+    }
     res.json(messages);
   } catch (err) {
     res.status(500).json({ error: err.message });

package/server/routes/notifications.js

@@ -26,67 +26,67 @@ router.get("/vapid-public-key", (req, res) => {
   res.json({ key: vapidPublicKey });
 });
 
-router.post("/subscribe", (req, res) => {
+router.post("/subscribe", async (req, res) => {
   const { endpoint, keys } = req.body;
   if (!endpoint || !keys?.p256dh || !keys?.auth) {
     return res.status(400).json({ error: "Invalid subscription" });
   }
-  upsertPushSubscription(endpoint, keys.p256dh, keys.auth);
+  await upsertPushSubscription(endpoint, keys.p256dh, keys.auth);
   res.json({ ok: true });
 });
 
-router.post("/unsubscribe", (req, res) => {
+router.post("/unsubscribe", async (req, res) => {
   const { endpoint } = req.body;
   if (!endpoint) {
     return res.status(400).json({ error: "Missing endpoint" });
   }
-  deletePushSubscription(endpoint);
+  await deletePushSubscription(endpoint);
   res.json({ ok: true });
 });
 
 // ── Create notification (from frontend) ───────────────────
-router.post("/create", (req, res) => {
+router.post("/create", async (req, res) => {
   const { type, title, body, metadata, sourceSessionId, sourceAgentId } = req.body;
   if (!type || !title) {
     return res.status(400).json({ error: "type and title are required" });
   }
-  const notification = logNotification(type, title, body || null, metadata || null, sourceSessionId || null, sourceAgentId || null);
+  const notification = await logNotification(type, title, body || null, metadata || null, sourceSessionId || null, sourceAgentId || null);
   res.json(notification);
 });
 
 // ── Notification history & management ─────────────────────
-router.get("/history", (req, res) => {
+router.get("/history", async (req, res) => {
   const limit = Math.min(parseInt(req.query.limit) || 20, 100);
   const offset = parseInt(req.query.offset) || 0;
   const unreadOnly = req.query.unread_only === "true";
   const type = req.query.type || null;
-  const items = getNotificationHistory(limit, offset, unreadOnly, type);
+  const items = await getNotificationHistory(limit, offset, unreadOnly, type);
   res.json(items);
 });
 
-router.get("/unread-count", (_req, res) => {
-  res.json({ count: getUnreadNotificationCount() });
+router.get("/unread-count", async (_req, res) => {
+  res.json({ count: await getUnreadNotificationCount() });
 });
 
-router.post("/read", (req, res) => {
+router.post("/read", async (req, res) => {
   const { ids, all, before } = req.body;
   if (all) {
-    markAllNotificationsRead();
-    broadcastReadUpdate([]);
+    await markAllNotificationsRead();
+    await broadcastReadUpdate([]);
   } else if (before) {
-    markNotificationsReadBefore(before);
-    broadcastReadUpdate([]);
+    await markNotificationsReadBefore(before);
+    await broadcastReadUpdate([]);
   } else if (Array.isArray(ids) && ids.length > 0) {
-    markNotificationsRead(ids);
-    broadcastReadUpdate(ids);
+    await markNotificationsRead(ids);
+    await broadcastReadUpdate(ids);
   } else {
     return res.status(400).json({ error: "Provide ids, all, or before" });
   }
-  res.json({ ok: true, unreadCount: getUnreadNotificationCount() });
+  res.json({ ok: true, unreadCount: await getUnreadNotificationCount() });
 });
 
-router.delete("/old", (_req, res) => {
-  purgeOldNotifications(90);
+router.delete("/old", async (_req, res) => {
+  await purgeOldNotifications(90);
   res.json({ ok: true });
 });