session-collab-mcp 0.5.4 → 0.6.0

package/dist/cli.js

@@ -4409,143 +4409,114 @@ async function listClaims(db, params = {}) {
   }));
 }
 async function checkConflicts(db, files, excludeSessionId, symbols) {
+  if (files.length === 0) {
+    return [];
+  }
   const conflicts = [];
   const symbolsByFile = /* @__PURE__ */ new Map();
+  const allSymbolNames = /* @__PURE__ */ new Set();
   if (symbols && symbols.length > 0) {
     for (const sc of symbols) {
       const existing = symbolsByFile.get(sc.file) ?? /* @__PURE__ */ new Set();
       for (const sym of sc.symbols) {
         existing.add(sym);
+        allSymbolNames.add(sym);
       }
       symbolsByFile.set(sc.file, existing);
     }
   }
-  for (const filePath of files) {
-    const requestedSymbols = symbolsByFile.get(filePath);
-    if (requestedSymbols && requestedSymbols.size > 0) {
-      let symbolQuery = `
-        SELECT
-          c.id as claim_id,
-          c.session_id,
-          s.name as session_name,
-          cs.file_path,
-          c.intent,
-          c.scope,
-          c.created_at,
-          cs.symbol_name,
-          cs.symbol_type
-        FROM claim_symbols cs
-        JOIN claims c ON cs.claim_id = c.id
-        JOIN sessions s ON c.session_id = s.id
-        WHERE c.status = 'active'
-          AND s.status = 'active'
-          AND cs.file_path = ?
-          AND cs.symbol_name IN (${Array.from(requestedSymbols).map(() => "?").join(",")})
-      `;
-      const symbolBindings = [filePath, ...Array.from(requestedSymbols)];
-      if (excludeSessionId) {
-        symbolQuery += " AND c.session_id != ?";
-        symbolBindings.push(excludeSessionId);
-      }
-      const symbolResult = await db.prepare(symbolQuery).bind(...symbolBindings).all();
-      for (const r of symbolResult.results) {
-        conflicts.push({
-          ...r,
-          conflict_level: "symbol"
-        });
-      }
-      let fileClaimQuery = `
-        SELECT
-          c.id as claim_id,
-          c.session_id,
-          s.name as session_name,
-          cf.file_path,
-          c.intent,
-          c.scope,
-          c.created_at
-        FROM claim_files cf
-        JOIN claims c ON cf.claim_id = c.id
-        JOIN sessions s ON c.session_id = s.id
-        WHERE c.status = 'active'
-          AND s.status = 'active'
-          AND (cf.file_path = ? OR (cf.is_pattern = 1 AND ? GLOB cf.file_path))
-          AND NOT EXISTS (
-            SELECT 1 FROM claim_symbols cs WHERE cs.claim_id = c.id AND cs.file_path = cf.file_path
-          )
-      `;
-      const fileClaimBindings = [filePath, filePath];
-      if (excludeSessionId) {
-        fileClaimQuery += " AND c.session_id != ?";
-        fileClaimBindings.push(excludeSessionId);
-      }
-      const fileClaimResult = await db.prepare(fileClaimQuery).bind(...fileClaimBindings).all();
-      for (const r of fileClaimResult.results) {
-        conflicts.push({
-          ...r,
-          conflict_level: "file"
-        });
-      }
-    } else {
-      let fileQuery = `
-        SELECT
-          c.id as claim_id,
-          c.session_id,
-          s.name as session_name,
-          cf.file_path,
-          c.intent,
-          c.scope,
-          c.created_at
-        FROM claim_files cf
-        JOIN claims c ON cf.claim_id = c.id
-        JOIN sessions s ON c.session_id = s.id
-        WHERE c.status = 'active'
-          AND s.status = 'active'
-          AND (cf.file_path = ? OR (cf.is_pattern = 1 AND ? GLOB cf.file_path))
-      `;
-      const fileBindings = [filePath, filePath];
-      if (excludeSessionId) {
-        fileQuery += " AND c.session_id != ?";
-        fileBindings.push(excludeSessionId);
-      }
-      const fileResult = await db.prepare(fileQuery).bind(...fileBindings).all();
-      for (const r of fileResult.results) {
-        conflicts.push({
-          ...r,
-          conflict_level: "file"
-        });
-      }
-      let symbolOnlyQuery = `
-        SELECT DISTINCT
-          c.id as claim_id,
-          c.session_id,
-          s.name as session_name,
-          cs.file_path,
-          c.intent,
-          c.scope,
-          c.created_at,
-          cs.symbol_name,
-          cs.symbol_type
-        FROM claim_symbols cs
-        JOIN claims c ON cs.claim_id = c.id
-        JOIN sessions s ON c.session_id = s.id
-        WHERE c.status = 'active'
-          AND s.status = 'active'
-          AND cs.file_path = ?
-      `;
-      const symbolOnlyBindings = [filePath];
-      if (excludeSessionId) {
-        symbolOnlyQuery += " AND c.session_id != ?";
-        symbolOnlyBindings.push(excludeSessionId);
-      }
-      const symbolOnlyResult = await db.prepare(symbolOnlyQuery).bind(...symbolOnlyBindings).all();
-      for (const r of symbolOnlyResult.results) {
-        conflicts.push({
-          ...r,
-          conflict_level: "symbol"
-        });
-      }
-    }
+  const hasSymbols = symbolsByFile.size > 0;
+  const sessionFilter = excludeSessionId ? " AND c.session_id != ?" : "";
+  const fileConditions = files.map(() => "(cf.file_path = ? OR (cf.is_pattern = 1 AND ? GLOB cf.file_path))").join(" OR ");
+  let fileQuery = `
+    SELECT DISTINCT
+      c.id as claim_id,
+      c.session_id,
+      s.name as session_name,
+      cf.file_path,
+      c.intent,
+      c.scope,
+      c.created_at,
+      NULL as symbol_name,
+      NULL as symbol_type,
+      'file' as conflict_level
+    FROM claim_files cf
+    JOIN claims c ON cf.claim_id = c.id
+    JOIN sessions s ON c.session_id = s.id
+    WHERE c.status = 'active'
+      AND s.status = 'active'
+      AND (${fileConditions})
+      ${sessionFilter}
+  `;
+  if (hasSymbols) {
+    fileQuery += `
+      AND NOT EXISTS (
+        SELECT 1 FROM claim_symbols cs
+        WHERE cs.claim_id = c.id AND cs.file_path = cf.file_path
+      )
+    `;
   }
+  const fileBindings = files.flatMap((f) => [f, f]);
+  if (excludeSessionId) {
+    fileBindings.push(excludeSessionId);
+  }
+  const fileResult = await db.prepare(fileQuery).bind(...fileBindings).all();
+  conflicts.push(...fileResult.results);
+  const symbolFilePlaceholders = files.map(() => "?").join(",");
+  let symbolQuery;
+  let symbolBindings;
+  if (hasSymbols && allSymbolNames.size > 0) {
+    const symbolPlaceholders = Array.from(allSymbolNames).map(() => "?").join(",");
+    symbolQuery = `
+      SELECT DISTINCT
+        c.id as claim_id,
+        c.session_id,
+        s.name as session_name,
+        cs.file_path,
+        c.intent,
+        c.scope,
+        c.created_at,
+        cs.symbol_name,
+        cs.symbol_type,
+        'symbol' as conflict_level
+      FROM claim_symbols cs
+      JOIN claims c ON cs.claim_id = c.id
+      JOIN sessions s ON c.session_id = s.id
+      WHERE c.status = 'active'
+        AND s.status = 'active'
+        AND cs.file_path IN (${symbolFilePlaceholders})
+        AND cs.symbol_name IN (${symbolPlaceholders})
+        ${sessionFilter}
+    `;
+    symbolBindings = [...files, ...Array.from(allSymbolNames)];
+  } else {
+    symbolQuery = `
+      SELECT DISTINCT
+        c.id as claim_id,
+        c.session_id,
+        s.name as session_name,
+        cs.file_path,
+        c.intent,
+        c.scope,
+        c.created_at,
+        cs.symbol_name,
+        cs.symbol_type,
+        'symbol' as conflict_level
+      FROM claim_symbols cs
+      JOIN claims c ON cs.claim_id = c.id
+      JOIN sessions s ON c.session_id = s.id
+      WHERE c.status = 'active'
+        AND s.status = 'active'
+        AND cs.file_path IN (${symbolFilePlaceholders})
+        ${sessionFilter}
+    `;
+    symbolBindings = [...files];
+  }
+  if (excludeSessionId) {
+    symbolBindings.push(excludeSessionId);
+  }
+  const symbolResult = await db.prepare(symbolQuery).bind(...symbolBindings).all();
+  conflicts.push(...symbolResult.results);
   const seen = /* @__PURE__ */ new Set();
   return conflicts.filter((c) => {
     const key = `${c.claim_id}:${c.file_path}:${c.symbol_name ?? ""}`;
@@ -4589,9 +4560,8 @@ async function listMessages(db, params) {
   if (params.mark_as_read && messages.results.length > 0) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const ids = messages.results.map((m) => m.id);
-    for (const id of ids) {
-      await db.prepare("UPDATE messages SET read_at = ? WHERE id = ? AND read_at IS NULL").bind(now, id).run();
-    }
+    const placeholders = ids.map(() => "?").join(",");
+    await db.prepare(`UPDATE messages SET read_at = ? WHERE id IN (${placeholders}) AND read_at IS NULL`).bind(now, ...ids).run();
   }
   return messages.results;
 }
@@ -4624,24 +4594,30 @@ async function listDecisions(db, params = {}) {
   return result.results;
 }
 async function storeReferences(db, sessionId, references) {
-  let stored = 0;
-  let skipped = 0;
   const now = (/* @__PURE__ */ new Date()).toISOString();
+  const statements = [];
   for (const ref of references) {
     for (const r of ref.references) {
-      try {
-        await db.prepare(
+      statements.push(
+        db.prepare(
           `INSERT OR IGNORE INTO symbol_references
              (source_file, source_symbol, ref_file, ref_line, ref_context, session_id, created_at)
              VALUES (?, ?, ?, ?, ?, ?, ?)`
-        ).bind(ref.source_file, ref.source_symbol, r.file, r.line, r.context ?? null, sessionId, now).run();
-        stored++;
-      } catch {
-        skipped++;
-      }
+        ).bind(ref.source_file, ref.source_symbol, r.file, r.line, r.context ?? null, sessionId, now)
+      );
     }
   }
-  return { stored, skipped };
+  if (statements.length === 0) {
+    return { stored: 0, skipped: 0 };
+  }
+  try {
+    const results = await db.batch(statements);
+    const stored = results.reduce((acc, r) => acc + r.meta.changes, 0);
+    return { stored, skipped: statements.length - stored };
+  } catch (err) {
+    console.error("[storeReferences] Batch insert failed:", err);
+    return { stored: 0, skipped: statements.length };
+  }
 }
 async function getReferencesForSymbol(db, sourceFile, sourceSymbol) {
   const result = await db.prepare(
@@ -4873,6 +4849,57 @@ function validateInput(schema, data) {
   return { success: false, error: errors };
 }
 
+// src/utils/response.ts
+var ERROR_CODES = {
+  INVALID_INPUT: "INVALID_INPUT",
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  SESSION_INVALID: "SESSION_INVALID",
+  CLAIM_NOT_FOUND: "CLAIM_NOT_FOUND",
+  CLAIM_ALREADY_RELEASED: "CLAIM_ALREADY_RELEASED",
+  NOT_OWNER: "NOT_OWNER",
+  TARGET_SESSION_INVALID: "TARGET_SESSION_INVALID"
+};
+function errorResponse(code, message, data) {
+  return createToolResult(
+    JSON.stringify({ error: code, message, ...data }),
+    true
+  );
+}
+function successResponse(data, prettyPrint = false) {
+  return createToolResult(
+    JSON.stringify(data, null, prettyPrint ? 2 : void 0)
+  );
+}
+async function validateActiveSession(db, sessionId) {
+  const session = await getSession(db, sessionId);
+  if (!session) {
+    return {
+      valid: false,
+      error: errorResponse(ERROR_CODES.SESSION_NOT_FOUND, "Session not found")
+    };
+  }
+  if (session.status !== "active") {
+    return {
+      valid: false,
+      error: errorResponse(ERROR_CODES.SESSION_INVALID, "Session not found or inactive.")
+    };
+  }
+  return { valid: true, session };
+}
+async function validateSessionExists(db, sessionId) {
+  const session = await getSession(db, sessionId);
+  if (!session) {
+    return {
+      valid: false,
+      error: errorResponse(ERROR_CODES.SESSION_NOT_FOUND, "Session not found")
+    };
+  }
+  return { valid: true, session };
+}
+function validationError(message) {
+  return errorResponse(ERROR_CODES.INVALID_INPUT, message);
+}
+
 // src/mcp/tools/session.ts
 var sessionTools = [
   {
@@ -5029,10 +5056,7 @@ async function handleSessionTool(db, name, args, userId) {
     case "collab_session_start": {
       const validation = validateInput(sessionStartSchema, args);
       if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
+        return validationError(validation.error);
       }
       const input = validation.data;
       await cleanupStaleSessions(db, 30);
@@ -5063,34 +5087,23 @@ async function handleSessionTool(db, name, args, userId) {
     case "collab_session_end": {
       const validation = validateInput(sessionEndSchema, args);
       if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
+        return validationError(validation.error);
       }
       const input = validation.data;
-      const session = await getSession(db, input.session_id);
-      if (!session) {
-        return createToolResult(
-          JSON.stringify({ error: "SESSION_NOT_FOUND", message: "Session not found" }),
-          true
-        );
+      const sessionResult = await validateSessionExists(db, input.session_id);
+      if (!sessionResult.valid) {
+        return sessionResult.error;
       }
       await endSession(db, input.session_id, input.release_claims);
-      return createToolResult(
-        JSON.stringify({
-          success: true,
-          message: `Session ended. All claims marked as ${input.release_claims === "complete" ? "completed" : "abandoned"}.`
-        })
-      );
+      return successResponse({
+        success: true,
+        message: `Session ended. All claims marked as ${input.release_claims === "complete" ? "completed" : "abandoned"}.`
+      });
     }
     case "collab_session_list": {
       const validation = validateInput(sessionListSchema, args);
       if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
+        return validationError(validation.error);
       }
       const input = validation.data;
       const sessions = await listSessions(db, {
@@ -5134,10 +5147,7 @@ async function handleSessionTool(db, name, args, userId) {
     case "collab_session_heartbeat": {
       const validation = validateInput(sessionHeartbeatSchema, args);
       if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
+        return validationError(validation.error);
       }
       const input = validation.data;
       const updated = await updateSessionHeartbeat(db, input.session_id, {
@@ -5145,41 +5155,27 @@ async function handleSessionTool(db, name, args, userId) {
         todos: input.todos
       });
       if (!updated) {
-        return createToolResult(
-          JSON.stringify({
-            error: "SESSION_NOT_FOUND",
-            message: "Session not found or inactive. Please start a new session."
-          }),
-          true
+        return errorResponse(
+          ERROR_CODES.SESSION_NOT_FOUND,
+          "Session not found or inactive. Please start a new session."
         );
       }
-      return createToolResult(
-        JSON.stringify({
-          success: true,
-          message: "Heartbeat updated",
-          status_synced: !!(input.current_task || input.todos)
-        })
-      );
+      return successResponse({
+        success: true,
+        message: "Heartbeat updated",
+        status_synced: !!(input.current_task || input.todos)
+      });
     }
     case "collab_status_update": {
       const validation = validateInput(statusUpdateSchema, args);
       if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
+        return validationError(validation.error);
       }
       const input = validation.data;
       const todos = input.todos;
-      const session = await getSession(db, input.session_id);
-      if (!session || session.status !== "active") {
-        return createToolResult(
-          JSON.stringify({
-            error: "SESSION_INVALID",
-            message: "Session not found or inactive."
-          }),
-          true
-        );
+      const sessionResult = await validateActiveSession(db, input.session_id);
+      if (!sessionResult.valid) {
+        return sessionResult.error;
       }
       await updateSessionStatus(db, input.session_id, {
         current_task: input.current_task,
@@ -5194,34 +5190,24 @@ async function handleSessionTool(db, name, args, userId) {
           percentage: Math.round(completed / todos.length * 100)
         };
       }
-      return createToolResult(
-        JSON.stringify({
-          success: true,
-          message: "Status updated successfully.",
-          current_task: input.current_task ?? null,
-          progress
-        })
-      );
+      return successResponse({
+        success: true,
+        message: "Status updated successfully.",
+        current_task: input.current_task ?? null,
+        progress
+      });
     }
     case "collab_config": {
       const validation = validateInput(configSchema, args);
       if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
+        return validationError(validation.error);
       }
       const input = validation.data;
-      const session = await getSession(db, input.session_id);
-      if (!session || session.status !== "active") {
-        return createToolResult(
-          JSON.stringify({
-            error: "SESSION_INVALID",
-            message: "Session not found or inactive."
-          }),
-          true
-        );
+      const sessionResult = await validateActiveSession(db, input.session_id);
+      if (!sessionResult.valid) {
+        return sessionResult.error;
       }
+      const { session } = sessionResult;
       let currentConfig = DEFAULT_SESSION_CONFIG;
       if (session.config) {
         try {
@@ -5236,13 +5222,11 @@ async function handleSessionTool(db, name, args, userId) {
         stale_threshold_hours: input.stale_threshold_hours ?? currentConfig.stale_threshold_hours
       };
       await updateSessionConfig(db, input.session_id, newConfig);
-      return createToolResult(
-        JSON.stringify({
-          success: true,
-          message: "Configuration updated.",
-          config: newConfig
-        })
-      );
+      return successResponse({
+        success: true,
+        message: "Configuration updated.",
+        config: newConfig
+      });
     }
     default:
       return createToolResult(`Unknown session tool: ${name}`, true);
@@ -5394,22 +5378,13 @@ async function handleClaimTool(db, name, args) {
     case "collab_claim": {
       const validation = validateInput(claimCreateSchema, args);
       if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
+        return validationError(validation.error);
       }
       const { session_id: sessionId, files, symbols, intent, scope = "medium" } = validation.data;
       const hasSymbols = symbols && symbols.length > 0;
-      const session = await getSession(db, sessionId);
-      if (!session || session.status !== "active") {
-        return createToolResult(
-          JSON.stringify({
-            error: "SESSION_INVALID",
-            message: "Session not found or inactive. Please start a new session."
-          }),
-          true
-        );
+      const sessionResult = await validateActiveSession(db, sessionId);
+      if (!sessionResult.valid) {
+        return sessionResult.error;
       }
       const allFiles = new Set(files ?? []);
       if (hasSymbols) {
@@ -5473,10 +5448,7 @@ async function handleClaimTool(db, name, args) {
     case "collab_check": {
       const validation = validateInput(claimCheckSchema, args);
       if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
+        return validationError(validation.error);
       }
       const { files, symbols, session_id: sessionId } = validation.data;
       let hasInProgressTodo = false;
@@ -5625,20 +5597,14 @@ async function handleClaimTool(db, name, args) {
     case "collab_release": {
       const validation = validateInput(claimReleaseSchema, args);
       if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
+        return validationError(validation.error);
       }
       const { session_id: sessionId, claim_id: claimId, status, summary, force } = validation.data;
       const claim = await getClaim(db, claimId);
       if (!claim) {
-        return createToolResult(
-          JSON.stringify({
-            error: "CLAIM_NOT_FOUND",
-            message: "Claim not found. It may have already been released."
-          }),
-          true
+        return errorResponse(
+          ERROR_CODES.CLAIM_NOT_FOUND,
+          "Claim not found. It may have already been released."
         );
       }
       if (claim.session_id !== sessionId) {
@@ -5673,12 +5639,9 @@ async function handleClaimTool(db, name, args) {
         }
       }
       if (claim.status !== "active") {
-        return createToolResult(
-          JSON.stringify({
-            error: "CLAIM_ALREADY_RELEASED",
-            message: `Claim was already ${claim.status}.`
-          }),
-          true
+        return errorResponse(
+          ERROR_CODES.CLAIM_ALREADY_RELEASED,
+          `Claim was already ${claim.status}.`
         );
       }
       const isOwnClaim = claim.session_id === sessionId;
@@ -5696,33 +5659,24 @@ async function handleClaimTool(db, name, args) {
     case "collab_claims_list": {
       const validation = validateInput(claimListSchema, args);
       if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
+        return validationError(validation.error);
       }
       const { session_id, status = "active", project_root } = validation.data;
       const claims = await listClaims(db, { session_id, status, project_root });
-      return createToolResult(
-        JSON.stringify(
-          {
-            claims: claims.map((c) => ({
-              id: c.id,
-              session_id: c.session_id,
-              session_name: c.session_name,
-              files: c.files,
-              intent: c.intent,
-              scope: c.scope,
-              status: c.status,
-              created_at: c.created_at,
-              completed_summary: c.completed_summary
-            })),
-            total: claims.length
-          },
-          null,
-          2
-        )
-      );
+      return successResponse({
+        claims: claims.map((c) => ({
+          id: c.id,
+          session_id: c.session_id,
+          session_name: c.session_name,
+          files: c.files,
+          intent: c.intent,
+          scope: c.scope,
+          status: c.status,
+          created_at: c.created_at,
+          completed_summary: c.completed_summary
+        })),
+        total: claims.length
+      }, true);
     }
     default:
       return createToolResult(`Unknown claim tool: ${name}`, true);
@@ -5781,31 +5735,19 @@ async function handleMessageTool(db, name, args) {
     case "collab_message_send": {
       const validation = validateInput(messageSendSchema, args);
       if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
+        return validationError(validation.error);
       }
       const input = validation.data;
-      const fromSession = await getSession(db, input.from_session_id);
-      if (!fromSession || fromSession.status !== "active") {
-        return createToolResult(
-          JSON.stringify({
-            error: "SESSION_INVALID",
-            message: "Your session is not active."
-          }),
-          true
-        );
+      const senderResult = await validateActiveSession(db, input.from_session_id);
+      if (!senderResult.valid) {
+        return errorResponse(ERROR_CODES.SESSION_INVALID, "Your session is not active.");
       }
       if (input.to_session_id) {
-        const toSession = await getSession(db, input.to_session_id);
-        if (!toSession || toSession.status !== "active") {
-          return createToolResult(
-            JSON.stringify({
-              error: "TARGET_SESSION_INVALID",
-              message: "Target session not found or inactive."
-            }),
-            true
+        const targetResult = await validateActiveSession(db, input.to_session_id);
+        if (!targetResult.valid) {
+          return errorResponse(
+            ERROR_CODES.TARGET_SESSION_INVALID,
+            "Target session not found or inactive."
           );
         }
       }
@@ -5814,22 +5756,17 @@ async function handleMessageTool(db, name, args) {
         to_session_id: input.to_session_id,
         content: input.content
       });
-      return createToolResult(
-        JSON.stringify({
-          success: true,
-          message_id: message.id,
-          sent_to: input.to_session_id ?? "all sessions (broadcast)",
-          message: "Message sent successfully."
-        })
-      );
+      return successResponse({
+        success: true,
+        message_id: message.id,
+        sent_to: input.to_session_id ?? "all sessions (broadcast)",
+        message: "Message sent successfully."
+      });
     }
     case "collab_message_list": {
       const validation = validateInput(messageListSchema, args);
       if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
+        return validationError(validation.error);
       }
       const input = validation.data;
       const unreadOnly = input.unread_only ?? true;
@@ -5840,30 +5777,22 @@ async function handleMessageTool(db, name, args) {
         mark_as_read: markAsRead
       });
       if (messages.length === 0) {
-        return createToolResult(
-          JSON.stringify({
-            messages: [],
-            message: unreadOnly ? "No unread messages." : "No messages."
-          })
-        );
+        return successResponse({
+          messages: [],
+          message: unreadOnly ? "No unread messages." : "No messages."
+        });
       }
-      return createToolResult(
-        JSON.stringify(
-          {
-            messages: messages.map((m) => ({
-              id: m.id,
-              from_session_id: m.from_session_id,
-              content: m.content,
-              created_at: m.created_at,
-              is_broadcast: m.to_session_id === null
-            })),
-            total: messages.length,
-            marked_as_read: markAsRead
-          },
-          null,
-          2
-        )
-      );
+      return successResponse({
+        messages: messages.map((m) => ({
+          id: m.id,
+          from_session_id: m.from_session_id,
+          content: m.content,
+          created_at: m.created_at,
+          is_broadcast: m.to_session_id === null
+        })),
+        total: messages.length,
+        marked_as_read: markAsRead
+      }, true);
     }
     default:
       return createToolResult(`Unknown message tool: ${name}`, true);
@@ -5923,21 +5852,12 @@ async function handleDecisionTool(db, name, args) {
     case "collab_decision_add": {
       const validation = validateInput(decisionAddSchema, args);
       if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
+        return validationError(validation.error);
       }
       const input = validation.data;
-      const session = await getSession(db, input.session_id);
-      if (!session || session.status !== "active") {
-        return createToolResult(
-          JSON.stringify({
-            error: "SESSION_INVALID",
-            message: "Session not found or inactive."
-          }),
-          true
-        );
+      const sessionResult = await validateActiveSession(db, input.session_id);
+      if (!sessionResult.valid) {
+        return sessionResult.error;
       }
       const decision = await addDecision(db, {
         session_id: input.session_id,
@@ -5945,43 +5865,32 @@ async function handleDecisionTool(db, name, args) {
         title: input.title,
         description: input.description
       });
-      return createToolResult(
-        JSON.stringify({
-          success: true,
-          decision_id: decision.id,
-          message: "Decision recorded successfully."
-        })
-      );
+      return successResponse({
+        success: true,
+        decision_id: decision.id,
+        message: "Decision recorded successfully."
+      });
     }
     case "collab_decision_list": {
       const validation = validateInput(decisionListSchema, args);
       if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
+        return validationError(validation.error);
       }
       const input = validation.data;
       const decisions = await listDecisions(db, {
         category: input.category,
         limit: input.limit ?? 20
       });
-      return createToolResult(
-        JSON.stringify(
-          {
-            decisions: decisions.map((d) => ({
-              id: d.id,
-              category: d.category,
-              title: d.title,
-              description: d.description,
-              created_at: d.created_at
-            })),
-            total: decisions.length
-          },
-          null,
-          2
-        )
-      );
+      return successResponse({
+        decisions: decisions.map((d) => ({
+          id: d.id,
+          category: d.category,
+          title: d.title,
+          description: d.description,
+          created_at: d.created_at
+        })),
+        total: decisions.length
+      }, true);
     }
     default:
       return createToolResult(`Unknown decision tool: ${name}`, true);
@@ -6842,14 +6751,14 @@ async function main() {
           break;
         }
         default: {
-          const errorResponse = jsonRpcError(id, -32601, `Method not found: ${method}`);
-          console.log(errorResponse);
+          const errorResponse2 = jsonRpcError(id, -32601, `Method not found: ${method}`);
+          console.log(errorResponse2);
         }
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      const errorResponse = jsonRpcError(null, -32700, `Parse error: ${errorMessage}`);
-      console.log(errorResponse);
+      const errorResponse2 = jsonRpcError(null, -32700, `Parse error: ${errorMessage}`);
+      console.log(errorResponse2);
     }
   });
   rl.on("close", () => {