session-collab-mcp 2.3.0 → 2.3.1

package/dist/{chunk-TFGXE3EI.js → chunk-UDJMG3TR.js}

@@ -188,12 +188,20 @@ Coordinate sessions and persist context across conversations.
 
 1. **On start**: \`collab_session_start\` with project_root
 2. **Before editing**: \`collab_claim\` action="check"
-3. **For changes**: \`collab_claim\` action="create" (blocked by default if another active session conflicts)
+3. **For changes**: \`collab_claim\` action="create" (smart mode claims safe files and queues blocked files)
 4. **Save context**: \`collab_memory_save\` for important findings
 5. **While working**: \`collab_session_update\` with current_task/todos
 6. **When done**: \`collab_claim\` action="release"
 7. **On end**: \`collab_session_end\`
 
+## Conflict Handling
+
+- \`strict\`: conflicting claims are blocked; coordinate before editing.
+- \`smart\` (default): same-file work can proceed when symbol claims do not overlap; mixed requests claim safe files and create coordination requests for blocked files.
+- \`bypass\`: overlapping claims require explicit \`allow_conflicts=true\` and return a warning.
+- If a file is blocked, narrow the claim to specific symbols before retrying. Do not overwrite, revert, or delete another active session's work.
+- Check \`collab_status\` or \`collab_session_list\` for pending coordination requests.
+
 ## Memory Categories
 
 - **finding**: Discovered facts, root causes
@@ -4286,6 +4294,29 @@ function createToolResult(text, isError = false) {
   };
 }
 
+// src/db/types.ts
+function getPriorityLevel(priority) {
+  if (priority >= 90) return { value: priority, level: "critical", label: "Critical (90-100)" };
+  if (priority >= 70) return { value: priority, level: "high", label: "High (70-89)" };
+  if (priority >= 40) return { value: priority, level: "normal", label: "Normal (40-69)" };
+  return { value: priority, level: "low", label: "Low (0-39)" };
+}
+var DEFAULT_SESSION_CONFIG = {
+  mode: "smart",
+  allow_release_others: false,
+  auto_release_stale: false,
+  stale_threshold_hours: 2,
+  auto_release_immediate: false,
+  auto_release_delay_minutes: 5
+};
+var SCOPE_WAIT_MINUTES = {
+  small: 30,
+  medium: 120,
+  // 2 hours
+  large: 480
+  // 8 hours
+};
+
 // src/utils/crypto.ts
 function generateId() {
   return crypto.randomUUID();
@@ -4681,6 +4712,144 @@ 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 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 existing = await db.prepare("SELECT * FROM claim_queue WHERE claim_id = ? AND session_id = ?").bind(params.claim_id, params.session_id).first();
+  if (existing) {
+    return existing;
+  }
+  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 listQueue(db, params = {}) {
+  let query = `
+    SELECT
+      q.*,
+      s.name as session_name,
+      c.session_id as owner_session_id,
+      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 c.status = 'active'
+      AND s.status = 'active'
+      AND cs.status = 'active'
+  `;
+  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);
+  }
+  if (params.owner_session_id) {
+    query += " AND c.session_id = ?";
+    bindings.push(params.owner_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((entry) => ({
+    ...entry,
+    claim_files: entry.claim_files_concat ? entry.claim_files_concat.split("|||") : []
+  }));
+}
+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 notifyQueueOnClaimRelease(db, claimId, releasedBy, files) {
+  const queuedSessions = await listQueue(db, { claim_id: claimId });
+  let notified = 0;
+  for (const entry of queuedSessions) {
+    await createNotification(db, {
+      session_id: entry.session_id,
+      type: "queue_ready",
+      title: "Claim released",
+      message: `The claim for ${files.join(", ")} has been released. You can claim these files now.`,
+      reference_type: "claim",
+      reference_id: claimId,
+      metadata: {
+        claim_id: claimId,
+        files,
+        released_by: releasedBy,
+        queue_position: entry.position
+      }
+    });
+    notified++;
+  }
+  return notified;
+}
 async function logAuditEvent(db, params) {
   const id = generateId();
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -4953,22 +5122,6 @@ async function getProtectedFiles(db, sessionId) {
   });
 }
 
-// src/db/types.ts
-function getPriorityLevel(priority) {
-  if (priority >= 90) return { value: priority, level: "critical", label: "Critical (90-100)" };
-  if (priority >= 70) return { value: priority, level: "high", label: "High (70-89)" };
-  if (priority >= 40) return { value: priority, level: "normal", label: "Normal (40-69)" };
-  return { value: priority, level: "low", label: "Low (0-39)" };
-}
-var DEFAULT_SESSION_CONFIG = {
-  mode: "smart",
-  allow_release_others: false,
-  auto_release_stale: false,
-  stale_threshold_hours: 2,
-  auto_release_immediate: false,
-  auto_release_delay_minutes: 5
-};
-
 // 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");
@@ -5148,6 +5301,35 @@ function parseJsonField(value) {
     return null;
   }
 }
+function formatIncomingCoordination(entry) {
+  return {
+    queue_id: entry.id,
+    owner_claim_id: entry.claim_id,
+    requested_by_session_id: entry.session_id,
+    requested_by_session_name: entry.session_name,
+    intent: entry.intent,
+    files: entry.claim_files,
+    priority: getPriorityLevel(entry.priority),
+    position: entry.position,
+    estimated_wait_minutes: entry.estimated_wait_minutes,
+    created_at: entry.created_at
+  };
+}
+function formatOutgoingCoordination(entry) {
+  return {
+    queue_id: entry.id,
+    owner_claim_id: entry.claim_id,
+    owner_session_id: entry.owner_session_id,
+    owner_session_name: entry.claim_session_name,
+    owner_intent: entry.claim_intent,
+    intent: entry.intent,
+    files: entry.claim_files,
+    priority: getPriorityLevel(entry.priority),
+    position: entry.position,
+    estimated_wait_minutes: entry.estimated_wait_minutes,
+    created_at: entry.created_at
+  };
+}
 var sessionTools = [
   {
     name: "collab_session_start",
@@ -5381,6 +5563,8 @@ Decisions:
       const sessionsWithClaims = await Promise.all(
         sessions.map(async (session) => {
           const claims = await listClaims(db, { session_id: session.id, status: "active" });
+          const incomingCoordination = await listQueue(db, { owner_session_id: session.id });
+          const outgoingCoordination = await listQueue(db, { session_id: session.id });
           return {
             id: session.id,
             name: session.name,
@@ -5396,6 +5580,11 @@ Decisions:
               priority: getPriorityLevel(c.priority),
               created_at: c.created_at
             })),
+            pending_coordination: {
+              incoming: incomingCoordination.length,
+              outgoing: outgoingCoordination.length
+            },
+            coordination_requests: incomingCoordination.map(formatIncomingCoordination),
             last_heartbeat: session.last_heartbeat
           };
         })
@@ -5479,6 +5668,8 @@ Decisions:
       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 });
+      const incomingCoordination = await listQueue(db, { owner_session_id: sessionId });
+      const outgoingCoordination = await listQueue(db, { session_id: sessionId });
       return successResponse({
         session: {
           id: session.id,
@@ -5492,6 +5683,14 @@ Decisions:
         })),
         active_memories: memories.length,
         other_sessions: allSessions.filter((s) => s.id !== sessionId).length,
+        pending_coordination: {
+          incoming: incomingCoordination.length,
+          outgoing: outgoingCoordination.length
+        },
+        coordination_requests: {
+          incoming: incomingCoordination.map(formatIncomingCoordination),
+          outgoing: outgoingCoordination.map(formatOutgoingCoordination)
+        },
         message: `Session active. ${claims.length} claim(s), ${memories.length} memories.`
       });
     }
@@ -5501,11 +5700,155 @@ Decisions:
 }
 
 // src/mcp/tools/claim.ts
+function parseSessionConfig(session) {
+  if (!session.config) {
+    return DEFAULT_SESSION_CONFIG;
+  }
+  try {
+    return { ...DEFAULT_SESSION_CONFIG, ...JSON.parse(session.config) };
+  } catch {
+    return DEFAULT_SESSION_CONFIG;
+  }
+}
+function mapConflict(conflict, ownerSession) {
+  return {
+    claim_id: conflict.claim_id,
+    session_id: conflict.session_id,
+    session_name: conflict.session_name,
+    file: conflict.file_path,
+    intent: conflict.intent,
+    scope: conflict.scope,
+    created_at: conflict.created_at,
+    conflict_level: conflict.conflict_level,
+    symbol_name: conflict.symbol_name ?? null,
+    symbol_type: conflict.symbol_type ?? null,
+    current_task: ownerSession?.current_task ?? null,
+    last_heartbeat: ownerSession?.last_heartbeat ?? null
+  };
+}
+async function formatConflicts(db, conflicts) {
+  const sessions = /* @__PURE__ */ new Map();
+  for (const conflict of conflicts) {
+    if (!sessions.has(conflict.session_id)) {
+      sessions.set(conflict.session_id, await getSession(db, conflict.session_id));
+    }
+  }
+  return conflicts.map((conflict) => mapConflict(conflict, sessions.get(conflict.session_id) ?? null));
+}
+function uniqueBlockedFiles(conflicts) {
+  return Array.from(new Set(conflicts.map((conflict) => conflict.file_path)));
+}
+function filterSafeSymbols(symbols, safeFiles) {
+  if (!symbols || symbols.length === 0) {
+    return void 0;
+  }
+  const safeFileSet = new Set(safeFiles);
+  const safeSymbols = symbols.filter((symbol) => safeFileSet.has(symbol.file));
+  return safeSymbols.length > 0 ? safeSymbols : void 0;
+}
+function getCoordinationRecommendation(symbols, conflicts) {
+  const hasFileLevelConflict = conflicts.some((conflict) => conflict.conflict_level === "file");
+  if (symbols && symbols.length > 0 && hasFileLevelConflict) {
+    return "provide_symbols_or_wait";
+  }
+  return "wait_for_release_or_coordinate";
+}
+async function createTrackedClaim(db, input) {
+  const { claim } = await createClaim(db, {
+    session_id: input.session_id,
+    files: input.files,
+    symbols: input.symbols,
+    intent: input.intent,
+    scope: input.scope,
+    priority: input.priority
+  });
+  await logAuditEvent(db, {
+    session_id: input.session_id,
+    action: "claim_created",
+    entity_type: "claim",
+    entity_id: claim.id,
+    metadata: { files: input.files, intent: input.intent }
+  });
+  await saveMemory(db, input.session_id, {
+    category: "state",
+    key: `claim_${claim.id}`,
+    content: `Working on: ${input.intent}
+Files: ${input.files.join(", ")}`,
+    priority: 60,
+    related_claim_id: claim.id,
+    metadata: { claim_id: claim.id, files: input.files }
+  });
+  return claim.id;
+}
+async function createCoordinationRequests(db, input, conflicts) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const conflict of conflicts) {
+    const existing = grouped.get(conflict.claim_id);
+    if (existing) {
+      existing.files.add(conflict.file_path);
+    } else {
+      grouped.set(conflict.claim_id, {
+        conflict,
+        files: /* @__PURE__ */ new Set([conflict.file_path])
+      });
+    }
+  }
+  const requests = [];
+  for (const { conflict, files } of grouped.values()) {
+    const fileList = Array.from(files);
+    const queueEntry = await joinQueue(db, {
+      claim_id: conflict.claim_id,
+      session_id: input.session_id,
+      intent: input.intent,
+      priority: input.priority,
+      scope: input.scope
+    });
+    await logAuditEvent(db, {
+      session_id: input.session_id,
+      action: "queue_joined",
+      entity_type: "queue",
+      entity_id: queueEntry.id,
+      metadata: {
+        claim_id: conflict.claim_id,
+        files: fileList,
+        conflicting_session_id: conflict.session_id,
+        conflicting_session_name: conflict.session_name ?? void 0,
+        priority: queueEntry.priority,
+        scope: queueEntry.scope
+      }
+    });
+    await createNotification(db, {
+      session_id: conflict.session_id,
+      type: "conflict_detected",
+      title: "Coordination requested",
+      message: `Another session is waiting to coordinate work on ${fileList.join(", ")}.`,
+      reference_type: "claim",
+      reference_id: conflict.claim_id,
+      metadata: {
+        claim_id: conflict.claim_id,
+        files: fileList,
+        conflicting_session_id: input.session_id
+      }
+    });
+    requests.push({
+      queue_id: queueEntry.id,
+      owner_claim_id: conflict.claim_id,
+      owner_session_id: conflict.session_id,
+      owner_session_name: conflict.session_name,
+      requested_by_session_id: input.session_id,
+      requested_intent: input.intent,
+      files: fileList,
+      position: queueEntry.position,
+      estimated_wait_minutes: queueEntry.estimated_wait_minutes
+    });
+  }
+  return requests;
+}
 var claimTools = [
   {
     name: "collab_claim",
     description: `Unified tool for file/symbol claims. Use action parameter to:
-- "create": Declare files you're about to modify
+- "create": Declare files you're about to modify; smart mode queues blocked files for coordination
 - "check": Check if files are being worked on (ALWAYS call before editing)
 - "release": Release a claim when done
 - "list": List all active claims`,
@@ -5609,67 +5952,111 @@ async function handleClaimTool(db, name, args) {
       if (!sessionResult.valid) {
         return sessionResult.error;
       }
+      const config = parseSessionConfig(sessionResult.session);
       const symbolFiles = (input.symbols ?? []).map((symbol) => symbol.file);
       const files = Array.from(/* @__PURE__ */ new Set([...input.files ?? [], ...symbolFiles]));
       const conflicts = await checkConflicts(db, files, input.session_id, input.symbols);
-      if (conflicts.length > 0 && !input.allow_conflicts) {
+      const formattedConflicts = await formatConflicts(db, conflicts);
+      const blockedFiles = uniqueBlockedFiles(conflicts);
+      const safeFiles = files.filter((file) => !blockedFiles.includes(file));
+      const safeSymbols = filterSafeSymbols(input.symbols, safeFiles);
+      if (conflicts.length > 0 && config.mode === "strict") {
         return successResponse({
           success: false,
           status: "blocked_by_conflicts",
           files,
           symbols: input.symbols ?? [],
-          conflicts: conflicts.map((c) => ({
-            session_name: c.session_name,
-            file: c.file_path,
-            intent: c.intent
-          })),
+          claimed_files: [],
+          safe_files: safeFiles,
+          blocked_files: blockedFiles,
+          conflicts: formattedConflicts,
+          recommendation: "coordinate_before_editing",
           message: `Claim not created. ${conflicts.length} conflict(s) detected. Coordinate before proceeding.`
         });
       }
-      const { claim } = await createClaim(db, {
-        session_id: input.session_id,
-        files,
-        symbols: input.symbols,
-        intent: input.intent,
-        scope: input.scope,
-        priority: input.priority
-      });
-      await logAuditEvent(db, {
-        session_id: input.session_id,
-        action: "claim_created",
-        entity_type: "claim",
-        entity_id: claim.id,
-        metadata: { files, intent: input.intent }
-      });
-      await saveMemory(db, input.session_id, {
-        category: "state",
-        key: `claim_${claim.id}`,
-        content: `Working on: ${input.intent}
-Files: ${files.join(", ")}`,
-        priority: 60,
-        related_claim_id: claim.id,
-        metadata: { claim_id: claim.id, files }
-      });
       if (conflicts.length > 0) {
+        if (!input.allow_conflicts) {
+          const coordinationRequests = await createCoordinationRequests(db, {
+            session_id: input.session_id,
+            intent: input.intent,
+            scope: input.scope,
+            priority: input.priority
+          }, conflicts);
+          if (config.mode === "smart" && safeFiles.length > 0) {
+            const claimId3 = await createTrackedClaim(db, {
+              session_id: input.session_id,
+              files: safeFiles,
+              symbols: safeSymbols,
+              intent: input.intent,
+              scope: input.scope,
+              priority: input.priority
+            });
+            return successResponse({
+              success: true,
+              claim_id: claimId3,
+              status: "partial_claim_created",
+              files,
+              claimed_files: safeFiles,
+              safe_files: safeFiles,
+              blocked_files: blockedFiles,
+              symbols: safeSymbols ?? [],
+              conflicts: formattedConflicts,
+              coordination_requests: coordinationRequests,
+              recommendation: getCoordinationRecommendation(input.symbols, conflicts),
+              message: `Claim created for safe files only. Coordinate before editing blocked files: [${blockedFiles.join(", ")}].`
+            });
+          }
+          return successResponse({
+            success: false,
+            status: "waiting_for_coordination",
+            files,
+            claimed_files: [],
+            safe_files: [],
+            blocked_files: blockedFiles,
+            symbols: input.symbols ?? [],
+            conflicts: formattedConflicts,
+            coordination_requests: coordinationRequests,
+            recommendation: getCoordinationRecommendation(input.symbols, conflicts),
+            message: `Claim not created. Waiting for coordination on blocked files: [${blockedFiles.join(", ")}].`
+          });
+        }
+        const claimId2 = await createTrackedClaim(db, {
+          session_id: input.session_id,
+          files,
+          symbols: input.symbols,
+          intent: input.intent,
+          scope: input.scope,
+          priority: input.priority
+        });
         return successResponse({
           success: true,
-          claim_id: claim.id,
+          claim_id: claimId2,
           status: "created_with_conflicts",
           files,
+          claimed_files: files,
+          safe_files: safeFiles,
+          blocked_files: blockedFiles,
           symbols: input.symbols ?? [],
-          conflicts: conflicts.map((c) => ({
-            session_name: c.session_name,
-            file: c.file_path,
-            intent: c.intent
-          })),
+          conflicts: formattedConflicts,
           warning: `\u26A0\uFE0F ${conflicts.length} conflict(s) detected. Coordinate before proceeding.`
         });
       }
+      const claimId = await createTrackedClaim(db, {
+        session_id: input.session_id,
+        files,
+        symbols: input.symbols,
+        intent: input.intent,
+        scope: input.scope,
+        priority: input.priority
+      });
       return successResponse({
         success: true,
-        claim_id: claim.id,
+        claim_id: claimId,
         status: "created",
         files,
+        claimed_files: files,
+        safe_files: files,
+        blocked_files: [],
         symbols: input.symbols ?? [],
         intent: input.intent,
         message: "Claim created successfully."
@@ -5687,6 +6074,7 @@ Files: ${files.join(", ")}`,
       const excludeSelf = input.exclude_self ?? true;
       const excludeSessionId = excludeSelf ? input.session_id : void 0;
       const conflicts = await checkConflicts(db, input.files, excludeSessionId, input.symbols);
+      const formattedConflicts = await formatConflicts(db, conflicts);
       if (conflicts.length === 0) {
         return successResponse({
           safe: true,
@@ -5707,11 +6095,7 @@ Files: ${files.join(", ")}`,
         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
-        })),
+        conflicts: formattedConflicts,
         message: safeFiles.length > 0 ? `Edit ONLY safe files: [${safeFiles.join(", ")}]. Skip blocked files.` : "All files blocked. Coordinate with other session(s)."
       });
     }
@@ -5746,6 +6130,7 @@ Files: ${files.join(", ")}`,
       if (claim.status !== "active") {
         return errorResponse(ERROR_CODES.CLAIM_ALREADY_RELEASED, `Claim already ${claim.status}`);
       }
+      const notifications_sent = await notifyQueueOnClaimRelease(db, input.claim_id, input.session_id, claim.files);
       await releaseClaim(db, input.claim_id, {
         status,
         summary: input.summary
@@ -5762,6 +6147,7 @@ Files: ${files.join(", ")}`,
         success: true,
         claim_id: input.claim_id,
         files: claim.files,
+        notifications_sent,
         message: `Claim ${status} released. Files now available.`
       });
     }
@@ -6234,4 +6620,4 @@ export {
   getMcpTools,
   handleMcpRequest
 };
-//# sourceMappingURL=chunk-TFGXE3EI.js.map
+//# sourceMappingURL=chunk-UDJMG3TR.js.map