@agentvault/claude-bridge 0.3.1 → 0.3.3

package/dist/bridge.d.ts

@@ -9,17 +9,38 @@ export interface RoomMessage {
 export interface MessageMeta {
     roomId?: string;
 }
+/** #392 room hush (advisory) — emitted by SecureChannel from the backend's
+ *  `room_hushed` event. ``hushedUntil`` is an ISO string, or null when cleared. */
+export interface RoomHushed {
+    roomId: string;
+    hushedUntil: string | null;
+}
 export interface RoomChannel {
     on(ev: "room_message", cb: (e: RoomMessage) => void): unknown;
     on(ev: "message", cb: (text: string, metadata: MessageMeta) => void): unknown;
+    on(ev: "room_hushed", cb: (e: RoomHushed) => void): unknown;
     on(ev: "error", cb: (err: unknown) => void): unknown;
     sendToRoom(roomId: string, text: string): Promise<void>;
     send(text: string): Promise<void>;
 }
+/**
+ * #392 cooperative quiet: tracks per-room hush windows so the native agent holds
+ * (does not room_say) while the owner has hushed the room. Advisory — the agent
+ * cooperates; the hard backstops are owner mute / remove (enforced server-side).
+ */
+export declare class RoomHushState {
+    private until;
+    set(roomId: string, hushedUntilIso: string | null): void;
+    isHushed(roomId: string, now?: number): boolean;
+}
 export interface RoomSession {
     /** `reply` is the immutable reply sink captured for THIS message (see
-     *  ActiveTarget.snapshotReply) — the session invokes it when Claude answers. */
-    push(text: string, reply?: (text: string) => Promise<void>): void;
+     *  ActiveTarget.snapshotReply) — the session invokes it when Claude answers.
+     *  `opts.autoReplyOnText` (set for 1:1 DMs) makes the session fall back to
+     *  sending plain assistant text when the model never calls the say tool (#416). */
+    push(text: string, reply?: (text: string) => Promise<void>, opts?: {
+        autoReplyOnText?: boolean;
+    }): void;
 }
 /** Where a reply should go: a room (sendToRoom) or a 1:1 DM (send). */
 export type BridgeTarget = {

package/dist/index.js

@@ -66743,6 +66743,19 @@ var init_channel = __esm({
                 }
               });
             }
+            if (data.event === "room_hushed") {
+              this.emit("room_hushed", {
+                roomId: data.data?.room_id,
+                hushedUntil: data.data?.hushed_until ?? null
+              });
+            }
+            if (data.event === "room_advisory") {
+              this.emit("room_advisory", {
+                roomId: data.data?.room_id,
+                kind: data.data?.kind,
+                message: data.data?.message
+              });
+            }
             if (data.event === "policy_blocked") {
               this.emit("policy_blocked", data.data);
             }
@@ -131541,14 +131554,25 @@ var PersistentClaudeSession = class {
   /** Reply sink bound to the message currently being processed. Set as each
    *  message is handed to the model so the say tool routes to the right place. */
   activeReply;
-  push(text, reply) {
+  /** Per-turn state for the #416 DM auto-reply fallback. */
+  currentAutoReply = false;
+  saidThisTurn = false;
+  turnText = "";
+  /**
+   * Queue an inbound message for the model.
+   * @param opts.autoReplyOnText — for 1:1 DMs (where the owner always expects a
+   *   reply): if the turn produces assistant text but never calls the say tool,
+   *   send that text as the reply instead of silently dropping it (#416). Rooms
+   *   omit this so the agent can still choose silence.
+   */
+  push(text, reply, opts) {
     const msg = {
       type: "user",
       message: { role: "user", content: text },
       parent_tool_use_id: null,
       session_id: ""
     };
-    const item = { msg, reply };
+    const item = { msg, reply, autoReplyOnText: opts?.autoReplyOnText };
     if (this.waiting) {
       const w2 = this.waiting;
       this.waiting = null;
@@ -131561,21 +131585,19 @@ var PersistentClaudeSession = class {
    *  back to opts.onSay. This is what closes the DM→room leak: the destination is
    *  the one captured for the message being answered, not a live global target. */
   async deliver(text) {
+    this.saidThisTurn = true;
     if (this.activeReply) await this.activeReply(text);
     else if (this.opts.onSay) await this.opts.onSay(text);
   }
   async *input() {
     while (true) {
-      if (this.pending.length > 0) {
-        const item2 = this.pending.shift();
-        this.activeReply = item2.reply;
-        yield item2.msg;
-        continue;
-      }
-      const item = await new Promise((resolve2) => {
+      const item = this.pending.length > 0 ? this.pending.shift() : await new Promise((resolve2) => {
         this.waiting = resolve2;
       });
       this.activeReply = item.reply;
+      this.currentAutoReply = item.autoReplyOnText ?? false;
+      this.saidThisTurn = false;
+      this.turnText = "";
       yield item.msg;
     }
   }
@@ -131622,13 +131644,38 @@ var PersistentClaudeSession = class {
       if (m6.type === "assistant") {
         const blocks = m6.message?.content ?? [];
         const text = blocks.filter((b5) => b5.type === "text").map((b5) => b5.text ?? "").join("");
-        if (text.trim()) this.opts.onObserve?.(text);
+        if (text.trim()) {
+          this.turnText += text;
+          this.opts.onObserve?.(text);
+        }
+      } else if (m6.type === "result") {
+        const reply = this.activeReply;
+        if (this.currentAutoReply && !this.saidThisTurn && this.turnText.trim() && reply) {
+          void reply(this.turnText);
+        }
       }
     }
   }
 };
 
 // src/bridge.ts
+var RoomHushState = class {
+  until = /* @__PURE__ */ new Map();
+  set(roomId, hushedUntilIso) {
+    if (!roomId) return;
+    if (!hushedUntilIso) {
+      this.until.delete(roomId);
+      return;
+    }
+    const t7 = new Date(hushedUntilIso).getTime();
+    if (Number.isNaN(t7)) return;
+    this.until.set(roomId, t7);
+  }
+  isHushed(roomId, now = Date.now()) {
+    const t7 = this.until.get(roomId);
+    return t7 !== void 0 && now < t7;
+  }
+};
 var ActiveTarget = class {
   target = null;
   setRoom(roomId) {
@@ -131696,17 +131743,30 @@ function wireBridge(channel, session, target, opts = {}) {
     const msg = err instanceof Error ? err.message : String(err);
     log(`channel error (auto-reconnecting): ${msg}`);
   });
+  const hush = new RoomHushState();
+  channel.on("room_hushed", (e7) => {
+    hush.set(e7.roomId, e7.hushedUntil);
+    log(
+      e7.hushedUntil ? `room ${e7.roomId.slice(0, 8)} hushed until ${e7.hushedUntil} \u2014 holding` : `room ${e7.roomId.slice(0, 8)} hush cleared`
+    );
+  });
   channel.on("room_message", (e7) => {
     if (opts.roomFilter && e7.roomId !== opts.roomFilter) return;
+    if (hush.isHushed(e7.roomId)) {
+      log(`inbound from ${e7.senderName} in ${e7.roomId.slice(0, 8)} \u2014 room hushed, holding (not replying)`);
+      return;
+    }
     log(`inbound from ${e7.senderName} in ${e7.roomId.slice(0, 8)}`);
     target.setRoom(e7.roomId);
-    session.push(`[${e7.senderName}]: ${e7.plaintext}`, target.snapshotReply(channel, log));
+    session.push(`[${e7.senderName}]: ${e7.plaintext}`, target.snapshotReply(channel, log), {
+      autoReplyOnText: false
+    });
   });
   channel.on("message", (text, metadata) => {
     if (metadata?.roomId) return;
     log("inbound 1:1 DM from owner");
     target.setDm();
-    session.push(text, target.snapshotReply(channel, log));
+    session.push(text, target.snapshotReply(channel, log), { autoReplyOnText: true });
   });
 }
 
@@ -131742,7 +131802,7 @@ async function main() {
   });
   wireBridge(
     channel,
-    { push: (t7, reply) => session.push(t7, reply) },
+    { push: (t7, reply, opts) => session.push(t7, reply, opts) },
     target,
     { roomFilter: cfg.roomFilter, log: (m6) => console.error("[bridge] " + m6) }
   );

package/dist/session.d.ts

@@ -63,8 +63,21 @@ export declare class PersistentClaudeSession {
     /** Reply sink bound to the message currently being processed. Set as each
      *  message is handed to the model so the say tool routes to the right place. */
     private activeReply?;
+    /** Per-turn state for the #416 DM auto-reply fallback. */
+    private currentAutoReply;
+    private saidThisTurn;
+    private turnText;
     constructor(opts: SessionOpts);
-    push(text: string, reply?: ReplySink): void;
+    /**
+     * Queue an inbound message for the model.
+     * @param opts.autoReplyOnText — for 1:1 DMs (where the owner always expects a
+     *   reply): if the turn produces assistant text but never calls the say tool,
+     *   send that text as the reply instead of silently dropping it (#416). Rooms
+     *   omit this so the agent can still choose silence.
+     */
+    push(text: string, reply?: ReplySink, opts?: {
+        autoReplyOnText?: boolean;
+    }): void;
     /** Route a say-tool message to the reply bound to the in-flight message, falling
      *  back to opts.onSay. This is what closes the DM→room leak: the destination is
      *  the one captured for the message being answered, not a live global target. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentvault/claude-bridge",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "type": "module",
   "description": "AgentVault Claude Bridge — daemon for bridging a Claude agent into secure E2E-encrypted AgentVault 1:1 direct messages and rooms.",
   "main": "dist/index.js",