@securecoms/agent-bridge 0.3.2 → 0.5.0

package/dist/bridge-agent.d.ts

@@ -327,6 +327,13 @@ export declare class BridgeAgent {
     private readonly listeners;
     private startedAt;
     private readonly store;
+    private readonly memory;
+    /** Task 2: warn-once-per-channel guard for the enclave-map fallback (below). */
+    private enclaveFallbackWarned;
+    /** Task 2: dedupe guard so ingestOnce writes a channel's enclave at most once
+     *  per process — a channel's enclave is immutable, so no need to UPSERT on
+     *  every message on the hot receive path (audit M2). */
+    private channelEnclaveRecorded;
     private readonly latency;
     /** Track 5: injectable blob download fn (default: fetch-based). */
     private readonly downloadBlobImpl;
@@ -350,6 +357,17 @@ export declare class BridgeAgent {
     start(): Promise<void>;
     /** C3: a random 0..SELF_HEAL_SWEEP_JITTER_MS decorrelation offset. */
     private sweepJitter;
+    /**
+     * Task 2 (multi-enclave core fix): resolve the enclave to stamp on outbound
+     * traffic for `channelId`. The daemon previously stamped `cfg.enclaveId`
+     * (its "home" enclave) on EVERY channel, so an agent admitted to a second
+     * enclave got a backend 400 on every send/reply there. The channel→enclave
+     * map (`channel_meta`, Task 1) is fed by inbound envelopes (`ingestOnce`)
+     * and by `listChannels`; a channel not yet in the map (never seen inbound,
+     * never discovered) falls back to home and logs once so the fallback is
+     * diagnosable (audit H3) rather than silently wrong.
+     */
+    private resolveEnclave;
     private reconcileJoin;
     /**
      * The held-KP re-Welcome signal (Task 11), shared by EVERY heal path: the
@@ -479,20 +497,57 @@ export declare class BridgeAgent {
         message_id: string;
         status: "sent";
     }>;
-    listChannels(): Promise<Array<{
+    /** Task 3: delegates to the configured MemoryProvider (SecureComsLocal | Null). */
+    recordMemory(input: import("@agentvault/connect-mls-store").MemoryRecordInput): Promise<{
+        seq: number;
+        deduped: boolean;
+    }>;
+    memoryContext(conversationId: string, limit?: number): Promise<import("@agentvault/connect-mls-store").MemoryContextResult>;
+    /**
+     * List channels in one enclave (default: the daemon's own home enclave).
+     * Task 3: called per-*known* enclave by refreshChannelMeta so a
+     * cross-enclave room's is_dm gets resolved — see the scope caveat there
+     * (same-tenant only; a cross-tenant enclave 404s under the agent's bearer).
+     */
+    listChannels(enclaveId?: string): Promise<Array<{
         channel_id: string;
         name: string | null;
         is_dm: boolean;
         joined: boolean;
+        enclave_id: string;
     }>>;
-    /** A live channelMeta entry, or undefined if missing OR expired past the TTL. */
+    /**
+     * A live channelMeta entry, or undefined if missing OR expired past the
+     * TTL. A never-cached-this-process channel (no in-memory entry at all —
+     * cold start, or every listChannels() call in refreshChannelMeta failed,
+     * e.g. network down) falls back to the store's persisted is_dm (Task 3) so
+     * a cross-enclave room stays classified across a restart instead of
+     * reverting to UNKNOWN/fail-open. The store has no TTL (is_dm is immutable
+     * per channel); `name` is not persisted so it comes back undefined on this
+     * path and re-resolves once a listChannels() call succeeds.
+     *
+     * A TTL-*expired* in-memory entry deliberately does NOT use the store
+     * fallback and is still treated as a miss — that miss is what drives
+     * ingestOnce to retry a refresh each cycle (S-2: keeping `name` fresh after
+     * a rename); serving the persisted is_dm there would silently suppress
+     * that retry forever.
+     */
     private freshMeta;
     /**
-     * One-shot, whole-listing refresh of channelMeta. Called AT MOST ONCE per
-     * ingest cycle (the caller guards with a cycle-local "refreshed" flag), so a
-     * burst of K unknown channels fires a single listChannels() instead of K. Any
-     * listChannels failure is swallowed (UNKNOWN → fail open) so ingest never
-     * blocks on the network.
+     * Whole-listing refresh of channelMeta, one listChannels() call per *known*
+     * enclave — the daemon's own home enclave plus every enclave it has learned
+     * about from inbound envelopes or a prior discovery (store.distinctEnclaveIds()).
+     * Called AT MOST ONCE per ingest cycle (the caller guards with a
+     * cycle-local "refreshed" flag). Task 3 (M1): without this, a cross-enclave
+     * room is never listed under the home-enclave-only call, so its is_dm never
+     * resolves and the @mention filter fails open for that room.
+     *
+     * Each enclave is wrapped in its own try/catch (scope caveat — audit
+     * H2/tenant): list_channels_in_enclave filters on tenant_id, so a
+     * same-tenant enclave the agent has learned about resolves fine, but a
+     * cross-TENANT federated-partner enclave 404s under this agent's bearer;
+     * that enclave's channels are left unresolved (fail open) without aborting
+     * the other enclaves in the set.
      */
     private refreshChannelMeta;
     /** A live roster for a channel, or undefined if missing OR expired past the TTL. */
@@ -608,6 +663,12 @@ export declare class BridgeAgent {
         delivery_pings: number;
         uptime_s: number;
         version: string;
+        /** Optional memory-adapter counters (e.g. Hermes provider); present only when the active provider exposes stats(). */
+        hermes_no_session?: number;
+        hermes_skipped?: number;
+        hermes_write_failed?: number;
+        openclaw_no_session?: number;
+        openclaw_read_failed?: number;
     };
     /**
      * Loopback observability snapshot served at GET /v1/metrics.

package/dist/config.d.ts

@@ -17,7 +17,14 @@ export interface BridgeConfig {
     rateLimitCapacity?: number;
     /** Per-channel send-floor refill rate per minute. Default 20. */
     rateLimitRefillPerMinute?: number;
+    /** Per-agent memory provider. Default "securecoms"; "none" disables the memory taps; "hermes"/"openclaw" read the named harness store. */
+    memoryProvider: "securecoms" | "none" | "hermes" | "openclaw";
+    /** For memoryProvider="hermes"/"openclaw": base dir of the harness install (default "~/.hermes" / "~/.openclaw"). */
+    memoryBaseDir?: string;
+    /** For memoryProvider="openclaw": the OpenClaw agent dir slug, e.g. "cortina" (→ <base_dir>/agents/<agent>/). */
+    memoryAgent?: string;
 }
+export declare const REQUIRED: readonly ["api_key", "identity_id", "device_id", "signing_private_key", "enclave_id", "api_base"];
 export declare function loadConfig(opts: {
     credentialPath: string;
     storePath?: string;

package/dist/http-server.d.ts

@@ -1,4 +1,5 @@
 import { type Server } from "node:http";
+import { z } from "zod";
 import type { BridgeAgent, BridgeMessage } from "./bridge-agent.js";
 export declare function writeSse(res: {
     destroyed?: boolean;
@@ -24,6 +25,47 @@ export declare function capabilities(opts: {
     send_types: string[];
     webhook_push: boolean;
 };
+export declare const memoryRecordSchema: z.ZodEffects<z.ZodObject<{
+    conversation_id: z.ZodString;
+    role: z.ZodEnum<["peer", "agent"]>;
+    peer_id: z.ZodOptional<z.ZodString>;
+    text: z.ZodString;
+    modality: z.ZodEnum<["text", "voice"]>;
+    message_id: z.ZodOptional<z.ZodString>;
+    idempotency_key: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    role: "peer" | "agent";
+    text: string;
+    conversation_id: string;
+    modality: "text" | "voice";
+    message_id?: string | undefined;
+    idempotency_key?: string | undefined;
+    peer_id?: string | undefined;
+}, {
+    role: "peer" | "agent";
+    text: string;
+    conversation_id: string;
+    modality: "text" | "voice";
+    message_id?: string | undefined;
+    idempotency_key?: string | undefined;
+    peer_id?: string | undefined;
+}>, {
+    role: "peer" | "agent";
+    text: string;
+    conversation_id: string;
+    modality: "text" | "voice";
+    message_id?: string | undefined;
+    idempotency_key?: string | undefined;
+    peer_id?: string | undefined;
+}, {
+    role: "peer" | "agent";
+    text: string;
+    conversation_id: string;
+    modality: "text" | "voice";
+    message_id?: string | undefined;
+    idempotency_key?: string | undefined;
+    peer_id?: string | undefined;
+}>;
 export declare function createHttpServer(agent: BridgeAgent, opts: HttpServerOptions): {
     server: Server;
     closeAllSseStreams: () => void;