@ixo/oracle-runtime-workers 0.10.0 → 0.11.1

package/src/matrix/inbox-store.ts

@@ -46,6 +46,20 @@ export function ensureInboxTable(sql: SqlStorage): void {
       attempts INTEGER NOT NULL DEFAULT 0
     ) WITHOUT ROWID`,
   );
+  // Columns added after the table first shipped (the group-chat gate reads
+  // them on replay): CREATE TABLE IF NOT EXISTS leaves an existing table alone.
+  const columns = new Set(
+    sql
+      .exec<{ name: string }>(`PRAGMA table_info(turn_inbox)`)
+      .toArray()
+      .map((row) => row.name),
+  );
+  if (!columns.has('mentions_bot'))
+    sql.exec(
+      `ALTER TABLE turn_inbox ADD COLUMN mentions_bot INTEGER NOT NULL DEFAULT 0`,
+    );
+  if (!columns.has('in_reply_to'))
+    sql.exec(`ALTER TABLE turn_inbox ADD COLUMN in_reply_to TEXT`);
 }
 
 /** Record a message before its turn starts. A repeat of the same event id is a no-op. */
@@ -56,8 +70,8 @@ export function insertInboxRow(
 ): void {
   sql.exec(
     `INSERT OR IGNORE INTO turn_inbox
-      (event_id, room_id, sender, ts, body, thread_root_id, attachment, received_at, attempts)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0)`,
+      (event_id, room_id, sender, ts, body, thread_root_id, attachment, received_at, attempts, mentions_bot, in_reply_to)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)`,
     msg.eventId,
     msg.roomId,
     msg.sender,
@@ -66,6 +80,8 @@ export function insertInboxRow(
     msg.threadRootId ?? null,
     msg.attachment ? JSON.stringify(msg.attachment) : null,
     receivedAt,
+    msg.mentionsBot ? 1 : 0,
+    msg.inReplyTo ?? null,
   );
 }
 
@@ -112,13 +128,15 @@ type InboxSqlRow = {
   attachment: string | null;
   received_at: number;
   attempts: number;
+  mentions_bot: number;
+  in_reply_to: string | null;
 } & Record<string, SqlStorageValue>;
 
 /** Every pending row, oldest first (the order the messages arrived in). */
 export function listInboxRows(sql: SqlStorage): InboxRow[] {
   return sql
     .exec<InboxSqlRow>(
-      `SELECT event_id, room_id, sender, ts, body, thread_root_id, attachment, received_at, attempts
+      `SELECT event_id, room_id, sender, ts, body, thread_root_id, attachment, received_at, attempts, mentions_bot, in_reply_to
        FROM turn_inbox ORDER BY ts ASC, event_id ASC`,
     )
     .toArray()
@@ -132,6 +150,8 @@ export function listInboxRows(sql: SqlStorage): InboxRow[] {
       ...(row.attachment
         ? { attachment: parseAttachment(row.attachment) }
         : {}),
+      ...(Number(row.mentions_bot) ? { mentionsBot: true } : {}),
+      ...(row.in_reply_to ? { inReplyTo: row.in_reply_to } : {}),
       receivedAt: Number(row.received_at),
       attempts: Number(row.attempts),
     }));

package/src/matrix/ingest.ts

@@ -7,6 +7,12 @@
  * so the sender must resolve to a user DID before anything else happens.
  * Own-message, stale and duplicate gating happens upstream, in the bot SDK's
  * pipeline; `gateway-do.ts` adapts its `BotMessage`s into `InboundMessage`s.
+ *
+ * Threads are sessions, exactly as on Node: the thread root of a message is
+ * its session id (`reply-chain.ts` resolves it; a bare message is its own
+ * root), the reply is posted into that thread, and a Portal session — whose
+ * id is its marker event — is continued by replying inside its thread. The
+ * main timeline of a room never carries a reply and is never a session.
  */
 
 import { didToAliasPart } from '../do/contracts';
@@ -28,23 +34,40 @@ export interface InboundMessage {
   ts: number;
   /** Text body; empty for a media-only message. */
   body: string;
-  /** Thread root when the message was sent inside a thread. */
+  /**
+   * The message's thread root: the `m.thread` root, the root of a quote-reply
+   * chain (`gateway-do.ts` resolves it before the offer), or — for a bare
+   * message — nothing: the message roots its own thread (`threadRootIdOf`).
+   */
   threadRootId?: string;
   /** Present for media messages — fetched and decrypted at turn time. */
   attachment?: InboundAttachment;
+  /** The bot is in the message's `m.mentions` (the group-chat gate answers a mention). */
+  mentionsBot?: boolean;
+  /** The event a quote-reply answers (`m.in_reply_to`); a reply to the bot's own message is answered too. */
+  inReplyTo?: string;
 }
 
 export interface IngestTurn {
   userDid: string;
   matrixUserId: string;
   roomId: string;
-  /** Present when the user wrote inside a thread; replies go there too. */
-  threadId?: string;
-  /** `matrix:<roomId>` (main timeline) or `thread:<threadRootId>`. */
+  /** The thread the reply goes to: the message's root, or the message itself. */
+  threadId: string;
+  /** The thread root event id — the session is the thread (Node parity). */
   sessionId: string;
   /** Debounced messages joined with newlines, oldest first. */
   message: string;
   eventIds: string[];
+  /**
+   * The message the turn's metadata comes from — the latest text message of
+   * the burst, else its first (Node's `sourceEvent`): its mentions and reply
+   * target drive the group-chat gate, its timestamp dates the turn.
+   */
+  sourceEventId: string;
+  ts: number;
+  mentionsBot: boolean;
+  inReplyTo?: string;
   /** Media shared in the same debounce window, oldest first. */
   attachments?: InboundAttachment[];
 }
@@ -52,6 +75,12 @@ export interface IngestTurn {
 export interface IngestDeps {
   /** The DID that forms the oracle half of the user↔oracle room alias. */
   oracleDid: string;
+  /**
+   * The bot's Matrix user id. Its first occurrence in a message is rewritten
+   * to `(USER MENTIONED YOU @AI_AGENT)` before the agent sees it, as the Node
+   * bridge does; omit to leave messages as sent.
+   */
+  botUserId?: string;
   debounceMs?: number;
   /** `m.room.canonical_alias` of the room, when known. */
   canonicalAlias(roomId: string): string | null;
@@ -66,6 +95,8 @@ interface Pending {
 }
 
 export const DEFAULT_DEBOUNCE_MS = 500;
+/** What the bot's own user id becomes in a message body (the Node bridge's wording). */
+export const MENTIONED_BOT_MARKER = '(USER MENTIONED YOU @AI_AGENT)';
 
 /** `did-ixo-ixo1abc` → `did:ixo:ixo1abc`. Only the first two dashes are separators. */
 export function aliasPartToDid(part: string): string | null {
@@ -119,8 +150,11 @@ export function resolveUserDid(opts: {
   return fromAlias ?? fromSender;
 }
 
-export function sessionIdFor(roomId: string, threadRootId?: string): string {
-  return threadRootId ? `thread:${threadRootId}` : `matrix:${roomId}`;
+/** The thread a message belongs to: its resolved root, else the message itself. */
+export function threadRootIdOf(
+  msg: Pick<InboundMessage, 'eventId' | 'threadRootId'>,
+): string {
+  return msg.threadRootId ?? msg.eventId;
 }
 
 export class IngestPipeline {
@@ -144,7 +178,7 @@ export class IngestPipeline {
     });
     if (!userDid) return 'unmapped';
 
-    const key = `${msg.roomId}|${sessionIdFor(msg.roomId, msg.threadRootId)}`;
+    const key = `${msg.roomId}|${threadRootIdOf(msg)}`;
     const existing = this.pending.get(key);
     if (existing) {
       clearTimeout(existing.timer);
@@ -177,27 +211,36 @@ export class IngestPipeline {
     this.pending.delete(key);
     const first = entry.messages[0];
     if (!first) return;
-    const threadId = first.threadRootId;
+    const threadId = threadRootIdOf(first);
     const texts = entry.messages.map((m) => m.body).filter((b) => b.trim());
+    const source =
+      [...entry.messages].reverse().find((m) => m.body.trim()) ?? first;
     const attachments = entry.messages.flatMap((m) =>
       m.attachment ? [m.attachment] : [],
     );
     // A file-only send still needs a user message the agent can act on —
     // the Node bridge's wording.
-    const message =
+    const raw =
       texts.length > 0
         ? texts.join('\n')
         : attachments.length === 1
           ? `User shared a file: ${attachments[0]?.filename ?? 'file'}`
           : `User shared ${attachments.length} file(s): ${attachments.map((a) => a.filename).join(', ')}`;
+    const message = this.deps.botUserId
+      ? raw.replace(this.deps.botUserId, MENTIONED_BOT_MARKER)
+      : raw;
     const turn: IngestTurn = {
       userDid: entry.userDid,
       matrixUserId: first.sender,
       roomId: first.roomId,
-      sessionId: sessionIdFor(first.roomId, threadId),
+      threadId,
+      sessionId: threadId,
       message,
       eventIds: entry.messages.map((m) => m.eventId),
-      ...(threadId ? { threadId } : {}),
+      sourceEventId: source.eventId,
+      ts: source.ts,
+      mentionsBot: source.mentionsBot === true,
+      ...(source.inReplyTo ? { inReplyTo: source.inReplyTo } : {}),
       ...(attachments.length > 0 ? { attachments } : {}),
     };
     try {

package/src/matrix/reply-chain.ts

@@ -1,15 +1,18 @@
 /**
- * Quote-reply → thread resolution — the port of the Node listener bridge's
- * `getThreadRoot`. A client that quote-replies (`m.in_reply_to`) to a
- * message that lives in a thread, without adding the `m.thread` relation
- * itself, still means "continue that thread": walk the reply chain upward
- * until an event that carries `m.thread` (→ its root) or a bare event.
+ * Thread root of an inbound message — the port of the Node listener bridge's
+ * `getThreadRoot`, and with it Node's rule for room conversations: EVERY
+ * message has a thread root, and that root is the session.
  *
- * Unlike Node — where every bare room message opens its own thread-session —
- * this runtime keeps the main timeline as ONE session (`matrix:<roomId>`), so
- * a chain that ends on a bare event resolves to "no thread" (main timeline)
- * rather than to that event. Results are memoised per event id with a
- * bounded cache; cycles and missing events terminate the walk.
+ *  - a message inside a thread (`m.thread`) → the thread's root;
+ *  - a bare message (no relation) → the message itself: the reply opens a
+ *    thread on it, and later replies in that thread continue the session;
+ *  - a quote-reply (`m.in_reply_to` without `m.thread`, from a client that
+ *    does not thread natively) → walk the reply chain upward until an event
+ *    that carries `m.thread` (→ its root) or a bare event (→ that event).
+ *
+ * The walk ends where Node's does: on a cycle, on an event that cannot be
+ * fetched, or past the hop bound, the last event reached is the root.
+ * Results are memoised per event id with a bounded cache.
  */
 
 export interface MatrixRelatesTo {
@@ -35,7 +38,7 @@ export function inReplyToOf(rel: MatrixRelatesTo | undefined): string | null {
   return typeof id === 'string' && id.length > 0 ? id : null;
 }
 
-/** Bounded event-id → thread-root ('' = main timeline) memo. */
+/** Bounded event-id → thread-root memo. */
 export class ThreadRootCache {
   private readonly map = new Map<string, string>();
 
@@ -56,7 +59,7 @@ export class ThreadRootCache {
 
 export interface ResolveReplyChainInput {
   eventId: string;
-  /** The event's own relation (from the clear or wire content). */
+  /** The event's own relation (from the clear or wire content); undefined for a bare message. */
   relatesTo: MatrixRelatesTo | undefined;
   /** Fetches a room event's `m.relates_to` (null when the event is unavailable). */
   fetchRelatesTo: (eventId: string) => Promise<MatrixRelatesTo | null>;
@@ -66,44 +69,50 @@ export interface ResolveReplyChainInput {
 }
 
 /**
- * Thread root for the event, or `null` for the main timeline. Never throws:
- * a fetch failure ends the walk at the last known event (→ main timeline).
+ * The thread root of the event (see the module comment). Never throws: a
+ * fetch failure ends the walk at the event that could not be fetched.
  */
 export async function resolveReplyChainRoot(
   input: ResolveReplyChainInput,
-): Promise<string | null> {
+): Promise<string> {
   const { eventId, relatesTo, fetchRelatesTo, cache } = input;
   const maxHops = input.maxHops ?? 25;
-  const remember = (ids: string[], root: string | null): string | null => {
-    for (const id of ids) cache.set(id, root ?? '');
+  const remember = (ids: string[], root: string): string => {
+    for (const id of ids) cache.set(id, root);
     return root;
   };
 
   const own = threadRootOf(relatesTo);
   if (own) return remember([eventId], own);
   const firstParent = inReplyToOf(relatesTo);
-  if (!firstParent) return remember([eventId], null);
+  // A bare message roots its own thread.
+  if (!firstParent) return remember([eventId], eventId);
 
   const path = [eventId];
   const visited = new Set<string>([eventId]);
-  let cursor: string | null = firstParent;
+  let cursor: string = firstParent;
   let hops = 0;
-  while (cursor && !visited.has(cursor) && hops < maxHops) {
-    hops += 1;
+  for (;;) {
     visited.add(cursor);
     path.push(cursor);
     const known = cache.get(cursor);
-    if (known !== undefined) return remember(path, known === '' ? null : known);
+    if (known !== undefined) return remember(path, known);
     let parentRel: MatrixRelatesTo | null;
     try {
       parentRel = await fetchRelatesTo(cursor);
     } catch {
       parentRel = null;
     }
-    if (parentRel === null) return remember(path, null);
+    // Unavailable: the quoted event is the best root there is (Node's
+    // fallback is the last cursor as well).
+    if (parentRel === null) return remember(path, cursor);
     const parentRoot = threadRootOf(parentRel);
     if (parentRoot) return remember(path, parentRoot);
-    cursor = inReplyToOf(parentRel);
+    const next = inReplyToOf(parentRel);
+    // A bare ancestor is the root of the chain.
+    if (!next) return remember(path, cursor);
+    hops += 1;
+    if (visited.has(next) || hops >= maxHops) return remember(path, cursor);
+    cursor = next;
   }
-  return remember(path, null);
 }

package/src/plugin-api/tool-helper.ts

@@ -17,6 +17,11 @@ export interface ToolHelperOptions {
    * `manifest.visibility` setting.
    */
   visibility?: PluginTool['visibility'];
+  /**
+   * `'read'` for a tool with no external effect (safe to run again when a
+   * turn resumes after a reset); omitted or `'write'` otherwise.
+   */
+  effect?: PluginTool['effect'];
   /**
    * Billing gate marker, kept for source compatibility with the Node
    * runtime's plugin contract. The Workers runtime has no commerce lane, so
@@ -49,7 +54,7 @@ export function tool(
   if (!options || typeof options !== 'object') {
     throw new TypeError('tool(handler, options): `options` is required.');
   }
-  const { name, description, schema, visibility, billing } = options;
+  const { name, description, schema, visibility, billing, effect } = options;
   if (!name || typeof name !== 'string') {
     throw new TypeError(
       'tool(handler, options): `options.name` must be a non-empty string.',
@@ -78,5 +83,8 @@ export function tool(
   if (billing !== undefined) {
     pluginTool.billing = billing;
   }
+  if (effect !== undefined) {
+    pluginTool.effect = effect;
+  }
   return pluginTool;
 }

package/src/plugin-api/types.ts

@@ -78,6 +78,56 @@ export interface MatrixEvent {
   readonly originServerTs?: number;
 }
 
+export interface MatrixRoomInfo {
+  isDirect: boolean;
+  memberCount: number;
+  joinedMemberIds: string[];
+  /**
+   * Whether the deployment runs the group-chat lane in group rooms
+   * (`MATRIX_GROUP_ROOMS=gate` on the gateway). False by default: the bot
+   * then never speaks in a group room and the channel-memory tools are not
+   * offered.
+   */
+  groupLane: boolean;
+}
+
+/** One compacted batch of a group room's messages (the Node `ChannelMemoryChunk`). */
+export interface ChannelMemoryChunk {
+  id: string;
+  roomId: string;
+  summary: string;
+  fromEventId: string;
+  toEventId: string;
+  fromTimestamp: number;
+  toTimestamp: number;
+  messageCount: number;
+  participants: string[];
+  threadIds: string[];
+  tier: number;
+  createdAt: number;
+}
+
+export interface PinnedRoomFact {
+  id: string;
+  roomId: string;
+  fact: string;
+  pinnedByDid: string;
+  sourceEventId?: string;
+  createdAt: number;
+}
+
+export interface ChannelRoomMember {
+  matrixUserId: string;
+  displayName: string;
+  did?: string;
+}
+
+export interface ChannelMemoryRecall {
+  chunks: ChannelMemoryChunk[];
+  pinnedFacts: PinnedRoomFact[];
+  members: ChannelRoomMember[];
+}
+
 /** Memory-enriched user context (mirrors `state.userContext`). */
 export type UserContextData = Record<string, unknown>;
 
@@ -521,6 +571,34 @@ export interface RuntimeContext<TConfig = MergedConfig> {
     ) => Promise<string>;
     getRoomState: (roomId: string) => Promise<RoomStateSnapshot>;
     getEventById: (roomId: string, eventId: string) => Promise<MatrixEvent>;
+    /**
+     * Whether a room is a direct room or a group room — the Node
+     * `MatrixManager.getRoomInfo` (`is_direct` on the create event, else
+     * ≤ 2 joined members), cached by the gateway. Absent on hosts without a
+     * Matrix gateway.
+     */
+    roomInfo?: (roomId: string) => Promise<MatrixRoomInfo>;
+    /**
+     * A group room's channel memory (the `matrix-group-chats` plugin's
+     * tools read and write it): compacted summary chunks, pinned facts and
+     * the member roster, kept by the gateway per room. Absent on hosts
+     * without a Matrix gateway.
+     */
+    channelMemory?: {
+      recall: (roomId: string, limit?: number) => Promise<ChannelMemoryRecall>;
+      search: (
+        roomId: string,
+        query: string,
+        limit?: number,
+      ) => Promise<ChannelMemoryChunk[]>;
+      pin: (args: {
+        roomId: string;
+        fact: string;
+        pinnedByDid: string;
+        sourceEventId?: string;
+      }) => Promise<PinnedRoomFact>;
+      unpin: (roomId: string, factId: string) => Promise<boolean>;
+    };
     /**
      * Credentials of the oracle's own crypto-less device for plugins that run
      * their own Matrix client (editor, flows). Minted and kept by the gateway.
@@ -790,6 +868,14 @@ export interface PluginTool {
   handler: (args: unknown, ctx: RuntimeContext) => Promise<unknown>;
   /** Override visibility — by default inherits from the plugin's `manifest.visibility`. */
   visibility?: 'always' | 'on-demand' | 'silent';
+  /**
+   * Whether calling the tool changes anything outside the conversation.
+   * `'read'` tools may be executed again when a turn is resumed after a
+   * runtime reset; a `'write'` (the default for undeclared tools) call that
+   * was cut off mid-execution is never repeated — the model is told its
+   * outcome is unknown. See `core/middlewares/tool-marks.ts`.
+   */
+  effect?: 'read' | 'write';
   /**
    * Billing gate. `'contracted'` marks a tool that performs paid contracted
    * work: the runtime binds it only while the turn runs inside an active work

package/src/plugins/index.ts

@@ -21,6 +21,7 @@ import { UserPreferencesPlugin } from './user-preferences';
 import { PortalPlugin } from './portal';
 import { AGUIPlugin } from './agui';
 import { AttachmentsPlugin } from './attachments';
+import { MatrixGroupChatsPlugin } from './matrix-group-chats';
 
 export * from './composio';
 export * from './editor';
@@ -46,6 +47,7 @@ export const userPreferencesPlugin = new UserPreferencesPlugin();
 export const portalPlugin = new PortalPlugin();
 export const aguiPlugin = new AGUIPlugin();
 export const attachmentsPlugin = new AttachmentsPlugin();
+export const matrixGroupChatsPlugin = new MatrixGroupChatsPlugin();
 /** TasksPlugin is already an object (defineOraclePlugin), not a class. */
 export const tasksPlugin = TasksPlugin;
 
@@ -67,4 +69,5 @@ export const BUNDLED_WORKERS_PLUGINS = [
   portalPlugin,
   aguiPlugin,
   attachmentsPlugin,
+  matrixGroupChatsPlugin,
 ] as const satisfies readonly OraclePlugin[];

package/src/plugins/matrix-group-chats/README.md

@@ -0,0 +1,70 @@
+# matrix-group-chats (Workers)
+
+**Status: under development — off by default.** The port of the Node
+runtime's `matrix-group-chats` plugin is complete and tested (unit, local
+harness, devnet), but it has not been reviewed for production use and it
+differs from Node in the ways listed below. Until that review, every
+deployment runs with the gateway's `MATRIX_GROUP_ROOMS=silent` (the default):
+the bot never speaks in a room with more than two members and captures
+nothing there. It only talks in direct rooms — the user↔oracle room and the
+task rooms it creates. Set `MATRIX_GROUP_ROOMS=gate` on the gateway to turn
+the lane on for a deployment; `answer` replies to everything (Node without
+the plugin).
+
+How it works when enabled: [operations — Rooms: group chats](../../../docs/operations.md#rooms-group-chats).
+Env knobs: [configuration](../../../docs/configuration.md#matrix).
+Drills: `pnpm test:e2e:group` (gate) and `GROUP_ROOMS=silent pnpm test:e2e:group`
+(the default) in `apps/qiforge-workers-example`; unit tests in
+`src/matrix/group-chat.test.ts` and this directory.
+
+## What is the Node contract, unchanged
+
+- The gate and its order: a direct room always answers; in a group room the
+  bot answers a message that mentions it (`m.mentions.user_ids`), a
+  quote-reply to one of its own messages, or a message in a thread it
+  answered within `GROUP_CHAT_ACTIVE_THREAD_TTL_MS` (30 min); otherwise it
+  stays silent. An answer is skipped when the bot's power level is below the
+  room's `m.room.message` threshold or `GROUP_CHAT_REQUIRE_POWER_LEVEL`.
+- Every group message, answered or not, is captured into the room's channel
+  memory; batches are compacted with the Node summarizer prompt, verbatim,
+  into summary chunks (FTS5 search with the porter tokenizer, LIKE fallback,
+  `OR` of the words, ranked), next to pinned facts and the member roster.
+- The four tools with Node's names, descriptions and schemas:
+  `recall_channel_memory`, `search_channel_memory`, `pin_room_fact`,
+  `unpin_room_fact` — offered only to a session in a group room.
+- A group message reaches the model as `[DisplayName]: …`; the bot's own
+  user id in a message body becomes `(USER MENTIONED YOU @AI_AGENT)`; the
+  message's `additional_kwargs` carry `senderDid`, `senderMatrixUserId`,
+  `senderDisplayName`, `threadId`, `eventId`.
+- Compaction at 20 buffered messages, and just in time before an answer when
+  5 or more are buffered, capped at 3 s so the reply is not held up.
+- The `delegation_required` prompt for a member without a delegation is
+  posted into the room the message came from, as on Node.
+
+## Where it differs from Node
+
+| Area                                                                                                      | Node                                                                                                                                                                                                              | Workers                                                                                                                                                                    | Why                                                                                                                                                                                                  |
+| --------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Where the gate runs                                                                                       | An agent middleware inside the speaker's turn: every group message was dispatched as a turn (typing indicator, `work_status` card, the message appended to the speaker's thread history) and then ended silently. | The gateway decides before a turn exists: an ignored message shows no typing, posts no card, wakes no user object and is not appended to the speaker's thread history.     | Cheaper, and a member who cannot boot a user object never fails a turn for a message nobody would answer. Cross-person context came from channel memory on both runtimes.                            |
+| Direct-room rule                                                                                          | `is_direct` on the create event, else ≤ 2 joined members.                                                                                                                                                         | The same two rules, plus: a room whose canonical alias is a user↔oracle alias of this oracle is direct whatever its member count.                                          | A real user↔oracle room also holds the rooms appservice bot and the memory-engine bot (four members on devnet); Node's rule alone would gate the oracle's own conversation with its user.            |
+| Active threads after a restart                                                                            | Scanned the room's last 100 messages for the bot's own replies.                                                                                                                                                   | A durable `group_bot_threads` table written whenever the bot decides to answer; nothing is scanned.                                                                        | The gateway restarts far more often than a Node process; a table read is local and exact. Threads answered before this build are not in it — one mention re-activates them.                          |
+| Where channel memory lives                                                                                | One SQLite file per room on the oracle's disk, gzipped and uploaded into the room as an encrypted media event (`qiforge.channel_memory.v1`) after every change, restored from there on a cold start.              | The gateway's Durable Object SQLite (`group_*` tables), which survives deploys on its own; nothing is uploaded to the room.                                                | No disk and no need for the room copy on Workers. A Node-era snapshot in a room is **not imported**; the tables use Node's column layout, so an importer is a small addition.                        |
+| Who runs the summarizer                                                                                   | The oracle process, `session-title` model role.                                                                                                                                                                   | The speaker's user object (`summarizeGroupMessages` RPC), same model role and prompt.                                                                                      | The gateway script holds no model keys.                                                                                                                                                              |
+| Compaction buffer                                                                                         | In memory; lost on restart.                                                                                                                                                                                       | Durable (`group_message_buffer`); a replayed message is not buffered twice.                                                                                                | Gateway resets are routine.                                                                                                                                                                          |
+| Idle compaction                                                                                           | After 5 quiet minutes.                                                                                                                                                                                            | Not ported; the next engagement compacts the buffer (threshold and just-in-time triggers are unchanged).                                                                   | The gateway's alarm belongs to the bot SDK. A quiet room's summary exists by the first moment anyone could read it.                                                                                  |
+| Tier rollups (weekly / monthly)                                                                           | Code present, never scheduled.                                                                                                                                                                                    | Not ported; `tier` stays 1.                                                                                                                                                | Dead on Node.                                                                                                                                                                                        |
+| Prompt injection of roster, pinned facts, recent messages (`buildSessionContext`) and `getCurrentSpeaker` | Code present, never called.                                                                                                                                                                                       | Not ported.                                                                                                                                                                | Dead on Node.                                                                                                                                                                                        |
+| Speaker prefix on file messages                                                                           | Strings only.                                                                                                                                                                                                     | Also the first text block of block content (a caption with an attachment).                                                                                                 | Workers' attachment pipeline produces block content.                                                                                                                                                 |
+| Members without a delegation                                                                              | Answered (a turn needed no delegation; memory calls failed softly).                                                                                                                                               | On a VFS-backed deployment their user object cannot boot, so a mention from them ends in the "try again" notice.                                                           | The Workers owner-copy design: the user's history file lives in their VFS and needs their delegation. The Portal deposits one for whoever invites the oracle into a room, not for the other members. |
+| Enabling                                                                                                  | On by default (`features: { 'matrix-group-chats': false }` to turn off).                                                                                                                                          | `MATRIX_GROUP_ROOMS` on the gateway: `silent` (default), `gate`, `answer`. Disabling the plugin only removes the tools; the gateway policy decides whether the bot speaks. | The gate is runtime infrastructure here, not a plugin middleware.                                                                                                                                    |
+
+## Open items before this can be the default
+
+- Review the divergences above with the product owner.
+- Decide whether members without a delegation should be prompted in group
+  rooms (the Portal's `delegation_required` listener is deliberately not
+  mounted) or answered without a user file.
+- Decide whether Node-era channel-memory snapshots need importing.
+- Decide whether task rooms should be recognised by the gateway's own record
+  of the rooms it created rather than by member count (a task room with a
+  third member becomes a group room today).