borgmcp 4.9.0 → 4.10.0

package/src/read-log-digest.ts

@@ -0,0 +1,98 @@
+import type { MessageTaxonomy } from 'borgmcp-shared/templates';
+import { formatLogEntryMarkdown } from './regen-format.js';
+
+// Small backlogs remain verbatim so normal wake triage is unchanged.
+export const DIGEST_THRESHOLD = 50;
+// The latest decisions stay in full while older activity is summarized.
+export const DIGEST_TAIL = 25;
+// One reattach cannot consume an unbounded amount of local memory or output.
+export const DIGEST_FETCH_CAP = 2000;
+
+interface ReadLogDigestInput {
+  entries: any[];
+  selfDroneId: string;
+  taxonomy: MessageTaxonomy | null | undefined;
+  droneById: Map<string, any>;
+  roleById: Map<string, any>;
+  tail: number;
+  capped: number;
+}
+
+export interface ReadLogDigest {
+  text: string;
+  tailEntries: any[];
+  omitted: number;
+}
+
+function senderLabel(
+  entry: any,
+  droneById: Map<string, any>,
+  roleById: Map<string, any>,
+): string {
+  const drone = droneById.get(entry.drone_id);
+  const role = drone ? roleById.get(drone.role_id) : undefined;
+  const label = drone?.label ?? entry.drone_label ?? '?';
+  const roleName = role?.name ?? entry.role_name ?? '?';
+  return `${label} (${roleName})`;
+}
+
+function messageClass(message: unknown, taxonomy: MessageTaxonomy | null | undefined): string {
+  if (typeof message !== 'string') return 'other';
+  for (const classDef of taxonomy ?? []) {
+    if (classDef.prefixes?.some((prefix) => message.startsWith(prefix))) return classDef.class;
+  }
+  return 'other';
+}
+
+function increment(counts: Map<string, number>, key: string): void {
+  counts.set(key, (counts.get(key) ?? 0) + 1);
+}
+
+export function buildReadLogDigest(input: ReadLogDigestInput): ReadLogDigest {
+  const tailEntries = input.entries.slice(-input.tail);
+  const omitted = input.entries.length - tailEntries.length;
+  const oldest = new Date(input.entries[0].created_at).toISOString();
+  const newest = new Date(input.entries[input.entries.length - 1].created_at).toISOString();
+  const senderCounts = new Map<string, number>();
+  const classCounts = new Map<string, number>();
+
+  for (const entry of input.entries) {
+    increment(senderCounts, senderLabel(entry, input.droneById, input.roleById));
+    increment(classCounts, messageClass(entry.message, input.taxonomy));
+  }
+
+  const lines = [
+    `Reattach digest — ${input.entries.length} unread entries from ${oldest} to ${newest}; ${omitted} older entries are summarized, not shown. Older directed entries may be superseded: confirm with the sender or borg_read-entry before acting.`,
+  ];
+  if (input.capped > 0) {
+    lines.push(`${input.capped} additional unread ${input.capped === 1 ? 'entry was' : 'entries were'} not covered because the ${DIGEST_FETCH_CAP}-entry fetch cap was reached.`);
+  }
+
+  lines.push('', '## Counts by sender');
+  for (const [sender, count] of senderCounts) lines.push(`- ${sender}: ${count}`);
+  lines.push('', '## Counts by message class');
+  for (const [className, count] of classCounts) lines.push(`- ${className}: ${count}`);
+
+  const directed = input.entries.slice(0, omitted).filter((entry) =>
+    entry.visibility === 'direct' &&
+    Array.isArray(entry.recipient_drone_ids) &&
+    entry.recipient_drone_ids.includes(input.selfDroneId)
+  );
+  if (directed.length > 0) {
+    lines.push('', '## Older entries directed to this seat');
+    for (const entry of directed) {
+      const ts = new Date(entry.created_at).toISOString();
+      const message = typeof entry.message === 'string'
+        ? entry.message.replace(/\s+/g, ' ').slice(0, 120)
+        : '';
+      lines.push(`[${ts}] [entry_id: ${entry.id}] ${senderLabel(entry, input.droneById, input.roleById)}: ${message}`);
+    }
+  }
+
+  lines.push('', `## Newest ${tailEntries.length} entries`);
+  for (const entry of tailEntries) {
+    lines.push(formatLogEntryMarkdown(entry, input.droneById, input.roleById));
+  }
+
+  return { text: lines.join('\n'), tailEntries, omitted };
+}

package/src/remote-client.ts

@@ -98,6 +98,7 @@ import {
   getLocalServerCursor,
   type LocalServerCursor,
 } from './local-server-cursor.js';
+import { DIGEST_FETCH_CAP, DIGEST_THRESHOLD } from './read-log-digest.js';
 import { readBoundedResponseBody } from './server-response.js';
 import { normalizeLogAudience, type LogAudience } from './direct-log.js';
 import { RoleSectionConflictError } from './local-manage-tool-result.js';
@@ -1093,7 +1094,16 @@ export async function readLog(
     unreadOnly?: boolean;
     serverTrustIdentity?: string;
   } = {}
-): Promise<{ entries: any[]; drones: any[]; roles: any[]; behind_by?: number; has_more?: boolean }> {
+): Promise<{
+  entries: any[];
+  drones: any[];
+  roles: any[];
+  message_taxonomy?: MessageTaxonomy | null;
+  behind_by?: number;
+  has_more?: boolean;
+  digest: boolean;
+  capped: number;
+}> {
   const local = await localAuthorityContext(
     sessionToken,
     apiUrl,
@@ -1102,7 +1112,7 @@ export async function readLog(
   let cursor: LocalServerCursor | null = null;
   if (opts.unreadOnly) cursor = await getLocalServerCursor(localCursorBinding(local));
   if (opts.since !== undefined) cursor = await resolveLocalLogCursor(local, opts.since);
-  const page = await localReadLogPage(local, {
+  let page = await localReadLogPage(local, {
     cursor,
     limit: opts.limit,
     // Keep the cursor payload stable across a lost response; do not re-read or
@@ -1112,13 +1122,37 @@ export async function readLog(
   if (opts.unreadOnly && page.cursor) {
     await advanceLocalServerCursor(localCursorBinding(local), page.cursor);
   }
+  const entries = [...page.entries];
+  const backlog = entries.length + (typeof page.behind_by === 'number' ? page.behind_by : 0);
+  const digest = opts.unreadOnly === true && opts.since === undefined && backlog > DIGEST_THRESHOLD;
+  if (digest) {
+    while (page.has_more === true && entries.length < DIGEST_FETCH_CAP) {
+      if (!page.cursor || page.entries.length === 0) {
+        throw new ProtocolContractError('Unread log page reported more entries without advancing its cursor.');
+      }
+      page = await localReadLogPage(local, {
+        cursor: page.cursor,
+        limit: Math.min(500, DIGEST_FETCH_CAP - entries.length),
+        retryMode: 'unread-cursor',
+      });
+      if (page.cursor) {
+        await advanceLocalServerCursor(localCursorBinding(local), page.cursor);
+      }
+      entries.push(...page.entries);
+    }
+  }
   const composed = await localCubeComposition(local);
   return {
-    entries: page.entries,
+    entries,
     drones: composed.drones,
     roles: composed.roles,
+    message_taxonomy: composed.cube.message_taxonomy ?? null,
     behind_by: page.behind_by,
     has_more: page.has_more,
+    digest,
+    capped: digest && page.has_more === true && typeof page.behind_by === 'number'
+      ? page.behind_by
+      : 0,
   };
 }
 

package/src/tool-manifest.ts

@@ -220,7 +220,7 @@ const BASE_TOOL_MANIFEST: ToolManifestEntry[] = [
             "with the drone that wrote it and that drone's role. For wake triage, prefer " +
             '`unread_only=true` with a modest limit and drain until `has_more=false`; ' +
             'this reads oldest-unread-first from your server cursor and ' +
-            'advances the watermark so bursts are not skipped. Optional `since` is a strict-after ' +
+            'advances the watermark so bursts are not skipped. A backlog above 50 returns a digest plus the newest 25 entries. Optional `since` is a strict-after ' +
             'cursor for explicit bounded reads only; do not use it with the same timestamp as a ' +
             'notification preview because it can skip the boundary entry. Use `borg_read-entry` ' +
             'to fetch one known entry without changing the unread cursor.',
@@ -915,6 +915,7 @@ export const TOOL_OUTPUT_SCHEMAS: Record<string, OutputSchema> = {
       entries: { type: 'array', items: LOG_ENTRY_OUTPUT },
       behind_by: { type: ['number', 'null'], description: 'Visible entries still unread after this read; null when the server did not report it.' },
       has_more: { type: 'boolean' },
+      omitted: { type: 'number', description: 'Older fetched entries summarized outside the structured entry tail; absent when digest mode was not used.' },
     },
     required: ['entries', 'behind_by', 'has_more'],
   },