@openmarket/rooms-client 0.5.1 → 0.7.0

package/src/agent/armed-mode.ts

@@ -164,6 +164,17 @@ export function ownSeqsOf(entries: ReadonlyArray<RoomLedgerEntry>, ownUserId: st
  * to the user. Agent posts, system entries, the user's own posts, and
  * non-mentions never trigger. Pure.
  */
+/** Webhook-ingested entries are machine posts even though isAgent is
+ *  false (the flag marks agent USERS). They must never count as the human
+ *  in any autonomy gate: a webhook @mention cannot start an unreviewed
+ *  autonomous turn, and webhook chatter cannot satisfy the
+ *  human-activity brake. */
+function isWebhookEntry(entry: RoomLedgerEntry): boolean {
+  return Boolean(
+    (entry.metadata as { webhook?: unknown } | undefined)?.webhook,
+  );
+}
+
 export function isTriggeringEntry(
   entry: RoomLedgerEntry,
   ownHandle: string,
@@ -172,7 +183,10 @@ export function isTriggeringEntry(
 ): boolean {
   if (entry.type !== RoomLedgerEntryType.POST) return false;
   if (entry.isAgent) return false;
-  if (!entry.text?.trim()) return false;
+  if (isWebhookEntry(entry)) return false;
+  // A poll is substantive content even with no caption, and a captionless
+  // poll REPLY is addressed at us like any other reply.
+  if (!entry.text?.trim() && entry.poll == null) return false;
   // Never trigger on our own message (we post as this handle/userId).
   const fromHandle = normalizeHandle(entry.handle).toLowerCase();
   const me = normalizeHandle(ownHandle).toLowerCase();
@@ -185,7 +199,9 @@ export function isTriggeringEntry(
   // old mentionsAgent) fired on ordinary words for short handles like "may" /
   // "btc"; armed posting has no human review, so it triggers ONLY on an `@handle`
   // token. Empty handle never matches (mentionsAgentExplicit guards it).
-  return mentionsAgentExplicit(entry.text, ownHandle);
+  // Mentions can live in the poll question too (member-authored content).
+  const mentionSource = [entry.text ?? "", entry.poll?.question ?? ""].filter(Boolean).join(" ");
+  return mentionsAgentExplicit(mentionSource, ownHandle);
 }
 
 /**
@@ -379,11 +395,12 @@ export function isHumanResetEntry(
 ): boolean {
   if (entry.type !== RoomLedgerEntryType.POST) return false;
   if (entry.isAgent) return false;
+  if (isWebhookEntry(entry)) return false;
   if (entry.userId === ownUserId) return false;
   const fromHandle = normalizeHandle(entry.handle).toLowerCase();
   const me = normalizeHandle(ownHandle).toLowerCase();
   if (me.length > 0 && fromHandle === me) return false;
-  return Boolean(entry.text?.trim());
+  return Boolean(entry.text?.trim()) || entry.poll != null;
 }
 
 /** Note a turn/post error against the kill switch; returns true once the room

package/src/agent/clients/common.ts

@@ -1,6 +1,14 @@
 import { getProviders, type KnownProvider } from "@earendil-works/pi-ai";
 
-export type SurfaceId = "cli" | "telegram" | "discord" | "slack" | "webui";
+/** Every chat surface, as a runtime list. The `SurfaceId` union derives from
+ *  this literal so per-surface policy checklists (packages/cli/test/
+ *  harness-budgets.test.ts) can iterate the surfaces at runtime while a new
+ *  entry still breaks type-exhaustive tables at compile time. Adding a
+ *  surface here requires classifying it in EVERY policy set (see AGENTS.md,
+ *  "Harness invariants"). */
+export const SURFACE_IDS = ["cli", "telegram", "discord", "slack", "webui"] as const;
+
+export type SurfaceId = (typeof SURFACE_IDS)[number];
 
 export interface AgentToolCall {
   id: string;
@@ -16,6 +24,11 @@ export type AgentMessage =
 export interface ToolDispatchResult {
   isError?: true;
   content: string;
+  /** Full-fidelity render payload for in-process SURFACES (e.g. the TUI's
+   *  backtest card). Present only on the streamed copy channels consume —
+   *  the agent runtime strips it before the result reaches the model's
+   *  messages or the conversation store, so it never costs context. */
+  artifact?: unknown;
 }
 
 export interface LlmTool {
@@ -79,7 +92,10 @@ export type RunLlmTurn = (input: RunLlmTurnInput) => AsyncIterable<TurnEvent>;
 export function stringifyToolContent(value: unknown): string {
   if (value === undefined) return "";
   if (typeof value === "string") return value;
-  return JSON.stringify(value, null, 2);
+  // Compact on purpose: this string is LLM input, and 2-space pretty-printing
+  // inflated every structured tool result by roughly a fifth in tokens for
+  // zero model benefit.
+  return JSON.stringify(value);
 }
 
 export function parseToolArguments(raw: unknown): unknown {

package/src/agent/topic-inbox.ts

@@ -26,6 +26,20 @@ import type {
 /** The reserved bucket key for untopicked (linear) messages. */
 export const UNTOPICKED_BUCKET = "";
 
+/** Effective attention for a bucket: an elapsed timed mute reads as the
+ *  base attention ('default'). The store expires timed mutes lazily (no
+ *  deadline-triggered frame), so a hydrated inbox would otherwise stay
+ *  muted past the deadline until the next hydration. A null or absent
+ *  deadline keeps the stored attention (permanent mute). */
+export function resolveTopicAttention(
+  state: Pick<RoomTopicBucketState, "attention" | "muteUntil">,
+  nowMs: number = Date.now(),
+): RoomTopicAttention {
+  if (state.attention !== "mute" || state.muteUntil == null) return state.attention;
+  const deadline = Date.parse(state.muteUntil);
+  return Number.isFinite(deadline) && deadline <= nowMs ? "default" : "mute";
+}
+
 export interface TopicInboxItem {
   /** Bucket key: a topicId, or UNTOPICKED_BUCKET for the linear lane. */
   key: string;
@@ -141,7 +155,7 @@ export class RoomTopicInbox {
   }
 
   attentionFor(topicId: string): RoomTopicAttention {
-    return this.bucketFor(topicId).attention;
+    return resolveTopicAttention(this.bucketFor(topicId));
   }
 
   /** A registry mutation arrived (TOPIC_UPDATED, or a verb result echo). */
@@ -196,6 +210,10 @@ export class RoomTopicInbox {
       this.buckets.set(topicId, bucket);
     }
     bucket.attention = attention;
+    // The mirror knows only the new attention: a stale deadline from a
+    // previous timed mute must not expire it. The next hydration restores
+    // any server-side deadline.
+    delete bucket.muteUntil;
   }
 
   /**
@@ -224,7 +242,7 @@ export class RoomTopicInbox {
   channelUnread(): number {
     let total = 0;
     for (const bucket of this.buckets.values()) {
-      if (bucket.attention === "mute") continue;
+      if (resolveTopicAttention(bucket) === "mute") continue;
       total += bucket.unreadCount;
     }
     return total;
@@ -241,7 +259,7 @@ export class RoomTopicInbox {
   inboxItems(): TopicInboxItem[] {
     const items: TopicInboxItem[] = [];
     const untopicked = this.bucketFor(UNTOPICKED_BUCKET);
-    if (untopicked.unreadCount > 0 && untopicked.attention !== "mute") {
+    if (untopicked.unreadCount > 0 && resolveTopicAttention(untopicked) !== "mute") {
       items.push({
         key: UNTOPICKED_BUCKET,
         topic: undefined,
@@ -254,11 +272,11 @@ export class RoomTopicInbox {
     for (const topic of this.topics.values()) {
       if (topic.mergedInto) continue;
       const state = this.bucketFor(topic.topicId);
-      if (state.attention === "mute") continue;
+      if (resolveTopicAttention(state) === "mute") continue;
       let aliasUnread = 0;
       for (const alias of this.aliasesOf(topic.topicId)) {
         const aliasState = this.bucketFor(alias);
-        if (aliasState.attention === "mute") continue;
+        if (resolveTopicAttention(aliasState) === "mute") continue;
         aliasUnread += aliasState.unreadCount;
       }
       if (state.unreadCount + aliasUnread === 0) continue;

package/src/shared/rooms-protocol.ts

@@ -250,6 +250,19 @@ export interface RoomLedgerEntry {
   since?: string | number | null | undefined;
   reactions?: Array<{ emoji: string; count: number }> | undefined;
   editedAt?: string | number | Date | undefined;
+  /** Database-serialized edit counter: positive integer, strictly
+   *  increasing per event row, incremented on every successful text or
+   *  caption edit; absent means never edited. Orders caption edits where
+   *  wall-clock editedAt stamps can tie or skew across store replicas.
+   *  Missing on stores older than edit revisions. */
+  editRevision?: number | undefined;
+  /** Database-serialized card-mutation counter: positive integer,
+   *  strictly increasing per event row, bumped on every unfurl card
+   *  mutation (attach, edit-drop, purge); absent means cards were never
+   *  mutated. Consumers apply card patches only at or above their known
+   *  revision, making stale post-removal unfurl frames inert. Missing on
+   *  stores older than unfurl revisions. */
+  unfurlsRevision?: number | undefined;
   deletedAt?: string | number | Date | undefined;
   deletedBy?: string | undefined;
   replyCount?: number | undefined;
@@ -258,8 +271,14 @@ export interface RoomLedgerEntry {
   pinnedBy?: string | null | undefined;
   pinnedAt?: string | number | Date | null | undefined;
   attachments?: RoomAttachment[] | undefined;
+  /** Counts-only poll summary when this message carries a poll. Additive:
+   *  non-poll entries omit it, and live updates ride ENTRY_UPDATED. */
+  poll?: RoomPollSummary | null | undefined;
+  /** Server-rendered link unfurl cards. Additive: entries without links
+   *  (and servers older than the unfurl worker) omit it. */
+  unfurls?: RoomUnfurl[] | undefined;
   roomRole?: RoomRole | null | undefined;
-  metadata?: (Record<string, unknown> & Partial<RoomForwardMetadata>) | undefined;
+  metadata?: (Record<string, unknown> & Partial<RoomForwardMetadata> & Partial<RoomWebhookMetadata>) | undefined;
 }
 
 export type RoomForwardedFrom =
@@ -278,6 +297,19 @@ export interface RoomForwardMetadata {
   forwardedFrom: RoomForwardedFrom;
 }
 
+/** Sender identity for messages posted through a channel webhook (the
+ *  Discord-compatible ingest). Entries carrying it render the webhook's
+ *  name and avatar with an APP-style badge; the entry's handle mirrors
+ *  the display name and its userId is the synthetic `webhook:<id>`, so a
+ *  webhook can never impersonate a member. */
+export interface RoomWebhookMetadata {
+  webhook: {
+    id: string;
+    name: string;
+    avatarUrl?: string | undefined;
+  };
+}
+
 export interface RoomAttachment {
   /**
    * Object key under room-attachments/; clients sign it at render time.
@@ -300,6 +332,49 @@ export interface RoomAttachment {
  */
 export type RoomAttachmentInput = RoomAttachment & { key: string };
 
+export interface RoomPollOption {
+  id: string;
+  text: string;
+  /** Vote count for this option. Counts only, never voter identities
+   *  (voters are fetched on demand, exactly like reactors). */
+  count: number;
+}
+
+/**
+ * Counts-only poll summary denormalized onto the carrying message (a poll
+ * IS a message). Vote/close/edit updates ride the existing ENTRY_UPDATED
+ * frame with the refreshed summary; the server's side collections stay the
+ * authoritative copy.
+ */
+export interface RoomPollSummary {
+  question: string;
+  options: RoomPollOption[];
+  multi: boolean;
+  /** ISO date when the poll auto-closes; null or absent means open-ended. */
+  closesAt?: string | null | undefined;
+  closed: boolean;
+  /** Store-serialized poll ordering revision, strictly increasing per
+   *  poll: consumers reject frames below their known revision so
+   *  bus-reordered vote/close updates cannot regress tallies. Present
+   *  where the relay forwards it; missing on older relays. */
+  revision?: number | undefined;
+}
+
+/**
+ * Server-rendered link unfurl card on an entry. `url` is the canonical
+ * URL; `thumbnailKey` is the re-hosted copy in the attachments bucket,
+ * signed through the member-scoped attachment path. The origin's image URL
+ * never crosses the wire. Cards appear via ENTRY_UPDATED when the unfurl
+ * worker lands.
+ */
+export interface RoomUnfurl {
+  url: string;
+  title?: string | undefined;
+  description?: string | undefined;
+  siteName?: string | undefined;
+  thumbnailKey?: string | undefined;
+}
+
 /**
  * A registry-backed topic inside a channel. The id is permanent: rename
  * changes `name` only, and links (`om://topic/<topicId>`) keep resolving.
@@ -370,6 +445,21 @@ export interface RoomReadStatePayload {
    *  Present when the store surfaces it and on ROOM_SET_ATTENTION acks
    *  (which reply READ_STATE scoped to the one room, readState empty). */
   attention?: Record<string, RoomTopicAttention> | undefined;
+  /** Per-room timed-mute expiry (ISO date), keyed like attention. Rides
+   *  beside a 'mute' attention entry when the mute carries an expiry; null
+   *  marks an explicitly cleared or permanent mute. A lapsed expiry never
+   *  appears: the server resolves it at read time and the attention value
+   *  reads as its base ('default'). Missing on servers older than
+   *  mute-with-duration. */
+  muteUntil?: Record<string, string | null> | undefined;
+  /** Per-room attention commit revision, keyed like attention: a
+   *  database-serialized, strictly increasing counter per (user, room),
+   *  present only for rooms whose attention has ever been committed.
+   *  ORDERING CONTRACT: a consumer that has synced revision R for a room
+   *  must ignore snapshot attention entries whose revision is <= R (a
+   *  snapshot read before a newer commit can arrive after that commit's
+   *  sync frame). Missing on stores older than attention revisions. */
+  attentionRevision?: Record<string, number> | undefined;
   /** Unread mention counts by room, server-computed from the notify
    *  worker's ROOM_MENTION rows so badges survive reload and clear through
    *  the ack path. Unlike readState/attention the map is SPARSE AND
@@ -593,7 +683,7 @@ export interface RoomDmMessage {
   createdAt?: string | number | undefined;
   /** Sealed DM: content is '' and the opaque envelope rides here. */
   secret?: RoomLedgerSecretPayload | null | undefined;
-  metadata?: (Record<string, unknown> & Partial<RoomForwardMetadata>) | undefined;
+  metadata?: (Record<string, unknown> & Partial<RoomForwardMetadata> & Partial<RoomWebhookMetadata>) | undefined;
   /** Legacy public chat-image URL (renders as-is, no signing). */
   imageUrl?: string | null | undefined;
   /** Private, signed, scanned DM attachments (dm-attachments/ keyspace).
@@ -982,6 +1072,14 @@ export interface RoomTopicBucketState {
   unreadCount: number;
   cursor: number;
   attention: RoomTopicAttention;
+  /** Standing timed-mute deadline (ISO date; null = permanent mute).
+   *  Present only on the room-wide '' bucket and only while its attention
+   *  is an active 'mute'; never on topic buckets. Same semantics as the
+   *  read-state muteUntil: the store expires timed mutes lazily, so
+   *  consumers resolve an elapsed deadline back to the base attention
+   *  ('default') at read time (see resolveTopicAttention). Missing on
+   *  servers older than mute-with-duration. */
+  muteUntil?: string | null | undefined;
 }
 
 export interface RoomTopicResultPayload {