chatlab-cli 0.36.2 → 0.37.0

package/dist/{chunk-HWIXK7SU.mjs → chunk-FM3GXNEO.mjs}

@@ -28,7 +28,7 @@ import {
   getWeekdayActivity,
   queryMessages,
   searchMessagesByKeywords
-} from "./chunk-TRGR3KKJ.mjs";
+} from "./chunk-4J4MA3RC.mjs";
 
 // ../../packages/tools/src/utils/limits.ts
 function resolveMessageLimit(requestedLimit, defaultLimit, maxMessagesLimit) {
@@ -1482,6 +1482,1612 @@ var retrieveChatEvidenceTool = {
   truncationStrategy: "keep_first"
 };
 
+// ../../packages/tools/src/definitions/cross-chat-tools.ts
+var scopeItems = {
+  type: "object",
+  properties: {
+    sessionId: { type: "string", description: "Stable session ID returned by resolve_chat_entities" },
+    memberIds: { type: "array", items: { type: "number" }, description: "Local member IDs for this session" },
+    label: { type: "string", description: "Human-readable scope label" }
+  },
+  required: ["sessionId"]
+};
+var recentDaysProperty = {
+  type: "number",
+  minimum: 1,
+  description: "Relative time window ending at the real current time. Use 30 for unspecified recent activity, but omit it for a latest available private-chat recap without an explicit date or duration."
+};
+var resolveSchema = {
+  type: "object",
+  properties: {
+    entities: {
+      type: "array",
+      description: "Contact or session references. A contact may use a stable contactKey or a displayName lookup from the user text.",
+      items: {
+        type: "object",
+        properties: {
+          type: { type: "string", enum: ["contact", "session"] },
+          contactKey: { type: "string" },
+          sessionId: { type: "string" },
+          displayName: { type: "string" },
+          sessionType: { type: "string", enum: ["private", "group"] }
+        },
+        required: ["type", "displayName"]
+      }
+    }
+  },
+  required: ["entities"]
+};
+var searchSchema = {
+  type: "object",
+  properties: {
+    keywords: {
+      type: "array",
+      items: { type: "string" },
+      description: "Exact substring keywords. May be omitted only with explicit scopes to sample recent messages from those scopes."
+    },
+    scopes: {
+      type: "array",
+      description: "Resolved session/member scopes. Omit only when the user clearly requested global discovery.",
+      items: scopeItems
+    },
+    match_mode: { type: "string", enum: ["any", "all"], description: "Whether any or all keywords must match" },
+    recent_days: recentDaysProperty,
+    sender: {
+      type: "string",
+      enum: ["all", "owner"],
+      description: "Message sender filter. Use owner when the user's wording makes them the subject, such as 'I discussed buying a home'."
+    },
+    sort: { type: "string", enum: ["asc", "desc"], description: "Timestamp order; defaults to newest first" },
+    ...timeParamProperties
+  }
+};
+var recentSessionSchema = {
+  type: "object",
+  properties: {
+    session_id: {
+      type: "string",
+      description: "One exact session ID returned by resolve_chat_entities"
+    }
+  },
+  required: ["session_id"]
+};
+var contextSchema = {
+  type: "object",
+  properties: {
+    session_id: { type: "string", description: "Source session ID from cross-chat search evidence" },
+    message_id: { type: "number", description: "Message ID inside that source session" },
+    context_size: { type: "number", description: "Messages before and after the source message; defaults to 10" }
+  },
+  required: ["session_id", "message_id"]
+};
+var overviewSchema = {
+  type: "object",
+  properties: {
+    scopes: {
+      type: "array",
+      description: "Resolved session/member scopes to summarize separately",
+      items: scopeItems
+    },
+    recent_days: recentDaysProperty,
+    ...timeParamProperties
+  },
+  required: ["scopes"]
+};
+var rankPrivateContactsSchema = {
+  type: "object",
+  properties: {
+    rank_by: {
+      type: "string",
+      enum: ["message_count", "active_days"],
+      description: "Ranking metric. Defaults to total private-chat message count."
+    },
+    limit: { type: "number", minimum: 1, maximum: 50, description: "Number of ranked contacts to return" },
+    recent_days: recentDaysProperty,
+    ...timeParamProperties
+  }
+};
+var rankGroupSessionsSchema = {
+  type: "object",
+  properties: {
+    mode: {
+      type: "string",
+      enum: ["owner_activity", "total_activity"],
+      description: "Use owner_activity for 'where was I most active' and total_activity for 'which groups were busiest overall'."
+    },
+    limit: { type: "number", minimum: 1, maximum: 50, description: "Number of ranked groups to return" },
+    recent_days: recentDaysProperty,
+    ...timeParamProperties
+  },
+  required: ["mode"]
+};
+var globalActivitySummarySchema = {
+  type: "object",
+  properties: {
+    mode: {
+      type: "string",
+      enum: ["year", "recent_365"],
+      description: "Use year for a calendar year and recent_365 for the rolling latest 365 days. Defaults to year."
+    },
+    year: {
+      type: "number",
+      minimum: 1970,
+      description: "Calendar year for mode=year. Omit it to use the current year."
+    }
+  }
+};
+var inspectContactSessionsSchema = {
+  type: "object",
+  properties: {
+    contact_key: {
+      type: "string",
+      description: "Stable contact key returned by resolve_chat_entities; display names are not accepted"
+    },
+    recent_days: recentDaysProperty,
+    include_roster_only: {
+      type: "boolean",
+      description: "Include imported sessions where the member is recorded but did not speak in the selected range",
+      default: true
+    },
+    cursor: { type: "string", description: "Opaque continuation cursor from the previous result" },
+    page_size: { type: "number", description: "Maximum matching sessions returned in this batch" },
+    max_wall_time_ms: { type: "number", description: "Maximum wall time for this inspection batch" },
+    ...timeParamProperties
+  },
+  required: ["contact_key"]
+};
+var MAX_SHARED_ANCHORS_PER_PAIR = 8;
+var inspectSharedInteractionsSchema = {
+  type: "object",
+  properties: {
+    participants: {
+      type: "array",
+      description: "Two to five distinct people. Use type=owner for the local user in each session or type=contact with a stable contact_key.",
+      items: {
+        type: "object",
+        properties: {
+          type: { type: "string", enum: ["owner", "contact"] },
+          contact_key: { type: "string" }
+        },
+        required: ["type"]
+      }
+    },
+    recent_days: recentDaysProperty,
+    cursor: { type: "string", description: "Opaque continuation cursor from the previous result" },
+    page_size: { type: "number", description: "Maximum common sessions returned in this batch" },
+    max_anchors_per_pair: {
+      type: "number",
+      description: "Maximum direct-reply and proximity message anchors returned for each participant pair",
+      minimum: 0,
+      maximum: MAX_SHARED_ANCHORS_PER_PAIR
+    },
+    max_wall_time_ms: { type: "number", description: "Maximum wall time for this inspection batch" },
+    ...timeParamProperties
+  },
+  required: ["participants"]
+};
+var DEFAULT_CONTACT_INSPECTION_PAGE_SIZE = 50;
+var MAX_CONTACT_INSPECTION_PAGE_SIZE = 100;
+var MODEL_LABEL_MAX_LENGTH = 80;
+var DEFAULT_SHARED_INSPECTION_PAGE_SIZE = 20;
+var DEFAULT_SHARED_ANCHORS_PER_PAIR = 4;
+var TOOL_RESULT_CHARS_PER_TOKEN = 4;
+var TOOL_RESULT_BASE_CHARS = 1500;
+var CONTACT_SESSION_ESTIMATED_CHARS = 650;
+var SHARED_SESSION_BASE_CHARS = 550;
+var SHARED_PARTICIPANT_ESTIMATED_CHARS = 240;
+var SHARED_PAIR_BASE_CHARS = 260;
+var SHARED_ANCHOR_ESTIMATED_CHARS = 180;
+async function resolveHandler(params, context) {
+  const inputs = parseEntityInputs(params.entities);
+  const refs = [];
+  const contactLookups = [];
+  for (const input of inputs) {
+    if (input.type === "contact" && !input.contactKey) {
+      const lookup = context.analysisService.lookupContact(input.displayName);
+      contactLookups.push(lookup);
+      if (lookup.status === "resolved" && lookup.candidates[0]) {
+        refs.push({
+          type: "contact",
+          contactKey: lookup.candidates[0].contactKey,
+          displayName: lookup.candidates[0].displayName
+        });
+      }
+      continue;
+    }
+    refs.push(input);
+  }
+  const resolution = await context.analysisService.resolveEntities(dedupeEntityRefs(refs), {
+    signal: context.abortSignal
+  });
+  trackResolvedEntityRefs(context.resolvedEntityRefs, resolution);
+  const data = { ...resolution, contactLookups };
+  const modelData = limitEntityResolutionToBudget(
+    resolution,
+    contactLookups,
+    context.maxToolResultTokens,
+    context.countTokens
+  );
+  return { content: JSON.stringify(modelData), data };
+}
+async function searchHandler(params, context) {
+  const timeFilter = parseExtendedTimeParams(params);
+  const keywords = params.keywords === void 0 ? [] : parseStringArray(params.keywords);
+  const result = await context.analysisService.searchMessages(
+    {
+      keywords,
+      scopes: params.scopes === void 0 ? void 0 : parseScopes(params.scopes),
+      startTs: timeFilter?.startTs,
+      endTs: timeFilter?.endTs,
+      recentDays: parseOptionalNumber(params.recent_days),
+      sender: params.sender === "owner" ? "owner" : "all",
+      matchMode: params.match_mode === "all" ? "all" : "any",
+      sort: params.sort === "asc" ? "asc" : "desc"
+    },
+    {
+      signal: context.abortSignal,
+      onProgress: (progress) => context.reportProgress?.({
+        phase: "searching",
+        current: progress.processedSessions,
+        total: progress.totalSessions
+      })
+    }
+  );
+  const safeMessages = await preprocessBySession(context, result.messages);
+  const buildCoverage = (budgetTruncated) => ({
+    ...result.coverage,
+    truncated: result.coverage.truncated || budgetTruncated,
+    truncatedReasons: budgetTruncated ? [.../* @__PURE__ */ new Set([...result.coverage.truncatedReasons, "evidence_budget"])] : result.coverage.truncatedReasons
+  });
+  const buildModelData = (messages, budgetTruncated) => ({
+    totalMatches: result.totalMatches,
+    returned: messages.length,
+    selection: summarizeEvidenceSelection(messages),
+    appliedFilters: result.appliedFilters,
+    coverage: buildCoverage(budgetTruncated),
+    messages: messages.map(toModelMessage)
+  });
+  const limited = limitMessagesToBudget(safeMessages, context.maxToolResultTokens, buildModelData, {
+    countTokens: context.countTokens
+  });
+  const modelData = buildModelData(limited.messages, limited.truncated);
+  const evidence = {
+    version: 1,
+    query: keywords.join(" "),
+    sources: limited.messages.map(toEvidenceSource),
+    coverage: modelData.coverage
+  };
+  const data = {
+    ...modelData,
+    crossChatEvidence: evidence
+  };
+  return { content: JSON.stringify(modelData), data };
+}
+async function readRecentSessionHandler(params, context) {
+  const result = context.analysisService.readRecentSession(requireString(params.session_id, "session_id"));
+  const safeMessages = await preprocessBySession(context, result.messages);
+  const safeSummaries = await context.preprocessSummariesBySession(result.source.sessionId, result.summaries);
+  const sessionPseudonym = "Session1";
+  const modelSource = {
+    ...result.source,
+    sessionName: context.preprocessModelLabel(result.source.sessionName, sessionPseudonym)
+  };
+  const toRecentModelMessage = (message) => ({
+    ...toModelMessage(message),
+    sessionName: context.preprocessModelLabel(message.sessionName, sessionPseudonym)
+  });
+  const buildModelData = (messages, budgetTruncated) => ({
+    source: modelSource,
+    selection: {
+      strategy: "latest_session_slice",
+      totalMessages: result.coverage.totalMessages,
+      returnedMessages: messages.length,
+      returnedSummaries: safeSummaries.length,
+      hasEarlierMessages: result.coverage.hasEarlierMessages,
+      toolResultTruncated: budgetTruncated
+    },
+    summaries: safeSummaries,
+    messages: messages.map(toRecentModelMessage)
+  });
+  const limited = limitMessagesToBudget(safeMessages, context.maxToolResultTokens, buildModelData, {
+    countTokens: context.countTokens
+  });
+  const modelData = buildModelData(limited.messages, limited.truncated);
+  const evidence = {
+    version: 1,
+    query: "recent session recap",
+    sources: limited.messages.map(toEvidenceSource),
+    coverage: {
+      candidateSessions: 1,
+      scannedSessions: 1,
+      matchedSessions: limited.messages.length > 0 ? 1 : 0,
+      failedSessions: 0,
+      truncated: limited.truncated,
+      truncatedReasons: limited.truncated ? ["evidence_budget"] : []
+    }
+  };
+  return {
+    content: JSON.stringify(modelData),
+    data: {
+      ...modelData,
+      source: result.source,
+      messages: limited.messages.map(toModelMessage),
+      crossChatEvidence: evidence
+    }
+  };
+}
+async function contextHandler(params, context) {
+  const sessionId = requireString(params.session_id, "session_id");
+  const messageId = requireNumber(params.message_id, "message_id");
+  const contextSize = parseOptionalNumber(params.context_size);
+  const result = context.analysisService.getMessageContext({ sessionId, messageId, contextSize });
+  const safeMessages = await preprocessBySession(context, result.messages);
+  const buildModelData = (messages, truncated) => ({
+    source: result.source,
+    returned: messages.length,
+    truncated,
+    messages: messages.map(toModelMessage)
+  });
+  const limited = limitMessagesToBudget(safeMessages, context.maxToolResultTokens, buildModelData, {
+    priorityIndexes: buildContextPriority(safeMessages, messageId),
+    continueAfterOverflow: true,
+    countTokens: context.countTokens
+  });
+  const data = buildModelData(limited.messages, limited.truncated);
+  return { content: JSON.stringify(data), data };
+}
+async function overviewHandler(params, context) {
+  const timeFilter = parseExtendedTimeParams(params);
+  const result = await context.analysisService.getOverview(
+    {
+      scopes: parseScopes(params.scopes),
+      startTs: timeFilter?.startTs,
+      endTs: timeFilter?.endTs,
+      recentDays: parseOptionalNumber(params.recent_days)
+    },
+    {
+      signal: context.abortSignal,
+      onProgress: (progress) => context.reportProgress?.({
+        phase: "analyzing",
+        current: progress.processedSessions,
+        total: progress.totalSessions
+      })
+    }
+  );
+  const data = {
+    appliedRange: result.appliedRange,
+    items: result.items.map(({ memberNames: _memberNames, ...item }) => item),
+    coverage: result.coverage
+  };
+  const fullModelData = {
+    ...data,
+    items: data.items.map((item, index) => {
+      const sessionPseudonym = `Session${index + 1}`;
+      const preprocessMember = (member) => ({
+        ...member,
+        memberName: context.preprocessModelLabel(member.memberName, `U${member.memberId}@${item.sessionId}`)
+      });
+      return {
+        ...item,
+        sessionName: context.preprocessModelLabel(item.sessionName, sessionPseudonym),
+        label: context.preprocessModelLabel(item.label, sessionPseudonym),
+        memberActivities: item.memberActivities.map(preprocessMember),
+        topMembers: item.topMembers.map(preprocessMember)
+      };
+    })
+  };
+  const modelData = limitOverviewToBudget(
+    fullModelData,
+    context.maxToolResultTokens,
+    context.countTokens ?? estimatePayloadTokens
+  );
+  return { content: JSON.stringify(modelData), data };
+}
+async function rankPrivateContactsHandler(params, context) {
+  const timeFilter = parseExtendedTimeParams(params);
+  const result = await context.analysisService.rankPrivateContacts(
+    {
+      startTs: timeFilter?.startTs,
+      endTs: timeFilter?.endTs,
+      recentDays: parseOptionalNumber(params.recent_days),
+      rankBy: params.rank_by === "active_days" ? "active_days" : "message_count",
+      limit: parseOptionalNumber(params.limit)
+    },
+    {
+      signal: context.abortSignal,
+      onProgress: (progress) => context.reportProgress?.({
+        phase: "analyzing",
+        current: progress.processedSessions,
+        total: progress.totalSessions
+      })
+    }
+  );
+  const modelData = {
+    ...result,
+    items: result.items.map((item) => ({
+      ...item,
+      displayName: context.preprocessModelLabel(item.displayName, `Contact${item.rank}`)
+    }))
+  };
+  return { content: JSON.stringify(modelData), data: result };
+}
+async function rankGroupSessionsHandler(params, context) {
+  const timeFilter = parseExtendedTimeParams(params);
+  const mode = requireString(params.mode, "mode");
+  if (mode !== "owner_activity" && mode !== "total_activity") {
+    throw new Error("mode must be owner_activity or total_activity");
+  }
+  const result = await context.analysisService.rankGroupSessions(
+    {
+      mode,
+      startTs: timeFilter?.startTs,
+      endTs: timeFilter?.endTs,
+      recentDays: parseOptionalNumber(params.recent_days),
+      limit: parseOptionalNumber(params.limit)
+    },
+    {
+      signal: context.abortSignal,
+      onProgress: (progress) => context.reportProgress?.({
+        phase: "analyzing",
+        current: progress.processedSessions,
+        total: progress.totalSessions
+      })
+    }
+  );
+  const modelData = {
+    ...result,
+    items: result.items.map((item) => ({
+      ...item,
+      sessionName: context.preprocessModelLabel(item.sessionName, `Group${item.rank}`)
+    }))
+  };
+  return { content: JSON.stringify(modelData), data: result };
+}
+async function globalActivitySummaryHandler(params, context) {
+  const mode = params.mode ?? "year";
+  if (mode !== "year" && mode !== "recent_365") throw new Error("mode must be year or recent_365");
+  const result = context.analysisService.getGlobalActivitySummary({
+    mode,
+    year: parseOptionalNumber(params.year)
+  });
+  const modelData = limitGlobalActivitySummaryToBudget(
+    buildGlobalActivityModelData(result),
+    context.maxToolResultTokens,
+    context.countTokens ?? estimatePayloadTokens
+  );
+  return { content: JSON.stringify(modelData), data: result };
+}
+function buildGlobalActivityModelData(result) {
+  const summary = result.summary;
+  return {
+    mode: result.mode,
+    dataState: result.dataState,
+    range: summary.range,
+    availableDataYears: summary.availableDataYears,
+    latestDataYear: summary.latestDataYear,
+    metrics: summary.metrics,
+    monthlyActivity: summary.monthlyActivity,
+    monthlyDirectContacts: summary.monthlyDirectContacts,
+    dailyActivity: summary.dailyActivity,
+    messageTypes: summary.messageTypes,
+    textLength: summary.textLength,
+    coverage: summary.coverage,
+    cache: {
+      status: summary.cache.status,
+      computedAt: summary.cache.computedAt,
+      staleReason: summary.cache.staleReason
+    },
+    task: {
+      status: summary.task.status,
+      startedAt: summary.task.startedAt,
+      finishedAt: summary.task.finishedAt,
+      processedSessions: summary.task.processedSessions,
+      totalSessions: summary.task.totalSessions
+    },
+    selection: {
+      dailyActivityTotal: summary.dailyActivity.length,
+      dailyActivityReturned: summary.dailyActivity.length,
+      dailyActivityFormat: "objects",
+      toolResultTruncated: false,
+      truncatedReasons: []
+    }
+  };
+}
+async function inspectContactSessionsHandler(params, context) {
+  const timeFilter = parseExtendedTimeParams(params);
+  const requestedPageSize = parseOptionalNumber(params.page_size);
+  const budgetedPageSize = limitContactPageSizeToBudget(requestedPageSize, context.maxToolResultTokens);
+  const result = await context.analysisService.inspectContactSessions(
+    {
+      contactKey: requireString(params.contact_key, "contact_key"),
+      startTs: timeFilter?.startTs,
+      endTs: timeFilter?.endTs,
+      recentDays: parseOptionalNumber(params.recent_days),
+      includeRosterOnly: params.include_roster_only === void 0 ? true : requireBoolean(params.include_roster_only),
+      cursor: typeof params.cursor === "string" && params.cursor.trim() ? params.cursor.trim() : void 0,
+      pageSize: budgetedPageSize.value,
+      maxWallTimeMs: parseOptionalNumber(params.max_wall_time_ms)
+    },
+    {
+      signal: context.abortSignal,
+      onProgress: (progress) => context.reportProgress?.({
+        phase: "analyzing",
+        current: progress.processedSessions,
+        total: progress.totalSessions
+      })
+    }
+  );
+  const countTokens = context.countTokens ?? estimatePayloadTokens;
+  const pageBudgetTruncated = budgetedPageSize.limited && result.coverage.truncatedReasons.includes("page_size");
+  const payloadExceedsBudget = !!context.maxToolResultTokens && context.maxToolResultTokens > 0 && countTokens(JSON.stringify(result)) > context.maxToolResultTokens;
+  const data = pageBudgetTruncated || payloadExceedsBudget ? withToolResultBudgetReason(result) : result;
+  const modelData = limitContactResultToBudget(data, context.maxToolResultTokens, countTokens);
+  return { content: JSON.stringify(modelData), data };
+}
+async function inspectSharedInteractionsHandler(params, context) {
+  const timeFilter = parseExtendedTimeParams(params);
+  const participants = parseParticipants(params.participants);
+  const requestedPageSize = parseOptionalNumber(params.page_size);
+  const requestedAnchorsPerPair = parseOptionalNumber(params.max_anchors_per_pair);
+  const budget = limitSharedRequestToBudget(
+    participants.length,
+    requestedPageSize,
+    requestedAnchorsPerPair,
+    context.maxToolResultTokens
+  );
+  const result = await context.analysisService.inspectSharedInteractions(
+    {
+      participants,
+      startTs: timeFilter?.startTs,
+      endTs: timeFilter?.endTs,
+      recentDays: parseOptionalNumber(params.recent_days),
+      cursor: typeof params.cursor === "string" && params.cursor.trim() ? params.cursor.trim() : void 0,
+      pageSize: budget.pageSize,
+      maxAnchorsPerPair: budget.maxAnchorsPerPair,
+      maxWallTimeMs: parseOptionalNumber(params.max_wall_time_ms)
+    },
+    {
+      signal: context.abortSignal,
+      onProgress: (progress) => context.reportProgress?.({
+        phase: "analyzing",
+        current: progress.processedSessions,
+        total: progress.totalSessions
+      })
+    }
+  );
+  const pageBudgetTruncated = budget.pageLimited && result.coverage.nextCursor !== null && result.coverage.truncatedReasons.includes("page_size");
+  const anchorBudgetTruncated = budget.anchorsLimited && result.sessions.some((session) => session.pairs.some((pair) => pair.anchorsTruncated));
+  const countTokens = context.countTokens ?? estimatePayloadTokens;
+  const payloadExceedsBudget = !!context.maxToolResultTokens && context.maxToolResultTokens > 0 && countTokens(JSON.stringify(result)) > context.maxToolResultTokens;
+  const data = pageBudgetTruncated || anchorBudgetTruncated || payloadExceedsBudget ? withToolResultBudgetReason(result) : result;
+  const modelData = limitSharedModelResultToBudget(data, context.maxToolResultTokens, countTokens);
+  return { content: JSON.stringify(modelData), data };
+}
+var resolveChatEntitiesTool = {
+  name: "resolve_chat_entities",
+  description: "Resolve contacts and sessions into exact source scopes. Stable refs resolve directly; typed contact names search the contact catalog. Continue automatically for one candidate, ask the user to choose when contactLookups reports ambiguous, and never guess among multiple candidates.",
+  inputSchema: resolveSchema,
+  handler: resolveHandler,
+  category: "core"
+};
+var readRecentSessionTool = {
+  name: "read_recent_session",
+  description: "Read one exactly resolved session for a concise latest-available recap. The tool internally returns a bounded newest message slice plus up to five existing segment summaries, with source evidence and preprocessing. Use it after resolve_chat_entities when the user asks what happened recently in one private chat or one explicitly selected session without a calendar range. Do not pass message budgets. For explicit dates, durations, keywords, multi-session work, or deeper history, use search_messages_globally instead.",
+  inputSchema: recentSessionSchema,
+  handler: readRecentSessionHandler,
+  category: "core",
+  truncationStrategy: "keep_first"
+};
+var searchMessagesGloballyTool = {
+  name: "search_messages_globally",
+  description: "Search exact keywords across resolved contacts or sessions. Use recent_days=30 for unspecified recent activity, but for a latest available private-chat recap without an explicit date or duration, scope only the direct private session and omit recent_days. Use sender=owner when the user is the subject of the requested action. The tool controls evidence volume internally, prioritizes private-chat evidence, ranks remaining group sources by matching activity, and automatically includes surrounding context. With explicit scopes, omit keywords to sample recent messages. Unscoped global discovery always requires keywords. Results include applied filters, source identity, coverage, and truncation status.",
+  inputSchema: searchSchema,
+  handler: searchHandler,
+  category: "core",
+  truncationStrategy: "keep_first"
+};
+var getCrossChatMessageContextTool = {
+  name: "get_cross_chat_message_context",
+  description: "Load surrounding messages for one cross-chat evidence item. Both session_id and message_id are required because message IDs are only unique inside a session.",
+  inputSchema: contextSchema,
+  handler: contextHandler,
+  category: "core",
+  truncationStrategy: "keep_last"
+};
+var getCrossChatOverviewTool = {
+  name: "get_cross_chat_overview",
+  description: "Compare already-resolved contact or session scopes within an exact time range. Returns deterministic message counts, active days and members, per-requested-member activity, owner coverage, fixed top members for groups, dataset cutoff, and completeness. It does not discover or rank sessions globally.",
+  inputSchema: overviewSchema,
+  handler: overviewHandler,
+  category: "core"
+};
+var rankPrivateContactsTool = {
+  name: "rank_private_contacts",
+  description: "Deterministically rank private-chat contacts across all eligible imported sessions for an exact time range. Use this for questions such as who the user chatted with most or had the most active private-chat days. This tool counts non-system messages and never uses keyword-search hits as a ranking proxy. Results include owner/contact splits, dataset cutoff, identity coverage, and completeness.",
+  inputSchema: rankPrivateContactsSchema,
+  handler: rankPrivateContactsHandler,
+  category: "core"
+};
+var rankGroupSessionsTool = {
+  name: "rank_group_sessions",
+  description: "Deterministically rank imported group sessions for an exact time range. mode=owner_activity answers where the user personally spoke most; mode=total_activity answers which groups were busiest overall. Never mix these metrics or substitute sampled search hits. Results include total and owner counts, active members/days, owner-resolution coverage, dataset cutoff, and completeness.",
+  inputSchema: rankGroupSessionsSchema,
+  handler: rankGroupSessionsHandler,
+  category: "core"
+};
+var getGlobalActivitySummaryTool = {
+  name: "get_global_activity_summary",
+  description: "Read the existing deterministic owner activity snapshot for the current calendar year, another calendar year, or the rolling latest 365 days. Use it for total sent messages, active days, direct-contact counts, monthly/daily trends, message types, and text-length distribution. It never reads chat text or returns contact/group rankings. fresh and stale states contain usable metrics; preparing and failed do not and must not be described as zero activity. Do not poll a preparing result in the same answer.",
+  inputSchema: globalActivitySummarySchema,
+  handler: globalActivitySummaryHandler,
+  category: "core"
+};
+var inspectContactSessionsTool = {
+  name: "inspect_contact_sessions",
+  description: "Inspect one resolved contact across imported private and group sessions. Returns the contact's own message counts, first/last speech, active days, roster-only presence, dataset cutoff, and coverage. Use recent_days=30 for recent activity without an explicit duration; never derive start_time from the dataset cutoff. Use only for person source/activity questions after exact identity resolution; this tool does not infer relationship labels or return message text.",
+  inputSchema: inspectContactSessionsSchema,
+  handler: inspectContactSessionsHandler,
+  category: "core"
+};
+var inspectSharedInteractionsTool = {
+  name: "inspect_shared_interactions",
+  description: "Inspect common imported sessions for two to five exactly resolved people, including owner when requested. Returns per-person activity, directional replies, proximity signals, co-active days, message anchors, dataset cutoff, and coverage. Use recent_days=30 for recent interaction questions without an explicit duration; never derive start_time from the dataset cutoff. Common sessions contain every requested participant. These structural signals guide evidence reading and must never be treated as relationship labels or replace message context.",
+  inputSchema: inspectSharedInteractionsSchema,
+  handler: inspectSharedInteractionsHandler,
+  category: "core"
+};
+function parseEntityInputs(value) {
+  if (!Array.isArray(value)) throw new Error("entities must be an array");
+  return value.map((item) => {
+    if (!isRecord(item)) throw new Error("each entity must be an object");
+    const type = requireString(item.type, "entity.type");
+    const displayName = requireString(item.displayName, "entity.displayName");
+    if (type === "contact") {
+      return {
+        type,
+        ...typeof item.contactKey === "string" && item.contactKey.trim() ? { contactKey: item.contactKey.trim() } : {},
+        displayName
+      };
+    }
+    if (type === "session") {
+      const sessionType = item.sessionType === "private" ? "private" : item.sessionType === "group" ? "group" : null;
+      if (!sessionType) throw new Error("entity.sessionType must be private or group");
+      return { type, sessionId: requireString(item.sessionId, "entity.sessionId"), displayName, sessionType };
+    }
+    throw new Error("entity.type must be contact or session");
+  });
+}
+function dedupeEntityRefs(refs) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    byKey.set(entityRefKey(ref), ref);
+  }
+  return [...byKey.values()];
+}
+function trackResolvedEntityRefs(currentRunRefs, resolution) {
+  if (!currentRunRefs) return;
+  const resolvedRefs = [
+    ...resolution.contacts.filter((item) => item.status === "resolved" || item.status === "partial").map((item) => item.ref),
+    ...resolution.sessions.filter((item) => item.status === "resolved").map((item) => item.ref)
+  ];
+  const existingKeys = new Set(currentRunRefs.map(entityRefKey));
+  for (const ref of resolvedRefs) {
+    const key = entityRefKey(ref);
+    if (existingKeys.has(key)) continue;
+    currentRunRefs.push(ref);
+    existingKeys.add(key);
+  }
+}
+function entityRefKey(ref) {
+  return ref.type === "contact" ? `contact:${ref.contactKey}` : `session:${ref.sessionId}`;
+}
+function parseScopes(value) {
+  if (!Array.isArray(value)) throw new Error("scopes must be an array");
+  return value.map((item) => {
+    if (!isRecord(item)) throw new Error("each scope must be an object");
+    return {
+      sessionId: requireString(item.sessionId, "scope.sessionId"),
+      memberIds: item.memberIds === void 0 ? void 0 : parseNumberArray(item.memberIds),
+      label: typeof item.label === "string" ? item.label : void 0
+    };
+  });
+}
+function parseParticipants(value) {
+  if (!Array.isArray(value)) throw new Error("participants must be an array");
+  return value.map((item) => {
+    if (!isRecord(item)) throw new Error("each participant must be an object");
+    if (item.type === "owner") return { type: "owner" };
+    if (item.type === "contact") {
+      return { type: "contact", contactKey: requireString(item.contact_key, "participant.contact_key") };
+    }
+    throw new Error("participant.type must be owner or contact");
+  });
+}
+function limitOverviewToBudget(fullData, maxToolResultTokens, countTokens) {
+  if (!maxToolResultTokens || maxToolResultTokens <= 0) return fullData;
+  if (countTokens(JSON.stringify(fullData)) <= maxToolResultTokens) return fullData;
+  const compactItems = fullData.items.map((item) => ({
+    ...item,
+    sessionName: truncateModelLabel(item.sessionName),
+    label: truncateModelLabel(item.label),
+    memberActivities: item.memberActivities.map((member) => ({
+      memberId: member.memberId,
+      memberName: truncateModelLabel(member.memberName),
+      messageCount: member.messageCount,
+      activeDays: member.activeDays,
+      firstMessageTs: member.firstMessageTs,
+      lastMessageTs: member.lastMessageTs
+    })),
+    topMembers: item.topMembers.map((member) => ({
+      memberName: truncateModelLabel(member.memberName),
+      messageCount: member.messageCount,
+      activeDays: member.activeDays,
+      lastMessageTs: member.lastMessageTs
+    }))
+  }));
+  const buildCandidate = (items, itemFormat) => ({
+    appliedRange: fullData.appliedRange,
+    items,
+    coverage: fullData.coverage,
+    selection: buildOverviewSelection(fullData.items, items, itemFormat)
+  });
+  const fits = (candidate) => countTokens(JSON.stringify(candidate)) <= maxToolResultTokens;
+  const maxTopMembers = compactItems.reduce((max, item) => Math.max(max, item.topMembers.length), 0);
+  const topMemberCandidate = findLargestOverviewDetailLimit(
+    maxTopMembers,
+    (limit) => buildCandidate(
+      compactItems.map((item) => ({ ...item, topMembers: item.topMembers.slice(0, limit) })),
+      "compact"
+    )
+  );
+  if (topMemberCandidate && fits(topMemberCandidate)) return topMemberCandidate;
+  const maxMemberActivities = compactItems.reduce((max, item) => Math.max(max, item.memberActivities.length), 0);
+  const memberActivityCandidate = findLargestOverviewDetailLimit(
+    maxMemberActivities,
+    (limit) => buildCandidate(
+      compactItems.map((item) => ({
+        ...item,
+        memberActivities: item.memberActivities.slice(0, limit),
+        topMembers: []
+      })),
+      "compact"
+    )
+  );
+  if (memberActivityCandidate && fits(memberActivityCandidate)) return memberActivityCandidate;
+  const coreItems = compactItems.map((item) => ({
+    sessionId: item.sessionId,
+    sessionName: item.sessionName,
+    sessionType: item.sessionType,
+    platform: item.platform,
+    label: item.label,
+    totalMessages: item.totalMessages,
+    activeDays: item.activeDays,
+    activeMembers: item.activeMembers,
+    firstMessageTs: item.firstMessageTs,
+    lastMessageTs: item.lastMessageTs,
+    ownerStatus: item.ownerStatus,
+    ownerMessages: item.ownerMessages,
+    ownerActiveDays: item.ownerActiveDays
+  }));
+  const coreCandidate = buildCandidate(coreItems, "core");
+  if (fits(coreCandidate)) return coreCandidate;
+  const identityItems = compactItems.map((item) => ({
+    sessionId: item.sessionId,
+    sessionName: item.sessionName,
+    sessionType: item.sessionType,
+    label: item.label,
+    totalMessages: item.totalMessages,
+    activeDays: item.activeDays,
+    lastMessageTs: item.lastMessageTs
+  }));
+  const identityCandidate = buildCandidate(identityItems, "identity");
+  if (fits(identityCandidate)) return identityCandidate;
+  const returnedItems = findLargestOverviewItemSlice(identityItems, (items) => buildCandidate(items, "identity"));
+  if (returnedItems) return returnedItems;
+  const omitted = buildCandidate([], "omitted");
+  const candidates = [
+    omitted,
+    {
+      selection: buildOverviewSelection(fullData.items, [], "omitted")
+    },
+    { toolResultTruncated: true, truncatedReasons: ["tool_result_budget"] },
+    {}
+  ];
+  return candidates.find(fits) ?? {};
+  function findLargestOverviewDetailLimit(maximum, build) {
+    if (!fits(build(0))) return null;
+    let low = 0;
+    let high = maximum;
+    while (low < high) {
+      const middle = Math.ceil((low + high) / 2);
+      if (fits(build(middle))) low = middle;
+      else high = middle - 1;
+    }
+    return build(low);
+  }
+  function findLargestOverviewItemSlice(items, build) {
+    if (!fits(build([]))) return null;
+    let low = 0;
+    let high = items.length;
+    while (low < high) {
+      const middle = Math.ceil((low + high) / 2);
+      if (fits(build(items.slice(0, middle)))) low = middle;
+      else high = middle - 1;
+    }
+    return build(items.slice(0, low));
+  }
+}
+function buildOverviewSelection(fullItems, returnedItems, itemFormat) {
+  const memberActivitiesTotal = fullItems.reduce((sum, item) => sum + item.memberActivities.length, 0);
+  const topMembersTotal = fullItems.reduce((sum, item) => sum + item.topMembers.length, 0);
+  const memberActivitiesReturned = returnedItems.reduce(
+    (sum, item) => sum + (Array.isArray(item.memberActivities) ? item.memberActivities.length : 0),
+    0
+  );
+  const topMembersReturned = returnedItems.reduce(
+    (sum, item) => sum + (Array.isArray(item.topMembers) ? item.topMembers.length : 0),
+    0
+  );
+  const truncatedReasons = [
+    ...memberActivitiesReturned < memberActivitiesTotal ? ["member_activities_budget"] : [],
+    ...topMembersReturned < topMembersTotal ? ["top_members_budget"] : [],
+    ...returnedItems.length < fullItems.length ? ["session_items_budget"] : [],
+    "item_fields_budget",
+    "tool_result_budget"
+  ];
+  return {
+    sessionItemsTotal: fullItems.length,
+    sessionItemsReturned: returnedItems.length,
+    memberActivitiesTotal,
+    memberActivitiesReturned,
+    topMembersTotal,
+    topMembersReturned,
+    itemFormat,
+    toolResultTruncated: true,
+    truncatedReasons
+  };
+}
+function limitGlobalActivitySummaryToBudget(fullData, maxToolResultTokens, countTokens) {
+  if (!maxToolResultTokens || maxToolResultTokens <= 0) return fullData;
+  if (countTokens(JSON.stringify(fullData)) <= maxToolResultTokens) return fullData;
+  const totalDailyPoints = fullData.dailyActivity.length;
+  const buildCompactedDailyData = (returned) => ({
+    ...fullData,
+    dailyActivity: sampleEvenly(fullData.dailyActivity, returned).map(
+      (point) => [point.date, point.messageCount]
+    ),
+    selection: {
+      dailyActivityTotal: totalDailyPoints,
+      dailyActivityReturned: returned,
+      dailyActivityFormat: "date_message_count_tuples",
+      toolResultTruncated: returned < totalDailyPoints,
+      truncatedReasons: returned < totalDailyPoints ? ["daily_activity_budget"] : []
+    }
+  });
+  let low = 0;
+  let high = totalDailyPoints;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (countTokens(JSON.stringify(buildCompactedDailyData(middle))) <= maxToolResultTokens) low = middle;
+    else high = middle - 1;
+  }
+  const compacted = buildCompactedDailyData(low);
+  if (countTokens(JSON.stringify(compacted)) <= maxToolResultTokens) return compacted;
+  const truncatedReasons = [...totalDailyPoints > 0 ? ["daily_activity_budget"] : [], "tool_result_budget"];
+  const selection = {
+    dailyActivityTotal: totalDailyPoints,
+    dailyActivityReturned: 0,
+    dailyActivityFormat: "omitted",
+    toolResultTruncated: true,
+    truncatedReasons
+  };
+  const candidates = [
+    {
+      mode: fullData.mode,
+      dataState: fullData.dataState,
+      range: fullData.range,
+      metrics: fullData.metrics,
+      monthlyActivity: fullData.monthlyActivity,
+      monthlyDirectContacts: fullData.monthlyDirectContacts,
+      messageTypes: fullData.messageTypes,
+      textLength: fullData.textLength,
+      coverage: fullData.coverage,
+      cache: fullData.cache,
+      selection
+    },
+    {
+      mode: fullData.mode,
+      dataState: fullData.dataState,
+      range: fullData.range,
+      metrics: fullData.metrics,
+      coverage: fullData.coverage,
+      cache: fullData.cache,
+      selection
+    },
+    { mode: fullData.mode, dataState: fullData.dataState, metrics: fullData.metrics, selection },
+    { dataState: fullData.dataState, selection },
+    { toolResultTruncated: true, truncatedReasons: ["tool_result_budget"] },
+    {}
+  ];
+  return candidates.find((candidate) => countTokens(JSON.stringify(candidate)) <= maxToolResultTokens) ?? {};
+}
+function sampleEvenly(items, limit) {
+  if (limit <= 0 || items.length === 0) return [];
+  if (limit >= items.length) return [...items];
+  if (limit === 1) return [items[items.length - 1]];
+  return Array.from({ length: limit }, (_, index) => {
+    const sourceIndex = Math.round(index * (items.length - 1) / (limit - 1));
+    return items[sourceIndex];
+  });
+}
+function limitContactPageSizeToBudget(requestedPageSize, maxToolResultTokens) {
+  if (!maxToolResultTokens || maxToolResultTokens <= 0) {
+    return { value: requestedPageSize, limited: false };
+  }
+  const requested = Math.min(
+    MAX_CONTACT_INSPECTION_PAGE_SIZE,
+    Math.max(1, Math.floor(requestedPageSize ?? DEFAULT_CONTACT_INSPECTION_PAGE_SIZE))
+  );
+  const maxChars = maxToolResultTokens * TOOL_RESULT_CHARS_PER_TOKEN;
+  const budgeted = Math.max(1, Math.floor((maxChars - TOOL_RESULT_BASE_CHARS) / CONTACT_SESSION_ESTIMATED_CHARS));
+  return {
+    value: budgeted < requested ? budgeted : requestedPageSize,
+    limited: budgeted < requested
+  };
+}
+function limitSharedRequestToBudget(participantCount, requestedPageSize, requestedAnchorsPerPair, maxToolResultTokens) {
+  const normalizedAnchorsPerPair = requestedAnchorsPerPair === void 0 ? void 0 : Math.min(MAX_SHARED_ANCHORS_PER_PAIR, Math.max(0, Math.floor(requestedAnchorsPerPair)));
+  if (!maxToolResultTokens || maxToolResultTokens <= 0) {
+    return {
+      pageSize: requestedPageSize,
+      maxAnchorsPerPair: normalizedAnchorsPerPair,
+      pageLimited: false,
+      anchorsLimited: false
+    };
+  }
+  const pairCount = participantCount * (participantCount - 1) / 2;
+  const requestedPage = requestedPageSize ?? DEFAULT_SHARED_INSPECTION_PAGE_SIZE;
+  const requestedAnchors = normalizedAnchorsPerPair ?? DEFAULT_SHARED_ANCHORS_PER_PAIR;
+  const maxChars = maxToolResultTokens * TOOL_RESULT_CHARS_PER_TOKEN;
+  let maxAnchorsPerPair = requestedAnchors;
+  const estimateSessionChars = (anchorsPerPair) => SHARED_SESSION_BASE_CHARS + participantCount * SHARED_PARTICIPANT_ESTIMATED_CHARS + pairCount * (SHARED_PAIR_BASE_CHARS + anchorsPerPair * SHARED_ANCHOR_ESTIMATED_CHARS);
+  while (maxAnchorsPerPair > 0 && TOOL_RESULT_BASE_CHARS + estimateSessionChars(maxAnchorsPerPair) > maxChars) {
+    maxAnchorsPerPair--;
+  }
+  const pageSize = Math.min(
+    requestedPage,
+    Math.max(1, Math.floor((maxChars - TOOL_RESULT_BASE_CHARS) / estimateSessionChars(maxAnchorsPerPair)))
+  );
+  return {
+    pageSize,
+    maxAnchorsPerPair,
+    pageLimited: pageSize < requestedPage,
+    anchorsLimited: maxAnchorsPerPair < requestedAnchors
+  };
+}
+function withToolResultBudgetReason(result) {
+  return {
+    ...result,
+    coverage: {
+      ...result.coverage,
+      truncated: true,
+      truncatedReasons: [.../* @__PURE__ */ new Set([...result.coverage.truncatedReasons, "tool_result_budget"])]
+    }
+  };
+}
+function limitContactResultToBudget(result, maxToolResultTokens, countTokens) {
+  if (!maxToolResultTokens || maxToolResultTokens <= 0) return result;
+  if (countTokens(JSON.stringify(result)) <= maxToolResultTokens) return result;
+  const compactLabels = {
+    ...result,
+    contact: result.contact ? { ...result.contact, displayName: truncateModelLabel(result.contact.displayName) } : null,
+    sessions: result.sessions.map((session) => ({
+      ...session,
+      sessionName: truncateModelLabel(session.sessionName),
+      memberName: truncateModelLabel(session.memberName)
+    }))
+  };
+  const coreFacts = {
+    algorithmVersion: result.algorithmVersion,
+    contact: compactLabels.contact,
+    appliedRange: result.appliedRange,
+    summary: result.summary,
+    sessions: result.sessions.map((session) => ({
+      sessionId: session.sessionId,
+      sessionName: truncateModelLabel(session.sessionName),
+      sessionType: session.sessionType,
+      platform: session.platform,
+      presence: session.presence,
+      ownMessageCount: session.ownMessageCount,
+      sessionMessageCount: session.sessionMessageCount,
+      firstOwnMessageTs: session.firstOwnMessageTs,
+      lastOwnMessageTs: session.lastOwnMessageTs,
+      activeDays: session.activeDays,
+      memberCount: session.memberCount,
+      sessionFirstMessageTs: session.sessionFirstMessageTs,
+      lastMessageTs: session.lastMessageTs
+    })),
+    coverage: result.coverage
+  };
+  const identityFacts = {
+    contact: result.contact ? {
+      contactKey: result.contact.contactKey,
+      displayName: truncateModelLabel(result.contact.displayName),
+      platform: result.contact.platform
+    } : null,
+    sessions: result.sessions.map((session) => ({
+      sessionId: session.sessionId,
+      sessionType: session.sessionType,
+      presence: session.presence,
+      ownMessageCount: session.ownMessageCount,
+      lastOwnMessageTs: session.lastOwnMessageTs
+    })),
+    coverage: result.coverage
+  };
+  const coverageOnly = { coverage: result.coverage };
+  const candidates = [compactLabels, coreFacts, identityFacts, coverageOnly];
+  return candidates.find((candidate) => countTokens(JSON.stringify(candidate)) <= maxToolResultTokens) ?? {
+    truncated: true,
+    truncatedReasons: ["tool_result_budget"]
+  };
+}
+function limitSharedModelResultToBudget(result, maxToolResultTokens, countTokens) {
+  if (!maxToolResultTokens || maxToolResultTokens <= 0) return result;
+  if (countTokens(JSON.stringify(result)) <= maxToolResultTokens) return result;
+  const compactLabels = {
+    ...result,
+    participants: result.participants.map((participant) => ({
+      ...participant,
+      displayName: truncateModelLabel(participant.displayName)
+    })),
+    sessions: result.sessions.map((session) => ({
+      ...session,
+      sessionName: truncateModelLabel(session.sessionName),
+      participants: session.participants.map((participant) => ({
+        ...participant,
+        memberName: truncateModelLabel(participant.memberName)
+      }))
+    }))
+  };
+  const withAnchorLimit = (maxAnchorsPerPair) => ({
+    ...compactLabels,
+    sessions: compactLabels.sessions.map((session) => ({
+      ...session,
+      pairs: session.pairs.map((pair) => ({
+        ...pair,
+        anchors: pair.anchors.slice(0, maxAnchorsPerPair).map(({ sessionId: _sessionId, ...anchor }) => anchor),
+        anchorsTruncated: pair.anchorsTruncated || pair.anchors.length > maxAnchorsPerPair
+      }))
+    }))
+  });
+  const identityFacts = {
+    algorithmVersion: result.algorithmVersion,
+    proximityAlgorithmVersion: result.proximityAlgorithmVersion,
+    participants: compactLabels.participants.map((participant) => ({
+      index: participant.index,
+      ref: participant.ref,
+      status: participant.status,
+      displayName: participant.displayName,
+      platform: participant.platform
+    })),
+    appliedRange: result.appliedRange,
+    summary: result.summary,
+    sessions: compactLabels.sessions.map((session) => ({
+      sessionId: session.sessionId,
+      sessionName: session.sessionName,
+      sessionType: session.sessionType,
+      platform: session.platform,
+      lastMessageTs: session.lastMessageTs,
+      memberCount: session.memberCount,
+      priorityReasons: session.priorityReasons,
+      proximityStatus: session.proximityStatus
+    })),
+    coverage: result.coverage
+  };
+  const coverageOnly = {
+    summary: result.summary,
+    coverage: result.coverage
+  };
+  const continuationOnly = {
+    coverage: {
+      complete: result.coverage.complete,
+      nextCursor: result.coverage.nextCursor,
+      truncated: true,
+      truncatedReasons: result.coverage.truncatedReasons
+    }
+  };
+  const candidates = [
+    compactLabels,
+    withAnchorLimit(2),
+    withAnchorLimit(1),
+    withAnchorLimit(0),
+    identityFacts,
+    coverageOnly,
+    continuationOnly,
+    { truncated: true, truncatedReasons: ["tool_result_budget"] },
+    {}
+  ];
+  return candidates.find((candidate) => countTokens(JSON.stringify(candidate)) <= maxToolResultTokens) ?? {};
+}
+function truncateModelLabel(value) {
+  const chars = Array.from(value);
+  return chars.length > MODEL_LABEL_MAX_LENGTH ? `${chars.slice(0, MODEL_LABEL_MAX_LENGTH).join("")}\u2026` : value;
+}
+async function preprocessBySession(context, messages) {
+  const bySession = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    const group = bySession.get(message.sessionId) ?? [];
+    group.push({ ...message });
+    bySession.set(message.sessionId, group);
+  }
+  const safe = [];
+  const processedBySession = /* @__PURE__ */ new Map();
+  for (const [sessionId, group] of bySession) {
+    const processed = await context.preprocessMessagesBySession(sessionId, group);
+    const byMessageId = /* @__PURE__ */ new Map();
+    for (const message of processed) {
+      if (message.sessionId === sessionId) byMessageId.set(message.messageId, message);
+    }
+    processedBySession.set(sessionId, byMessageId);
+  }
+  for (const message of messages) {
+    const processed = processedBySession.get(message.sessionId)?.get(message.messageId);
+    if (processed) safe.push(processed);
+  }
+  return safe;
+}
+function limitMessagesToBudget(messages, maxToolResultTokens, buildPayload, options = {}) {
+  const prepared = messages.map((message) => ({
+    ...message,
+    content: message.content.length > 500 ? `${message.content.slice(0, 500)}\u2026` : message.content
+  }));
+  if (!maxToolResultTokens || maxToolResultTokens <= 0) {
+    return { messages: prepared, truncated: false };
+  }
+  const countTokens = options.countTokens ?? estimatePayloadTokens;
+  const priorityIndexes = [...new Set(options.priorityIndexes ?? prepared.map((_, index) => index))].filter(
+    (index) => index >= 0 && index < prepared.length
+  );
+  if (!options.continueAfterOverflow) {
+    let low = 0;
+    let high = priorityIndexes.length;
+    while (low < high) {
+      const middle = Math.ceil((low + high) / 2);
+      const candidateIndexes = priorityIndexes.slice(0, middle).sort((left, right) => left - right);
+      const candidateMessages = candidateIndexes.map((candidateIndex) => prepared[candidateIndex]);
+      const truncated = candidateMessages.length < prepared.length;
+      const serializedCandidate = JSON.stringify(buildPayload(candidateMessages, truncated));
+      if (countTokens(serializedCandidate) <= maxToolResultTokens) low = middle;
+      else high = middle - 1;
+    }
+    const limitedIndexes = priorityIndexes.slice(0, low).sort((left, right) => left - right);
+    const limited2 = limitedIndexes.map((index) => prepared[index]);
+    return { messages: limited2, truncated: limited2.length < prepared.length };
+  }
+  const selectedIndexes = /* @__PURE__ */ new Set();
+  for (const index of priorityIndexes) {
+    const candidateIndexes = [...selectedIndexes, index].sort((left, right) => left - right);
+    const candidateMessages = candidateIndexes.map((candidateIndex) => prepared[candidateIndex]);
+    const truncated = candidateMessages.length < prepared.length;
+    const serializedCandidate = JSON.stringify(buildPayload(candidateMessages, truncated));
+    if (countTokens(serializedCandidate) > maxToolResultTokens) {
+      if (options.continueAfterOverflow) continue;
+      break;
+    }
+    selectedIndexes.add(index);
+  }
+  const limited = [...selectedIndexes].sort((left, right) => left - right).map((index) => prepared[index]);
+  return { messages: limited, truncated: limited.length < prepared.length };
+}
+function limitEntityResolutionToBudget(resolution, contactLookups, maxToolResultTokens, injectedCountTokens) {
+  const fullData = { ...resolution, contactLookups };
+  if (!maxToolResultTokens || maxToolResultTokens <= 0) return fullData;
+  const countTokens = injectedCountTokens ?? estimatePayloadTokens;
+  const scopeItems2 = buildEntityResolutionScopePriority(resolution);
+  let includeLookupHints = true;
+  let emptyPayload = buildEntityResolutionPayload(resolution, contactLookups, scopeItems2, 0, includeLookupHints);
+  if (countTokens(JSON.stringify(emptyPayload)) > maxToolResultTokens) {
+    includeLookupHints = false;
+    emptyPayload = buildEntityResolutionPayload(resolution, contactLookups, scopeItems2, 0, includeLookupHints);
+  }
+  if (countTokens(JSON.stringify(emptyPayload)) > maxToolResultTokens) {
+    return buildMinimalEntityResolutionPayload(resolution, contactLookups, maxToolResultTokens, countTokens);
+  }
+  let low = 0;
+  let high = scopeItems2.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    const candidate = buildEntityResolutionPayload(resolution, contactLookups, scopeItems2, middle, includeLookupHints);
+    if (countTokens(JSON.stringify(candidate)) <= maxToolResultTokens) low = middle;
+    else high = middle - 1;
+  }
+  return buildEntityResolutionPayload(resolution, contactLookups, scopeItems2, low, includeLookupHints);
+}
+function buildEntityResolutionScopePriority(resolution) {
+  const items = [];
+  for (const [sessionIndex, session] of resolution.sessions.entries()) {
+    if (session.status === "resolved" && session.session) items.push({ kind: "session", sessionIndex, session });
+  }
+  const contactSessions = resolution.contacts.map(
+    (contact) => [...contact.sessions].sort(
+      (left, right) => (right.lastMessageTs ?? Number.NEGATIVE_INFINITY) - (left.lastMessageTs ?? Number.NEGATIVE_INFINITY)
+    )
+  );
+  for (let depth = 0; ; depth++) {
+    let added = false;
+    for (const [contactIndex, sessions] of contactSessions.entries()) {
+      const session = sessions[depth];
+      if (!session) continue;
+      items.push({ kind: "contact", contactIndex, session });
+      added = true;
+    }
+    if (!added) break;
+  }
+  return items;
+}
+function buildEntityResolutionPayload(resolution, contactLookups, scopeItems2, selectedScopeCount, includeLookupHints) {
+  const selectedContactSessions = /* @__PURE__ */ new Map();
+  const selectedSessionIndexes = /* @__PURE__ */ new Set();
+  for (const item of scopeItems2.slice(0, selectedScopeCount)) {
+    if (item.kind === "session") {
+      selectedSessionIndexes.add(item.sessionIndex);
+      continue;
+    }
+    const sessions2 = selectedContactSessions.get(item.contactIndex) ?? [];
+    sessions2.push(item.session);
+    selectedContactSessions.set(item.contactIndex, sessions2);
+  }
+  const truncated = selectedScopeCount < scopeItems2.length;
+  const contacts = resolution.contacts.map((contact, index) => {
+    const sessions2 = selectedContactSessions.get(index) ?? [];
+    return {
+      ref: contact.ref,
+      status: contact.status,
+      cacheStatus: contact.cacheStatus,
+      sessionCount: contact.sessions.length,
+      returnedSessions: sessions2.length,
+      sessions: sessions2,
+      unresolvedSessionCount: contact.unresolvedSessionIds.length,
+      failedSessionCount: contact.failedSessionIds.length
+    };
+  });
+  const sessions = resolution.sessions.filter(
+    (session, index) => session.status === "unresolved" || selectedSessionIndexes.has(index)
+  );
+  return {
+    contacts,
+    sessions,
+    unresolved: resolution.unresolved,
+    coverage: {
+      ...resolution.coverage,
+      returnedContactEntities: contacts.length,
+      returnedSessionEntities: sessions.length,
+      returnedSourceScopes: selectedScopeCount,
+      truncated,
+      truncatedReasons: truncated ? ["tool_result_budget"] : []
+    },
+    contactLookups: buildModelContactLookups(contactLookups, includeLookupHints)
+  };
+}
+function buildModelContactLookups(contactLookups, includeHints) {
+  return contactLookups.map((lookup) => ({
+    query: lookup.query,
+    status: lookup.status,
+    cacheStatus: lookup.cacheStatus,
+    totalCandidates: lookup.totalCandidates,
+    candidates: lookup.candidates.map((candidate) => {
+      const hints = includeHints && lookup.status === "ambiguous" ? candidate.sourceSessions.slice(0, 3) : [];
+      return {
+        contactKey: candidate.contactKey,
+        displayName: candidate.displayName,
+        platform: candidate.platform,
+        aliases: candidate.aliases.slice(0, 8),
+        aliasCount: candidate.aliases.length,
+        sourceSessionCount: candidate.sourceSessions.length,
+        sourceSessionHintsReturned: hints.length,
+        sourceSessionHintsTruncated: lookup.status === "ambiguous" && hints.length < candidate.sourceSessions.length,
+        ...hints.length > 0 ? {
+          sourceSessionHints: hints
+        } : {}
+      };
+    })
+  }));
+}
+function buildMinimalEntityResolutionPayload(resolution, contactLookups, maxToolResultTokens, countTokens) {
+  const coverage = {
+    ...resolution.coverage,
+    returnedContactEntities: 0,
+    returnedSessionEntities: 0,
+    returnedSourceScopes: 0,
+    truncated: true,
+    truncatedReasons: ["tool_result_budget"]
+  };
+  const candidates = [
+    {
+      contacts: [],
+      sessions: [],
+      unresolved: [],
+      coverage,
+      contactLookups: contactLookups.map((lookup) => ({
+        query: lookup.query,
+        status: lookup.status,
+        totalCandidates: lookup.totalCandidates
+      }))
+    },
+    { coverage },
+    { truncated: true, truncatedReasons: ["tool_result_budget"] }
+  ];
+  return candidates.find((candidate) => countTokens(JSON.stringify(candidate)) <= maxToolResultTokens) ?? {
+    truncated: true
+  };
+}
+function estimatePayloadTokens(text) {
+  let cjkChars = 0;
+  let otherChars = 0;
+  for (const char of text) {
+    const codePoint = char.codePointAt(0) ?? 0;
+    if (codePoint >= 13312 && codePoint <= 19903 || codePoint >= 19968 && codePoint <= 40959 || codePoint >= 12352 && codePoint <= 12543 || codePoint >= 44032 && codePoint <= 55215) {
+      cjkChars++;
+    } else {
+      otherChars++;
+    }
+  }
+  return Math.ceil(cjkChars / 1.6 + otherChars / 4);
+}
+function buildContextPriority(messages, anchorMessageId) {
+  const anchorIndex = messages.findIndex((message) => message.messageId === anchorMessageId);
+  if (anchorIndex < 0) return messages.map((_, index) => index);
+  const indexes = [anchorIndex];
+  for (let distance = 1; indexes.length < messages.length; distance++) {
+    const before = anchorIndex - distance;
+    const after = anchorIndex + distance;
+    if (before >= 0) indexes.push(before);
+    if (after < messages.length) indexes.push(after);
+  }
+  return indexes;
+}
+function toModelMessage(message) {
+  return {
+    sessionId: message.sessionId,
+    sessionName: message.sessionName,
+    sessionType: message.sessionType,
+    messageId: message.messageId,
+    senderId: message.senderId,
+    senderName: message.senderName,
+    timestamp: message.timestamp,
+    content: message.content,
+    evidenceRole: message.evidenceRole
+  };
+}
+function summarizeEvidenceSelection(messages) {
+  let matchedMessages = 0;
+  let contextMessages = 0;
+  let privateMessages = 0;
+  let groupMessages = 0;
+  for (const message of messages) {
+    if (message.evidenceRole === "context") contextMessages++;
+    else matchedMessages++;
+    if (message.sessionType === "private") privateMessages++;
+    else groupMessages++;
+  }
+  return { matchedMessages, contextMessages, privateMessages, groupMessages };
+}
+function toEvidenceSource(message) {
+  return {
+    sessionId: message.sessionId,
+    sessionName: message.sessionName,
+    sessionType: message.sessionType,
+    platform: message.platform,
+    messageId: message.messageId,
+    senderName: message.senderName,
+    timestamp: message.timestamp,
+    snippet: message.content
+  };
+}
+function parseStringArray(value) {
+  if (!Array.isArray(value)) throw new Error("keywords must be an array");
+  return value.map((item) => requireString(item, "keyword")).filter(Boolean);
+}
+function parseNumberArray(value) {
+  if (!Array.isArray(value)) throw new Error("memberIds must be an array");
+  return value.map((item) => requireNumber(item, "memberId"));
+}
+function requireString(value, name) {
+  if (typeof value !== "string" || !value.trim()) throw new Error(`${name} is required`);
+  return value.trim();
+}
+function requireNumber(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${name} must be a number`);
+  return value;
+}
+function requireBoolean(value) {
+  if (typeof value !== "boolean") throw new Error("include_roster_only must be a boolean");
+  return value;
+}
+function parseOptionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../../packages/tools/src/definitions/memory-tools.ts
+var readSchema = {
+  type: "object",
+  properties: {
+    scope_type: { type: "string", enum: ["global", "self", "contact", "group"] },
+    scope_id: {
+      type: "string",
+      description: "Stable contactKey or group sessionId. Omit for global and self memory."
+    },
+    query: {
+      type: "string",
+      description: "Current question or topic used to rank memories inside the authorized scope."
+    },
+    limit: { type: "number", minimum: 1, maximum: 50, default: 20 }
+  },
+  required: ["scope_type"]
+};
+var writeSchema = {
+  type: "object",
+  properties: {
+    id: { type: "string", description: "Stable memory ID. Provide it to update an existing memory." },
+    scope_type: { type: "string", enum: ["global", "self", "contact", "group"] },
+    scope_id: {
+      type: "string",
+      description: "Stable contactKey or group sessionId. Omit for global and self memory."
+    },
+    content: { type: "string", description: "One durable fact or preference, without chat transcripts." },
+    source_type: {
+      type: "string",
+      enum: ["user", "ai"],
+      description: "Use user only for explicit user-provided facts or corrections; use ai for derived conclusions."
+    }
+  },
+  required: ["scope_type", "content", "source_type"]
+};
+var forgetSchema = {
+  type: "object",
+  properties: {
+    id: { type: "string", description: "Stable memory ID returned by memory_read or memory_write." }
+  },
+  required: ["id"]
+};
+var memoryReadTool = {
+  name: "memory_read",
+  description: "Read durable global preferences, facts about the user, or memories for one resolved contact/group. Pass the current question or topic as query to rank relevant entries inside that authorized scope. Self memory is read on demand and is never injected automatically. AI-derived memories are leads and must be re-verified against current chat evidence.",
+  inputSchema: readSchema,
+  handler: memoryReadHandler
+};
+var memoryWriteTool = {
+  name: "memory_write",
+  description: "Create or update one durable memory. Read the target scope first, use stable entity IDs, and never store transcripts, temporary requests, or ordinary statistics.",
+  inputSchema: writeSchema,
+  executionMode: "sequential",
+  handler: memoryWriteHandler
+};
+var memoryForgetTool = {
+  name: "memory_forget",
+  description: "Permanently delete one memory by its stable ID after the user asks to forget or confirms it is invalid.",
+  inputSchema: forgetSchema,
+  executionMode: "sequential",
+  handler: memoryForgetHandler
+};
+async function memoryReadHandler(params, context) {
+  const scope = parseScope(params);
+  await assertResolvableEntityScope(scope, context);
+  const limit = parseLimit(params.limit);
+  const query = optionalString(params.query);
+  const searchResult = query ? context.memoryService.search(scope, query, context.locale) : { entries: context.memoryService.list(scope), retrievalMode: "recent_fallback" };
+  const allEntries = searchResult.entries;
+  const entries = allEntries.slice(0, limit);
+  const truncated = allEntries.length > entries.length;
+  const verificationGuidance = entries.some((entry) => entry.sourceType === "ai") ? context.locale?.startsWith("zh") ? "\u6807\u8BB0\u4E3A ai \u7684\u8BB0\u5FC6\u53EA\u662F\u8C03\u67E5\u7EBF\u7D22\uFF0C\u4F7F\u7528\u524D\u5FC5\u987B\u91CD\u65B0\u67E5\u8BE2\u539F\u59CB\u804A\u5929\u8BC1\u636E\u3002" : "Memories marked ai are investigation leads. Re-query the original chat evidence before using them." : null;
+  const data = { entries, truncated, retrievalMode: searchResult.retrievalMode, verificationGuidance };
+  return { content: JSON.stringify(data), data };
+}
+async function memoryWriteHandler(params, context) {
+  const scope = parseScope(params);
+  await assertResolvableEntityScope(scope, context);
+  const content = requireString2(params.content, "content");
+  const sourceType = parseSourceType(params.source_type);
+  const id = optionalString(params.id);
+  let entry;
+  if (id) {
+    const current = context.memoryService.get(id);
+    if (!current) throw new Error(`AI memory not found: ${id}`);
+    if (current.scopeType !== scope.scopeType || current.scopeId !== scope.scopeId) {
+      throw new Error("AI memory scope does not match the existing memory");
+    }
+    entry = context.memoryService.update(id, {
+      content,
+      sourceType,
+      sourceAIChatId: context.aiChatId,
+      sourceMessageId: null
+    });
+  } else {
+    entry = context.memoryService.create({
+      ...scope,
+      content,
+      sourceType,
+      sourceAIChatId: context.aiChatId,
+      sourceMessageId: null
+    });
+  }
+  context.reportMemoryChange?.(entry.id);
+  return { content: JSON.stringify(entry), data: entry };
+}
+async function memoryForgetHandler(params, context) {
+  const id = requireString2(params.id, "id");
+  const current = context.memoryService.get(id);
+  if (!current) {
+    const data2 = { id, deleted: false };
+    return { content: JSON.stringify(data2), data: data2 };
+  }
+  await assertResolvableEntityScope(current, context, true);
+  const data = { id, deleted: context.memoryService.forget(id) };
+  return { content: JSON.stringify(data), data };
+}
+function parseScope(params) {
+  const scopeType = params.scope_type;
+  if (scopeType !== "global" && scopeType !== "self" && scopeType !== "contact" && scopeType !== "group") {
+    throw new Error("scope_type must be global, self, contact, or group");
+  }
+  const scopeId = optionalString(params.scope_id);
+  if (scopeType === "global" || scopeType === "self") {
+    if (scopeId) throw new Error(`${scopeType} memory does not accept scope_id`);
+    return { scopeType, scopeId: null };
+  }
+  if (!scopeId) throw new Error(`${scopeType} memory requires a stable scope_id`);
+  return { scopeType, scopeId };
+}
+function parseSourceType(value) {
+  if (value !== "user" && value !== "ai") throw new Error("source_type must be user or ai");
+  return value;
+}
+function parseLimit(value) {
+  if (value === void 0) return 20;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > 50) {
+    throw new Error("limit must be an integer between 1 and 50");
+  }
+  return value;
+}
+function requireString2(value, field) {
+  const normalized = optionalString(value);
+  if (!normalized) throw new Error(`${field} is required`);
+  return normalized;
+}
+function optionalString(value) {
+  if (typeof value !== "string") return null;
+  return value.trim() || null;
+}
+async function assertResolvableEntityScope(scope, context, requireCurrentTurnEntity = false) {
+  if (scope.scopeType === "global" || scope.scopeType === "self") return;
+  const currentTurnRefs = [...context.entityRefs ?? [], ...context.resolvedEntityRefs ?? []];
+  const matchesCurrentTurn = currentTurnRefs.some((ref2) => matchesMemoryScope(ref2, scope));
+  if ((requireCurrentTurnEntity || currentTurnRefs.length > 0) && !matchesCurrentTurn) {
+    throw new Error("scope_id must match an entity selected or resolved for the current turn");
+  }
+  const ref = scope.scopeType === "contact" ? { type: "contact", contactKey: scope.scopeId, displayName: scope.scopeId } : { type: "session", sessionId: scope.scopeId, displayName: scope.scopeId, sessionType: "group" /* GROUP */ };
+  const resolution = await context.analysisService.resolveEntities([ref], {
+    signal: context.abortSignal
+  });
+  if (scope.scopeType === "contact") {
+    const resolved2 = resolution.contacts.some(
+      (item) => item.ref.contactKey === scope.scopeId && (item.status === "resolved" || item.status === "partial")
+    );
+    if (!resolved2) throw new Error("scope_id must be a resolvable stable contact ID");
+    return;
+  }
+  const resolved = resolution.sessions.some(
+    (item) => item.ref.sessionId === scope.scopeId && item.status === "resolved" && item.session?.sessionType === "group" /* GROUP */
+  );
+  if (!resolved) throw new Error("scope_id must be a resolvable stable group ID");
+}
+function matchesMemoryScope(ref, scope) {
+  return scope.scopeType === "contact" ? ref.type === "contact" && ref.contactKey === scope.scopeId : ref.type === "session" && ref.sessionType === "group" /* GROUP */ && ref.sessionId === scope.scopeId;
+}
+
 // ../../packages/tools/src/sql/definitions.ts
 var SQL_TOOL_DEFS = [
   // ==================== 通用分析 ====================
@@ -1773,6 +3379,21 @@ var AGENT_TOOL_REGISTRY = [
   retrieveChatEvidenceTool,
   ...createAllSqlToolDefinitions(SQL_TOOL_DEFS)
 ];
+var CROSS_CHAT_AGENT_TOOL_REGISTRY = [
+  resolveChatEntitiesTool,
+  readRecentSessionTool,
+  searchMessagesGloballyTool,
+  getCrossChatMessageContextTool,
+  getCrossChatOverviewTool,
+  rankPrivateContactsTool,
+  rankGroupSessionsTool,
+  getGlobalActivitySummaryTool,
+  inspectContactSessionsTool,
+  inspectSharedInteractionsTool,
+  memoryReadTool,
+  memoryWriteTool,
+  memoryForgetTool
+];
 var SEMANTIC_SEARCH_TOOL_NAME = semanticSearchCurrentChatTool.name;
 var RETRIEVE_CHAT_EVIDENCE_TOOL_NAME = retrieveChatEvidenceTool.name;
 var MCP_TOOL_REGISTRY = [
@@ -1929,6 +3550,24 @@ async function executeToolForAgent(tool, params, context) {
     return { content: [{ type: "text", text: `Error: ${message}` }], details: null, isError: true };
   }
 }
+function createCrossChatAgentToolAdapters(context) {
+  const runContext = {
+    ...context,
+    resolvedEntityRefs: context.resolvedEntityRefs ?? []
+  };
+  return CROSS_CHAT_AGENT_TOOL_REGISTRY.map((tool) => ({
+    name: tool.name,
+    label: tool.name,
+    description: tool.description,
+    parameters: toAgentToolParameters(tool.inputSchema),
+    executionMode: tool.executionMode,
+    execute: async (_toolCallId, params, signal, onUpdate) => executeToolForAgent(tool, params, {
+      ...runContext,
+      abortSignal: signal,
+      reportProgress: (progress) => onUpdate?.({ content: [], details: { progress } })
+    })
+  }));
+}
 
 export {
   AGENT_TOOL_REGISTRY,
@@ -1936,6 +3575,7 @@ export {
   MCP_TOOL_REGISTRY,
   CoreDataProvider,
   toAgentToolParameters,
-  executeToolForAgent
+  executeToolForAgent,
+  createCrossChatAgentToolAdapters
 };
-//# sourceMappingURL=chunk-HWIXK7SU.mjs.map
+//# sourceMappingURL=chunk-FM3GXNEO.mjs.map