session-collab-mcp 0.8.8 → 1.0.0

package/dist/cli.js

@@ -4203,13 +4203,6 @@ var DEFAULT_SESSION_CONFIG = {
   auto_release_immediate: false,
   auto_release_delay_minutes: 5
 };
-var SCOPE_WAIT_MINUTES = {
-  small: 30,
-  medium: 120,
-  // 2 hours
-  large: 480
-  // 8 hours
-};
 
 // src/db/queries.ts
 async function createSession(db, params) {
@@ -4256,66 +4249,6 @@ async function listSessions(db, params = {}) {
   const result = await db.prepare(query).bind(...bindings).all();
   return result.results;
 }
-async function updateSessionHeartbeat(db, id, statusUpdate) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  let progress = null;
-  let todosJson = null;
-  if (statusUpdate?.todos) {
-    const total = statusUpdate.todos.length;
-    const completed = statusUpdate.todos.filter((t) => t.status === "completed").length;
-    progress = {
-      completed,
-      total,
-      percentage: total > 0 ? Math.round(completed / total * 100) : 0
-    };
-    todosJson = JSON.stringify(statusUpdate.todos);
-  }
-  let query = "UPDATE sessions SET last_heartbeat = ?";
-  const bindings = [now];
-  if (statusUpdate?.current_task !== void 0) {
-    query += ", current_task = ?";
-    bindings.push(statusUpdate.current_task);
-  }
-  if (progress) {
-    query += ", progress = ?";
-    bindings.push(JSON.stringify(progress));
-  }
-  if (todosJson) {
-    query += ", todos = ?";
-    bindings.push(todosJson);
-  }
-  query += " WHERE id = ? AND status = 'active'";
-  bindings.push(id);
-  const result = await db.prepare(query).bind(...bindings).run();
-  return result.meta.changes > 0;
-}
-async function updateSessionStatus(db, id, params) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  let progress = null;
-  let todosJson = null;
-  if (params.todos) {
-    const total = params.todos.length;
-    const completed = params.todos.filter((t) => t.status === "completed").length;
-    progress = {
-      completed,
-      total,
-      percentage: total > 0 ? Math.round(completed / total * 100) : 0
-    };
-    todosJson = JSON.stringify(params.todos);
-  }
-  const result = await db.prepare(
-    `UPDATE sessions
-       SET current_task = ?, progress = ?, todos = ?, last_heartbeat = ?
-       WHERE id = ? AND status = 'active'`
-  ).bind(
-    params.current_task ?? null,
-    progress ? JSON.stringify(progress) : null,
-    todosJson,
-    now,
-    id
-  ).run();
-  return result.meta.changes > 0;
-}
 async function endSession(db, id, release_claims = "abandon") {
   const claimStatus = release_claims === "complete" ? "completed" : "abandoned";
   await db.prepare("UPDATE claims SET status = ?, updated_at = ? WHERE session_id = ? AND status = 'active'").bind(claimStatus, (/* @__PURE__ */ new Date()).toISOString(), id).run();
@@ -4423,11 +4356,6 @@ async function createClaim(db, params) {
     symbols: params.symbols
   };
 }
-async function updateClaimPriority(db, claimId, priority) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const result = await db.prepare("UPDATE claims SET priority = ?, updated_at = ? WHERE id = ? AND status = ?").bind(priority, now, claimId, "active").run();
-  return result.meta.changes > 0;
-}
 async function getClaim(db, id) {
   const result = await db.prepare(
     `SELECT
@@ -4617,209 +4545,6 @@ async function releaseClaim(db, id, params) {
   const result = await db.prepare("UPDATE claims SET status = ?, updated_at = ?, completed_summary = ? WHERE id = ?").bind(params.status, now, params.summary ?? null, id).run();
   return result.meta.changes > 0;
 }
-async function getClaimInfoByFile(db, sessionId, filePath) {
-  const claim = await db.prepare(
-    `SELECT c.id, c.scope
-       FROM claims c
-       JOIN claim_files cf ON c.id = cf.claim_id
-       WHERE c.session_id = ? AND c.status = 'active' AND cf.file_path = ?`
-  ).bind(sessionId, filePath).first();
-  if (!claim) {
-    return null;
-  }
-  const filesResult = await db.prepare("SELECT file_path FROM claim_files WHERE claim_id = ?").bind(claim.id).all();
-  const files = (filesResult.results ?? []).map((f) => f.file_path);
-  return {
-    claim_id: claim.id,
-    scope: claim.scope,
-    file_count: files.length,
-    files
-  };
-}
-async function releaseClaimByFile(db, sessionId, filePath) {
-  const claim = await db.prepare(
-    `SELECT c.id, c.scope
-       FROM claims c
-       JOIN claim_files cf ON c.id = cf.claim_id
-       WHERE c.session_id = ? AND c.status = 'active' AND cf.file_path = ?`
-  ).bind(sessionId, filePath).first();
-  if (!claim) {
-    return { released: false };
-  }
-  const fileCount = await db.prepare("SELECT COUNT(*) as count FROM claim_files WHERE claim_id = ?").bind(claim.id).first();
-  const count = fileCount?.count ?? 0;
-  if (count <= 1) {
-    await releaseClaim(db, claim.id, { status: "completed" });
-    return { released: true, claim_id: claim.id, scope: claim.scope, partial: false };
-  } else {
-    await db.prepare("DELETE FROM claim_files WHERE claim_id = ? AND file_path = ?").bind(claim.id, filePath).run();
-    await db.prepare("DELETE FROM claim_symbols WHERE claim_id = ? AND file_path = ?").bind(claim.id, filePath).run();
-    await db.prepare("UPDATE claims SET updated_at = ? WHERE id = ?").bind((/* @__PURE__ */ new Date()).toISOString(), claim.id).run();
-    return {
-      released: true,
-      claim_id: claim.id,
-      scope: claim.scope,
-      partial: true,
-      files_remaining: count - 1
-    };
-  }
-}
-async function sendMessage(db, params) {
-  const id = generateId();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  await db.prepare(
-    `INSERT INTO messages (id, from_session_id, to_session_id, content, created_at)
-       VALUES (?, ?, ?, ?, ?)`
-  ).bind(id, params.from_session_id, params.to_session_id ?? null, params.content, now).run();
-  return {
-    id,
-    from_session_id: params.from_session_id,
-    to_session_id: params.to_session_id ?? null,
-    content: params.content,
-    read_at: null,
-    created_at: now
-  };
-}
-async function listMessages(db, params) {
-  let query = `
-    SELECT * FROM messages
-    WHERE (to_session_id = ? OR to_session_id IS NULL)
-  `;
-  const bindings = [params.session_id];
-  if (params.unread_only) {
-    query += " AND read_at IS NULL";
-  }
-  query += " ORDER BY created_at DESC";
-  const messages = await db.prepare(query).bind(...bindings).all();
-  if (params.mark_as_read && messages.results.length > 0) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const ids = messages.results.map((m) => m.id);
-    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;
-}
-async function addDecision(db, params) {
-  const id = generateId();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  await db.prepare(
-    `INSERT INTO decisions (id, session_id, category, title, description, created_at)
-       VALUES (?, ?, ?, ?, ?, ?)`
-  ).bind(id, params.session_id, params.category ?? null, params.title, params.description, now).run();
-  return {
-    id,
-    session_id: params.session_id,
-    category: params.category ?? null,
-    title: params.title,
-    description: params.description,
-    created_at: now
-  };
-}
-async function listDecisions(db, params = {}) {
-  let query = "SELECT * FROM decisions WHERE 1=1";
-  const bindings = [];
-  if (params.category) {
-    query += " AND category = ?";
-    bindings.push(params.category);
-  }
-  query += " ORDER BY created_at DESC LIMIT ?";
-  bindings.push(params.limit ?? 20);
-  const result = await db.prepare(query).bind(...bindings).all();
-  return result.results;
-}
-async function storeReferences(db, sessionId, references) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const statements = [];
-  for (const ref of references) {
-    for (const r of ref.references) {
-      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)
-      );
-    }
-  }
-  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(
-    `SELECT * FROM symbol_references
-       WHERE source_file = ? AND source_symbol = ?
-       ORDER BY ref_file, ref_line`
-  ).bind(sourceFile, sourceSymbol).all();
-  return result.results;
-}
-async function analyzeClaimImpact(db, sourceFile, sourceSymbol, excludeSessionId) {
-  const refs = await getReferencesForSymbol(db, sourceFile, sourceSymbol);
-  const affectedFiles = [...new Set(refs.map((r) => r.ref_file))];
-  const affectedClaims = [];
-  if (affectedFiles.length > 0) {
-    const placeholders = affectedFiles.map(() => "?").join(",");
-    let query = `
-      SELECT DISTINCT
-        c.id as claim_id,
-        s.name as session_name,
-        c.intent,
-        cf.file_path
-      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 IN (${placeholders})
-    `;
-    const bindings = [...affectedFiles];
-    if (excludeSessionId) {
-      query += " AND c.session_id != ?";
-      bindings.push(excludeSessionId);
-    }
-    const claimResults = await db.prepare(query).bind(...bindings).all();
-    const claimMap = /* @__PURE__ */ new Map();
-    for (const r of claimResults.results) {
-      const existing = claimMap.get(r.claim_id);
-      if (existing) {
-        existing.files.push(r.file_path);
-      } else {
-        claimMap.set(r.claim_id, {
-          session_name: r.session_name,
-          intent: r.intent,
-          files: [r.file_path]
-        });
-      }
-    }
-    for (const [claimId, data] of claimMap) {
-      affectedClaims.push({
-        claim_id: claimId,
-        session_name: data.session_name,
-        intent: data.intent,
-        affected_symbols: data.files
-      });
-    }
-  }
-  return {
-    symbol: sourceSymbol,
-    file: sourceFile,
-    affected_claims: affectedClaims,
-    reference_count: refs.length,
-    affected_files: affectedFiles
-  };
-}
-async function clearSessionReferences(db, sessionId) {
-  const result = await db.prepare("DELETE FROM symbol_references WHERE session_id = ?").bind(sessionId).run();
-  return result.meta.changes;
-}
 async function logAuditEvent(db, params) {
   const id = generateId();
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -4838,226 +4563,10 @@ async function logAuditEvent(db, params) {
     created_at: now
   };
 }
-async function listAuditHistory(db, params = {}) {
-  let query = `
-    SELECT h.*, s.name as session_name
-    FROM audit_history h
-    LEFT JOIN sessions s ON h.session_id = s.id
-    WHERE 1=1
-  `;
-  const bindings = [];
-  if (params.session_id) {
-    query += " AND h.session_id = ?";
-    bindings.push(params.session_id);
-  }
-  if (params.action) {
-    query += " AND h.action = ?";
-    bindings.push(params.action);
-  }
-  if (params.entity_type) {
-    query += " AND h.entity_type = ?";
-    bindings.push(params.entity_type);
-  }
-  if (params.entity_id) {
-    query += " AND h.entity_id = ?";
-    bindings.push(params.entity_id);
-  }
-  if (params.from_date) {
-    query += " AND h.created_at >= ?";
-    bindings.push(params.from_date);
-  }
-  if (params.to_date) {
-    query += " AND h.created_at <= ?";
-    bindings.push(params.to_date);
-  }
-  query += " ORDER BY h.created_at DESC LIMIT ?";
-  bindings.push(params.limit ?? 50);
-  const result = await db.prepare(query).bind(...bindings).all();
-  return result.results;
-}
-async function cleanupOldAuditHistory(db, retentionDays = 7) {
-  const cutoff = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1e3).toISOString();
-  const result = await db.prepare("DELETE FROM audit_history WHERE created_at < ?").bind(cutoff).run();
-  return result.meta.changes;
-}
-async function getNextQueuePosition(db, claimId) {
-  const result = await db.prepare("SELECT MAX(position) as max_pos FROM claim_queue WHERE claim_id = ?").bind(claimId).first();
-  return (result?.max_pos ?? 0) + 1;
-}
-async function calculateEstimatedWait(db, claimId, position) {
-  const result = await db.prepare(
-    `SELECT scope FROM claim_queue
-       WHERE claim_id = ? AND position < ?
-       ORDER BY priority DESC, position ASC`
-  ).bind(claimId, position).all();
-  let totalMinutes = 0;
-  for (const entry of result.results) {
-    totalMinutes += SCOPE_WAIT_MINUTES[entry.scope] ?? SCOPE_WAIT_MINUTES.medium;
-  }
-  const claim = await getClaim(db, claimId);
-  if (claim) {
-    totalMinutes += Math.round(SCOPE_WAIT_MINUTES[claim.scope] / 2);
-  }
-  return totalMinutes;
-}
-async function joinQueue(db, params) {
-  const id = generateId();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const priority = params.priority ?? 50;
-  const scope = params.scope ?? "medium";
-  const position = await getNextQueuePosition(db, params.claim_id);
-  const estimatedWait = await calculateEstimatedWait(db, params.claim_id, position);
-  await db.prepare(
-    `INSERT INTO claim_queue (id, claim_id, session_id, intent, position, priority, scope, estimated_wait_minutes, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  ).bind(id, params.claim_id, params.session_id, params.intent, position, priority, scope, estimatedWait, now).run();
-  return {
-    id,
-    claim_id: params.claim_id,
-    session_id: params.session_id,
-    intent: params.intent,
-    position,
-    priority,
-    scope,
-    estimated_wait_minutes: estimatedWait,
-    created_at: now
-  };
-}
-async function leaveQueue(db, queueId) {
-  const result = await db.prepare("DELETE FROM claim_queue WHERE id = ?").bind(queueId).run();
-  return result.meta.changes > 0;
-}
-async function getQueueEntry(db, queueId) {
-  const result = await db.prepare("SELECT * FROM claim_queue WHERE id = ?").bind(queueId).first();
-  return result ?? null;
-}
-async function listQueue(db, params = {}) {
-  let query = `
-    SELECT
-      q.*,
-      s.name as session_name,
-      c.intent as claim_intent,
-      cs.name as claim_session_name,
-      GROUP_CONCAT(cf.file_path, '|||') as claim_files_concat
-    FROM claim_queue q
-    JOIN sessions s ON q.session_id = s.id
-    JOIN claims c ON q.claim_id = c.id
-    JOIN sessions cs ON c.session_id = cs.id
-    LEFT JOIN claim_files cf ON c.id = cf.claim_id
-    WHERE 1=1
-  `;
-  const bindings = [];
-  if (params.claim_id) {
-    query += " AND q.claim_id = ?";
-    bindings.push(params.claim_id);
-  }
-  if (params.session_id) {
-    query += " AND q.session_id = ?";
-    bindings.push(params.session_id);
-  }
-  query += " GROUP BY q.id ORDER BY q.priority DESC, q.position ASC";
-  const result = await db.prepare(query).bind(...bindings).all();
-  return result.results.map((r) => ({
-    ...r,
-    claim_files: r.claim_files_concat ? r.claim_files_concat.split("|||") : []
-  }));
-}
 async function removeSessionFromAllQueues(db, sessionId) {
   const result = await db.prepare("DELETE FROM claim_queue WHERE session_id = ?").bind(sessionId).run();
   return result.meta.changes;
 }
-async function getQueuedSessionsForClaim(db, claimId) {
-  const result = await db.prepare(
-    `SELECT q.session_id, s.name as session_name, q.position
-       FROM claim_queue q
-       JOIN sessions s ON q.session_id = s.id
-       WHERE q.claim_id = ?
-       ORDER BY q.priority DESC, q.position ASC`
-  ).bind(claimId).all();
-  return result.results;
-}
-async function createNotification(db, params) {
-  const id = generateId();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const metadataJson = params.metadata ? JSON.stringify(params.metadata) : null;
-  await db.prepare(
-    `INSERT INTO notifications (id, session_id, type, title, message, reference_type, reference_id, metadata, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  ).bind(
-    id,
-    params.session_id,
-    params.type,
-    params.title,
-    params.message,
-    params.reference_type ?? null,
-    params.reference_id ?? null,
-    metadataJson,
-    now
-  ).run();
-  return {
-    id,
-    session_id: params.session_id,
-    type: params.type,
-    title: params.title,
-    message: params.message,
-    reference_type: params.reference_type ?? null,
-    reference_id: params.reference_id ?? null,
-    metadata: metadataJson,
-    read_at: null,
-    created_at: now
-  };
-}
-async function listNotifications(db, params) {
-  let query = "SELECT * FROM notifications WHERE session_id = ?";
-  const bindings = [params.session_id];
-  if (params.unread_only) {
-    query += " AND read_at IS NULL";
-  }
-  if (params.type) {
-    query += " AND type = ?";
-    bindings.push(params.type);
-  }
-  query += " ORDER BY created_at DESC LIMIT ?";
-  bindings.push(params.limit ?? 50);
-  const result = await db.prepare(query).bind(...bindings).all();
-  return result.results;
-}
-async function markNotificationsRead(db, notificationIds) {
-  if (notificationIds.length === 0) return 0;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const placeholders = notificationIds.map(() => "?").join(",");
-  const result = await db.prepare(`UPDATE notifications SET read_at = ? WHERE id IN (${placeholders}) AND read_at IS NULL`).bind(now, ...notificationIds).run();
-  return result.meta.changes;
-}
-async function getNotification(db, id) {
-  const result = await db.prepare("SELECT * FROM notifications WHERE id = ?").bind(id).first();
-  return result ?? null;
-}
-async function notifyQueueOnClaimRelease(db, claimId, releasedBy, files) {
-  const queuedSessions = await getQueuedSessionsForClaim(db, claimId);
-  if (queuedSessions.length === 0) return 0;
-  let notified = 0;
-  for (let i = 0; i < queuedSessions.length; i++) {
-    const entry = queuedSessions[i];
-    const isFirst = i === 0;
-    await createNotification(db, {
-      session_id: entry.session_id,
-      type: isFirst ? "queue_ready" : "claim_released",
-      title: isFirst ? "You are next in queue!" : "Claim released",
-      message: isFirst ? `The claim for ${files.join(", ")} has been released. You can now claim these files.` : `A claim you were waiting for has been released. Position: ${i + 1}`,
-      reference_type: "claim",
-      reference_id: claimId,
-      metadata: {
-        claim_id: claimId,
-        files,
-        released_by: releasedBy,
-        queue_position: i + 1
-      }
-    });
-    notified++;
-  }
-  return notified;
-}
 async function saveMemory(db, sessionId, input) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const metadataJson = input.metadata ? JSON.stringify(input.metadata) : null;
@@ -5117,34 +4626,6 @@ async function recallMemory(db, sessionId, params = {}) {
   const result = await db.prepare(query).bind(...bindings).all();
   return result.results;
 }
-async function updateMemory(db, sessionId, key, updates) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const setParts = ["updated_at = ?"];
-  const bindings = [now];
-  if (updates.content !== void 0) {
-    setParts.push("content = ?");
-    bindings.push(updates.content);
-  }
-  if (updates.priority !== void 0) {
-    setParts.push("priority = ?");
-    bindings.push(updates.priority);
-  }
-  if (updates.pinned !== void 0) {
-    setParts.push("pinned = ?");
-    bindings.push(updates.pinned ? 1 : 0);
-  }
-  if (updates.expires_at !== void 0) {
-    setParts.push("expires_at = ?");
-    bindings.push(updates.expires_at);
-  }
-  if (updates.metadata !== void 0) {
-    setParts.push("metadata = ?");
-    bindings.push(JSON.stringify(updates.metadata));
-  }
-  bindings.push(sessionId, key);
-  const result = await db.prepare(`UPDATE working_memory SET ${setParts.join(", ")} WHERE session_id = ? AND key = ?`).bind(...bindings).run();
-  return result.meta.changes > 0;
-}
 async function clearMemory(db, sessionId, params = {}) {
   if (params.key) {
     const result = await db.prepare("DELETE FROM working_memory WHERE session_id = ? AND key = ?").bind(sessionId, params.key).run();
@@ -5160,30 +4641,6 @@ async function clearMemory(db, sessionId, params = {}) {
   }
   return 0;
 }
-async function pinMemory(db, sessionId, key, pinned) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const result = await db.prepare("UPDATE working_memory SET pinned = ?, updated_at = ? WHERE session_id = ? AND key = ?").bind(pinned ? 1 : 0, now, sessionId, key).run();
-  return result.meta.changes > 0;
-}
-async function getMemoryStats(db, sessionId) {
-  const totalResult = await db.prepare("SELECT COUNT(*) as count FROM working_memory WHERE session_id = ?").bind(sessionId).first();
-  const categoryResult = await db.prepare(
-    `SELECT category, COUNT(*) as count
-       FROM working_memory
-       WHERE session_id = ?
-       GROUP BY category`
-  ).bind(sessionId).all();
-  const pinnedResult = await db.prepare("SELECT COUNT(*) as count FROM working_memory WHERE session_id = ? AND pinned = 1").bind(sessionId).first();
-  const byCategory = {};
-  for (const row of categoryResult.results) {
-    byCategory[row.category] = row.count;
-  }
-  return {
-    total: totalResult?.count ?? 0,
-    by_category: byCategory,
-    pinned_count: pinnedResult?.count ?? 0
-  };
-}
 async function getActiveMemories(db, sessionId, params = {}) {
   const threshold = params.priority_threshold ?? 70;
   const limit = params.max_items ?? 20;
@@ -5219,40 +4676,6 @@ ${params.content_summary}`,
     }
   });
 }
-async function updatePlanStatus(db, sessionId, filePath, newStatus, summary) {
-  const key = `plan:${filePath}`;
-  const memories = await recallMemory(db, sessionId, { key });
-  if (memories.length === 0) return false;
-  const current = memories[0];
-  let metadata = {};
-  try {
-    metadata = current.metadata ? JSON.parse(current.metadata) : {};
-  } catch {
-  }
-  metadata.status = newStatus;
-  if (newStatus === "completed") {
-    metadata.completed_at = (/* @__PURE__ */ new Date()).toISOString();
-  }
-  let priority = 95;
-  let pinned = true;
-  if (newStatus === "completed") {
-    priority = 50;
-    pinned = false;
-  } else if (newStatus === "archived") {
-    priority = 30;
-    pinned = false;
-  }
-  const updatedContent = summary ? `[PLAN] ${metadata.title}
-Status: ${newStatus}
-
-${summary}` : current.content.replace(/Status: \w+/, `Status: ${newStatus}`);
-  return updateMemory(db, sessionId, key, {
-    content: updatedContent,
-    priority,
-    pinned,
-    metadata
-  });
-}
 async function getPlan(db, sessionId, filePath) {
   const key = `plan:${filePath}`;
   const memories = await recallMemory(db, sessionId, { key });
@@ -5401,7 +4824,10 @@ async function getProtectedFiles(db, sessionId) {
 // src/mcp/schemas.ts
 var sessionIdSchema = external_exports.string().min(1, "session_id is required");
 var claimIdSchema = external_exports.string().min(1, "claim_id is required");
-var filePathSchema = external_exports.string().min(1);
+var filePathSchema = external_exports.string().min(1).refine(
+  (path) => !path.includes("..") && !path.includes("\0"),
+  { message: "Path cannot contain path traversal sequences (..) or null bytes" }
+);
 var filesArraySchema = external_exports.array(filePathSchema).min(1, "At least one file is required");
 var symbolClaimSchema = external_exports.object({
   file: external_exports.string().min(1),
@@ -5676,7 +5102,7 @@ function validationError(message) {
 var sessionTools = [
   {
     name: "collab_session_start",
-    description: "Register a new collaboration session. Call this when starting work to enable coordination with other sessions.",
+    description: "Start a new session. Call this when starting work.",
     inputSchema: {
       type: "object",
       properties: {
@@ -5687,10 +5113,6 @@ var sessionTools = [
         project_root: {
           type: "string",
           description: "Project root directory path"
-        },
-        machine_id: {
-          type: "string",
-          description: "Optional machine identifier for multi-machine setups"
         }
       },
       required: ["project_root"]
@@ -5698,7 +5120,7 @@ var sessionTools = [
   },
   {
     name: "collab_session_end",
-    description: "End a session and release all its claims.",
+    description: "End session and release all claims.",
     inputSchema: {
       type: "object",
       properties: {
@@ -5709,7 +5131,7 @@ var sessionTools = [
         release_claims: {
           type: "string",
           enum: ["complete", "abandon"],
-          description: "How to handle unreleased claims: complete (mark as done) or abandon"
+          description: "How to handle unreleased claims"
         }
       },
       required: ["session_id"]
@@ -5717,13 +5139,13 @@ var sessionTools = [
   },
   {
     name: "collab_session_list",
-    description: "List all active sessions. Use to see who else is working.",
+    description: "List all active sessions.",
     inputSchema: {
       type: "object",
       properties: {
         include_inactive: {
           type: "boolean",
-          description: "Include inactive/terminated sessions"
+          description: "Include inactive sessions"
         },
         project_root: {
           type: "string",
@@ -5732,68 +5154,9 @@ var sessionTools = [
       }
     }
   },
-  {
-    name: "collab_session_heartbeat",
-    description: "Update session heartbeat to indicate the session is still active.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Session ID to update"
-        },
-        current_task: {
-          type: "string",
-          description: "Optional: Current task being worked on"
-        },
-        todos: {
-          type: "array",
-          description: "Optional: Current todo list to sync",
-          items: {
-            type: "object",
-            properties: {
-              content: { type: "string" },
-              status: { type: "string", enum: ["pending", "in_progress", "completed"] }
-            }
-          }
-        }
-      },
-      required: ["session_id"]
-    }
-  },
-  {
-    name: "collab_status_update",
-    description: "Update session work status. Use this to share what you are currently working on with other sessions.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        current_task: {
-          type: "string",
-          description: 'Description of current task (e.g., "Refactoring auth module")'
-        },
-        todos: {
-          type: "array",
-          description: "Your current todo list",
-          items: {
-            type: "object",
-            properties: {
-              content: { type: "string", description: "Task description" },
-              status: { type: "string", enum: ["pending", "in_progress", "completed"] }
-            },
-            required: ["content", "status"]
-          }
-        }
-      },
-      required: ["session_id"]
-    }
-  },
   {
     name: "collab_config",
-    description: "Configure session behavior for conflict handling. Settings persist for the session duration.",
+    description: "Configure session behavior.",
     inputSchema: {
       type: "object",
       properties: {
@@ -5804,19 +5167,11 @@ var sessionTools = [
         mode: {
           type: "string",
           enum: ["strict", "smart", "bypass"],
-          description: "Conflict handling mode: strict (always ask), smart (ask but suggest for stale), bypass (warn only)"
+          description: "Conflict handling mode"
         },
         allow_release_others: {
           type: "boolean",
-          description: "Allow releasing claims from other sessions (default: false)"
-        },
-        auto_release_stale: {
-          type: "boolean",
-          description: "Automatically release stale claims (default: false)"
-        },
-        stale_threshold_hours: {
-          type: "number",
-          description: "Hours before a claim is considered stale (default: 2)"
+          description: "Allow releasing other sessions claims"
         }
       },
       required: ["session_id"]
@@ -5855,54 +5210,19 @@ async function handleSessionTool(db, name, args, userId) {
         });
         for (const mem of memories) {
           allMemories.push({
-            session_name: otherSession.name,
             category: mem.category,
             key: mem.key,
-            content: mem.content,
-            priority: mem.priority,
-            pinned: mem.pinned === 1
+            content: mem.content
           });
         }
       }
-      allMemories.sort((a, b) => {
-        if (a.pinned !== b.pinned) return b.pinned ? 1 : -1;
-        return b.priority - a.priority;
+      return successResponse({
+        session_id: session.id,
+        name: session.name,
+        active_sessions: activeSessions.length,
+        restored_context: allMemories.length > 0 ? allMemories.slice(0, 15) : null,
+        message: `Session started. ${activeSessions.length} active session(s).`
       });
-      const topMemories = allMemories.slice(0, 20);
-      const memoriesByCategory = {};
-      for (const mem of topMemories) {
-        if (!memoriesByCategory[mem.category]) {
-          memoriesByCategory[mem.category] = [];
-        }
-        memoriesByCategory[mem.category].push({
-          key: mem.key,
-          content: mem.content,
-          session: mem.session_name
-        });
-      }
-      return createToolResult(
-        JSON.stringify(
-          {
-            session_id: session.id,
-            name: session.name,
-            message: `Session registered. ${activeSessions.length} active session(s) in this project.`,
-            active_sessions: activeSessions.map((s) => ({
-              id: s.id,
-              name: s.name,
-              last_heartbeat: s.last_heartbeat
-            })),
-            // AUTO-LOADED CONTEXT
-            restored_context: topMemories.length > 0 ? {
-              count: topMemories.length,
-              by_category: memoriesByCategory,
-              note: "These memories were automatically loaded from previous sessions. Use them to maintain context continuity."
-            } : null,
-            tip: "Use collab_memory_save to persist important context. Plans and files are auto-protected when registered."
-          },
-          null,
-          2
-        )
-      );
     }
     case "collab_session_end": {
       const validation = validateInput(sessionEndSchema, args);
@@ -5915,26 +5235,10 @@ async function handleSessionTool(db, name, args, userId) {
         return sessionResult.error;
       }
       const activeClaims = await listClaims(db, { session_id: input.session_id, status: "active" });
-      const claimsToRelease = activeClaims.map((claim) => ({
-        id: claim.id,
-        files: claim.files,
-        intent: claim.intent,
-        scope: claim.scope,
-        created_at: claim.created_at
-      }));
       const memories = await recallMemory(db, input.session_id, {});
-      let memorySummary = null;
       if (memories.length > 0) {
         const findings = memories.filter((m) => m.category === "finding").map((m) => m.content);
         const decisions = memories.filter((m) => m.category === "decision").map((m) => m.content);
-        const important = memories.filter((m) => m.category === "important" || m.pinned === 1).map((m) => m.content);
-        memorySummary = {
-          total: memories.length,
-          findings: findings.slice(0, 5),
-          // Top 5
-          decisions: decisions.slice(0, 5),
-          important: important.slice(0, 5)
-        };
         const summaryContent = [
           `Session: ${sessionResult.session.name || input.session_id}`,
           `Ended: ${(/* @__PURE__ */ new Date()).toISOString()}`,
@@ -5943,43 +5247,29 @@ Findings:
 - ${findings.slice(0, 5).join("\n- ")}` : "",
           decisions.length > 0 ? `
 Decisions:
-- ${decisions.slice(0, 5).join("\n- ")}` : "",
-          important.length > 0 ? `
-Important:
-- ${important.slice(0, 5).join("\n- ")}` : ""
+- ${decisions.slice(0, 5).join("\n- ")}` : ""
         ].filter(Boolean).join("\n");
         await saveMemory(db, input.session_id, {
           category: "context",
           key: "session_summary",
           content: summaryContent,
           priority: 80,
-          pinned: true,
-          metadata: {
-            session_name: sessionResult.session.name,
-            ended_at: (/* @__PURE__ */ new Date()).toISOString(),
-            memory_count: memories.length
-          }
+          pinned: true
         });
       }
-      const removedFromQueues = await removeSessionFromAllQueues(db, input.session_id);
+      await removeSessionFromAllQueues(db, input.session_id);
       await endSession(db, input.session_id, input.release_claims);
-      const claimStatus = input.release_claims === "complete" ? "completed" : "abandoned";
       await logAuditEvent(db, {
         session_id: input.session_id,
         action: "session_ended",
         entity_type: "session",
-        entity_id: input.session_id,
-        metadata: { status: claimStatus, memory_count: memories.length }
+        entity_id: input.session_id
       });
       return successResponse({
         success: true,
-        message: `Session ended. ${claimsToRelease.length} claim(s) marked as ${input.release_claims === "complete" ? "completed" : "abandoned"}.${removedFromQueues > 0 ? ` Removed from ${removedFromQueues} queue(s).` : ""}`,
-        claims_released: claimsToRelease.length > 0 ? {
-          count: claimsToRelease.length,
-          status: input.release_claims === "complete" ? "completed" : "abandoned",
-          details: claimsToRelease
-        } : null,
-        memory_summary: memorySummary
+        claims_released: activeClaims.length,
+        memories_saved: memories.length,
+        message: `Session ended. ${activeClaims.length} claim(s) released.`
       });
     }
     case "collab_session_list": {
@@ -5992,102 +5282,32 @@ Important:
         include_inactive: input.include_inactive,
         project_root: input.project_root
       });
-      const sessionsWithDetails = await Promise.all(
+      const sessionsWithClaims = await Promise.all(
         sessions.map(async (session) => {
           const claims = await listClaims(db, { session_id: session.id, status: "active" });
-          let progress = null;
-          let todos = null;
-          try {
-            if (session.progress) progress = JSON.parse(session.progress);
-            if (session.todos) todos = JSON.parse(session.todos);
-          } catch {
-          }
           return {
             id: session.id,
             name: session.name,
-            project_root: session.project_root,
             status: session.status,
             active_claims: claims.length,
-            last_heartbeat: session.last_heartbeat,
-            current_task: session.current_task,
-            progress,
-            todos
+            last_heartbeat: session.last_heartbeat
           };
         })
       );
-      return createToolResult(
-        JSON.stringify(
-          {
-            sessions: sessionsWithDetails,
-            total: sessionsWithDetails.length
-          },
-          null,
-          2
-        )
-      );
+      return successResponse({
+        sessions: sessionsWithClaims,
+        total: sessionsWithClaims.length
+      });
     }
-    case "collab_session_heartbeat": {
-      const validation = validateInput(sessionHeartbeatSchema, args);
+    case "collab_config": {
+      const validation = validateInput(configSchema, args);
       if (!validation.success) {
         return validationError(validation.error);
       }
       const input = validation.data;
-      const updated = await updateSessionHeartbeat(db, input.session_id, {
-        current_task: input.current_task,
-        todos: input.todos
-      });
-      if (!updated) {
-        return errorResponse(
-          ERROR_CODES.SESSION_NOT_FOUND,
-          "Session not found or inactive. Please start a new session."
-        );
-      }
-      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 validationError(validation.error);
-      }
-      const input = validation.data;
-      const todos = input.todos;
-      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,
-        todos
-      });
-      let progress = null;
-      if (todos && todos.length > 0) {
-        const completed = todos.filter((t) => t.status === "completed").length;
-        progress = {
-          completed,
-          total: todos.length,
-          percentage: Math.round(completed / todos.length * 100)
-        };
-      }
-      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 validationError(validation.error);
-      }
-      const input = validation.data;
-      const sessionResult = await validateActiveSession(db, input.session_id);
-      if (!sessionResult.valid) {
-        return sessionResult.error;
+      const sessionResult = await validateActiveSession(db, input.session_id);
+      if (!sessionResult.valid) {
+        return sessionResult.error;
       }
       const { session } = sessionResult;
       let currentConfig = DEFAULT_SESSION_CONFIG;
@@ -6099,17 +5319,45 @@ Important:
       }
       const newConfig = {
         mode: input.mode ?? currentConfig.mode,
-        allow_release_others: input.allow_release_others !== void 0 ? input.allow_release_others : currentConfig.allow_release_others,
-        auto_release_stale: input.auto_release_stale !== void 0 ? input.auto_release_stale : currentConfig.auto_release_stale,
+        allow_release_others: input.allow_release_others ?? currentConfig.allow_release_others,
+        auto_release_stale: input.auto_release_stale ?? currentConfig.auto_release_stale,
         stale_threshold_hours: input.stale_threshold_hours ?? currentConfig.stale_threshold_hours,
-        auto_release_immediate: input.auto_release_immediate !== void 0 ? input.auto_release_immediate : currentConfig.auto_release_immediate,
+        auto_release_immediate: input.auto_release_immediate ?? currentConfig.auto_release_immediate,
         auto_release_delay_minutes: input.auto_release_delay_minutes ?? currentConfig.auto_release_delay_minutes
       };
       await updateSessionConfig(db, input.session_id, newConfig);
       return successResponse({
         success: true,
-        message: "Configuration updated.",
-        config: newConfig
+        config: newConfig,
+        message: "Configuration updated."
+      });
+    }
+    case "collab_status": {
+      const sessionId = args.session_id;
+      if (!sessionId) {
+        return validationError("session_id is required");
+      }
+      const session = await getSession(db, sessionId);
+      if (!session) {
+        return errorResponse(ERROR_CODES.SESSION_NOT_FOUND, "Session not found");
+      }
+      const claims = await listClaims(db, { session_id: sessionId, status: "active" });
+      const memories = await getActiveMemories(db, sessionId, { priority_threshold: 70, max_items: 10 });
+      const allSessions = await listSessions(db, { project_root: session.project_root });
+      return successResponse({
+        session: {
+          id: session.id,
+          name: session.name,
+          status: session.status
+        },
+        claims: claims.map((c) => ({
+          id: c.id,
+          files: c.files,
+          intent: c.intent
+        })),
+        active_memories: memories.length,
+        other_sessions: allSessions.filter((s) => s.id !== sessionId).length,
+        message: `Session active. ${claims.length} claim(s), ${memories.length} memories.`
       });
     }
     default:
@@ -6121,10 +5369,19 @@ Important:
 var claimTools = [
   {
     name: "collab_claim",
-    description: "Declare files or specific symbols (functions/classes) you are about to modify. Use symbols for fine-grained claims that allow other sessions to work on different parts of the same file.",
+    description: `Unified tool for file/symbol claims. Use action parameter to:
+- "create": Declare files you're about to modify
+- "check": Check if files are being worked on (ALWAYS call before editing)
+- "release": Release a claim when done
+- "list": List all active claims`,
     inputSchema: {
       type: "object",
       properties: {
+        action: {
+          type: "string",
+          enum: ["create", "check", "release", "list"],
+          description: "Action to perform"
+        },
         session_id: {
           type: "string",
           description: "Your session ID"
@@ -6132,476 +5389,141 @@ var claimTools = [
         files: {
           type: "array",
           items: { type: "string" },
-          description: "File paths to claim. Supports glob patterns like 'src/api/*'. Use this for whole-file claims."
-        },
-        symbols: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              file: { type: "string", description: "File path containing the symbols" },
-              symbols: {
-                type: "array",
-                items: { type: "string" },
-                description: "Symbol names (function, class, method names) to claim"
-              },
-              symbol_type: {
-                type: "string",
-                enum: ["function", "class", "method", "variable", "block", "other"],
-                description: "Type of symbols being claimed (default: function)"
-              }
-            },
-            required: ["file", "symbols"]
-          },
-          description: "Symbol-level claims for fine-grained conflict detection. Use this instead of files when you only need to modify specific functions/classes."
+          description: "File paths (for create/check actions)"
         },
         intent: {
           type: "string",
-          description: "What you plan to do with these files/symbols"
-        },
-        scope: {
-          type: "string",
-          enum: ["small", "medium", "large"],
-          description: "Estimated scope: small(<30min), medium(30min-2hr), large(>2hr)"
-        },
-        priority: {
-          type: "number",
-          description: "Priority (0-100). Levels: critical (90-100), high (70-89), normal (40-69, default: 50), low (0-39)"
-        }
-      },
-      required: ["session_id", "intent"]
-    }
-  },
-  {
-    name: "collab_check",
-    description: "Check if files or symbols are being worked on by other sessions. ALWAYS call this before modifying files. Supports symbol-level checking for fine-grained conflict detection.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        files: {
-          type: "array",
-          items: { type: "string" },
-          description: "File paths to check"
-        },
-        symbols: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              file: { type: "string", description: "File path containing the symbols" },
-              symbols: {
-                type: "array",
-                items: { type: "string" },
-                description: "Symbol names to check for conflicts"
-              }
-            },
-            required: ["file", "symbols"]
-          },
-          description: "Symbol-level check. If provided, only checks for conflicts with these specific symbols."
-        },
-        session_id: {
-          type: "string",
-          description: "Your session ID (to exclude your own claims from results)"
-        }
-      },
-      required: ["files"]
-    }
-  },
-  {
-    name: "collab_release",
-    description: "Release a claim when done or abandoning work. By default you can only release your own claims. Use force=true with user confirmation to release stale claims from other sessions.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID (required to verify ownership)"
+          description: "What you plan to do (for create action)"
         },
         claim_id: {
           type: "string",
-          description: "Claim ID to release"
+          description: "Claim ID (for release action)"
         },
         status: {
           type: "string",
           enum: ["completed", "abandoned"],
-          description: "Whether work was completed or abandoned"
-        },
-        summary: {
-          type: "string",
-          description: "Optional summary of what was done (for completed claims)"
-        },
-        force: {
-          type: "boolean",
-          description: "Force release even if claim belongs to another session (requires user confirmation)"
-        }
-      },
-      required: ["session_id", "claim_id", "status"]
-    }
-  },
-  {
-    name: "collab_claims_list",
-    description: "List all WIP claims. Use to see what files are being worked on.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Filter by session ID"
-        },
-        status: {
-          type: "string",
-          enum: ["active", "completed", "abandoned", "all"],
-          description: "Filter by claim status"
-        },
-        project_root: {
-          type: "string",
-          description: "Filter by project root"
-        }
-      }
-    }
-  },
-  {
-    name: "collab_claim_update_priority",
-    description: "Update the priority of an existing claim. Higher priority claims take precedence in queue ordering.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        claim_id: {
-          type: "string",
-          description: "Claim ID to update"
-        },
-        priority: {
-          type: "number",
-          description: "New priority (0-100). Levels: critical (90-100), high (70-89), normal (40-69), low (0-39)"
-        },
-        reason: {
-          type: "string",
-          description: "Optional reason for priority change"
-        }
-      },
-      required: ["session_id", "claim_id", "priority"]
-    }
-  },
-  {
-    name: "collab_auto_release",
-    description: "Automatically release claims for a file after editing. Call this after Edit/Write operations to release the claim for the edited file. For small scope claims, releases immediately. For medium/large scope claims, requires force=true or auto_release_immediate config.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        file_path: {
-          type: "string",
-          description: "The file that was just edited"
+          description: "Release status (for release action)"
         },
         force: {
           type: "boolean",
-          description: "Force release even for medium/large scope claims"
+          description: "Force release even if not owner (for release action)"
         }
       },
-      required: ["session_id", "file_path"]
+      required: ["action", "session_id"]
     }
   }
 ];
 async function handleClaimTool(db, name, args) {
-  switch (name) {
-    case "collab_claim": {
-      const validation = validateInput(claimCreateSchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
+  if (name !== "collab_claim") {
+    return createToolResult(`Unknown tool: ${name}`, true);
+  }
+  const action = args.action;
+  const sessionId = args.session_id;
+  if (!action || !sessionId) {
+    return validationError("action and session_id are required");
+  }
+  switch (action) {
+    case "create": {
+      const files = args.files;
+      const intent = args.intent;
+      if (!intent) {
+        return validationError("intent is required for create action");
+      }
+      if (!files || files.length === 0) {
+        return validationError("files array is required for create action");
       }
-      const { session_id: sessionId, files, symbols, intent, scope = "medium", priority = 50 } = validation.data;
-      const hasSymbols = symbols && symbols.length > 0;
-      const priorityInfo = getPriorityLevel(priority);
       const sessionResult = await validateActiveSession(db, sessionId);
       if (!sessionResult.valid) {
         return sessionResult.error;
       }
-      const allFiles = new Set(files ?? []);
-      if (hasSymbols) {
-        for (const sc of symbols) {
-          allFiles.add(sc.file);
-        }
-      }
-      const fileList = Array.from(allFiles);
       const { claim } = await createClaim(db, {
         session_id: sessionId,
-        files: fileList,
+        files,
         intent,
-        scope,
-        priority,
-        symbols: hasSymbols ? symbols : void 0
+        scope: "medium",
+        priority: 50
       });
       await logAuditEvent(db, {
         session_id: sessionId,
         action: "claim_created",
         entity_type: "claim",
         entity_id: claim.id,
-        metadata: { files: fileList, intent, scope, priority }
+        metadata: { files, intent }
       });
       await saveMemory(db, sessionId, {
         category: "state",
         key: `claim_${claim.id}`,
         content: `Working on: ${intent}
-Files: ${fileList.join(", ")}${hasSymbols ? `
-Symbols: ${symbols.map((s) => `${s.file}:[${s.symbols.join(",")}]`).join(", ")}` : ""}`,
+Files: ${files.join(", ")}`,
         priority: 60,
         related_claim_id: claim.id,
-        metadata: {
-          claim_id: claim.id,
-          files: fileList,
-          symbols: hasSymbols ? symbols : void 0,
-          scope
-        }
+        metadata: { claim_id: claim.id, files }
       });
-      const autoRegistered = [];
-      for (const file of fileList) {
-        const lowerFile = file.toLowerCase();
-        const isPlanLike = (lowerFile.endsWith(".md") || lowerFile.endsWith(".txt")) && (lowerFile.includes("plan") || lowerFile.includes("design") || lowerFile.includes("spec") || lowerFile.includes("proposal") || lowerFile.includes("rfc") || lowerFile.includes("adr"));
-        if (isPlanLike) {
-          try {
-            await registerPlan(db, sessionId, {
-              file_path: file,
-              title: `Plan: ${file.split("/").pop() || file}`,
-              content_summary: intent,
-              status: "in_progress"
-            });
-            autoRegistered.push(file);
-          } catch {
-          }
-        }
-      }
-      const conflicts = await checkConflicts(db, fileList, sessionId, symbols);
+      const conflicts = await checkConflicts(db, files, sessionId);
       if (conflicts.length > 0) {
-        for (const conflict of conflicts) {
-          await logAuditEvent(db, {
-            session_id: sessionId,
-            action: "conflict_detected",
-            entity_type: "claim",
-            entity_id: claim.id,
-            metadata: {
-              conflicting_session_id: conflict.session_id,
-              conflicting_session_name: conflict.session_name ?? void 0,
-              files: [conflict.file_path]
-            }
-          });
-        }
-        const fileConflicts = conflicts.filter((c) => c.conflict_level === "file");
-        const symbolConflicts = conflicts.filter((c) => c.conflict_level === "symbol");
-        const conflictDetails = {
-          file_level: fileConflicts.map((c) => ({
+        return successResponse({
+          claim_id: claim.id,
+          status: "created_with_conflicts",
+          files,
+          conflicts: conflicts.map((c) => ({
             session_name: c.session_name,
             file: c.file_path,
             intent: c.intent
           })),
-          symbol_level: symbolConflicts.map((c) => ({
-            session_name: c.session_name,
-            file: c.file_path,
-            symbol: c.symbol_name,
-            symbol_type: c.symbol_type,
-            intent: c.intent
-          }))
-        };
-        return createToolResult(
-          JSON.stringify(
-            {
-              claim_id: claim.id,
-              status: "created_with_conflicts",
-              files: fileList,
-              symbols: hasSymbols ? symbols : void 0,
-              conflicts: conflictDetails,
-              warning: `\u26A0\uFE0F Conflicts detected: ${fileConflicts.length} file-level, ${symbolConflicts.length} symbol-level. Coordinate before proceeding.`,
-              auto_registered_plans: autoRegistered.length > 0 ? autoRegistered : void 0
-            },
-            null,
-            2
-          )
-        );
+          warning: `\u26A0\uFE0F ${conflicts.length} conflict(s) detected. Coordinate before proceeding.`
+        });
       }
-      return createToolResult(
-        JSON.stringify({
-          claim_id: claim.id,
-          status: "created",
-          files: fileList,
-          symbols: hasSymbols ? symbols : void 0,
-          intent,
-          scope,
-          priority: priorityInfo,
-          message: hasSymbols ? "Symbol-level claim created. Other sessions can work on different symbols in the same file." : "Claim created successfully. Other sessions will be warned about these files.",
-          auto_registered_plans: autoRegistered.length > 0 ? autoRegistered : void 0,
-          auto_registered_note: autoRegistered.length > 0 ? `Auto-protected ${autoRegistered.length} plan file(s). Use collab_plan_update_status to manage lifecycle.` : void 0
-        })
-      );
+      return successResponse({
+        claim_id: claim.id,
+        status: "created",
+        files,
+        intent,
+        message: "Claim created successfully."
+      });
     }
-    case "collab_check": {
-      const validation = validateInput(claimCheckSchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
-      }
-      const { files, symbols, session_id: sessionId } = validation.data;
-      let hasInProgressTodo = false;
-      let todosStatus = null;
-      if (sessionId) {
-        const session = await getSession(db, sessionId);
-        if (session?.todos) {
-          try {
-            const todos = JSON.parse(session.todos);
-            const inProgress = todos.filter((t) => t.status === "in_progress").length;
-            const completed = todos.filter((t) => t.status === "completed").length;
-            const pending = todos.filter((t) => t.status === "pending").length;
-            hasInProgressTodo = inProgress > 0;
-            todosStatus = {
-              total: todos.length,
-              in_progress: inProgress,
-              completed,
-              pending
-            };
-          } catch {
-          }
-        }
-      }
-      const hasSymbols = symbols && Array.isArray(symbols) && symbols.length > 0;
-      const conflicts = await checkConflicts(db, files, sessionId, hasSymbols ? symbols : void 0);
-      const blockedFiles = /* @__PURE__ */ new Set();
-      const blockedSymbols = /* @__PURE__ */ new Map();
-      for (const c of conflicts) {
-        if (c.conflict_level === "file") {
-          blockedFiles.add(c.file_path);
-        } else if (c.conflict_level === "symbol" && c.symbol_name) {
-          const existing = blockedSymbols.get(c.file_path) ?? /* @__PURE__ */ new Set();
-          existing.add(c.symbol_name);
-          blockedSymbols.set(c.file_path, existing);
-        }
-      }
-      let safeSymbols = [];
-      let blockedSymbolsList = [];
-      if (hasSymbols) {
-        for (const sc of symbols) {
-          const blocked = blockedSymbols.get(sc.file) ?? /* @__PURE__ */ new Set();
-          const safe = sc.symbols.filter((s) => !blocked.has(s));
-          const blockedList = sc.symbols.filter((s) => blocked.has(s));
-          if (safe.length > 0) {
-            safeSymbols.push({ file: sc.file, symbols: safe });
-          }
-          if (blockedList.length > 0) {
-            blockedSymbolsList.push({ file: sc.file, symbols: blockedList });
-          }
-        }
-      }
-      const safeFiles = files.filter((f) => !blockedFiles.has(f) && !blockedSymbols.has(f));
-      const blockedFilesList = files.filter((f) => blockedFiles.has(f));
-      let recommendation;
-      let canEdit;
-      const hasSafeContent = safeFiles.length > 0 || safeSymbols.length > 0;
-      if (conflicts.length === 0) {
-        recommendation = "proceed_all";
-        canEdit = true;
-      } else if (hasSafeContent) {
-        recommendation = "proceed_safe_only";
-        canEdit = true;
-      } else {
-        recommendation = "abort";
-        canEdit = false;
+    case "check": {
+      const files = args.files;
+      if (!files || files.length === 0) {
+        return validationError("files array is required for check action");
       }
+      const conflicts = await checkConflicts(db, files, sessionId);
       if (conflicts.length === 0) {
-        return createToolResult(
-          JSON.stringify({
-            has_conflicts: false,
-            safe: true,
-            can_edit: true,
-            recommendation: "proceed_all",
-            file_status: {
-              safe: files,
-              blocked: []
-            },
-            symbol_status: hasSymbols ? { safe: symbols, blocked: [] } : void 0,
-            message: hasSymbols ? "All symbols are safe to edit. Proceed." : "All files are safe to edit. Proceed.",
-            has_in_progress_todo: hasInProgressTodo,
-            todos_status: todosStatus
-          })
-        );
-      }
-      const bySession = /* @__PURE__ */ new Map();
-      for (const c of conflicts) {
-        const key = c.session_id;
-        const existing = bySession.get(key) ?? [];
-        existing.push(c);
-        bySession.set(key, existing);
+        return successResponse({
+          has_conflicts: false,
+          can_edit: true,
+          recommendation: "proceed",
+          safe_files: files,
+          message: "All files are safe to edit. Proceed."
+        });
       }
-      const conflictDetails = Array.from(bySession.entries()).map(([sessId, items]) => {
-        const fileItems = items.filter((i) => i.conflict_level === "file");
-        const symbolItems = items.filter((i) => i.conflict_level === "symbol");
-        return {
-          session_id: sessId,
-          session_name: items[0].session_name,
-          intent: items[0].intent,
-          scope: items[0].scope,
-          files: fileItems.map((i) => i.file_path),
-          symbols: symbolItems.map((i) => ({
-            file: i.file_path,
-            symbol: i.symbol_name,
-            type: i.symbol_type
-          })),
-          started_at: items[0].created_at
-        };
+      const blockedFiles = new Set(conflicts.map((c) => c.file_path));
+      const safeFiles = files.filter((f) => !blockedFiles.has(f));
+      return successResponse({
+        has_conflicts: true,
+        can_edit: safeFiles.length > 0,
+        recommendation: safeFiles.length > 0 ? "proceed_safe_only" : "abort",
+        safe_files: safeFiles,
+        blocked_files: Array.from(blockedFiles),
+        conflicts: conflicts.map((c) => ({
+          session_name: c.session_name,
+          file: c.file_path,
+          intent: c.intent
+        })),
+        message: safeFiles.length > 0 ? `Edit ONLY safe files: [${safeFiles.join(", ")}]. Skip blocked files.` : "All files blocked. Coordinate with other session(s)."
       });
-      let message;
-      if (recommendation === "proceed_safe_only") {
-        if (hasSymbols && safeSymbols.length > 0) {
-          const safeDesc = safeSymbols.map((s) => `${s.file}:[${s.symbols.join(",")}]`).join(", ");
-          const blockedDesc = blockedSymbolsList.map((s) => `${s.file}:[${s.symbols.join(",")}]`).join(", ");
-          message = `Edit ONLY these safe symbols: ${safeDesc}. Skip blocked: ${blockedDesc}.`;
-        } else {
-          message = `Edit ONLY these safe files: [${safeFiles.join(", ")}]. Skip blocked files: [${blockedFilesList.join(", ")}].`;
-        }
-      } else {
-        message = hasSymbols ? `All requested symbols are blocked. Coordinate with other session(s) or wait.` : `All ${files.length} file(s) are blocked. Coordinate with other session(s) or wait.`;
-      }
-      return createToolResult(
-        JSON.stringify(
-          {
-            has_conflicts: true,
-            safe: false,
-            can_edit: canEdit,
-            recommendation,
-            file_status: {
-              safe: safeFiles,
-              blocked: blockedFilesList
-            },
-            symbol_status: hasSymbols ? {
-              safe: safeSymbols,
-              blocked: blockedSymbolsList
-            } : void 0,
-            conflicts: conflictDetails,
-            message,
-            has_in_progress_todo: hasInProgressTodo,
-            todos_status: todosStatus
-          },
-          null,
-          2
-        )
-      );
     }
-    case "collab_release": {
-      const validation = validateInput(claimReleaseSchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
+    case "release": {
+      const claimId = args.claim_id;
+      const status = args.status || "completed";
+      const force = args.force;
+      if (!claimId) {
+        return validationError("claim_id is required for release action");
       }
-      const { session_id: sessionId, claim_id: claimId, status, summary, force } = validation.data;
       const claim = await getClaim(db, claimId);
       if (!claim) {
-        return errorResponse(
-          ERROR_CODES.CLAIM_NOT_FOUND,
-          "Claim not found. It may have already been released."
-        );
+        return errorResponse(ERROR_CODES.CLAIM_NOT_FOUND, "Claim not found");
       }
-      if (claim.session_id !== sessionId) {
+      if (claim.session_id !== sessionId && !force) {
         const callerSession = await getSession(db, sessionId);
         let config = DEFAULT_SESSION_CONFIG;
         if (callerSession?.config) {
@@ -6610,36 +5532,17 @@ Symbols: ${symbols.map((s) => `${s.file}:[${s.symbols.join(",")}]`).join(", ")}`
           } catch {
           }
         }
-        const canRelease = force === true || config.allow_release_others;
-        if (!canRelease) {
-          const claimAge = Date.now() - new Date(claim.created_at).getTime();
-          const staleHours = config.stale_threshold_hours;
-          const isStale = claimAge > staleHours * 60 * 60 * 1e3;
-          return createToolResult(
-            JSON.stringify({
-              error: "NOT_OWNER",
-              message: "You can only release your own claims. This claim belongs to another session.",
-              claim_owner: claim.session_name,
-              claim_age_hours: Math.round(claimAge / (60 * 60 * 1e3) * 10) / 10,
-              is_stale: isStale,
-              suggestions: [
-                "Use collab_message_send to ask the owner to release it.",
-                isStale ? "This claim is stale. Ask user for confirmation, then use force=true to release." : null,
-                "Use collab_config to enable allow_release_others for future releases."
-              ].filter(Boolean)
-            }),
-            true
+        if (!config.allow_release_others) {
+          return errorResponse(
+            ERROR_CODES.NOT_OWNER,
+            `Not your claim. Owner: ${claim.session_name}. Use force=true to override.`
           );
         }
       }
       if (claim.status !== "active") {
-        return errorResponse(
-          ERROR_CODES.CLAIM_ALREADY_RELEASED,
-          `Claim was already ${claim.status}.`
-        );
+        return errorResponse(ERROR_CODES.CLAIM_ALREADY_RELEASED, `Claim already ${claim.status}`);
       }
-      const isOwnClaim = claim.session_id === sessionId;
-      await releaseClaim(db, claimId, { status, summary });
+      await releaseClaim(db, claimId, { status });
       await logAuditEvent(db, {
         session_id: sessionId,
         action: "claim_released",
@@ -6648,211 +5551,72 @@ Symbols: ${symbols.map((s) => `${s.file}:[${s.symbols.join(",")}]`).join(", ")}`
         metadata: { status, files: claim.files }
       });
       await clearMemory(db, claim.session_id, { key: `claim_${claimId}` });
-      if (status === "completed" && summary) {
-        await saveMemory(db, sessionId, {
-          category: "decision",
-          key: `completed_${claimId}`,
-          content: `Completed: ${claim.intent}
-Summary: ${summary}
-Files: ${claim.files.join(", ")}`,
-          priority: 50,
-          metadata: {
-            claim_id: claimId,
-            files: claim.files,
-            completed_at: (/* @__PURE__ */ new Date()).toISOString()
-          }
-        });
-      }
-      const notifiedCount = await notifyQueueOnClaimRelease(db, claimId, sessionId, claim.files);
-      return createToolResult(
-        JSON.stringify({
-          success: true,
-          message: isOwnClaim ? `Claim ${status}. Files are now available for other sessions.` : `Claim from ${claim.session_name} forcefully ${status}.`,
-          files: claim.files,
-          summary: summary ?? null,
-          was_forced: !isOwnClaim,
-          notified_sessions: notifiedCount
-        })
-      );
-    }
-    case "collab_auto_release": {
-      const validation = validateInput(autoReleaseSchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
-      }
-      const { session_id: sessionId, file_path: filePath, force } = validation.data;
-      const sessionResult = await validateActiveSession(db, sessionId);
-      if (!sessionResult.valid) {
-        return sessionResult.error;
-      }
-      const session = await getSession(db, sessionId);
-      let config = DEFAULT_SESSION_CONFIG;
-      if (session?.config) {
-        try {
-          config = { ...DEFAULT_SESSION_CONFIG, ...JSON.parse(session.config) };
-        } catch {
-        }
-      }
-      const claimInfo = await getClaimInfoByFile(db, sessionId, filePath);
-      if (!claimInfo) {
-        return successResponse({
-          released: false,
-          message: "No active claim found for this file",
-          file_path: filePath
-        });
-      }
-      const isPartialRelease = claimInfo.file_count > 1;
-      const shouldAutoRelease = isPartialRelease || claimInfo.scope === "small" || force === true || config.auto_release_immediate;
-      if (!shouldAutoRelease) {
-        return successResponse({
-          released: false,
-          claim_id: claimInfo.claim_id,
-          scope: claimInfo.scope,
-          file_path: filePath,
-          file_count: claimInfo.file_count,
-          message: `Claim has ${claimInfo.scope} scope. Use force=true or enable auto_release_immediate config to auto-release.`,
-          suggestions: [
-            "Use collab_release with claim_id to release the full claim",
-            "Use collab_config to enable auto_release_immediate",
-            "Use force=true to force auto-release"
-          ]
-        });
-      }
-      const result = await releaseClaimByFile(db, sessionId, filePath);
-      if (!result.released) {
-        return errorResponse(
-          ERROR_CODES.RELEASE_FAILED,
-          "Failed to release claim. It may have been released by another operation."
-        );
-      }
-      await logAuditEvent(db, {
-        session_id: sessionId,
-        action: "claim_released",
-        entity_type: "claim",
-        entity_id: result.claim_id,
-        metadata: {
-          status: result.partial ? "partial" : "completed",
-          files: [filePath],
-          auto_release: true,
-          partial: result.partial,
-          files_remaining: result.files_remaining
-        }
-      });
-      let notifiedCount = 0;
-      if (!result.partial) {
-        notifiedCount = await notifyQueueOnClaimRelease(db, result.claim_id, sessionId, claimInfo.files);
-      }
       return successResponse({
-        released: true,
-        claim_id: result.claim_id,
-        file_path: filePath,
-        partial: result.partial,
-        files_remaining: result.files_remaining,
-        notified_sessions: notifiedCount,
-        message: result.partial ? `File released from claim. ${result.files_remaining} file(s) remaining in claim.` : "Claim released successfully."
+        success: true,
+        claim_id: claimId,
+        files: claim.files,
+        message: `Claim ${status}. Files now available.`
       });
     }
-    case "collab_claims_list": {
-      const validation = validateInput(claimListSchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
-      }
-      const { session_id, status = "active", project_root } = validation.data;
-      const claims = await listClaims(db, { session_id, status, project_root });
+    case "list": {
+      const claims = await listClaims(db, { session_id: sessionId, status: "active" });
       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,
           priority: getPriorityLevel(c.priority),
-          status: c.status,
-          created_at: c.created_at,
-          completed_summary: c.completed_summary
+          created_at: c.created_at
         })),
         total: claims.length
-      }, true);
-    }
-    case "collab_claim_update_priority": {
-      const validation = validateInput(claimUpdatePrioritySchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
-      }
-      const { session_id: sessionId, claim_id: claimId, priority, reason } = validation.data;
-      const sessionResult = await validateActiveSession(db, sessionId);
-      if (!sessionResult.valid) {
-        return sessionResult.error;
-      }
-      const claim = await getClaim(db, claimId);
-      if (!claim) {
-        return errorResponse(ERROR_CODES.CLAIM_NOT_FOUND, "Claim not found");
-      }
-      if (claim.session_id !== sessionId) {
-        return errorResponse(ERROR_CODES.NOT_OWNER, "You can only update priority of your own claims");
-      }
-      if (claim.status !== "active") {
-        return errorResponse(ERROR_CODES.CLAIM_ALREADY_RELEASED, `Claim is ${claim.status}, cannot update priority`);
-      }
-      const oldPriority = getPriorityLevel(claim.priority);
-      const newPriority = getPriorityLevel(priority);
-      const updated = await updateClaimPriority(db, claimId, priority);
-      if (!updated) {
-        return errorResponse(ERROR_CODES.CLAIM_NOT_FOUND, "Failed to update priority");
-      }
-      await logAuditEvent(db, {
-        session_id: sessionId,
-        action: "priority_changed",
-        entity_type: "claim",
-        entity_id: claimId,
-        metadata: {
-          old_value: claim.priority,
-          new_value: priority,
-          reason
-        }
-      });
-      return successResponse({
-        success: true,
-        claim_id: claimId,
-        old_priority: oldPriority,
-        new_priority: newPriority,
-        reason: reason ?? null,
-        message: `Priority updated from ${oldPriority.level} (${oldPriority.value}) to ${newPriority.level} (${newPriority.value})`
       });
     }
     default:
-      return createToolResult(`Unknown claim tool: ${name}`, true);
+      return createToolResult(`Unknown action: ${action}`, true);
   }
 }
 
-// src/mcp/tools/message.ts
-var messageTools = [
+// src/mcp/tools/memory.ts
+var memoryTools = [
   {
-    name: "collab_message_send",
-    description: "Send a message to another session or broadcast to all sessions.",
+    name: "collab_memory_save",
+    description: `Save or update context to working memory (upsert). Use to persist findings, decisions, or state that should survive context compaction.`,
     inputSchema: {
       type: "object",
       properties: {
-        from_session_id: {
+        session_id: {
           type: "string",
           description: "Your session ID"
         },
-        to_session_id: {
+        category: {
+          type: "string",
+          enum: ["finding", "decision", "state", "todo", "important", "context"],
+          description: "Category: finding, decision, state, todo, important, context"
+        },
+        key: {
           type: "string",
-          description: "Target session ID. Leave empty to broadcast to all."
+          description: 'Unique identifier (e.g., "auth_bug_root_cause")'
         },
         content: {
           type: "string",
-          description: "Message content"
+          description: "The content to remember"
+        },
+        priority: {
+          type: "number",
+          description: "Priority 0-100 (default 50). Higher = more important."
+        },
+        pinned: {
+          type: "boolean",
+          description: "If true, always loaded when recalling active memories."
         }
       },
-      required: ["from_session_id", "content"]
+      required: ["session_id", "category", "key", "content"]
     }
   },
   {
-    name: "collab_message_list",
-    description: "Read messages sent to your session.",
+    name: "collab_memory_recall",
+    description: `Recall memories. Use active=true to get pinned + high priority memories for context restoration.`,
     inputSchema: {
       type: "object",
       properties: {
@@ -6860,2477 +5624,371 @@ var messageTools = [
           type: "string",
           description: "Your session ID"
         },
-        unread_only: {
+        active: {
           type: "boolean",
-          description: "Only show unread messages"
+          description: "If true, return pinned + high priority memories only (default behavior for context restoration)"
+        },
+        category: {
+          type: "string",
+          enum: ["finding", "decision", "state", "todo", "important", "context"],
+          description: "Filter by category"
+        },
+        key: {
+          type: "string",
+          description: "Get a specific memory by key"
+        }
+      },
+      required: ["session_id"]
+    }
+  },
+  {
+    name: "collab_memory_clear",
+    description: "Clear memories. Specify key, category, or clear_all.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: {
+          type: "string",
+          description: "Your session ID"
         },
-        mark_as_read: {
+        key: {
+          type: "string",
+          description: "Clear specific memory by key"
+        },
+        category: {
+          type: "string",
+          enum: ["finding", "decision", "state", "todo", "important", "context"],
+          description: "Clear all in category"
+        },
+        clear_all: {
           type: "boolean",
-          description: "Mark retrieved messages as read"
+          description: "Clear ALL memories (use with caution)"
         }
       },
       required: ["session_id"]
     }
   }
 ];
-async function handleMessageTool(db, name, args) {
+async function handleMemoryTool(db, name, args) {
+  const sessionId = args.session_id;
+  if (!sessionId) {
+    return validationError("session_id is required");
+  }
+  const sessionCheck = await validateActiveSession(db, sessionId);
+  if (!sessionCheck.valid) {
+    return sessionCheck.error;
+  }
   switch (name) {
-    case "collab_message_send": {
-      const validation = validateInput(messageSendSchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
-      }
-      const input = validation.data;
-      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 targetResult = await validateActiveSession(db, input.to_session_id);
-        if (!targetResult.valid) {
-          return errorResponse(
-            ERROR_CODES.TARGET_SESSION_INVALID,
-            "Target session not found or inactive."
-          );
-        }
-      }
-      const message = await sendMessage(db, {
-        from_session_id: input.from_session_id,
-        to_session_id: input.to_session_id,
-        content: input.content
+    case "collab_memory_save": {
+      const category = args.category;
+      const key = args.key;
+      const content = args.content;
+      if (!category || !key || !content) {
+        return validationError("category, key, and content are required");
+      }
+      const memory = await saveMemory(db, sessionId, {
+        category,
+        key,
+        content,
+        priority: args.priority ?? 50,
+        pinned: args.pinned ?? false
+      });
+      return successResponse({
+        saved: true,
+        id: memory.id,
+        category: memory.category,
+        key: memory.key,
+        priority: memory.priority,
+        pinned: memory.pinned === 1,
+        message: `Memory saved: ${category}/${key}`
       });
-      const senderName = senderResult.session.name ?? "Unknown session";
-      const contentPreview = input.content.length > 50 ? input.content.substring(0, 50) + "..." : input.content;
-      if (input.to_session_id) {
-        await createNotification(db, {
-          session_id: input.to_session_id,
-          type: "session_message",
-          title: `Message from ${senderName}`,
-          message: contentPreview,
-          reference_type: "message",
-          reference_id: message.id,
-          metadata: { from_session_id: input.from_session_id, from_session_name: senderName }
+    }
+    case "collab_memory_recall": {
+      const active = args.active;
+      const category = args.category;
+      const key = args.key;
+      if (active) {
+        const memories2 = await getActiveMemories(db, sessionId, {
+          priority_threshold: 70,
+          max_items: 20
         });
-      } else {
-        const allSessions = await listSessions(db, { include_inactive: false });
-        for (const session of allSessions) {
-          if (session.id !== input.from_session_id) {
-            await createNotification(db, {
-              session_id: session.id,
-              type: "session_message",
-              title: `Broadcast from ${senderName}`,
-              message: contentPreview,
-              reference_type: "message",
-              reference_id: message.id,
-              metadata: { from_session_id: input.from_session_id, from_session_name: senderName, is_broadcast: true }
-            });
+        const formatted2 = memories2.map((m) => ({
+          category: m.category,
+          key: m.key,
+          content: m.content,
+          priority: m.priority,
+          pinned: m.pinned === 1
+        }));
+        const byCategory = {};
+        for (const mem of formatted2) {
+          if (!byCategory[mem.category]) {
+            byCategory[mem.category] = [];
           }
+          byCategory[mem.category].push({ key: mem.key, content: mem.content });
         }
+        return successResponse({
+          count: formatted2.length,
+          by_category: byCategory,
+          message: `Active memories: ${formatted2.length} items`
+        });
       }
+      const memories = await recallMemory(db, sessionId, { category, key });
+      const formatted = memories.map((m) => ({
+        category: m.category,
+        key: m.key,
+        content: m.content,
+        priority: m.priority,
+        pinned: m.pinned === 1
+      }));
       return successResponse({
-        success: true,
-        message_id: message.id,
-        sent_to: input.to_session_id ?? "all sessions (broadcast)",
-        message: "Message sent successfully."
+        count: formatted.length,
+        memories: formatted
       });
     }
-    case "collab_message_list": {
-      const validation = validateInput(messageListSchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
+    case "collab_memory_clear": {
+      const key = args.key;
+      const category = args.category;
+      const clearAll = args.clear_all;
+      if (!key && !category && !clearAll) {
+        return validationError("One of key, category, or clear_all is required");
       }
-      const input = validation.data;
-      const unreadOnly = input.unread_only ?? true;
-      const markAsRead = input.mark_as_read ?? true;
-      const messages = await listMessages(db, {
-        session_id: input.session_id,
-        unread_only: unreadOnly,
-        mark_as_read: markAsRead
+      const cleared = await clearMemory(db, sessionId, {
+        key,
+        category,
+        clear_all: clearAll
       });
-      if (messages.length === 0) {
-        return successResponse({
-          messages: [],
-          message: unreadOnly ? "No unread messages." : "No messages."
-        });
+      let message;
+      if (key) {
+        message = cleared > 0 ? `Memory cleared: ${key}` : `Memory not found: ${key}`;
+      } else if (category) {
+        message = `Cleared ${cleared} memories from category: ${category}`;
+      } else {
+        message = `Cleared all ${cleared} memories`;
       }
-      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);
+      return successResponse({ cleared, message });
     }
     default:
-      return createToolResult(`Unknown message tool: ${name}`, true);
+      return errorResponse(ERROR_CODES.UNKNOWN_TOOL, `Unknown memory tool: ${name}`);
   }
 }
 
-// src/mcp/tools/decision.ts
-var decisionTools = [
+// src/mcp/tools/protection.ts
+var protectionTools = [
   {
-    name: "collab_decision_add",
-    description: "Record an architectural or design decision for team reference.",
+    name: "collab_protect",
+    description: `Unified tool for file protection. Use action parameter to:
+- "register": Register a plan or file for protection
+- "check": Check if a file is protected before deleting
+- "list": List all protected files`,
     inputSchema: {
       type: "object",
       properties: {
+        action: {
+          type: "string",
+          enum: ["register", "check", "list"],
+          description: "Action to perform"
+        },
         session_id: {
           type: "string",
           description: "Your session ID"
         },
-        category: {
+        file_path: {
+          type: "string",
+          description: "File path (for register/check)"
+        },
+        type: {
           type: "string",
-          enum: ["architecture", "naming", "api", "database", "ui", "other"],
-          description: "Decision category"
+          enum: ["plan", "file"],
+          description: "Type of protection (for register). Default: file"
         },
         title: {
           type: "string",
-          description: "Brief title of the decision"
+          description: "Title (for plan registration)"
         },
-        description: {
+        content_summary: {
           type: "string",
-          description: "Detailed description of the decision and rationale"
+          description: "Summary (for plan registration)"
         }
       },
-      required: ["session_id", "title", "description"]
+      required: ["action", "session_id"]
     }
-  },
-  {
-    name: "collab_decision_list",
-    description: "List recorded decisions. Use to understand past architectural choices.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        category: {
-          type: "string",
-          enum: ["architecture", "naming", "api", "database", "ui", "other"],
-          description: "Filter by category"
-        },
-        limit: {
-          type: "number",
-          description: "Maximum number of decisions to return"
+  }
+];
+async function handleProtectionTool(db, name, args) {
+  if (name !== "collab_protect") {
+    return errorResponse(ERROR_CODES.UNKNOWN_TOOL, `Unknown tool: ${name}`);
+  }
+  const action = args.action;
+  const sessionId = args.session_id;
+  if (!action || !sessionId) {
+    return validationError("action and session_id are required");
+  }
+  const sessionCheck = await validateActiveSession(db, sessionId);
+  if (!sessionCheck.valid) {
+    return sessionCheck.error;
+  }
+  switch (action) {
+    case "register": {
+      const filePath = args.file_path;
+      const type = args.type ?? "file";
+      if (!filePath) {
+        return validationError("file_path is required for register");
+      }
+      if (type === "plan") {
+        const title = args.title;
+        const contentSummary = args.content_summary;
+        if (!title || !contentSummary) {
+          return validationError("title and content_summary are required for plan registration");
         }
+        const memory = await registerPlan(db, sessionId, {
+          file_path: filePath,
+          title,
+          content_summary: contentSummary,
+          status: "in_progress"
+        });
+        return successResponse({
+          registered: true,
+          type: "plan",
+          file_path: filePath,
+          title,
+          priority: memory.priority,
+          pinned: memory.pinned === 1,
+          message: `Plan registered and protected: ${title}`
+        });
+      } else {
+        const description = args.description;
+        const memory = await registerCreatedFile(db, sessionId, {
+          file_path: filePath,
+          file_type: "other",
+          description
+        });
+        return successResponse({
+          registered: true,
+          type: "file",
+          file_path: filePath,
+          priority: memory.priority,
+          message: `File registered for protection: ${filePath}`
+        });
       }
     }
-  }
-];
-async function handleDecisionTool(db, name, args) {
-  switch (name) {
-    case "collab_decision_add": {
-      const validation = validateInput(decisionAddSchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
+    case "check": {
+      const filePath = args.file_path;
+      if (!filePath) {
+        return validationError("file_path is required for check");
       }
-      const input = validation.data;
-      const sessionResult = await validateActiveSession(db, input.session_id);
-      if (!sessionResult.valid) {
-        return sessionResult.error;
+      const result = await isFileProtected(db, sessionId, filePath);
+      if (result.protected) {
+        return successResponse({
+          protected: true,
+          reason: result.reason,
+          warning: `\u26A0\uFE0F Protected (${result.reason}). Confirm before deleting.`
+        });
       }
-      const decision = await addDecision(db, {
-        session_id: input.session_id,
-        category: input.category,
-        title: input.title,
-        description: input.description
-      });
       return successResponse({
-        success: true,
-        decision_id: decision.id,
-        message: "Decision recorded successfully."
+        protected: false,
+        message: "File is not protected."
       });
     }
-    case "collab_decision_list": {
-      const validation = validateInput(decisionListSchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
-      }
-      const input = validation.data;
-      const decisions = await listDecisions(db, {
-        category: input.category,
-        limit: input.limit ?? 20
-      });
+    case "list": {
+      const files = await getProtectedFiles(db, sessionId);
+      const plans = await listPlans(db, sessionId, { include_archived: false });
       return successResponse({
-        decisions: decisions.map((d) => ({
-          id: d.id,
-          category: d.category,
-          title: d.title,
-          description: d.description,
-          created_at: d.created_at
+        protected_files: files.length,
+        plans: plans.length,
+        files,
+        plan_list: plans.map((p) => ({
+          file_path: p.file_path,
+          title: p.title,
+          status: p.status
         })),
-        total: decisions.length
-      }, true);
+        message: `${files.length} protected file(s), ${plans.length} plan(s)`
+      });
     }
     default:
-      return createToolResult(`Unknown decision tool: ${name}`, true);
+      return errorResponse(ERROR_CODES.UNKNOWN_TOOL, `Unknown action: ${action}`);
   }
 }
 
-// src/mcp/tools/lsp.ts
-var LSP_SYMBOL_KIND_MAP = {
-  5: "class",
-  // Class
-  6: "method",
-  // Method
-  9: "function",
-  // Constructor
-  12: "function",
-  // Function
-  13: "variable",
-  // Variable
-  14: "variable",
-  // Constant
-  23: "class"
-  // Struct
-  // Map others to 'other'
-};
-var lspTools = [
-  {
-    name: "collab_analyze_symbols",
-    description: `Analyze LSP symbols for conflict detection and reference impact.
+// src/constants.ts
+import { readFileSync } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+function getVersion() {
+  try {
+    const __dirname3 = dirname2(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync(join2(__dirname3, "..", "package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+var VERSION = getVersion();
+var SERVER_NAME = "session-collab-mcp";
+var SERVER_INSTRUCTIONS = `
+# Session Collaboration MCP
 
-WORKFLOW:
-1. Claude uses LSP.documentSymbol to get symbols from a file
-2. Claude passes those symbols to this tool
-3. This tool checks conflicts and returns which symbols are safe/blocked
+Coordinate sessions and persist context across conversations.
 
-This enables Claude to automatically proceed with safe symbols and skip blocked ones.`,
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID (to exclude your own claims)"
-        },
-        files: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              file: { type: "string", description: "File path" },
-              symbols: {
-                type: "array",
-                items: {
-                  type: "object",
-                  properties: {
-                    name: { type: "string", description: "Symbol name" },
-                    kind: { type: "number", description: "LSP SymbolKind" },
-                    range: {
-                      type: "object",
-                      properties: {
-                        start: {
-                          type: "object",
-                          properties: {
-                            line: { type: "number" },
-                            character: { type: "number" }
-                          }
-                        },
-                        end: {
-                          type: "object",
-                          properties: {
-                            line: { type: "number" },
-                            character: { type: "number" }
-                          }
-                        }
-                      }
-                    },
-                    children: {
-                      type: "array",
-                      description: "Nested symbols (e.g., methods in a class)"
-                    }
-                  },
-                  required: ["name", "kind"]
-                },
-                description: "LSP DocumentSymbol array from LSP.documentSymbol"
-              }
-            },
-            required: ["file", "symbols"]
-          },
-          description: "Files with their LSP symbols to analyze"
-        },
-        references: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              symbol: { type: "string", description: "Symbol name" },
-              file: { type: "string", description: "File containing the symbol" },
-              references: {
-                type: "array",
-                items: {
-                  type: "object",
-                  properties: {
-                    file: { type: "string" },
-                    line: { type: "number" },
-                    context: { type: "string" }
-                  },
-                  required: ["file", "line"]
-                },
-                description: "Locations that reference this symbol (from LSP.findReferences)"
-              }
-            },
-            required: ["symbol", "file", "references"]
-          },
-          description: "Optional: Reference data from LSP.findReferences for impact analysis"
-        },
-        check_symbols: {
-          type: "array",
-          items: { type: "string" },
-          description: "Optional: Only analyze these specific symbol names (filter)"
-        }
-      },
-      required: ["session_id", "files"]
-    }
-  },
-  {
-    name: "collab_validate_symbols",
-    description: `Validate that symbols exist in a file before claiming them.
+## 9 Core Tools
 
-Use this to verify symbol names are correct before calling collab_claim.
-Helps prevent claiming non-existent or misspelled symbols.`,
-    inputSchema: {
-      type: "object",
-      properties: {
-        file: {
-          type: "string",
-          description: "File path to validate symbols in"
-        },
-        symbols: {
-          type: "array",
-          items: { type: "string" },
-          description: "Symbol names to validate"
-        },
-        lsp_symbols: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              name: { type: "string" },
-              kind: { type: "number" }
-            },
-            required: ["name", "kind"]
-          },
-          description: "LSP symbols from the file (from LSP.documentSymbol)"
-        }
-      },
-      required: ["file", "symbols", "lsp_symbols"]
-    }
-  },
-  {
-    name: "collab_store_references",
-    description: `Store symbol reference data from LSP.findReferences for impact tracking.
+### Session (4 tools)
+- \`collab_session_start\`: Start session with project_root
+- \`collab_session_end\`: End session, release claims
+- \`collab_session_list\`: List active sessions
+- \`collab_config\`: Configure session behavior
 
-Call this after using LSP.findReferences to persist the reference data.
-This enables automatic impact warnings when other sessions claim related files.`,
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        references: {
-          type: "array",
-          items: {
-            type: "object",
-            properties: {
-              source_file: { type: "string", description: "File containing the symbol definition" },
-              source_symbol: { type: "string", description: "Symbol name" },
-              references: {
-                type: "array",
-                items: {
-                  type: "object",
-                  properties: {
-                    file: { type: "string" },
-                    line: { type: "number" },
-                    context: { type: "string" }
-                  },
-                  required: ["file", "line"]
-                }
-              }
-            },
-            required: ["source_file", "source_symbol", "references"]
-          },
-          description: "Reference data from LSP.findReferences"
-        },
-        clear_existing: {
-          type: "boolean",
-          description: "Clear existing references from this session before storing (default: false)"
-        }
-      },
-      required: ["session_id", "references"]
-    }
-  },
-  {
-    name: "collab_impact_analysis",
-    description: `Analyze the impact of modifying a symbol.
+### Claims (1 tool)
+- \`collab_claim\`: Unified claim tool
+  - action: "create" | "check" | "release" | "list"
 
-Returns which files reference this symbol and if any of those files have active claims.
-Use this before making changes to widely-used symbols.`,
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID (to exclude your own claims)"
-        },
-        file: {
-          type: "string",
-          description: "File containing the symbol"
-        },
-        symbol: {
-          type: "string",
-          description: "Symbol name to analyze"
-        }
-      },
-      required: ["session_id", "file", "symbol"]
-    }
-  }
-];
-function lspKindToSymbolType(kind) {
-  return LSP_SYMBOL_KIND_MAP[kind] ?? "other";
-}
-function flattenLspSymbols(symbols, file, parentName) {
-  const result = [];
-  for (const sym of symbols) {
-    const fullName = parentName ? `${parentName}.${sym.name}` : sym.name;
-    result.push({
-      name: sym.name,
-      type: lspKindToSymbolType(sym.kind),
-      file,
-      fullName
-    });
-    if (sym.children && sym.children.length > 0) {
-      result.push(...flattenLspSymbols(sym.children, file, fullName));
-    }
-  }
-  return result;
-}
-async function handleLspTool(db, name, args) {
-  switch (name) {
-    case "collab_analyze_symbols": {
-      const validation = validateInput(analyzeSymbolsSchema, args);
-      if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
-      }
-      const input = validation.data;
-      const files = input.files;
-      const references = input.references;
-      const checkSymbols = input.check_symbols;
-      const referenceMap = /* @__PURE__ */ new Map();
-      if (references) {
-        for (const ref of references) {
-          const key = `${ref.file}:${ref.symbol}`;
-          referenceMap.set(key, ref);
-        }
-      }
-      const allSymbols = [];
-      for (const fileInput of files) {
-        const flattened = flattenLspSymbols(fileInput.symbols, fileInput.file);
-        allSymbols.push(...flattened);
-      }
-      let symbolsToAnalyze = allSymbols;
-      if (checkSymbols && checkSymbols.length > 0) {
-        const checkSet = new Set(checkSymbols);
-        symbolsToAnalyze = allSymbols.filter((s) => checkSet.has(s.name) || checkSet.has(s.fullName));
-      }
-      const fileList = [...new Set(symbolsToAnalyze.map((s) => s.file))];
-      const symbolNames = [...new Set(symbolsToAnalyze.map((s) => s.name))];
-      const symbolConflicts = await querySymbolConflicts(db, fileList, symbolNames, input.session_id);
-      const fileConflicts = await queryFileConflicts(db, fileList, input.session_id);
-      const analyzedSymbols = [];
-      const safeSymbols = [];
-      const blockedSymbols = [];
-      for (const sym of symbolsToAnalyze) {
-        const fileConflict = fileConflicts.find((c) => c.file_path === sym.file);
-        const symbolConflict = symbolConflicts.find(
-          (c) => c.file_path === sym.file && c.symbol_name === sym.name
-        );
-        const conflict = fileConflict ?? symbolConflict;
-        const isBlocked = !!conflict;
-        const refKey = `${sym.file}:${sym.name}`;
-        const refData = referenceMap.get(refKey);
-        let impact;
-        if (refData && refData.references.length > 0) {
-          const affectedFiles = [...new Set(refData.references.map((r) => r.file))];
-          impact = {
-            references_count: refData.references.length,
-            affected_files: affectedFiles
-          };
-        }
-        const analyzed = {
-          name: sym.name,
-          type: sym.type,
-          file: sym.file,
-          conflict_status: isBlocked ? "blocked" : "safe",
-          ...conflict && {
-            conflict_info: {
-              session_name: conflict.session_name,
-              intent: conflict.intent,
-              claim_id: conflict.claim_id
-            }
-          },
-          ...impact && { impact }
-        };
-        analyzedSymbols.push(analyzed);
-        if (isBlocked) {
-          blockedSymbols.push(`${sym.file}:${sym.name}`);
-        } else {
-          safeSymbols.push(`${sym.file}:${sym.name}`);
-        }
-      }
-      const hasBlocked = blockedSymbols.length > 0;
-      const hasSafe = safeSymbols.length > 0;
-      let recommendation;
-      if (!hasBlocked) {
-        recommendation = "proceed_all";
-      } else if (hasSafe) {
-        recommendation = "proceed_safe_only";
-      } else {
-        recommendation = "abort";
-      }
-      let message;
-      if (recommendation === "proceed_all") {
-        message = `All ${safeSymbols.length} symbols are safe to edit. Proceed.`;
-      } else if (recommendation === "proceed_safe_only") {
-        message = `Edit ONLY ${safeSymbols.length} safe symbols. ${blockedSymbols.length} symbols are blocked.`;
-      } else {
-        message = `All ${blockedSymbols.length} symbols are blocked. Coordinate with other sessions.`;
-      }
-      return createToolResult(
-        JSON.stringify(
-          {
-            can_edit: hasSafe,
-            recommendation,
-            summary: {
-              total: symbolsToAnalyze.length,
-              safe: safeSymbols.length,
-              blocked: blockedSymbols.length
-            },
-            symbols: analyzedSymbols,
-            safe_symbols: safeSymbols,
-            blocked_symbols: blockedSymbols,
-            message
-          },
-          null,
-          2
-        )
-      );
-    }
-    case "collab_validate_symbols": {
-      const validation = validateInput(validateSymbolsSchema, args);
-      if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
-      }
-      const input = validation.data;
-      const availableSymbols = /* @__PURE__ */ new Set();
-      for (const lspSym of input.lsp_symbols) {
-        availableSymbols.add(lspSym.name);
-      }
-      const valid = [];
-      const invalid = [];
-      const suggestions = {};
-      for (const sym of input.symbols) {
-        if (availableSymbols.has(sym)) {
-          valid.push(sym);
-        } else {
-          invalid.push(sym);
-          const similar = Array.from(availableSymbols).filter(
-            (avail) => avail.toLowerCase().includes(sym.toLowerCase()) || sym.toLowerCase().includes(avail.toLowerCase())
-          );
-          if (similar.length > 0) {
-            suggestions[sym] = similar.slice(0, 3);
-          }
-        }
-      }
-      const allValid = invalid.length === 0;
-      return createToolResult(
-        JSON.stringify({
-          valid: allValid,
-          file: input.file,
-          valid_symbols: valid,
-          invalid_symbols: invalid,
-          suggestions: Object.keys(suggestions).length > 0 ? suggestions : void 0,
-          available_symbols: Array.from(availableSymbols),
-          message: allValid ? `All ${valid.length} symbols are valid.` : `${invalid.length} symbol(s) not found: ${invalid.join(", ")}`
-        })
-      );
-    }
-    case "collab_store_references": {
-      const validation = validateInput(storeReferencesSchema, args);
-      if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
-      }
-      const input = validation.data;
-      let cleared = 0;
-      if (input.clear_existing) {
-        cleared = await clearSessionReferences(db, input.session_id);
-      }
-      const result = await storeReferences(db, input.session_id, input.references);
-      return createToolResult(
-        JSON.stringify({
-          success: true,
-          stored: result.stored,
-          skipped: result.skipped,
-          cleared,
-          message: `Stored ${result.stored} references${cleared > 0 ? ` (cleared ${cleared} existing)` : ""}.`
-        })
-      );
-    }
-    case "collab_impact_analysis": {
-      const validation = validateInput(impactAnalysisSchema, args);
-      if (!validation.success) {
-        return createToolResult(
-          JSON.stringify({ error: "INVALID_INPUT", message: validation.error }),
-          true
-        );
-      }
-      const input = validation.data;
-      const impact = await analyzeClaimImpact(db, input.file, input.symbol, input.session_id);
-      let riskLevel;
-      if (impact.affected_claims.length > 0) {
-        riskLevel = "high";
-      } else if (impact.reference_count > 10) {
-        riskLevel = "medium";
-      } else {
-        riskLevel = "low";
-      }
-      let message;
-      if (impact.affected_claims.length > 0) {
-        const claimNames = impact.affected_claims.map((c) => c.session_name ?? "unknown").join(", ");
-        message = `\u26A0\uFE0F HIGH RISK: ${impact.affected_claims.length} active claim(s) on referencing files (${claimNames}). Coordinate before modifying.`;
-      } else if (impact.reference_count > 0) {
-        message = `${impact.reference_count} references across ${impact.affected_files.length} file(s). No active claims conflict.`;
-      } else {
-        message = "No stored references found. Consider running LSP.findReferences and collab_store_references first.";
-      }
-      return createToolResult(
-        JSON.stringify(
-          {
-            symbol: impact.symbol,
-            file: impact.file,
-            risk_level: riskLevel,
-            reference_count: impact.reference_count,
-            affected_files: impact.affected_files,
-            affected_claims: impact.affected_claims,
-            message
-          },
-          null,
-          2
-        )
-      );
-    }
-    default:
-      return createToolResult(`Unknown LSP tool: ${name}`, true);
-  }
-}
-async function querySymbolConflicts(db, files, symbolNames, excludeSessionId) {
-  if (files.length === 0 || symbolNames.length === 0) {
-    return [];
-  }
-  const filePlaceholders = files.map(() => "?").join(",");
-  const symbolPlaceholders = symbolNames.map(() => "?").join(",");
-  const query = `
-    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 c.session_id != ?
-      AND cs.file_path IN (${filePlaceholders})
-      AND cs.symbol_name IN (${symbolPlaceholders})
-  `;
-  const result = await db.prepare(query).bind(excludeSessionId, ...files, ...symbolNames).all();
-  return result.results.map((r) => ({
-    ...r,
-    conflict_level: "symbol"
-  }));
-}
-async function queryFileConflicts(db, files, excludeSessionId) {
-  if (files.length === 0) {
-    return [];
-  }
-  const placeholders = files.map(() => "?").join(",");
-  const query = `
-    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 c.session_id != ?
-      AND cf.file_path IN (${placeholders})
-      AND NOT EXISTS (
-        SELECT 1 FROM claim_symbols cs WHERE cs.claim_id = c.id AND cs.file_path = cf.file_path
-      )
-  `;
-  const result = await db.prepare(query).bind(excludeSessionId, ...files).all();
-  return result.results.map((r) => ({
-    ...r,
-    conflict_level: "file"
-  }));
-}
-
-// src/mcp/tools/history.ts
-var historyTools = [
-  {
-    name: "collab_history_list",
-    description: "List audit history entries. Useful for debugging coordination issues and understanding past actions.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Filter by session ID"
-        },
-        action: {
-          type: "string",
-          enum: [
-            "session_started",
-            "session_ended",
-            "claim_created",
-            "claim_released",
-            "conflict_detected",
-            "queue_joined",
-            "queue_left",
-            "priority_changed"
-          ],
-          description: "Filter by action type"
-        },
-        entity_type: {
-          type: "string",
-          enum: ["session", "claim", "queue"],
-          description: "Filter by entity type"
-        },
-        entity_id: {
-          type: "string",
-          description: "Filter by specific entity ID"
-        },
-        from_date: {
-          type: "string",
-          description: "Start date (ISO 8601 format)"
-        },
-        to_date: {
-          type: "string",
-          description: "End date (ISO 8601 format)"
-        },
-        limit: {
-          type: "number",
-          description: "Maximum entries to return (default: 50, max: 500)"
-        }
-      }
-    }
-  }
-];
-async function handleHistoryTool(db, name, args) {
-  switch (name) {
-    case "collab_history_list": {
-      const validation = validateInput(historyListSchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
-      }
-      const { session_id, action, entity_type, entity_id, from_date, to_date, limit } = validation.data;
-      await cleanupOldAuditHistory(db, 7);
-      const entries = await listAuditHistory(db, {
-        session_id,
-        action,
-        entity_type,
-        entity_id,
-        from_date,
-        to_date,
-        limit
-      });
-      return successResponse({
-        entries: entries.map((e) => ({
-          id: e.id,
-          session_id: e.session_id,
-          session_name: e.session_name,
-          action: e.action,
-          entity_type: e.entity_type,
-          entity_id: e.entity_id,
-          metadata: e.metadata ? JSON.parse(e.metadata) : null,
-          created_at: e.created_at
-        })),
-        total: entries.length,
-        message: entries.length > 0 ? `Found ${entries.length} audit entries` : "No audit entries found matching the criteria"
-      }, true);
-    }
-    default:
-      return successResponse({ error: `Unknown history tool: ${name}` });
-  }
-}
-
-// src/mcp/tools/queue.ts
-var queueTools = [
-  {
-    name: "collab_queue_join",
-    description: "Join waiting queue for a blocked claim. Use this when you want to work on files that are currently claimed by another session.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        claim_id: {
-          type: "string",
-          description: "The claim ID you want to wait for"
-        },
-        intent: {
-          type: "string",
-          description: "What you plan to do when the claim becomes available"
-        },
-        priority: {
-          type: "number",
-          description: "Priority (0-100). Higher priority entries are served first. Default: 50"
-        },
-        scope: {
-          type: "string",
-          enum: ["small", "medium", "large"],
-          description: "Estimated scope of your work: small(<30min), medium(30min-2hr), large(>2hr)"
-        }
-      },
-      required: ["session_id", "claim_id", "intent"]
-    }
-  },
-  {
-    name: "collab_queue_leave",
-    description: "Leave the waiting queue for a claim.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        queue_id: {
-          type: "string",
-          description: "Queue entry ID to leave"
-        }
-      },
-      required: ["session_id", "queue_id"]
-    }
-  },
-  {
-    name: "collab_queue_list",
-    description: "List queue entries. View who is waiting for claims.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        claim_id: {
-          type: "string",
-          description: "Filter by claim ID to see who is waiting for a specific claim"
-        },
-        session_id: {
-          type: "string",
-          description: "Filter by session ID to see what claims a session is waiting for"
-        }
-      }
-    }
-  }
-];
-async function handleQueueTool(db, name, args) {
-  switch (name) {
-    case "collab_queue_join": {
-      const validation = validateInput(queueJoinSchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
-      }
-      const { session_id: sessionId, claim_id: claimId, intent, priority, scope } = validation.data;
-      const sessionResult = await validateActiveSession(db, sessionId);
-      if (!sessionResult.valid) {
-        return sessionResult.error;
-      }
-      const claim = await getClaim(db, claimId);
-      if (!claim) {
-        return errorResponse(ERROR_CODES.CLAIM_NOT_FOUND, "Claim not found");
-      }
-      if (claim.session_id === sessionId) {
-        return errorResponse(
-          ERROR_CODES.CANNOT_QUEUE_OWN_CLAIM,
-          "You cannot queue for your own claim"
-        );
-      }
-      if (claim.status !== "active") {
-        return successResponse({
-          message: `Claim is already ${claim.status}. No need to queue - you can claim these files now.`,
-          claim_status: claim.status,
-          files: claim.files
-        });
-      }
-      const existingQueue = await listQueue(db, { claim_id: claimId, session_id: sessionId });
-      if (existingQueue.length > 0) {
-        return errorResponse(
-          ERROR_CODES.ALREADY_IN_QUEUE,
-          "You are already in the queue for this claim"
-        );
-      }
-      const entry = await joinQueue(db, {
-        claim_id: claimId,
-        session_id: sessionId,
-        intent,
-        priority,
-        scope
-      });
-      await logAuditEvent(db, {
-        session_id: sessionId,
-        action: "queue_joined",
-        entity_type: "queue",
-        entity_id: entry.id,
-        metadata: {
-          claim_id: claimId,
-          position: entry.position,
-          priority: entry.priority
-        }
-      });
-      const priorityInfo = getPriorityLevel(entry.priority);
-      return successResponse({
-        queue_id: entry.id,
-        position: entry.position,
-        priority: priorityInfo,
-        estimated_wait_minutes: entry.estimated_wait_minutes,
-        message: `Joined queue at position ${entry.position}. Estimated wait: ${entry.estimated_wait_minutes} minutes.`,
-        claim_owner: claim.session_name,
-        claim_intent: claim.intent,
-        files: claim.files
-      });
-    }
-    case "collab_queue_leave": {
-      const validation = validateInput(queueLeaveSchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
-      }
-      const { session_id: sessionId, queue_id: queueId } = validation.data;
-      const sessionResult = await validateActiveSession(db, sessionId);
-      if (!sessionResult.valid) {
-        return sessionResult.error;
-      }
-      const entry = await getQueueEntry(db, queueId);
-      if (!entry) {
-        return errorResponse(
-          ERROR_CODES.QUEUE_ENTRY_NOT_FOUND,
-          "Queue entry not found"
-        );
-      }
-      if (entry.session_id !== sessionId) {
-        return errorResponse(
-          ERROR_CODES.NOT_OWNER,
-          "You can only leave your own queue entries"
-        );
-      }
-      await leaveQueue(db, queueId);
-      await logAuditEvent(db, {
-        session_id: sessionId,
-        action: "queue_left",
-        entity_type: "queue",
-        entity_id: queueId,
-        metadata: { claim_id: entry.claim_id }
-      });
-      return successResponse({
-        success: true,
-        message: "Left the queue successfully"
-      });
-    }
-    case "collab_queue_list": {
-      const validation = validateInput(queueListSchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
-      }
-      const { claim_id: claimId, session_id: sessionId } = validation.data;
-      const entries = await listQueue(db, { claim_id: claimId, session_id: sessionId });
-      return successResponse({
-        entries: entries.map((e) => ({
-          queue_id: e.id,
-          claim_id: e.claim_id,
-          session_id: e.session_id,
-          session_name: e.session_name,
-          intent: e.intent,
-          position: e.position,
-          priority: getPriorityLevel(e.priority),
-          scope: e.scope,
-          estimated_wait_minutes: e.estimated_wait_minutes,
-          claim_owner: e.claim_session_name,
-          claim_intent: e.claim_intent,
-          files: e.claim_files,
-          created_at: e.created_at
-        })),
-        total: entries.length,
-        message: entries.length > 0 ? `Found ${entries.length} queue entries` : "No queue entries found"
-      }, true);
-    }
-    default:
-      return successResponse({ error: `Unknown queue tool: ${name}` });
-  }
-}
-
-// src/mcp/tools/notification.ts
-var notificationTools = [
-  {
-    name: "collab_notifications_list",
-    description: "List notifications for your session. Check periodically for claim releases, queue updates, and messages.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        unread_only: {
-          type: "boolean",
-          description: "Only show unread notifications (default: false)"
-        },
-        type: {
-          type: "string",
-          enum: ["claim_released", "queue_ready", "conflict_detected", "session_message"],
-          description: "Filter by notification type"
-        },
-        limit: {
-          type: "number",
-          description: "Maximum notifications to return (default: 50, max: 100)"
-        }
-      },
-      required: ["session_id"]
-    }
-  },
-  {
-    name: "collab_notifications_mark_read",
-    description: "Mark notifications as read.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        notification_ids: {
-          type: "array",
-          items: { type: "string" },
-          description: "Notification IDs to mark as read"
-        }
-      },
-      required: ["session_id", "notification_ids"]
-    }
-  }
-];
-async function handleNotificationTool(db, name, args) {
-  switch (name) {
-    case "collab_notifications_list": {
-      const validation = validateInput(notificationListSchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
-      }
-      const { session_id: sessionId, unread_only, type, limit } = validation.data;
-      const sessionResult = await validateActiveSession(db, sessionId);
-      if (!sessionResult.valid) {
-        return sessionResult.error;
-      }
-      const notifications = await listNotifications(db, {
-        session_id: sessionId,
-        unread_only,
-        type,
-        limit
-      });
-      const unreadCount = notifications.filter((n) => !n.read_at).length;
-      return successResponse({
-        notifications: notifications.map((n) => ({
-          id: n.id,
-          type: n.type,
-          title: n.title,
-          message: n.message,
-          reference_type: n.reference_type,
-          reference_id: n.reference_id,
-          metadata: n.metadata ? JSON.parse(n.metadata) : null,
-          is_read: !!n.read_at,
-          created_at: n.created_at
-        })),
-        total: notifications.length,
-        unread_count: unreadCount,
-        message: notifications.length > 0 ? `${notifications.length} notification(s), ${unreadCount} unread` : "No notifications"
-      }, true);
-    }
-    case "collab_notifications_mark_read": {
-      const validation = validateInput(notificationMarkReadSchema, args);
-      if (!validation.success) {
-        return validationError(validation.error);
-      }
-      const { session_id: sessionId, notification_ids: notificationIds } = validation.data;
-      const sessionResult = await validateActiveSession(db, sessionId);
-      if (!sessionResult.valid) {
-        return sessionResult.error;
-      }
-      for (const notifId of notificationIds) {
-        const notif = await getNotification(db, notifId);
-        if (!notif) {
-          return errorResponse(
-            ERROR_CODES.NOTIFICATION_NOT_FOUND,
-            `Notification ${notifId} not found`
-          );
-        }
-        if (notif.session_id !== sessionId) {
-          return errorResponse(
-            ERROR_CODES.NOT_OWNER,
-            "You can only mark your own notifications as read"
-          );
-        }
-      }
-      const markedCount = await markNotificationsRead(db, notificationIds);
-      return successResponse({
-        success: true,
-        marked_count: markedCount,
-        message: `Marked ${markedCount} notification(s) as read`
-      });
-    }
-    default:
-      return successResponse({ error: `Unknown notification tool: ${name}` });
-  }
-}
-
-// src/mcp/tools/memory.ts
-var memoryTools = [
-  {
-    name: "collab_memory_save",
-    description: "Save important context to working memory. Use this to persist findings, decisions, state, or any critical information that should survive context compaction.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        category: {
-          type: "string",
-          enum: ["finding", "decision", "state", "todo", "important", "context"],
-          description: "Category of memory: finding (discovered facts), decision (choices made), state (current status), todo (pending work), important (critical info), context (general context)"
-        },
-        key: {
-          type: "string",
-          description: 'Unique identifier for this memory within the category (e.g., "auth_bug_root_cause")'
-        },
-        content: {
-          type: "string",
-          description: "The actual content to remember"
-        },
-        priority: {
-          type: "number",
-          description: "Priority 0-100 (default 50). Higher priority memories are more likely to be recalled."
-        },
-        pinned: {
-          type: "boolean",
-          description: "If true, this memory will always be loaded when recalling active memories."
-        },
-        expires_at: {
-          type: "string",
-          description: "Optional ISO datetime when this memory should expire (e.g., for temporary state)"
-        },
-        related_claim_id: {
-          type: "string",
-          description: "Optional claim ID this memory relates to"
-        },
-        metadata: {
-          type: "object",
-          description: "Optional additional structured data (file_path, line_number, confidence, etc.)"
-        }
-      },
-      required: ["session_id", "category", "key", "content"]
-    }
-  },
-  {
-    name: "collab_memory_recall",
-    description: "Recall memories from working memory. Use this to retrieve previously saved context, findings, or state.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        category: {
-          type: "string",
-          enum: ["finding", "decision", "state", "todo", "important", "context"],
-          description: "Filter by category (optional)"
-        },
-        key: {
-          type: "string",
-          description: "Get a specific memory by key (optional)"
-        },
-        pinned_only: {
-          type: "boolean",
-          description: "Only return pinned memories"
-        },
-        limit: {
-          type: "number",
-          description: "Maximum number of memories to return (default: all)"
-        }
-      },
-      required: ["session_id"]
-    }
-  },
-  {
-    name: "collab_memory_update",
-    description: "Update an existing memory entry. Use this to modify content, priority, or other properties.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        key: {
-          type: "string",
-          description: "The key of the memory to update"
-        },
-        content: {
-          type: "string",
-          description: "New content (optional)"
-        },
-        priority: {
-          type: "number",
-          description: "New priority 0-100 (optional)"
-        },
-        pinned: {
-          type: "boolean",
-          description: "New pinned status (optional)"
-        },
-        expires_at: {
-          type: "string",
-          description: "New expiration time, or null to remove expiration (optional)"
-        },
-        metadata: {
-          type: "object",
-          description: "New metadata (replaces existing)"
-        }
-      },
-      required: ["session_id", "key"]
-    }
-  },
-  {
-    name: "collab_memory_clear",
-    description: "Clear memories from working memory. Can clear by key, category, or all.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        key: {
-          type: "string",
-          description: "Clear a specific memory by key"
-        },
-        category: {
-          type: "string",
-          enum: ["finding", "decision", "state", "todo", "important", "context"],
-          description: "Clear all memories in a category"
-        },
-        clear_all: {
-          type: "boolean",
-          description: "Clear ALL memories for this session (use with caution)"
-        }
-      },
-      required: ["session_id"]
-    }
-  },
-  {
-    name: "collab_memory_pin",
-    description: "Pin or unpin a memory. Pinned memories are always included when loading active memories.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        key: {
-          type: "string",
-          description: "The key of the memory to pin/unpin"
-        },
-        pinned: {
-          type: "boolean",
-          description: "True to pin, false to unpin"
-        }
-      },
-      required: ["session_id", "key", "pinned"]
-    }
-  },
-  {
-    name: "collab_memory_stats",
-    description: "Get statistics about working memory usage for this session.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        }
-      },
-      required: ["session_id"]
-    }
-  },
-  {
-    name: "collab_memory_active",
-    description: "Get all active (pinned + high priority) memories. This is the main function for loading context that should be preserved.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        priority_threshold: {
-          type: "number",
-          description: "Minimum priority to include (default: 70)"
-        },
-        max_items: {
-          type: "number",
-          description: "Maximum items to return (default: 20)"
-        }
-      },
-      required: ["session_id"]
-    }
-  }
-];
-async function handleMemoryTool(db, name, args) {
-  switch (name) {
-    case "collab_memory_save":
-      return handleMemorySave(db, args);
-    case "collab_memory_recall":
-      return handleMemoryRecall(db, args);
-    case "collab_memory_update":
-      return handleMemoryUpdate(db, args);
-    case "collab_memory_clear":
-      return handleMemoryClear(db, args);
-    case "collab_memory_pin":
-      return handleMemoryPin(db, args);
-    case "collab_memory_stats":
-      return handleMemoryStats(db, args);
-    case "collab_memory_active":
-      return handleMemoryActive(db, args);
-    default:
-      return errorResponse(ERROR_CODES.UNKNOWN_TOOL, `Unknown memory tool: ${name}`);
-  }
-}
-async function handleMemorySave(db, args) {
-  const sessionId = args.session_id;
-  const category = args.category;
-  const key = args.key;
-  const content = args.content;
-  if (!sessionId || !category || !key || !content) {
-    return validationError("session_id, category, key, and content are required");
-  }
-  const sessionCheck = await validateActiveSession(db, sessionId);
-  if (!sessionCheck.valid) {
-    return sessionCheck.error;
-  }
-  const memory = await saveMemory(db, sessionId, {
-    category,
-    key,
-    content,
-    priority: args.priority ?? 50,
-    pinned: args.pinned ?? false,
-    expires_at: args.expires_at,
-    related_claim_id: args.related_claim_id,
-    related_decision_id: args.related_decision_id,
-    metadata: args.metadata
-  });
-  return successResponse({
-    saved: true,
-    memory: {
-      id: memory.id,
-      category: memory.category,
-      key: memory.key,
-      priority: memory.priority,
-      pinned: memory.pinned === 1,
-      created_at: memory.created_at,
-      updated_at: memory.updated_at
-    },
-    message: `Memory saved: ${category}/${key}`
-  });
-}
-async function handleMemoryRecall(db, args) {
-  const sessionId = args.session_id;
-  if (!sessionId) {
-    return validationError("session_id is required");
-  }
-  const sessionCheck = await validateActiveSession(db, sessionId);
-  if (!sessionCheck.valid) {
-    return sessionCheck.error;
-  }
-  const memories = await recallMemory(db, sessionId, {
-    category: args.category,
-    key: args.key,
-    pinned_only: args.pinned_only,
-    limit: args.limit
-  });
-  const formattedMemories = memories.map((m) => ({
-    category: m.category,
-    key: m.key,
-    content: m.content,
-    priority: m.priority,
-    pinned: m.pinned === 1,
-    created_at: m.created_at,
-    updated_at: m.updated_at,
-    expires_at: m.expires_at,
-    metadata: m.metadata ? JSON.parse(m.metadata) : null
-  }));
-  return successResponse({
-    count: formattedMemories.length,
-    memories: formattedMemories
-  });
-}
-async function handleMemoryUpdate(db, args) {
-  const sessionId = args.session_id;
-  const key = args.key;
-  if (!sessionId || !key) {
-    return validationError("session_id and key are required");
-  }
-  const sessionCheck = await validateActiveSession(db, sessionId);
-  if (!sessionCheck.valid) {
-    return sessionCheck.error;
-  }
-  const updates = {};
-  if (args.content !== void 0) updates.content = args.content;
-  if (args.priority !== void 0) updates.priority = args.priority;
-  if (args.pinned !== void 0) updates.pinned = args.pinned;
-  if (args.expires_at !== void 0) updates.expires_at = args.expires_at;
-  if (args.metadata !== void 0) updates.metadata = args.metadata;
-  if (Object.keys(updates).length === 0) {
-    return validationError("At least one field to update is required");
-  }
-  const updated = await updateMemory(db, sessionId, key, updates);
-  if (!updated) {
-    return errorResponse(ERROR_CODES.MEMORY_NOT_FOUND, `Memory not found: ${key}`);
-  }
-  return successResponse({
-    updated: true,
-    key,
-    message: `Memory updated: ${key}`
-  });
-}
-async function handleMemoryClear(db, args) {
-  const sessionId = args.session_id;
-  if (!sessionId) {
-    return validationError("session_id is required");
-  }
-  const sessionCheck = await validateActiveSession(db, sessionId);
-  if (!sessionCheck.valid) {
-    return sessionCheck.error;
-  }
-  const key = args.key;
-  const category = args.category;
-  const clearAll = args.clear_all;
-  if (!key && !category && !clearAll) {
-    return validationError("One of key, category, or clear_all is required");
-  }
-  const cleared = await clearMemory(db, sessionId, {
-    key,
-    category,
-    clear_all: clearAll
-  });
-  let message;
-  if (key) {
-    message = cleared > 0 ? `Memory cleared: ${key}` : `Memory not found: ${key}`;
-  } else if (category) {
-    message = `Cleared ${cleared} memories from category: ${category}`;
-  } else {
-    message = `Cleared all ${cleared} memories`;
-  }
-  return successResponse({
-    cleared,
-    message
-  });
-}
-async function handleMemoryPin(db, args) {
-  const sessionId = args.session_id;
-  const key = args.key;
-  const pinned = args.pinned;
-  if (!sessionId || !key || pinned === void 0) {
-    return validationError("session_id, key, and pinned are required");
-  }
-  const sessionCheck = await validateActiveSession(db, sessionId);
-  if (!sessionCheck.valid) {
-    return sessionCheck.error;
-  }
-  const updated = await pinMemory(db, sessionId, key, pinned);
-  if (!updated) {
-    return errorResponse(ERROR_CODES.MEMORY_NOT_FOUND, `Memory not found: ${key}`);
-  }
-  return successResponse({
-    updated: true,
-    key,
-    pinned,
-    message: pinned ? `Memory pinned: ${key}` : `Memory unpinned: ${key}`
-  });
-}
-async function handleMemoryStats(db, args) {
-  const sessionId = args.session_id;
-  if (!sessionId) {
-    return validationError("session_id is required");
-  }
-  const sessionCheck = await validateActiveSession(db, sessionId);
-  if (!sessionCheck.valid) {
-    return sessionCheck.error;
-  }
-  const stats = await getMemoryStats(db, sessionId);
-  return successResponse({
-    ...stats,
-    message: `Working memory: ${stats.total} total, ${stats.pinned_count} pinned`
-  });
-}
-async function handleMemoryActive(db, args) {
-  const sessionId = args.session_id;
-  if (!sessionId) {
-    return validationError("session_id is required");
-  }
-  const sessionCheck = await validateActiveSession(db, sessionId);
-  if (!sessionCheck.valid) {
-    return sessionCheck.error;
-  }
-  const memories = await getActiveMemories(db, sessionId, {
-    priority_threshold: args.priority_threshold,
-    max_items: args.max_items
-  });
-  const formattedMemories = memories.map((m) => ({
-    category: m.category,
-    key: m.key,
-    content: m.content,
-    priority: m.priority,
-    pinned: m.pinned === 1
-  }));
-  const byCategory = {};
-  for (const mem of formattedMemories) {
-    if (!byCategory[mem.category]) {
-      byCategory[mem.category] = [];
-    }
-    byCategory[mem.category].push({
-      key: mem.key,
-      content: mem.content,
-      priority: mem.priority,
-      pinned: mem.pinned
-    });
-  }
-  return successResponse({
-    count: formattedMemories.length,
-    by_category: byCategory,
-    memories: formattedMemories,
-    message: `Active memories: ${formattedMemories.length} items (pinned + priority >= threshold)`
-  });
-}
-
-// src/mcp/tools/protection.ts
-var protectionTools = [
-  {
-    name: "collab_plan_register",
-    description: "Register a plan document for protection. Plans are automatically pinned with high priority to prevent context loss.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        file_path: {
-          type: "string",
-          description: "Path to the plan file"
-        },
-        title: {
-          type: "string",
-          description: "Title of the plan"
-        },
-        content_summary: {
-          type: "string",
-          description: "Summary of the plan content (key points, steps)"
-        },
-        status: {
-          type: "string",
-          enum: ["draft", "approved", "in_progress"],
-          description: "Initial status of the plan (default: draft)"
-        }
-      },
-      required: ["session_id", "file_path", "title", "content_summary"]
-    }
-  },
-  {
-    name: "collab_plan_update_status",
-    description: "Update plan status. Use this to progress plan through lifecycle: draft \u2192 approved \u2192 in_progress \u2192 completed \u2192 archived",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        file_path: {
-          type: "string",
-          description: "Path to the plan file"
-        },
-        status: {
-          type: "string",
-          enum: ["draft", "approved", "in_progress", "completed", "archived"],
-          description: "New status for the plan"
-        },
-        summary: {
-          type: "string",
-          description: "Optional updated summary (for completed plans, describe what was achieved)"
-        }
-      },
-      required: ["session_id", "file_path", "status"]
-    }
-  },
-  {
-    name: "collab_plan_get",
-    description: "Get plan information by file path.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        file_path: {
-          type: "string",
-          description: "Path to the plan file"
-        }
-      },
-      required: ["session_id", "file_path"]
-    }
-  },
-  {
-    name: "collab_plan_list",
-    description: "List all plans for this session.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        status: {
-          type: "string",
-          enum: ["draft", "approved", "in_progress", "completed", "archived"],
-          description: "Filter by status"
-        },
-        include_archived: {
-          type: "boolean",
-          description: "Include archived plans (default: false)"
-        }
-      },
-      required: ["session_id"]
-    }
-  },
-  {
-    name: "collab_file_register",
-    description: "Register a file created in this session for protection. Protected files will trigger warnings before deletion.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        file_path: {
-          type: "string",
-          description: "Path to the created file"
-        },
-        file_type: {
-          type: "string",
-          enum: ["plan", "code", "config", "doc", "other"],
-          description: "Type of file (default: other)"
-        },
-        description: {
-          type: "string",
-          description: "Brief description of the file purpose"
-        }
-      },
-      required: ["session_id", "file_path"]
-    }
-  },
-  {
-    name: "collab_file_list_created",
-    description: "List all files created in this session.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        }
-      },
-      required: ["session_id"]
-    }
-  },
-  {
-    name: "collab_file_check_protected",
-    description: "Check if a file is protected. Use this before deleting or overwriting files to prevent accidental loss.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        },
-        file_path: {
-          type: "string",
-          description: "Path to check"
-        }
-      },
-      required: ["session_id", "file_path"]
-    }
-  },
-  {
-    name: "collab_file_list_protected",
-    description: "List all protected files in this session (plans + created files).",
-    inputSchema: {
-      type: "object",
-      properties: {
-        session_id: {
-          type: "string",
-          description: "Your session ID"
-        }
-      },
-      required: ["session_id"]
-    }
-  }
-];
-async function handleProtectionTool(db, name, args) {
-  switch (name) {
-    case "collab_plan_register":
-      return handlePlanRegister(db, args);
-    case "collab_plan_update_status":
-      return handlePlanUpdateStatus(db, args);
-    case "collab_plan_get":
-      return handlePlanGet(db, args);
-    case "collab_plan_list":
-      return handlePlanList(db, args);
-    case "collab_file_register":
-      return handleFileRegister(db, args);
-    case "collab_file_list_created":
-      return handleFileListCreated(db, args);
-    case "collab_file_check_protected":
-      return handleFileCheckProtected(db, args);
-    case "collab_file_list_protected":
-      return handleFileListProtected(db, args);
-    default:
-      return errorResponse(ERROR_CODES.UNKNOWN_TOOL, `Unknown protection tool: ${name}`);
-  }
-}
-async function handlePlanRegister(db, args) {
-  const sessionId = args.session_id;
-  const filePath = args.file_path;
-  const title = args.title;
-  const contentSummary = args.content_summary;
-  const status = args.status ?? "draft";
-  if (!sessionId || !filePath || !title || !contentSummary) {
-    return validationError("session_id, file_path, title, and content_summary are required");
-  }
-  const sessionCheck = await validateActiveSession(db, sessionId);
-  if (!sessionCheck.valid) {
-    return sessionCheck.error;
-  }
-  const memory = await registerPlan(db, sessionId, {
-    file_path: filePath,
-    title,
-    content_summary: contentSummary,
-    status
-  });
-  return successResponse({
-    registered: true,
-    plan: {
-      file_path: filePath,
-      title,
-      status,
-      priority: memory.priority,
-      pinned: memory.pinned === 1
-    },
-    message: `Plan registered and protected: ${title}`
-  });
-}
-async function handlePlanUpdateStatus(db, args) {
-  const sessionId = args.session_id;
-  const filePath = args.file_path;
-  const status = args.status;
-  const summary = args.summary;
-  if (!sessionId || !filePath || !status) {
-    return validationError("session_id, file_path, and status are required");
-  }
-  const sessionCheck = await validateActiveSession(db, sessionId);
-  if (!sessionCheck.valid) {
-    return sessionCheck.error;
-  }
-  const updated = await updatePlanStatus(db, sessionId, filePath, status, summary);
-  if (!updated) {
-    return errorResponse(ERROR_CODES.MEMORY_NOT_FOUND, `Plan not found: ${filePath}`);
-  }
-  let message = `Plan status updated to: ${status}`;
-  if (status === "completed") {
-    message += ". Plan protection reduced (unpinned, lower priority).";
-  } else if (status === "archived") {
-    message += ". Plan archived and will be excluded from active memory.";
-  }
-  return successResponse({
-    updated: true,
-    file_path: filePath,
-    new_status: status,
-    message
-  });
-}
-async function handlePlanGet(db, args) {
-  const sessionId = args.session_id;
-  const filePath = args.file_path;
-  if (!sessionId || !filePath) {
-    return validationError("session_id and file_path are required");
-  }
-  const sessionCheck = await validateActiveSession(db, sessionId);
-  if (!sessionCheck.valid) {
-    return sessionCheck.error;
-  }
-  const plan = await getPlan(db, sessionId, filePath);
-  if (!plan) {
-    return successResponse({
-      found: false,
-      message: `No plan found for: ${filePath}`
-    });
-  }
-  return successResponse({
-    found: true,
-    plan
-  });
-}
-async function handlePlanList(db, args) {
-  const sessionId = args.session_id;
-  const status = args.status;
-  const includeArchived = args.include_archived;
-  if (!sessionId) {
-    return validationError("session_id is required");
-  }
-  const sessionCheck = await validateActiveSession(db, sessionId);
-  if (!sessionCheck.valid) {
-    return sessionCheck.error;
-  }
-  const plans = await listPlans(db, sessionId, { status, include_archived: includeArchived });
-  return successResponse({
-    count: plans.length,
-    plans
-  });
-}
-async function handleFileRegister(db, args) {
-  const sessionId = args.session_id;
-  const filePath = args.file_path;
-  const fileType = args.file_type;
-  const description = args.description;
-  if (!sessionId || !filePath) {
-    return validationError("session_id and file_path are required");
-  }
-  const sessionCheck = await validateActiveSession(db, sessionId);
-  if (!sessionCheck.valid) {
-    return sessionCheck.error;
-  }
-  const memory = await registerCreatedFile(db, sessionId, {
-    file_path: filePath,
-    file_type: fileType,
-    description
-  });
-  return successResponse({
-    registered: true,
-    file: {
-      file_path: filePath,
-      file_type: fileType ?? "other",
-      priority: memory.priority,
-      pinned: memory.pinned === 1
-    },
-    message: `File registered for protection: ${filePath}`
-  });
-}
-async function handleFileListCreated(db, args) {
-  const sessionId = args.session_id;
-  if (!sessionId) {
-    return validationError("session_id is required");
-  }
-  const sessionCheck = await validateActiveSession(db, sessionId);
-  if (!sessionCheck.valid) {
-    return sessionCheck.error;
-  }
-  const files = await getCreatedFiles(db, sessionId);
-  return successResponse({
-    count: files.length,
-    files
-  });
-}
-async function handleFileCheckProtected(db, args) {
-  const sessionId = args.session_id;
-  const filePath = args.file_path;
-  if (!sessionId || !filePath) {
-    return validationError("session_id and file_path are required");
-  }
-  const sessionCheck = await validateActiveSession(db, sessionId);
-  if (!sessionCheck.valid) {
-    return sessionCheck.error;
-  }
-  const result = await isFileProtected(db, sessionId, filePath);
-  if (result.protected) {
-    return successResponse({
-      protected: true,
-      reason: result.reason,
-      details: result.details,
-      warning: `\u26A0\uFE0F This file is protected (${result.reason}). Confirm before deleting or overwriting.`
-    });
-  }
-  return successResponse({
-    protected: false,
-    message: "File is not protected."
-  });
-}
-async function handleFileListProtected(db, args) {
-  const sessionId = args.session_id;
-  if (!sessionId) {
-    return validationError("session_id is required");
-  }
-  const sessionCheck = await validateActiveSession(db, sessionId);
-  if (!sessionCheck.valid) {
-    return sessionCheck.error;
-  }
-  const files = await getProtectedFiles(db, sessionId);
-  return successResponse({
-    count: files.length,
-    files,
-    message: files.length > 0 ? `${files.length} protected file(s). Check before deleting.` : "No protected files."
-  });
-}
-
-// src/constants.ts
-import { readFileSync } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
-import { fileURLToPath } from "url";
-function getVersion() {
-  try {
-    const __dirname3 = dirname2(fileURLToPath(import.meta.url));
-    const pkg = JSON.parse(readFileSync(join2(__dirname3, "..", "package.json"), "utf-8"));
-    return pkg.version;
-  } catch {
-    return "0.0.0";
-  }
-}
-var VERSION = getVersion();
-var SERVER_NAME = "session-collab-mcp";
-var SERVER_INSTRUCTIONS = `
-# Session Collaboration
-
-This MCP server coordinates multiple Claude Code sessions working on the same codebase.
-
-## Required Behaviors
-
-1. **On conversation start**: Immediately call \`collab_session_start\` with:
-   - project_root: Current working directory
-   - name: Descriptive session name (e.g., "feature-auth", "bugfix-api")
-
-2. **Before editing any file**: Call \`collab_check\` with the file path to verify no conflicts
-
-3. **Follow the \`recommendation\` from collab_check automatically**:
-   - \`proceed_all\`: All files/symbols safe. Edit them without asking user.
-   - \`proceed_safe_only\`: Some content blocked. Edit ONLY safe files/symbols, skip blocked. No need to ask user.
-   - \`abort\`: All content blocked. Inform user and suggest coordination.
-
-4. **For significant changes**: Call \`collab_claim\` before starting work
-
-5. **When done**: Call \`collab_release\` with YOUR session_id to free them
-   - Or use \`collab_auto_release\` after Edit/Write to release individual files
-
-6. **On conversation end**: Call \`collab_session_end\` to clean up
-
-## Auto-Release (NEW in 0.7.1)
-
-Automatically release claims after editing:
-
-### Immediate Release
-After Edit/Write, call \`collab_auto_release\` with:
-- \`session_id\`: Your session ID
-- \`file_path\`: The file you just edited
-- \`force\`: (optional) Force release for medium/large scope claims
-
-**Behavior by scope:**
-- \`small\`: Auto-releases immediately
-- \`medium/large\`: Requires \`force=true\` or \`auto_release_immediate\` config
-
-### Stale Claim Cleanup
-Claims are automatically cleaned up when:
-- Session has \`auto_release_stale: true\` in config
-- Claim exceeds \`stale_threshold_hours\` (default: 2 hours)
-
-### Configuration
-Use \`collab_config\` to enable auto-release:
-\`\`\`json
-{
-  "session_id": "...",
-  "auto_release_immediate": true,
-  "auto_release_stale": true,
-  "stale_threshold_hours": 2,
-  "auto_release_delay_minutes": 5
-}
-\`\`\`
-
-## Symbol-Level Claims (Fine-Grained)
-
-Use symbol-level claims when modifying specific functions/classes, allowing other sessions to work on different parts of the same file.
-
-**Claim specific symbols:**
-\`\`\`json
-{
-  "symbols": [
-    { "file": "src/auth.ts", "symbols": ["validateToken", "refreshToken"] }
-  ],
-  "intent": "Refactoring token validation"
-}
-\`\`\`
-
-**Check specific symbols:**
-\`\`\`json
-{
-  "files": ["src/auth.ts"],
-  "symbols": [
-    { "file": "src/auth.ts", "symbols": ["validateToken"] }
-  ]
-}
-\`\`\`
-
-**Conflict levels:**
-- \`file\`: Whole file is claimed (no symbols specified)
-- \`symbol\`: Only specific functions/classes are claimed
-
-**Example scenario:**
-- Session A claims \`validateToken\` in auth.ts
-- Session B wants to modify \`refreshToken\` in auth.ts
-- \u2192 No conflict! Session B can proceed.
-
-## Auto-Decision Rules
-
-When \`collab_check\` returns:
-- \`can_edit: true\` \u2192 Proceed with safe content automatically
-- \`can_edit: false\` \u2192 Stop and inform user about blocked content
-
-For symbol-level checks, use \`symbol_status.safe\` and \`symbol_status.blocked\`.
-
-## Permission Rules
-
-- You can ONLY release claims that belong to YOUR session
-- To release another session's claim, you must ask the user and they must explicitly confirm
-- Use \`force=true\` in \`collab_release\` only after user explicitly confirms
-
-## Conflict Handling Modes
-
-Configure your session behavior with \`collab_config\`:
-
-- **"strict"**: Always ask user, never bypass or auto-release
-- **"smart"** (default): Auto-proceed with safe content, ask for blocked
-- **"bypass"**: Proceed despite conflicts (just warn, don't block)
-
-## LSP Integration (Advanced)
-
-For precise symbol validation and impact analysis, use LSP tools:
-
-### Workflow with LSP
-
-1. **Get symbols from LSP**: Use \`LSP.documentSymbol\` to get actual symbols in a file
-2. **Validate before claiming**: Use \`collab_validate_symbols\` to verify symbol names
-3. **Analyze conflicts with context**: Use \`collab_analyze_symbols\` for enhanced conflict detection
-
-### collab_validate_symbols
-
-Validate symbol names exist before claiming:
-
-\`\`\`
-1. Claude: LSP.documentSymbol("src/auth.ts")
-2. Claude: collab_validate_symbols({
-     file: "src/auth.ts",
-     symbols: ["validateToken", "refreshTokne"],  // typo!
-     lsp_symbols: [/* LSP output */]
-   })
-3. Response: { invalid_symbols: ["refreshTokne"], suggestions: { "refreshTokne": ["refreshToken"] } }
-\`\`\`
-
-### collab_analyze_symbols
-
-Enhanced conflict detection with LSP data:
-
-\`\`\`
-1. Claude: LSP.documentSymbol("src/auth.ts")
-2. Claude: LSP.findReferences("validateToken")
-3. Claude: collab_analyze_symbols({
-     session_id: "...",
-     files: [{ file: "src/auth.ts", symbols: [/* LSP symbols */] }],
-     references: [{ symbol: "validateToken", file: "src/auth.ts", references: [...] }]
-   })
-4. Response: {
-     can_edit: true,
-     recommendation: "proceed_safe_only",
-     symbols: [
-       { name: "validateToken", conflict_status: "blocked", impact: { references_count: 5, affected_files: [...] } },
-       { name: "refreshToken", conflict_status: "safe" }
-     ]
-   }
-\`\`\`
-
-### Benefits of LSP Integration
-
-- **Accurate symbol names**: No typos in claims
-- **Impact awareness**: Know which files will be affected by changes
-- **Smart prioritization**: Focus on low-impact changes first
-
-## Reference Tracking & Impact Analysis
-
-Store and query symbol references for smart conflict detection:
-
-### collab_store_references
-
-Persist LSP reference data for future impact queries:
-
-\`\`\`
-1. Claude: LSP.findReferences("validateToken")
-2. Claude: collab_store_references({
-     session_id: "...",
-     references: [{
-       source_file: "src/auth.ts",
-       source_symbol: "validateToken",
-       references: [
-         { file: "src/api/users.ts", line: 15 },
-         { file: "src/api/orders.ts", line: 23 }
-       ]
-     }]
-   })
-\`\`\`
-
-### collab_impact_analysis
-
-Check if modifying a symbol would affect files claimed by others:
-
-\`\`\`
-Claude: collab_impact_analysis({
-  session_id: "...",
-  file: "src/auth.ts",
-  symbol: "validateToken"
-})
-
-Response: {
-  risk_level: "high",
-  reference_count: 3,
-  affected_files: ["src/api/users.ts", "src/api/orders.ts"],
-  affected_claims: [{ session_name: "other-session", intent: "..." }],
-  message: "HIGH RISK: 1 active claim on referencing files"
-}
-\`\`\`
-
-### Risk Levels
-
-- **high**: Other sessions have claims on files that reference this symbol
-- **medium**: Many references (>10) but no active claims conflict
-- **low**: Few references, no conflicts
-
-## Priority System
-
-Claims have priority levels (0-100):
-- **Critical (90-100)**: Urgent production fixes
-- **High (70-89)**: Important features
-- **Normal (40-69)**: Regular work (default: 50)
-- **Low (0-39)**: Nice-to-have changes
-
-Set priority when claiming:
-\`\`\`json
-{
-  "session_id": "...",
-  "files": ["src/critical-bug.ts"],
-  "intent": "Fix production crash",
-  "priority": 95
-}
-\`\`\`
-
-Use \`collab_claim_update_priority\` to escalate urgent work.
-
-## Claim Queue
-
-When blocked by another claim, join the waiting queue:
-
-1. **Join queue**: \`collab_queue_join\` with the blocked claim's ID
-2. **Check notifications**: \`collab_notifications_list\` for \`queue_ready\` notification
-3. **When notified**: Proceed with your work
-
-Higher priority claims are served first within the queue.
-
-Queue tools:
-- \`collab_queue_join\`: Join waiting queue for a blocked claim
-- \`collab_queue_leave\`: Leave the queue if no longer needed
-- \`collab_queue_list\`: View queue status
-
-## Notifications
-
-Check \`collab_notifications_list\` periodically for:
-- **claim_released**: Claim you waited for is now available
-- **queue_ready**: You're next in queue, proceed with your work
-- **conflict_detected**: Someone claimed files you're interested in
-- **session_message**: Direct message from another session
-
-Mark notifications as read with \`collab_notifications_mark_read\`.
-
-## Audit History
-
-Use \`collab_history_list\` to debug coordination issues:
-- Track session starts/ends
-- View claim creation/release history
-- Identify conflict patterns
-- Monitor queue activity
-
-Filter by session, action type, or date range. Entries auto-deleted after 7 days.
-
-## Working Memory (Context Persistence)
-
-Persist important context to survive Claude's automatic compaction/summarization.
-
-### When to Use
-
-- **Findings**: Important discoveries during investigation
-- **Decisions**: Choices made and their rationale
-- **State**: Current status, file paths, variable values
-- **Context**: General context that should be remembered
-
-### Save Important Context
-
-\`\`\`
-collab_memory_save({
-  session_id: "...",
-  category: "finding",
-  key: "auth_bug_root_cause",
-  content: "JWT validation skipped in middleware due to order issue",
-  priority: 80,
-  pinned: true
-})
-\`\`\`
-
-### Recall Context
-
-\`\`\`
-collab_memory_recall({
-  session_id: "...",
-  category: "finding"  // optional filter
-})
-\`\`\`
-
-### Get Active Memories
-
-Get all pinned + high-priority memories for context restoration:
-
-\`\`\`
-collab_memory_active({
-  session_id: "...",
-  priority_threshold: 70
-})
-\`\`\`
-
-### Memory Categories
-
-- **finding**: Discovered facts, root causes, patterns
-- **decision**: Architectural choices, implementation decisions
-- **state**: Current file, line number, tracking variables
-- **todo**: Pending work items, follow-ups
-- **important**: Critical information that must not be lost
-- **context**: General context for understanding
-
-### Priority Levels
-
-- **90-100**: Critical - always recall
-- **70-89**: High - recall by default
-- **50-69**: Normal - recall on demand
-- **0-49**: Low - background context
-
-### Pinned Memories
-
-Pin critical memories to ensure they are always loaded:
-
-\`\`\`
-collab_memory_pin({
-  session_id: "...",
-  key: "root_cause",
-  pinned: true
-})
-\`\`\`
-
-### Memory Tools
-
-| Tool | Purpose |
-|------|---------|
-| \`collab_memory_save\` | Save important context |
-| \`collab_memory_recall\` | Retrieve saved memories |
-| \`collab_memory_update\` | Update existing memory |
-| \`collab_memory_clear\` | Clear memories |
-| \`collab_memory_pin\` | Pin/unpin a memory |
-| \`collab_memory_stats\` | Get memory statistics |
-| \`collab_memory_active\` | Get all active memories |
-
-## Plan & File Protection
-
-Protect important files (plans, session-created files) from accidental deletion or overwriting.
-
-### Register Plans
-
-After creating a plan document, register it for protection:
-
-\`\`\`
-collab_plan_register({
-  session_id: "...",
-  file_path: "docs/implementation-plan.md",
-  title: "Auth System Refactor Plan",
-  content_summary: "1. Migrate to JWT\\n2. Add refresh tokens\\n3. Update middleware",
-  status: "approved"
-})
-\`\`\`
-
-Plans are automatically:
-- **Pinned** (always appear in active memory)
-- **High priority** (95/100)
-- **Protected** from deletion warnings
-
-### Plan Status Lifecycle
-
-\`\`\`
-draft \u2192 approved \u2192 in_progress \u2192 completed \u2192 archived
-                                     \u2193
-                              (Protection reduced)
-                              (Priority: 50 \u2192 30)
-                              (Unpinned)
-\`\`\`
-
-Update plan status as work progresses:
-
-\`\`\`
-collab_plan_update_status({
-  session_id: "...",
-  file_path: "docs/implementation-plan.md",
-  status: "completed",
-  summary: "All tasks completed. JWT auth implemented."
-})
-\`\`\`
-
-### Register Created Files
-
-Track important files created during the session:
-
-\`\`\`
-collab_file_register({
-  session_id: "...",
-  file_path: "src/auth/jwt-validator.ts",
-  file_type: "code",
-  description: "New JWT validation utility"
-})
-\`\`\`
-
-### Check Before Deleting
-
-Before deleting any file, check if it's protected:
-
-\`\`\`
-collab_file_check_protected({
-  session_id: "...",
-  file_path: "docs/implementation-plan.md"
-})
-
-// Response:
-{
-  protected: true,
-  reason: "plan",
-  warning: "\u26A0\uFE0F This file is protected (plan). Confirm before deleting."
-}
-\`\`\`
+### Memory (3 tools)
+- \`collab_memory_save\`: Save context (upsert)
+- \`collab_memory_recall\`: Recall context (use active=true for restoration)
+- \`collab_memory_clear\`: Clear memories
 
-### Protection Tools
+### Protection (1 tool)
+- \`collab_protect\`: Unified protection tool
+  - action: "register" | "check" | "list"
 
-| Tool | Purpose |
-|------|---------|
-| \`collab_plan_register\` | Register a plan for protection |
-| \`collab_plan_update_status\` | Update plan status |
-| \`collab_plan_get\` | Get plan info |
-| \`collab_plan_list\` | List all plans |
-| \`collab_file_register\` | Register created file |
-| \`collab_file_list_created\` | List created files |
-| \`collab_file_check_protected\` | Check if file is protected |
-| \`collab_file_list_protected\` | List all protected files |
+## Workflow
 
-### Why This Matters
+1. **On start**: \`collab_session_start\` with project_root
+2. **Before editing**: \`collab_claim\` action="check"
+3. **For changes**: \`collab_claim\` action="create"
+4. **Save context**: \`collab_memory_save\` for important findings
+5. **When done**: \`collab_claim\` action="release"
+6. **On end**: \`collab_session_end\`
 
-When Claude's context is compacted:
-- Important plan details may be lost
-- Session-created files might be forgotten
-- Claude might accidentally delete recently created files
+## Memory Categories
 
-With protection:
-- Plans are pinned in working memory
-- Created files are tracked
-- Deletion triggers warnings
-- Context survives summarization
+- **finding**: Discovered facts, root causes
+- **decision**: Architectural choices
+- **state**: Current tracking info
+- **important**: Critical context
+- **context**: General context
 
 ## Best Practices
 
-- **Prefer symbol-level claims** for focused changes (single function/class)
-- **Use file-level claims** for large refactors affecting many symbols
-- **Use LSP validation** when unsure about symbol names
-- **Check references** before modifying widely-used symbols
-- **Set appropriate priority** for urgent work (95+ for production fixes)
-- **Check notifications** when waiting for blocked claims
-- **Save important findings** to working memory as you discover them
-- **Pin critical context** that must survive compaction
-- Claim early, release when done
-- Use descriptive intents (e.g., "Refactoring validateToken for JWT support")
+- Save important findings to memory as you discover them
+- Use active=true in recall to restore context
+- Register plans with collab_protect for protection
+- Check files before editing to avoid conflicts
 `.trim();
 
 // src/mcp/server.ts
-var ALL_TOOLS = [...sessionTools, ...claimTools, ...messageTools, ...decisionTools, ...lspTools, ...historyTools, ...queueTools, ...notificationTools, ...memoryTools, ...protectionTools];
+var ALL_TOOLS = [...sessionTools, ...claimTools, ...memoryTools, ...protectionTools];
 function getMcpTools() {
   return ALL_TOOLS;
 }
 async function handleMcpRequest(db, name, args) {
   try {
-    if (name.startsWith("collab_session_") || name === "collab_status_update" || name === "collab_config") {
+    if (name.startsWith("collab_session_") || name === "collab_config" || name === "collab_status") {
       return await handleSessionTool(db, name, args);
-    } else if (name.startsWith("collab_claim") || name === "collab_check" || name === "collab_release" || name === "collab_auto_release") {
+    } else if (name === "collab_claim") {
       return await handleClaimTool(db, name, args);
-    } else if (name.startsWith("collab_message_")) {
-      return await handleMessageTool(db, name, args);
-    } else if (name.startsWith("collab_decision_")) {
-      return await handleDecisionTool(db, name, args);
-    } else if (name === "collab_analyze_symbols" || name === "collab_validate_symbols" || name === "collab_store_references" || name === "collab_impact_analysis") {
-      return await handleLspTool(db, name, args);
-    } else if (name === "collab_history_list") {
-      return await handleHistoryTool(db, name, args);
-    } else if (name.startsWith("collab_queue_")) {
-      return await handleQueueTool(db, name, args);
-    } else if (name.startsWith("collab_notifications_")) {
-      return await handleNotificationTool(db, name, args);
     } else if (name.startsWith("collab_memory_")) {
       return await handleMemoryTool(db, name, args);
-    } else if (name.startsWith("collab_plan_") || name.startsWith("collab_file_")) {
+    } else if (name === "collab_protect") {
       return await handleProtectionTool(db, name, args);
     } else {
       return createToolResult(`Unknown tool: ${name}`, true);