@openchambery/web 1.18.2-beta.4 → 1.18.2-beta.40

package/server/lib/event-stream/diff-summary.js

@@ -1,9 +1,13 @@
 // ---------------------------------------------------------------------------
-// Outbound FileDiff summarization for message-stream fan-out.
+// Outbound FileDiff summarization for message-stream fan-out and Host L1.
 //
-// Mirrors packages/ui/src/sync/sanitize.ts summarizeFileDiff(s) so Host never
-// pushes full patch/before/after/from/to blobs over Relay/WS (>64KB frames).
-// Pure JS — do not import UI TypeScript from the server package.
+// L1 (ordinary first-packet / SSE / exact message GET):
+//   keep `info.summary.diffs` as a slim file list
+//   `{ file, status?, additions, deletions }` plus additive
+//   `diffCount` / `hasDiffs` markers. Never ship patch bodies on these paths.
+//
+// Explicit L2/L3 APIs may still use summarizeFileDiff(s) for file-list / patch
+// responses. Pure JS — do not import UI TypeScript from the server package.
 // ---------------------------------------------------------------------------
 
 /** Lightweight FileDiff fields safe for outbound event frames (preview only). */
@@ -62,7 +66,15 @@ export function summarizeFileDiffs(diffs) {
   return changed ? next : diffs;
 }
 
-const summarizeSummaryDiffs = (owner) => {
+/**
+ * L1 projection: keep `summary.diffs` as a slim file-list array and set
+ * additive `diffCount` / `hasDiffs` markers. Drops patch/before/after/from/to.
+ * Keeps every other lightweight summary field. Identity when unchanged.
+ *
+ * @param {unknown} owner message info / session info / summary-bearing object
+ * @returns {unknown}
+ */
+export const projectMessageSummaryDiffSlim = (owner) => {
   if (!owner || typeof owner !== 'object' || Array.isArray(owner)) {
     return owner;
   }
@@ -72,12 +84,18 @@ const summarizeSummaryDiffs = (owner) => {
     return owner;
   }
 
-  if (!Array.isArray(summary.diffs)) {
+  if (!Object.prototype.hasOwnProperty.call(summary, 'diffs')) {
     return owner;
   }
 
-  const stripped = summarizeFileDiffs(summary.diffs);
-  if (stripped === summary.diffs) {
+  const rawDiffs = summary.diffs;
+  const slimDiffs = Array.isArray(rawDiffs) ? summarizeFileDiffs(rawDiffs) : [];
+  const diffCount = slimDiffs.length;
+  const hasDiffs = diffCount > 0;
+
+  const diffsUnchanged = slimDiffs === rawDiffs;
+  const markersMatch = summary.diffCount === diffCount && summary.hasDiffs === hasDiffs;
+  if (diffsUnchanged && markersMatch) {
     return owner;
   }
 
@@ -85,17 +103,27 @@ const summarizeSummaryDiffs = (owner) => {
     ...owner,
     summary: {
       ...summary,
-      diffs: stripped,
+      diffs: slimDiffs,
+      diffCount,
+      hasDiffs,
     },
   };
 };
 
+/** @deprecated Prefer projectMessageSummaryDiffSlim — same L1 slim-list behavior. */
+export const projectMessageSummaryDiffCounts = projectMessageSummaryDiffSlim;
+
+/** @deprecated Prefer projectMessageSummaryDiffSlim — L1 keeps slim file list + markers. */
+export const summarizeMessageDiffSnapshots = projectMessageSummaryDiffSlim;
+
 /**
  * Summarize FileDiff bodies on outbound event payloads.
  *
  * Handles:
  * - `session.diff` with legacy `properties.diff` or current `data.diff`
+ *   (keeps file/status/additions/deletions; drops patch bodies)
  * - message/session objects carrying `summary.diffs` under properties/data info
+ *   (L1: slim file list + diffCount/hasDiffs; never patch bodies)
  *
  * Non-diff events keep identity.
  */
@@ -154,7 +182,7 @@ export function summarizeOutboundEventPayload(payload) {
 
       // Common shape: properties.info.summary.diffs
       if (body.info && typeof body.info === 'object' && !Array.isArray(body.info)) {
-        const nextInfo = summarizeSummaryDiffs(body.info);
+        const nextInfo = projectMessageSummaryDiffSlim(body.info);
         if (nextInfo !== body.info) {
           next = {
             ...next,
@@ -169,7 +197,7 @@ export function summarizeOutboundEventPayload(payload) {
       }
 
       // Rare: properties.summary.diffs directly on the properties/data body
-      const nextBody = summarizeSummaryDiffs(body);
+      const nextBody = projectMessageSummaryDiffSlim(body);
       if (nextBody !== body) {
         next = {
           ...next,

package/server/lib/event-stream/diff-summary.test.js

@@ -1,6 +1,8 @@
 import { describe, expect, it } from 'vitest';
 
 import {
+  projectMessageSummaryDiffCounts,
+  projectMessageSummaryDiffSlim,
   summarizeFileDiff,
   summarizeFileDiffs,
   summarizeOutboundEventPayload,
@@ -48,6 +50,67 @@ describe('summarizeFileDiffs', () => {
   });
 });
 
+describe('projectMessageSummaryDiffSlim', () => {
+  it('keeps slim summary.diffs and sets diffCount/hasDiffs', () => {
+    const owner = {
+      id: 'msg_1',
+      summary: {
+        title: 'turn',
+        diffs: [
+          { file: 'a.ts', additions: 1, deletions: 0, patch: '@@' },
+          { file: 'b.ts', additions: 2, deletions: 1, before: 'x', after: 'y' },
+        ],
+      },
+    };
+
+    const next = projectMessageSummaryDiffSlim(owner);
+    expect(next).not.toBe(owner);
+    expect(next.summary).toEqual({
+      title: 'turn',
+      diffs: [
+        { file: 'a.ts', additions: 1, deletions: 0 },
+        { file: 'b.ts', additions: 2, deletions: 1 },
+      ],
+      diffCount: 2,
+      hasDiffs: true,
+    });
+    expect(JSON.stringify(next)).not.toContain('patch');
+    expect(JSON.stringify(next)).not.toContain('"before"');
+    expect(JSON.stringify(next)).not.toContain('"after"');
+  });
+
+  it('projects empty arrays to slim list + diffCount 0 / hasDiffs false', () => {
+    const owner = {
+      summary: { diffs: [] },
+    };
+    expect(projectMessageSummaryDiffSlim(owner).summary).toEqual({
+      diffs: [],
+      diffCount: 0,
+      hasDiffs: false,
+    });
+  });
+
+  it('keeps identity when summary has no diffs key', () => {
+    const owner = { summary: { title: 'x', diffCount: 3, hasDiffs: true } };
+    expect(projectMessageSummaryDiffSlim(owner)).toBe(owner);
+  });
+
+  it('keeps identity when diffs already slim and markers match', () => {
+    const owner = {
+      summary: {
+        diffs: [{ file: 'a.ts', additions: 1, deletions: 0 }],
+        diffCount: 1,
+        hasDiffs: true,
+      },
+    };
+    expect(projectMessageSummaryDiffSlim(owner)).toBe(owner);
+  });
+
+  it('exports projectMessageSummaryDiffCounts as a compatible alias', () => {
+    expect(projectMessageSummaryDiffCounts).toBe(projectMessageSummaryDiffSlim);
+  });
+});
+
 describe('summarizeOutboundEventPayload', () => {
   it('summarizes session.diff properties.diff', () => {
     const payload = {
@@ -97,7 +160,7 @@ describe('summarizeOutboundEventPayload', () => {
     }]);
   });
 
-  it('summarizes message.updated info.summary.diffs', () => {
+  it('projects message.updated info.summary.diffs to L1 slim list + markers', () => {
     const payload = {
       type: 'message.updated',
       properties: {
@@ -109,6 +172,8 @@ describe('summarizeOutboundEventPayload', () => {
               additions: 1,
               deletions: 0,
               patch: '@@',
+              from: 'blob-a',
+              to: 'blob-b',
             }],
           },
         },
@@ -116,11 +181,13 @@ describe('summarizeOutboundEventPayload', () => {
     };
 
     const next = summarizeOutboundEventPayload(payload);
-    expect(next.properties.info.summary.diffs).toEqual([{
-      file: 'a.ts',
-      additions: 1,
-      deletions: 0,
-    }]);
+    expect(next.properties.info.summary).toEqual({
+      diffs: [{ file: 'a.ts', additions: 1, deletions: 0 }],
+      diffCount: 1,
+      hasDiffs: true,
+    });
+    expect(JSON.stringify(next)).not.toContain('patch');
+    expect(JSON.stringify(next)).not.toContain('blob-a');
   });
 
   it('returns identity for session.status', () => {

package/server/lib/event-stream/protocol.test.js

@@ -223,7 +223,7 @@ describe('event stream protocol helpers', () => {
     expect(rawPayload.length).toBeLessThan(64 * 1024);
   });
 
-  it('summarizes message.updated summary.diffs patches on outbound frames', () => {
+  it('projects message.updated summary.diffs to L1 slim list + markers on outbound frames', () => {
     let rawPayload = null;
     const socket = {
       readyState: 1,
@@ -246,6 +246,8 @@ describe('event stream protocol helpers', () => {
               additions: 2,
               deletions: 1,
               patch: '@@ heavy patch body @@\n' + 'y'.repeat(1000),
+              before: 'old',
+              after: 'new',
             }],
           },
         },
@@ -254,13 +256,74 @@ describe('event stream protocol helpers', () => {
 
     expect(sent).toBe(true);
     const frame = JSON.parse(rawPayload);
-    expect(frame.payload.properties.info.summary.diffs).toEqual([{
-      file: 'a.ts',
-      status: 'modified',
-      additions: 2,
-      deletions: 1,
-    }]);
+    expect(frame.payload.properties.info.summary).toEqual({
+      diffs: [{
+        file: 'a.ts',
+        status: 'modified',
+        additions: 2,
+        deletions: 1,
+      }],
+      diffCount: 1,
+      hasDiffs: true,
+    });
     expect(JSON.stringify(frame)).not.toContain('patch');
+    expect(JSON.stringify(frame)).not.toContain('"before"');
+    expect(JSON.stringify(frame)).not.toContain('"after"');
+  });
+
+  it('keeps L1 message.updated serialization under 256KiB for a 463-file / ~14MB patch summary', () => {
+    let rawPayload = null;
+    const socket = {
+      readyState: 1,
+      send(payload) {
+        rawPayload = payload;
+      },
+    };
+
+    const patchBody = 'P'.repeat(Math.floor((14 * 1024 * 1024) / 463));
+    const diffs = Array.from({ length: 463 }, (_, i) => ({
+      file: `src/generated/file-${i}.ts`,
+      status: 'modified',
+      additions: i % 7,
+      deletions: i % 3,
+      patch: `${patchBody}-${i}`,
+      before: `before-${i}`,
+      after: `after-${i}`,
+      from: `from-${i}`,
+      to: `to-${i}`,
+    }));
+
+    const sent = sendMessageStreamWsEvent(socket, {
+      type: 'message.updated',
+      properties: {
+        info: {
+          id: 'msg_huge',
+          sessionID: 'ses_huge',
+          role: 'assistant',
+          summary: { title: 'huge', diffs },
+        },
+      },
+    });
+
+    expect(sent).toBe(true);
+    const frame = JSON.parse(rawPayload);
+    const summary = frame.payload.properties.info.summary;
+    expect(summary.diffCount).toBe(463);
+    expect(summary.hasDiffs).toBe(true);
+    expect(summary.diffs).toHaveLength(463);
+    expect(summary.diffs[0]).toEqual({
+      file: 'src/generated/file-0.ts',
+      status: 'modified',
+      additions: 0,
+      deletions: 0,
+    });
+    expect(rawPayload).not.toContain(patchBody.slice(0, 64));
+    expect(rawPayload).not.toContain('"patch"');
+    expect(rawPayload).not.toContain('"before"');
+    expect(rawPayload).not.toContain('"after"');
+    expect(rawPayload).not.toContain('"from"');
+    expect(rawPayload).not.toContain('"to"');
+    expect(Buffer.byteLength(rawPayload, 'utf8')).toBeLessThan(256 * 1024);
   });
 
   it('leaves ordinary session.status events unchanged', () => {

package/server/lib/message-queue/DOCUMENTATION.md

@@ -67,7 +67,7 @@ The root snapshot contains a catalog of scope identity, revision, lifecycle stat
 
 ## Manual send and optimistic chip projection
 
-Manual send stores a one-time durable dispatch intent at any moment (waiting statuses only). Scope and item DTOs expose the non-sensitive authoritative `manualDispatchRequested` field. Authoritative tracking rows—`manualDispatchRequested === true`, `sending`, and `reconciling`—remain durable until exact confirmation/tombstone, but UI chips hide them as already-sent tracking. `failed` / `unresolved` restore chip visibility and retry. Pending client send mutations hide the target chip immediately (same optimistic filter as edit/remove); a definitive mutation failure clears the overlay so the authoritative waiting/failed/unresolved row reappears. After the mutation leaves `pending`, a successful send keeps a **committed-ack-revision shadow**: the client result carries `committedRevision` from the action receipt even when post-commit scope reload fails, and chips continue hiding that exact runtime generation/scope send target while the authoritative scope revision is still behind the ack. Shadow ends when scope revision reaches the ack, the runtime generation changes, or the success mutation is cleaned from the MutationCache. The overlay never writes the revision-pinned Query cache.
+Manual send stores a one-time durable dispatch intent at any moment (waiting statuses only). Scope and item DTOs expose the non-sensitive authoritative `manualDispatchRequested` field. Authoritative tracking rows—`manualDispatchRequested === true`, `sending`, and `reconciling`—remain durable until exact confirmation/tombstone. UI chips keep pending client send, committed-ack send shadows, and authoritative `manualDispatchRequested` visible in a **"Sending…"** state (parallel to pending-admission "Queuing…"); chips hide only after authoritative `sending`/`reconciling` (or removal/confirm). `failed` / `unresolved` restore normal Send/Edit. Pending client send mutations leave the target chip visible; a definitive mutation failure clears the overlay so Send/Edit return. After the mutation leaves `pending`, a successful send keeps a **committed-ack-revision shadow**: the client result carries `committedRevision` from the action receipt even when post-commit scope reload fails, and the shadow continues selecting that exact runtime generation/scope send target for "Sending…" UI ownership while the authoritative scope revision is still behind the ack. Shadow ends when scope revision reaches the ack, the runtime generation changes, or the success mutation is cleaned from the MutationCache. Client send-pending presentation times out after 8s (`SERVER_QUEUE_SEND_PENDING_TIMEOUT_MS`) and restores clickable Send when stuck without reaching sending/reconciling/removal. The overlay never writes the revision-pinned Query cache.
 
 `beginAttempt` consumes the manual intent atomically with its message ID and attempt history; `sending` and `reconciling` status then represent active delivery tracking. Pre-attempt release and retry preserve the intent. Pause, expired-sending recovery, and ambiguity reconciliation clear the intent because the persisted attempt owns delivery certainty. Compact mutation acknowledgements retain their existing identity and revision fields. Dual-client replay of the same manual-send `requestID` returns the stored receipt once.
 

package/server/lib/notifications/DOCUMENTATION.md

@@ -45,8 +45,8 @@ This module provides notification message preparation utilities for the web serv
 - Returned API:
   - `maybeSendPushForTrigger(payload)`
 - Owns:
-  - top-level completion/question/permission trigger routing; completion is the sole task-status notification and child sessions are suppressed
-  - session parent cache for child-session suppression
+  - top-level completion/question/permission trigger routing; completion is the sole task-status notification and child sessions plus small-model system sessions (`metadata.openchamber.smallModel.purpose`) are suppressed
+  - session meta cache for child-session and small-model suppression
   - template resolution and fallback behavior
   - native notification fanout and web push payload fanout
   - push suppression while any fresh UI visibility heartbeat reports a focused client

package/server/lib/notifications/runtime.js

@@ -111,8 +111,8 @@ export const createNotificationTriggerRuntime = (deps) => {
   const notifiedPermissionRequests = new Set();
   const lastReadyNotificationAt = new Map();
 
-  const sessionParentIdCache = new Map();
-  const SESSION_PARENT_CACHE_TTL_MS = 60 * 1000;
+  const sessionMetaCache = new Map();
+  const SESSION_META_CACHE_TTL_MS = 60 * 1000;
 
   // Sessions where the client has enabled Permission Auto-Accept. Mirrored
   // from the client-side permissionStore via POST /api/notifications/auto-accept
@@ -136,43 +136,67 @@ export const createNotificationTriggerRuntime = (deps) => {
     return `/?session=${encodeURIComponent(sessionId)}`;
   };
 
-  const getSessionParentCacheKey = (sessionId, directory) => `${directory || ''}\0${sessionId}`;
+  const getSessionMetaCacheKey = (sessionId, directory) => `${directory || ''}\0${sessionId}`;
 
-  const getCachedSessionParentId = (sessionId, directory) => {
-    const cacheKey = getSessionParentCacheKey(sessionId, directory);
-    const entry = sessionParentIdCache.get(cacheKey);
+  const normalizeParentID = (value) => (
+    typeof value === 'string' && value.length > 0 ? value : null
+  );
+
+  const normalizeSmallModelPurpose = (value) => (
+    typeof value === 'string' && value.length > 0 ? value : null
+  );
+
+  const getCachedSessionMeta = (sessionId, directory) => {
+    const cacheKey = getSessionMetaCacheKey(sessionId, directory);
+    const entry = sessionMetaCache.get(cacheKey);
     if (!entry) return undefined;
-    if (Date.now() - entry.at > SESSION_PARENT_CACHE_TTL_MS) {
-      sessionParentIdCache.delete(cacheKey);
+    if (Date.now() - entry.at > SESSION_META_CACHE_TTL_MS) {
+      sessionMetaCache.delete(cacheKey);
       return undefined;
     }
-    return entry.parentID;
+    return entry;
   };
 
-  const setCachedSessionParentId = (sessionId, directory, parentID) => {
-    sessionParentIdCache.set(getSessionParentCacheKey(sessionId, directory), { parentID: parentID ?? null, at: Date.now() });
+  const setCachedSessionMeta = (sessionId, directory, meta) => {
+    const previous = getCachedSessionMeta(sessionId, directory);
+    sessionMetaCache.set(getSessionMetaCacheKey(sessionId, directory), {
+      parentID: meta.parentID !== undefined ? meta.parentID : (previous?.parentID ?? null),
+      smallModelPurpose: meta.smallModelPurpose !== undefined
+        ? meta.smallModelPurpose
+        : (previous?.smallModelPurpose ?? null),
+      at: Date.now(),
+    });
   };
 
   const getParentIdFromPayload = (payload) => {
     if (!payload || typeof payload !== 'object') return undefined;
     if (payload.type !== 'session.created' && payload.type !== 'session.updated') return undefined;
-    const parentID = payload.properties?.info?.parentID ?? null;
-    return typeof parentID === 'string' && parentID.length > 0 ? parentID : null;
+    return normalizeParentID(payload.properties?.info?.parentID);
+  };
+
+  const getSmallModelPurposeFromPayload = (payload) => {
+    if (!payload || typeof payload !== 'object') return undefined;
+    if (payload.type !== 'session.created' && payload.type !== 'session.updated') return undefined;
+    return normalizeSmallModelPurpose(payload.properties?.info?.metadata?.openchamber?.smallModel?.purpose);
   };
 
-  const maybeCacheSessionParentFromPayload = (payload) => {
+  const maybeCacheSessionMetaFromPayload = (payload) => {
     const sessionId = extractSessionIdFromPayload(payload);
     if (typeof sessionId !== 'string' || sessionId.length === 0) return;
     const directory = extractDirectoryFromPayload(payload);
     const parentID = getParentIdFromPayload(payload);
-    if (parentID === undefined) return;
-    setCachedSessionParentId(sessionId, directory, parentID);
+    const smallModelPurpose = getSmallModelPurposeFromPayload(payload);
+    if (parentID === undefined && smallModelPurpose === undefined) return;
+    setCachedSessionMeta(sessionId, directory, {
+      ...(parentID !== undefined ? { parentID } : {}),
+      ...(smallModelPurpose !== undefined ? { smallModelPurpose } : {}),
+    });
   };
 
-  const fetchSessionParentId = async (sessionId, directory) => {
+  const fetchSessionMeta = async (sessionId, directory) => {
     if (!sessionId) return undefined;
 
-    const cached = getCachedSessionParentId(sessionId, directory);
+    const cached = getCachedSessionMeta(sessionId, directory);
     if (cached !== undefined) return cached;
 
     try {
@@ -194,16 +218,22 @@ export const createNotificationTriggerRuntime = (deps) => {
         return undefined;
       }
 
-      const parentID = typeof session.parentID === 'string' && session.parentID.length > 0
-        ? session.parentID
-        : null;
-      setCachedSessionParentId(sessionId, directory, parentID);
-      return parentID;
+      const meta = {
+        parentID: normalizeParentID(session.parentID),
+        smallModelPurpose: normalizeSmallModelPurpose(session.metadata?.openchamber?.smallModel?.purpose),
+      };
+      setCachedSessionMeta(sessionId, directory, meta);
+      return meta;
     } catch {
       return undefined;
     }
   };
 
+  const fetchSessionParentId = async (sessionId, directory) => {
+    const meta = await fetchSessionMeta(sessionId, directory);
+    return meta?.parentID;
+  };
+
   // Mirrors client-side autoRespondsPermission: a session auto-accepts if it
   // OR any ancestor is flagged. Walks the parent chain via fetchSessionParentId.
   const isSessionAutoAccepting = async (sessionId, directory) => {
@@ -225,6 +255,17 @@ export const createNotificationTriggerRuntime = (deps) => {
     return typeof parentID === 'string' && parentID.length > 0;
   };
 
+  const isSmallModelSession = async (sessionId, directory) => {
+    const meta = await fetchSessionMeta(sessionId, directory);
+    return typeof meta?.smallModelPurpose === 'string' && meta.smallModelPurpose.length > 0;
+  };
+
+  const shouldSkipSystemSessionNotification = async (sessionId, directory) => {
+    if (await isSubtaskSession(sessionId, directory)) return true;
+    if (await isSmallModelSession(sessionId, directory)) return true;
+    return false;
+  };
+
   const extractSessionIdFromPayload = (payload) => {
     if (!payload || typeof payload !== 'object') return null;
     const props = payload.properties;
@@ -309,7 +350,7 @@ export const createNotificationTriggerRuntime = (deps) => {
       return;
     }
 
-    maybeCacheSessionParentFromPayload(payload);
+    maybeCacheSessionMetaFromPayload(payload);
 
     const sessionId = extractSessionIdFromPayload(payload);
     const notificationDirectory = extractDirectoryFromPayload(payload);
@@ -340,7 +381,7 @@ export const createNotificationTriggerRuntime = (deps) => {
         sessionId
         && info?.role === 'assistant'
         && (info?.finish === 'stop' || info?.finish === 'error')
-        && await isSubtaskSession(sessionId, notificationDirectory)
+        && await shouldSkipSystemSessionNotification(sessionId, notificationDirectory)
       ) {
         return;
       }
@@ -433,7 +474,7 @@ export const createNotificationTriggerRuntime = (deps) => {
     }
 
     if (payload.type === 'question.asked' && sessionId) {
-      if (await isSubtaskSession(sessionId, notificationDirectory)) {
+      if (await shouldSkipSystemSessionNotification(sessionId, notificationDirectory)) {
         return;
       }
       const existingTimer = pushQuestionDebounceTimers.get(sessionId);
@@ -534,7 +575,7 @@ export const createNotificationTriggerRuntime = (deps) => {
     }
 
     if (payload.type === 'permission.asked' && sessionId) {
-      if (await isSubtaskSession(sessionId, notificationDirectory)) {
+      if (await shouldSkipSystemSessionNotification(sessionId, notificationDirectory)) {
         return;
       }
       const requestId = payload.properties?.id ?? payload.properties?.requestID ?? payload.properties?.requestId;