session-collab-mcp 2.2.0 → 2.3.1

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

@@ -161,12 +161,13 @@ var SERVER_INSTRUCTIONS = `
 
 Coordinate sessions and persist context across conversations.
 
-## 10 Core Tools
+## Core Tools
 
-### Session (5 tools)
+### Session
 - \`collab_session_start\`: Start session with project_root
 - \`collab_session_end\`: End session, release claims
-- \`collab_session_list\`: List active sessions
+- \`collab_session_list\`: List active sessions and their active claim summaries
+- \`collab_session_update\`: Update heartbeat, current task, todos, and progress
 - \`collab_config\`: Configure session behavior
 - \`collab_status\`: Get session status and summary
 
@@ -187,10 +188,19 @@ 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"
+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. **When done**: \`collab_claim\` action="release"
-6. **On end**: \`collab_session_end\`
+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
 
@@ -4284,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();
@@ -4334,6 +4367,39 @@ 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 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();
@@ -4646,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();
@@ -4918,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");
@@ -4998,7 +5186,8 @@ var claimCreateSchema = external_exports.object({
   symbols: symbolClaimsArraySchema.optional(),
   intent: external_exports.string().min(1, "intent is required"),
   scope: claimScopeSchema.optional(),
-  priority: external_exports.number().min(0).max(100).optional()
+  priority: external_exports.number().min(0).max(100).optional(),
+  allow_conflicts: external_exports.boolean().optional()
 }).refine(
   (data) => data.files && data.files.length > 0 || data.symbols && data.symbols.length > 0,
   { message: "Either files or symbols must be provided" }
@@ -5104,6 +5293,43 @@ function validationError(message) {
 }
 
 // src/mcp/tools/session.ts
+function parseJsonField(value) {
+  if (!value) return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    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",
@@ -5159,6 +5385,39 @@ var sessionTools = [
       }
     }
   },
+  {
+    name: "collab_session_update",
+    description: "Update session heartbeat, current task, todos, and progress.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: {
+          type: "string",
+          description: "Session ID to update"
+        },
+        current_task: {
+          type: "string",
+          description: "Current work summary"
+        },
+        todos: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              content: { type: "string" },
+              status: {
+                type: "string",
+                enum: ["pending", "in_progress", "completed"]
+              }
+            },
+            required: ["content", "status"]
+          },
+          description: "Current todo state for progress reporting"
+        }
+      },
+      required: ["session_id"]
+    }
+  },
   {
     name: "collab_config",
     description: "Configure session behavior.",
@@ -5304,11 +5563,28 @@ 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,
             status: session.status,
+            current_task: session.current_task,
+            progress: parseJsonField(session.progress),
+            todos: parseJsonField(session.todos),
             active_claims: claims.length,
+            claims: claims.map((c) => ({
+              id: c.id,
+              files: c.files,
+              intent: c.intent,
+              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
           };
         })
@@ -5318,6 +5594,34 @@ Decisions:
         total: sessionsWithClaims.length
       });
     }
+    case "collab_session_update": {
+      const validation = validateInput(statusUpdateSchema, 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 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");
+      }
+      const session = await getSession(db, input.session_id);
+      return successResponse({
+        success: true,
+        session_id: input.session_id,
+        current_task: session?.current_task ?? null,
+        progress: parseJsonField(session?.progress ?? null),
+        todos: parseJsonField(session?.todos ?? null),
+        last_heartbeat: session?.last_heartbeat ?? null,
+        message: "Session updated."
+      });
+    }
     case "collab_config": {
       const validation = validateInput(configSchema, args);
       if (!validation.success) {
@@ -5364,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,
@@ -5377,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.`
       });
     }
@@ -5386,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`,
@@ -5457,6 +5915,10 @@ var claimTools = [
           type: "boolean",
           description: "Force release even if not owner (for release action)"
         },
+        allow_conflicts: {
+          type: "boolean",
+          description: "Explicitly create a claim even when conflicts are detected (for create action)"
+        },
         summary: {
           type: "string",
           description: "Release summary (for release action)"
@@ -5490,53 +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 { 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 }
-      });
       const conflicts = await checkConflicts(db, files, input.session_id, input.symbols);
+      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 ?? [],
+          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.`
+        });
+      }
       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."
@@ -5554,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,
@@ -5574,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)."
       });
     }
@@ -5613,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
@@ -5629,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.`
       });
     }
@@ -6101,4 +6620,4 @@ export {
   getMcpTools,
   handleMcpRequest
 };
-//# sourceMappingURL=chunk-SOUW3JSS.js.map
+//# sourceMappingURL=chunk-UDJMG3TR.js.map