openclaw-nostr 2026.9.2 → 2026.9.3

package/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## Unreleased (Cascadia Fork)
 
+### Fixes — relay AUTH regression in 2026.9.2 (ocn-a4wg)
+- **Upgrade from 2026.9.2.** That release swallowed every `relay.auth()` rejection and returned `false`, on the mistaken premise that nostr-tools never handles it. It handles it in two of three call sites: `SimplePool.subscribeMap` retries a CLOSED `auth-required:` via `auth().then(re-subscribe).catch(stop)`, and `SimplePool.publish` awaits it before republishing. Returning `false` made both treat a **failed** AUTH as success, so a NIP-29 room with `auth:true` re-subscribed unauthenticated in a loop — `closed: auth-required` → reconnect → repeat — with the relay's real refusal reason suppressed, which reads exactly like `auth:true` being ignored. `auth()` now rejects again; the returned promise carries a no-op `.catch()`, which marks it handled for Node's unhandled-rejection detection without consuming it, so the unawaited call in `AbstractRelay._onmessage` still cannot crash the process (the ocn-n5g guarantee) while awaiting callers keep their retry semantics.
+
 ### Fixes — relay AUTH refusal crashed the process (ocn-n5g, ocn-uao2)
 - **A relay refusing NIP-42 AUTH no longer takes the gateway down (ocn-n5g)**: a relay answering our AUTH event with `["OK", <id>, false, "error: relay needs serviceUrl to be configured before AUTH can work"]` — a misconfigured relay that can never authenticate anyone — rejected the auth promise inside nostr-tools' `AbstractRelay._onmessage`, which invokes `this.auth(this.onauth)` without awaiting or catching it. The rejection escaped as an unhandled rejection and killed the process (stability bundle written), with a stack containing no frames of ours. Our prototype patch previously swallowed only `SendingOnClosedConnection` and `"auth timed out"`, so relay-side refusals sailed through. It now swallows every auth rejection and returns `false` — since the sole caller never handles the promise, rethrowing can only ever crash — and clears the memoized `authPromise` so a later challenge retries instead of replaying a cached rejection forever. The patch moved to `nostr-bus-relay.ts` and is now installed by the fleet-tasks pool too, which sets `automaticallyAuth` but never ran it and carried the same latent crash.
 - **Failing relays are now named in the logs (ocn-uao2)**: the swallowed failure was reported as a bare string, so the offending relay was unidentifiable. Failures now carry a structured report (relay URL, kind, relay-supplied reason, occurrence and suppressed counts) and are classified `closed_connection` / `timed_out` / `no_challenge` / `relay_refused`, separating self-healing races from a relay that will never authenticate. Refusals route to `onError` so they are always visible in production logs; races route to `onDebug` and are lifted to `warn`. Repeats are throttled per relay+kind (first immediately, then at most one line per minute carrying the suppressed count) because a refusing relay re-refuses on every reconnect. AUTH sends dropped by the closed-connection guard, previously swallowed in silence, are now named too. Emits `relay.auth.rejected` tagged by relay and kind.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-nostr",
-  "version": "2026.9.2",
+  "version": "2026.9.3",
   "description": "Nostr channel plugin for OpenClaw",
   "type": "module",
   "files": [
@@ -16,9 +16,10 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "build": "tsc --noEmit --noCheck --module NodeNext --moduleResolution NodeNext --target ES2023 index.ts api.ts runtime-api.ts setup-api.ts setup-entry.ts src/*.ts test/setup.ts vitest.config.ts",
+    "build": "tsc -p tsconfig.json --noCheck",
     "test:bootstrap": "node --test test/nostr-claw-bootstrap.test.mjs",
-    "test:scanner": "vitest run test/runtime-security-scanner.test.ts"
+    "test:scanner": "vitest run test/runtime-security-scanner.test.ts",
+    "typecheck": "tsc -p tsconfig.json"
   },
   "dependencies": {
     "cascadia-ts": "file:../cascadia-nips/generated/typescript",

package/src/channel-directory.ts

@@ -40,7 +40,7 @@ type RoomConfigLike = {
 type NostrChannelCfgLike = {
   channels?: {
     nostr?: {
-      allowFrom?: readonly string[];
+      allowFrom?: readonly (string | number)[];
       profile?: { name?: string; displayName?: string };
       nostr_channels?: Record<string, RoomConfigLike | undefined>;
     };
@@ -82,8 +82,10 @@ function toNpub(pubkeyHex: string): string {
   }
 }
 
-function normalizeEntryPubkey(value: string): string | undefined {
-  const trimmed = value.trim();
+// See normalizeAllowEntry in nostr-taskflow-tool.ts: allowFrom entries may be
+// numbers, so stringify before trimming.
+function normalizeEntryPubkey(value: string | number): string | undefined {
+  const trimmed = String(value).trim();
   if (!trimmed || trimmed === "*") {
     return undefined;
   }

package/src/channel.ts

@@ -356,7 +356,7 @@ type NostrGroupInboundContextParams = {
   roomConfig?: NostrRoomChannelMap[string];
   preflight?: NostrGroupPreflightResult;
   cfg?: unknown;
-  accountAllowFrom?: readonly string[];
+  accountAllowFrom?: readonly (string | number)[];
   commandHelpers?: NostrGroupPreflightCommandHelpers;
   /** P3: a pending-commitment reminder injected as untrusted context for this turn. */
   commitmentReminder?: string;
@@ -373,7 +373,8 @@ type NostrChannelInboundEventContextParams = {
   messageIdFull?: string;
   timestamp?: number;
   from: string;
-  sender: {
+  /** Optional: system-authored room events have no actor pubkey. */
+  sender?: {
     id?: string;
     name?: string;
     displayLabel?: string;
@@ -509,12 +510,12 @@ function buildChannelInboundEventContextCompat(params: NostrChannelInboundEventC
     ConversationLabel: params.conversation.label,
     GroupSubject: params.conversation.kind !== "direct" ? params.conversation.label : undefined,
     UntrustedStructuredContext: params.supplemental?.untrustedContext,
-    SenderName: params.sender.name ?? params.sender.displayLabel,
-    SenderId: params.sender.id,
-    SenderIsBot: params.sender.isBot,
-    SenderUsername: params.sender.username,
-    SenderTag: params.sender.tag,
-    MemberRoleIds: params.sender.roles,
+    SenderName: params.sender?.name ?? params.sender?.displayLabel,
+    SenderId: params.sender?.id,
+    SenderIsBot: params.sender?.isBot,
+    SenderUsername: params.sender?.username,
+    SenderTag: params.sender?.tag,
+    MemberRoleIds: params.sender?.roles,
     Timestamp: params.timestamp,
     Provider: params.provider ?? params.channel,
     Surface: params.surface ?? params.provider ?? params.channel,
@@ -922,8 +923,11 @@ async function assertBackedNostrRoomCommitment(params: {
     }),
   );
   const assessment = await assessCommitment(params.text, roomKey, (reference) => {
+    // `effective` is a FleetTaskEventSnapshot; the status lives on its `task`
+    // payload. Reading it off the snapshot yielded undefined, so every
+    // referenced task — closed ones included — counted as still active.
     const task = activeFleetTaskServices.get(params.accountId)?.getTask(reference)?.effective;
-    if (task && task.status !== "closed") return true;
+    if (task && task.task.status !== "closed") return true;
     return resolveNostrTaskFlowBackingActive(
       getNostrRuntime(),
       params.accountId,
@@ -1297,8 +1301,11 @@ function localIsNostrAbortRequestText(text: string): boolean {
   return /^(?:abort|cancel|stop)\b/i.test(text.trim());
 }
 
-function normalizeNostrAllowEntry(value: string): string | undefined {
-  const trimmed = value.trim();
+// allowFrom entries may be numbers (the host's shared AllowFromListSchema is
+// ZodArray<ZodUnion<[ZodString, ZodNumber]>>), so stringify before trimming —
+// .trim() on a number throws, and this path gates control-command authorization.
+function normalizeNostrAllowEntry(value: string | number): string | undefined {
+  const trimmed = String(value).trim();
   if (!trimmed || trimmed === "*") {
     return undefined;
   }
@@ -1306,7 +1313,7 @@ function normalizeNostrAllowEntry(value: string): string | undefined {
 }
 
 function nostrAllowListExplicitlyIncludesSender(
-  allowFrom: readonly string[] | undefined,
+  allowFrom: readonly (string | number)[] | undefined,
   senderPubkey: string,
 ): boolean {
   const normalizedSender = senderPubkey.toLowerCase();
@@ -1317,7 +1324,7 @@ function resolveNostrCommandAuthorized(params: {
   hasControlCommand: boolean;
   senderPubkey: string;
   roomConfig?: NostrRoomChannelMap[string];
-  accountAllowFrom?: readonly string[];
+  accountAllowFrom?: readonly (string | number)[];
 }): boolean {
   if (!params.hasControlCommand) {
     return false;
@@ -1446,7 +1453,7 @@ export function resolveNostrGroupPreflight(params: {
   route: Pick<NostrGroupRouteFacts, "agentId">;
   meta: InboundGroupMessageMeta;
   roomConfig?: NostrRoomChannelMap[string];
-  accountAllowFrom?: readonly string[];
+  accountAllowFrom?: readonly (string | number)[];
   commandHelpers?: NostrGroupPreflightCommandHelpers;
   /** True when the sender is a peer for implicit-mention suppression (P1); may include unknownAsPeer. */
   senderIsPeer?: boolean;
@@ -1612,13 +1619,17 @@ function buildNostrGroupMembershipInboundEventContext(params: {
     messageIdFull: params.meta.eventId,
     timestamp: params.meta.createdAt ? params.meta.createdAt * 1000 : Date.now(),
     from: params.meta.actorPubkey ? `nostr:${params.meta.actorPubkey}` : "nostr:system",
-    sender: params.meta.actorPubkey
+    // Omit `sender` entirely when there is no actor, rather than setting it to
+    // undefined: the host's param type does not accept an explicit undefined.
+    ...(params.meta.actorPubkey
       ? {
-          id: params.meta.actorPubkey,
-          name: nip19.npubEncode(params.meta.actorPubkey),
-          displayLabel: nip19.npubEncode(params.meta.actorPubkey),
+          sender: {
+            id: params.meta.actorPubkey,
+            name: nip19.npubEncode(params.meta.actorPubkey),
+            displayLabel: nip19.npubEncode(params.meta.actorPubkey),
+          },
         }
-      : undefined,
+      : {}),
     conversation: {
       kind: "group",
       id: roomKey,
@@ -2868,7 +2879,7 @@ export const nostrPlugin: ChannelPlugin<ResolvedNostrAccount> = {
                   );
                 }
               }
-              nip46SessionState = sessionState;
+              nip46SessionState = sessionState ?? undefined;
 
               ctx.setStatus({
                 accountId: account.accountId,

package/src/fleet-tasks.ts

@@ -4,6 +4,7 @@ import {
   type Event,
   type EventTemplate,
   type Filter,
+  type VerifiedEvent,
 } from "nostr-tools";
 import { CAS_CP_STATE, NIP51_TASK_COLLECTION } from "cascadia-ts";
 import type { FleetAgentSigner } from "./fleet-agent.js";
@@ -771,8 +772,19 @@ export async function createFleetTaskService(
     ...(await buildPersistentPoolOptions()),
     enableReconnect: true,
   } as ConstructorParameters<typeof SimplePool>[0]);
+  // nostr-tools requires a VerifiedEvent here, not merely a signed one. The
+  // signer may be a remote NIP-46 bunker, so verify the returned event rather
+  // than asserting the brand: an unverifiable AUTH event would be rejected by
+  // the relay anyway, and failing here keeps a malformed bunker reply from
+  // being attributed to us.
   const onauth = options.auth
-    ? async (template: EventTemplate) => options.signer.signEvent(template)
+    ? async (template: EventTemplate): Promise<VerifiedEvent> => {
+        const signed = await options.signer.signEvent(template);
+        if (!verifyEvent(signed)) {
+          throw new Error("NIP-42 auth event failed signature verification");
+        }
+        return signed;
+      }
     : undefined;
   if (onauth) pool.automaticallyAuth = () => onauth;
   const metrics = createNoopMetrics();

package/src/metrics.ts

@@ -12,6 +12,7 @@ export type EventMetricName =
   | "event.processed"
   | "event.duplicate"
   | "event.skipped.service_envelope"
+  | "event.rejected.invalid_content"
   | "event.rejected.invalid_shape"
   | "event.rejected.wrong_kind"
   | "event.rejected.wrong_target"
@@ -143,6 +144,8 @@ export interface MetricsSnapshot {
   eventsDuplicate: number;
   /** Events rejected by reason */
   eventsRejected: {
+    /** Content too short to be a NIP-44 ciphertext. */
+    invalidContent: number;
     invalidShape: number;
     wrongKind: number;
     wrongTarget: number;
@@ -250,6 +253,7 @@ export function createMetrics(onMetric?: OnMetricCallback): NostrMetrics {
   let eventsProcessed = 0;
   let eventsDuplicate = 0;
   const eventsRejected = {
+    invalidContent: 0,
     invalidShape: 0,
     wrongKind: 0,
     wrongTarget: 0,
@@ -375,6 +379,9 @@ export function createMetrics(onMetric?: OnMetricCallback): NostrMetrics {
       case "event.duplicate":
         eventsDuplicate += value;
         break;
+      case "event.rejected.invalid_content":
+        eventsRejected.invalidContent += value;
+        break;
       case "event.rejected.invalid_shape":
         eventsRejected.invalidShape += value;
         break;
@@ -622,7 +629,8 @@ export function createMetrics(onMetric?: OnMetricCallback): NostrMetrics {
     eventsProcessed = 0;
     eventsDuplicate = 0;
     Object.assign(eventsRejected, {
-      invalidShape: 0,
+      invalidContent: 0,
+    invalidShape: 0,
       wrongKind: 0,
       wrongTarget: 0,
       stale: 0,
@@ -672,7 +680,8 @@ export function createNoopMetrics(): NostrMetrics {
     eventsProcessed: 0,
     eventsDuplicate: 0,
     eventsRejected: {
-      invalidShape: 0,
+      invalidContent: 0,
+    invalidShape: 0,
       wrongKind: 0,
       wrongTarget: 0,
       stale: 0,

package/src/nip46-signer.ts

@@ -360,7 +360,7 @@ export class SignerRequestQueue {
   }
 
   private async waitForDispatchSlot(): Promise<void> {
-    while (this.pending.length > 0 && this.state !== "closed") {
+    while (this.pending.length > 0 && !this.isClosed()) {
       const dispatchIntervalMs = Math.max(this.intervalMs, this.adaptiveIntervalMs);
       const now = Date.now();
       if (dispatchIntervalMs <= 0) {
@@ -381,17 +381,31 @@ export class SignerRequestQueue {
     }
   }
 
+  /**
+   * Read `state` through a method call, not a property access.
+   *
+   * `close()` flips the state to "closed" while `drain()` is parked on an
+   * `await`, but TypeScript does not invalidate property narrowing across an
+   * await — after one `this.state === "closed"` guard it believes the field can
+   * only be "open" | "closing" for the rest of the method and flags every later
+   * check as an impossible comparison. The checks are load-bearing, so re-read
+   * through a call, whose result is never narrowed.
+   */
+  private isClosed(): boolean {
+    return this.state === "closed";
+  }
+
   private async drain(): Promise<void> {
-    if (this.draining || this.state === "closed") return;
+    if (this.draining || this.isClosed()) return;
     this.draining = true;
     try {
       while (
         this.pending.length > 0
         && this.activeJobs.size < this.concurrency
-        && this.state !== "closed"
+        && !this.isClosed()
       ) {
         await this.waitForDispatchSlot();
-        if (this.state === "closed") break;
+        if (this.isClosed()) break;
         const job = this.pending.shift();
         if (!job) continue;
         this.activeJobs.add(job);
@@ -902,20 +916,23 @@ export async function connectNip46SignerForEnrollment(
       opts.connectionTimeoutMs ?? 60_000,
       opts.abortSignal,
     );
-    handle = createSessionSigner(bunker, resolved.transportPubkey, {
+    // `handle` stays a mutable let for the catch-block cleanup check, but the
+    // liveness closure below needs a binding TypeScript can prove is defined.
+    const session = createSessionSigner(bunker, resolved.transportPubkey, {
       ...opts,
       operatorRelays: opts.signerRelayMode === "operator-only"
         ? [...resolved.relays]
         : undefined,
     });
+    handle = session;
     const userPubkey = await runNip46OperationWithTimeout(
-      () => proveNip46SessionLiveness(handle.signer, opts.expectedUserPubkey),
+      () => proveNip46SessionLiveness(session.signer, opts.expectedUserPubkey),
       "liveness",
       opts.connectionTimeoutMs ?? 60_000,
       opts.abortSignal,
     );
-    handle.setUserPubkey(userPubkey);
-    return handle.signer;
+    session.setUserPubkey(userPubkey);
+    return session.signer;
   } catch (error) {
     if (handle) {
       try {
@@ -956,20 +973,23 @@ export async function resumeNip46Signer(
   });
   let handle: ReturnType<typeof createSessionSigner> | undefined;
   try {
-    handle = createSessionSigner(bunker, transportPubkey, {
+    // See the enrollment path above: `handle` remains a let for cleanup, while
+    // the closure captures a const the compiler can prove is defined.
+    const session = createSessionSigner(bunker, transportPubkey, {
       ...opts,
       operatorRelays: opts.signerRelayMode === "operator-only"
         ? [...pointer.relays]
         : undefined,
     });
+    handle = session;
     const userPubkey = await runNip46OperationWithTimeout(
-      () => proveNip46SessionLiveness(handle.signer, opts.pinnedUserPubkey),
+      () => proveNip46SessionLiveness(session.signer, opts.pinnedUserPubkey),
       "liveness",
       opts.connectionTimeoutMs ?? 60_000,
       opts.abortSignal,
     );
-    handle.setUserPubkey(userPubkey);
-    return handle.signer;
+    session.setUserPubkey(userPubkey);
+    return session.signer;
   } catch (error) {
     try {
       await handle?.signer.close();

package/src/nostr-bus-nip29.ts

@@ -14,6 +14,8 @@ import {
   type SimplePool,
   type Event,
   type EventTemplate,
+  type Filter,
+  type VerifiedEvent,
 } from "nostr-tools";
 import { Reaction as ReactionKind } from "nostr-tools/kinds";
 import { type NostrRoomState } from "./nostr-state-store.js";
@@ -807,6 +809,19 @@ export function createNip29Manager(ctx: Nip29Context): Nip29Manager {
   const doSignEvent = ctx.signEvent
     ?? ((template: EventTemplate) => Promise.resolve(finalizeEvent(template, sk)));
 
+  // nostr-tools' onauth contract requires a VerifiedEvent. doSignEvent may be a
+  // remote NIP-46 signer returning a plain Event, so verify rather than assert:
+  // an unverifiable AUTH event would be refused by the relay regardless.
+  const signAuthEventVerified = async (
+    authTemplate: EventTemplate,
+  ): Promise<VerifiedEvent> => {
+    const signed = await doSignEvent(authTemplate);
+    if (!verifyEvent(signed)) {
+      throw new Error("NIP-42 auth event failed signature verification");
+    }
+    return signed;
+  };
+
   async function withPublishTimeout<T>(promise: Promise<T>, relayUrl: string): Promise<T> {
     if (!publishTimeoutMs || publishTimeoutMs <= 0) {
       return promise;
@@ -872,7 +887,7 @@ export function createNip29Manager(ctx: Nip29Context): Nip29Manager {
     const event = await doSignEvent(args.template);
     const results = (args.auth
       ? roomPool.publish([args.relayUrl], event, {
-          onauth: async (authTemplate: EventTemplate) => doSignEvent(authTemplate),
+          onauth: signAuthEventVerified,
         })
       : roomPool.publish([args.relayUrl], event)
     ) as unknown as Promise<string>[];
@@ -1269,12 +1284,12 @@ export function createNip29Manager(ctx: Nip29Context): Nip29Manager {
         ` since=${since} room=${roomKey}`,
       );
       let caughtUp = false;
-      const eventFilter: Record<string, unknown> = {
+      const eventFilter: Filter = {
         kinds: [9, ReactionKind, 9000, 9001, 9005],
         "#h": [groupId],
         since,
       };
-      const metadataFilter: Record<string, unknown> = {
+      const metadataFilter: Filter = {
         kinds: [39000, 39001, 39002, 39003],
         "#d": [groupId],
         since,
@@ -1299,9 +1314,7 @@ export function createNip29Manager(ctx: Nip29Context): Nip29Manager {
         // NIP-42 subscription-level auth: only included when the channel has
         // auth:true. When the relay sends CLOSED auth-required, nostr-tools
         // calls this signer, sends AUTH, and automatically re-subscribes.
-        ...(auth
-          ? { onauth: async (authTemplate: EventTemplate) => doSignEvent(authTemplate) }
-          : {}),
+        ...(auth ? { onauth: signAuthEventVerified } : {}),
         onclose: (reasons: string[]) => {
           subscriptions.delete(sub);
           const normalized = normalizeCloseReasons(reasons, 1);

package/src/nostr-bus-relay.auth-patch.test.ts

@@ -45,7 +45,9 @@ describe("patchNostrToolsAuthSendRace", () => {
     );
     const relay = relayRejectingAuthWith("wss://relay.example", rejection);
 
-    await expect(relay.auth(async () => undefined)).resolves.toBe(false);
+    // The rejection must survive: nostr-tools' subscribeMap and publish both
+    // await auth() and treat a rejection as "auth failed, stop retrying".
+    await expect(relay.auth(async () => undefined)).rejects.toThrow(rejection);
 
     expect(relay.authPromise).toBeUndefined(); // cleared so a retry can happen
     expect(reports).toHaveLength(1);
@@ -71,8 +73,8 @@ describe("patchNostrToolsAuthSendRace", () => {
       new Error("auth timed out"),
     );
 
-    await closed.auth(async () => undefined);
-    await timedOut.auth(async () => undefined);
+    await expect(closed.auth(async () => undefined)).rejects.toThrow();
+    await expect(timedOut.auth(async () => undefined)).rejects.toThrow();
 
     expect(reports.map((r) => [r.relayUrl, r.kind, r.benign])).toEqual([
       ["wss://flaky.example", "closed_connection", true],
@@ -84,7 +86,7 @@ describe("patchNostrToolsAuthSendRace", () => {
     const reason = "error: relay needs serviceUrl to be configured before AUTH can work";
     for (let i = 0; i < 4; i++) {
       const relay = relayRejectingAuthWith("wss://noisy.example", new Error(reason));
-      await relay.auth(async () => undefined);
+      await expect(relay.auth(async () => undefined)).rejects.toThrow();
     }
 
     // First failure reports immediately; the rest are folded into the counters.
@@ -93,7 +95,7 @@ describe("patchNostrToolsAuthSendRace", () => {
 
     // A different relay is tracked independently, not throttled by the first.
     const other = relayRejectingAuthWith("wss://other.example", new Error(reason));
-    await other.auth(async () => undefined);
+    await expect(other.auth(async () => undefined)).rejects.toThrow();
     expect(reports).toHaveLength(2);
     expect(reports[1]!.relayUrl).toBe("wss://other.example");
   });
@@ -102,11 +104,32 @@ describe("patchNostrToolsAuthSendRace", () => {
     const relay = relayRejectingAuthWith("", new Error("nope"));
     relay.url = undefined;
 
-    await relay.auth(async () => undefined);
+    await expect(relay.auth(async () => undefined)).rejects.toThrow();
 
     expect(reports[0]!.relayUrl).toBe("<unknown relay>");
   });
 
+  // Regression: the ocn-n5g crash fix originally swallowed the rejection and
+  // returned false. That stopped the crash but broke nostr-tools' auth-required
+  // retry — subscribeMap re-subscribed and publish republished as though a
+  // failed AUTH had succeeded, producing an endless auth-required loop. Both
+  // properties have to hold at once.
+  it("keeps an unawaited auth rejection from surfacing as unhandled", async () => {
+    const unhandled: unknown[] = [];
+    const onUnhandled = (reason: unknown) => unhandled.push(reason);
+    process.on("unhandledRejection", onUnhandled);
+    try {
+      const relay = relayRejectingAuthWith("wss://crash.example", new Error("refused"));
+      // Exactly how AbstractRelay._onmessage `case "AUTH"` calls it: no await,
+      // no catch.
+      void relay.auth(async () => undefined);
+      await new Promise((resolve) => setTimeout(resolve, 20));
+      expect(unhandled).toEqual([]);
+    } finally {
+      process.off("unhandledRejection", onUnhandled);
+    }
+  });
+
   it("is idempotent across repeated installs", () => {
     const before = relayBase().auth;
     patchNostrToolsAuthSendRace();

package/src/nostr-bus-relay.ts

@@ -129,34 +129,47 @@ export function patchNostrToolsAuthSendRace(reporter?: RelayAuthPatchReporter):
     }
   };
   if (typeof originalAuth === "function") {
-    relayBase.auth = async function patchedAuth(signAuthEvent: unknown): Promise<unknown> {
+    relayBase.auth = function patchedAuth(signAuthEvent: unknown): Promise<unknown> {
       const self = this as { url?: string; authPromise?: unknown };
-      try {
-        return await originalAuth.call(this, signAuthEvent);
-      } catch (error) {
-        // nostr-tools invokes relay.auth() from its WebSocket message handler
-        // (`case "AUTH"`) without awaiting or catching the returned promise, so
-        // ANY rejection here escapes as an unhandled rejection and crashes the
-        // process. Every failure mode is non-fatal to us:
-        //   - closed_connection / timed_out: connection races, resolved by the
-        //     pool's reconnect + re-auth.
-        //   - relay_refused, surfaced as `["OK", id, false, reason]` (e.g.
-        //     "error: relay needs serviceUrl to be configured before AUTH can
-        //     work" from a misconfigured relay): we simply stay unauthenticated
-        //     on that relay.
-        // So we report and return false rather than rethrowing.
-        const err = error instanceof Error ? error : new Error(String(error));
-        // Drop the memoized rejected promise so a later challenge can retry
-        // instead of replaying this failure (and re-triggering the rejection).
-        self.authPromise = undefined;
-        reportRelayAuthFailure(relayUrlOf(self), err);
-        return false;
-      }
+      const promise = runPatchedAuth(originalAuth, self, signAuthEvent);
+      promise.catch(() => {});
+      // nostr-tools calls relay.auth() from three places, and they disagree
+      // about who owns the rejection:
+      //   - AbstractRelay._onmessage `case "AUTH"` calls it unawaited and
+      //     uncaught, so a rejection there crashes the process (ocn-n5g);
+      //   - SimplePool.subscribeMap retries a CLOSED "auth-required: " by
+      //     awaiting auth() and treating a rejection as "auth failed, stop";
+      //   - SimplePool.publish awaits it before republishing.
+      // Attaching a handler here marks the promise handled for Node's
+      // unhandled-rejection detection WITHOUT consuming it: the two awaiting
+      // callers still observe the rejection and keep their retry semantics.
+      // Swallowing the rejection outright (returning false) instead made those
+      // callers believe a failed AUTH had succeeded, so they re-subscribed and
+      // republished into an endless auth-required loop.
+      return promise;
     };
   }
   relayBase.__openclawAuthSendRacePatched = true;
 }
 
+async function runPatchedAuth(
+  originalAuth: (this: unknown, signAuthEvent: unknown) => Promise<unknown>,
+  self: { url?: string; authPromise?: unknown },
+  signAuthEvent: unknown,
+): Promise<unknown> {
+  try {
+    return await originalAuth.call(self, signAuthEvent);
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    // Drop the memoized rejected promise so a later challenge can retry
+    // instead of replaying this failure forever.
+    self.authPromise = undefined;
+    reportRelayAuthFailure(relayUrlOf(self), err);
+    // Rethrow: nostr-tools' own auth-required retry logic depends on it.
+    throw err;
+  }
+}
+
 // ============================================================================
 // Constants
 // ============================================================================

package/src/nostr-bus.ts

@@ -8,6 +8,7 @@ import {
   nip19,
   type Event,
   type EventTemplate,
+  type VerifiedEvent,
 } from "nostr-tools";
 import { decrypt as nip04Decrypt, encrypt as nip04Encrypt } from "nostr-tools/nip04";
 import * as nip59 from "nostr-tools/nip59";
@@ -157,8 +158,10 @@ const AUTH_SIGN_JITTER = 0.2;
 class DeterministicNip17Error extends Error {}
 
 type RelayAuthState = {
-  inFlight: Map<string, Promise<Event>>;
-  signedCache: Map<string, { event: Event; expiresAt: number }>;
+  // nostr-tools' auth contract is VerifiedEvent, so the coalescing cache holds
+  // the verified event rather than re-verifying on every cache hit.
+  inFlight: Map<string, Promise<VerifiedEvent>>;
+  signedCache: Map<string, { event: VerifiedEvent; expiresAt: number }>;
   serial: Promise<void>;
   lastSignStartedAt: number;
   windowStartedAt: number;
@@ -607,7 +610,7 @@ export async function startNostrBus(options: NostrBusOptions): Promise<NostrBusH
   const signRelayAuthEvent = async (
     relayURL: string,
     authTemplate: EventTemplate,
-  ): Promise<Event> => {
+  ): Promise<VerifiedEvent> => {
     const state = getRelayAuthState(relayURL);
     const key = stableAuthChallengeKey(relayURL, authTemplate);
     const now = Date.now();
@@ -684,6 +687,15 @@ export async function startNostrBus(options: NostrBusOptions): Promise<NostrBusH
         metrics.emit("relay.message.auth", 1, { relay: relayURL, outcome: "signed" });
         try {
           const signed = await signEvent(authTemplate);
+          // nostr-tools requires a VerifiedEvent here. signEvent may be a remote
+          // NIP-46 bunker returning a plain Event, so verify rather than assert:
+          // a relay would reject an unverifiable AUTH event anyway, and failing
+          // here keeps a malformed bunker reply from being attributed to us.
+          if (!verifyEvent(signed)) {
+            throw new Error(
+              `NIP-42 auth event for ${relayURL} failed signature verification`,
+            );
+          }
           state.backoffAttempt = 0;
           state.backoffUntil = 0;
           state.signedCache.set(key, {
@@ -718,7 +730,7 @@ export async function startNostrBus(options: NostrBusOptions): Promise<NostrBusH
   // Pool-level handler for WebSocket AUTH challenges; publish-level handler
   // (publishAuthSigner) for OK false "auth-required" responses on EVENT.
   pool.automaticallyAuth = (relayURL: string) => {
-    return async (unsignedAuthEvent: any) => {
+    return async (unsignedAuthEvent: EventTemplate) => {
       return signRelayAuthEvent(relayURL, unsignedAuthEvent);
     };
   };

package/src/nostr-state-store.ts

@@ -598,7 +598,9 @@ function parseNip46BunkerIdentity(
   }
   const identity = value as Record<string, unknown>;
   if (identity.kind === "bunker") {
-    const expected = `bunker://${transportPubkey}`;
+    // Annotated so the template literal keeps its `bunker://${string}` type
+    // instead of widening to string, which the return type requires.
+    const expected: `bunker://${string}` = `bunker://${transportPubkey}`;
     if (
       typeof identity.uri !== "string"
       || identity.uri !== expected

package/src/nostr-taskflow-tool.ts

@@ -212,7 +212,7 @@ type ResolvedTaskFlowRoom = {
 type NostrChannelConfigLike = {
   channels?: {
     nostr?: {
-      allowFrom?: readonly string[];
+      allowFrom?: readonly (string | number)[];
       nostr_channels?: Record<string, NostrRoomConfigLike | undefined>;
     };
   };
@@ -255,8 +255,12 @@ function roomTaskFlowsEnabled(roomConfig: NostrRoomConfigLike): boolean {
   return roomConfig.config?.taskFlows === true;
 }
 
-function normalizeAllowEntry(value: string): string | undefined {
-  const trimmed = value.trim();
+// allowFrom entries are `string | number` per the host's shared
+// AllowFromListSchema (ZodArray<ZodUnion<[ZodString, ZodNumber]>>), so a numeric
+// entry is valid config. Stringify before trimming — calling .trim() on a number
+// throws. src/nostr-access.ts already handles the union this way.
+function normalizeAllowEntry(value: string | number): string | undefined {
+  const trimmed = String(value).trim();
   if (!trimmed || trimmed === "*") {
     return undefined;
   }
@@ -290,8 +294,8 @@ export function resolveTaskFlowMutationPolicy(
 export function isTaskFlowMutationAllowed(params: {
   senderIsOwner?: boolean;
   requesterSenderId?: string;
-  roomAllowFrom?: readonly string[];
-  accountAllowFrom?: readonly string[];
+  roomAllowFrom?: readonly (string | number)[];
+  accountAllowFrom?: readonly (string | number)[];
   policy?: TaskFlowMutationPolicy;
 }): boolean {
   if (params.senderIsOwner === true) {
@@ -309,7 +313,7 @@ export function isTaskFlowMutationAllowed(params: {
   }
   if (
     params.policy === "room" &&
-    (params.roomAllowFrom ?? []).some((entry) => entry.trim() === "*")
+    (params.roomAllowFrom ?? []).some((entry) => String(entry).trim() === "*")
   ) {
     return true;
   }

package/src/setup-surface.ts

@@ -19,6 +19,10 @@ import { getPublicKeyFromPrivate, normalizePubkey } from "./nostr-bus.js";
 import { resolveNostrAccount } from "./types.js";
 
 const channel = "nostr" as const;
+
+// Widened deliberately — see the UPSTREAM GAP note at the textInput below.
+type WizardTextInputKey = NonNullable<ChannelSetupWizard["textInputs"]>[number]["inputKey"];
+const NIP46_BUNKER_URL_INPUT_KEY = "nip46BunkerUrl" as WizardTextInputKey;
 const setNostrAllowFrom = createTopLevelChannelAllowFromSetter({
   channel,
 });
@@ -148,7 +152,26 @@ export const nostrSetupAdapter: ChannelSetupAdapter = {
   },
 };
 
-export const nostrSetupWizard: ChannelSetupWizard = {
+/**
+ * Shape of the `toggles` steps the host does not implement (ocn-06u9). Declared
+ * locally so the entries stay type-checked instead of degrading to `any` while
+ * they wait to be ported onto a supported mechanism.
+ */
+type UnsupportedWizardToggle = {
+  inputKey: string;
+  message: string;
+  helpTitle?: string;
+  helpLines?: string[];
+  currentValue?: (params: { cfg: OpenClawConfig }) => boolean | undefined;
+  applySet?: (params: {
+    cfg: OpenClawConfig;
+    value: boolean;
+  }) => OpenClawConfig | Promise<OpenClawConfig>;
+};
+
+export const nostrSetupWizard: ChannelSetupWizard & {
+  toggles?: UnsupportedWizardToggle[];
+} = {
   channel,
   resolveAccountIdForConfigure: () => DEFAULT_ACCOUNT_ID,
   resolveShouldPromptAccountIds: () => false,
@@ -230,6 +253,12 @@ export const nostrSetupWizard: ChannelSetupWizard = {
         }),
     },
   ],
+  // DEAD CONFIG (ocn-06u9): the host's ChannelSetupWizard has no `toggles`
+  // member and its wizard runtime never reads one — it iterates `credentials`
+  // and `textInputs` only. This step is therefore never shown and `applySet`
+  // never runs; operators are never asked whether to enable NIP-46. Kept (with
+  // a cast, so the typecheck can be a gate) until ocn-06u9 reimplements it on a
+  // mechanism the host supports, rather than deleting a documented intent.
   toggles: [
     {
       inputKey: "nip46",
@@ -253,7 +282,18 @@ export const nostrSetupWizard: ChannelSetupWizard = {
   ],
   textInputs: [
     {
-      inputKey: "nip46BunkerUrl",
+      // UPSTREAM GAP (ocn-ozwe): the host's `ChannelSetupInput` is a closed type
+      // and has no `nip46BunkerUrl` member, though it does carry other
+      // nostr-specific keys (relayUrls, groupChannels, dmAllowlist). The cast
+      // records that gap rather than hiding a local defect.
+      //
+      // Runtime is unaffected: the host treats `inputKey` as an opaque computed
+      // key (onboard-channels reads `credentialValues[inputKey]`, then hands the
+      // entered value to our own `applySet`), so the interactive step works
+      // end to end. The real consequence is narrower — no CLI flag is derived
+      // for a key the host does not know, so this value cannot be supplied
+      // non-interactively via `openclaw channels add`.
+      inputKey: NIP46_BUNKER_URL_INPUT_KEY,
       message: "NIP-46 bunker URL (bunker://... or user@domain)",
       placeholder: "bunker://pubkey?relay=wss://relay.example.com",
       required: false,
@@ -268,10 +308,13 @@ export const nostrSetupWizard: ChannelSetupWizard = {
         return account.nip46BunkerUrl ?? "";
       },
       keepPrompt: (value) => `NIP-46 bunker URL set (${value}). Keep it?`,
-      validate: ({ value }) => {
-        if (!value.trim()) return null;
-        if (/^bunker:\/\/[0-9a-f]{64}/.test(value)) return null;
-        if (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return null;
+      // The host contract is `string | undefined` (it returns `void 0` for
+      // "valid" in its own adapters); `null` happened to work only because
+      // every consumer truthiness-checks the result.
+      validate: ({ value }): string | undefined => {
+        if (!value.trim()) return undefined;
+        if (/^bunker:\/\/[0-9a-f]{64}/.test(value)) return undefined;
+        if (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return undefined;
         return "Must be a bunker:// URL or user@domain NIP-05 identifier";
       },
       applySet: async ({ cfg, value }) =>

package/src/types.test.ts

@@ -798,3 +798,31 @@ describe("NIP-46 connect secret config resolution", () => {
     expect(account.config.nip46ReconnectPolicy).toEqual({ refreshOnStart: true });
   });
 });
+
+describe("resolveNostrAccount watchdog timeouts", () => {
+  // Regression (ocn-43nd): inboundDispatchAbortSeconds is documented and
+  // accepted by the Zod schema, but was absent from NostrAccountConfig and
+  // from this resolver, so the value an operator configured never reached the
+  // bus and the stage-2 hang watchdog always used its default.
+  it("propagates both inbound dispatch watchdog stages", () => {
+    const cfg = {
+      channels: {
+        nostr: {
+          privateKey: TEST_PRIVATE_KEY,
+          inboundDispatchTimeoutSeconds: 120,
+          inboundDispatchAbortSeconds: 600,
+        },
+      },
+    };
+    const account = resolveNostrAccount({ cfg });
+    expect(account.config.inboundDispatchTimeoutSeconds).toBe(120);
+    expect(account.config.inboundDispatchAbortSeconds).toBe(600);
+  });
+
+  it("leaves both undefined when unset so defaults apply", () => {
+    const cfg = { channels: { nostr: { privateKey: TEST_PRIVATE_KEY } } };
+    const account = resolveNostrAccount({ cfg });
+    expect(account.config.inboundDispatchTimeoutSeconds).toBeUndefined();
+    expect(account.config.inboundDispatchAbortSeconds).toBeUndefined();
+  });
+});

package/src/types.ts

@@ -62,6 +62,7 @@ export interface NostrAccountConfig {
   nip17Enabled?: boolean;
   nip04Enabled?: boolean;
   inboundDispatchTimeoutSeconds?: number;
+  inboundDispatchAbortSeconds?: number;
   publishTimeoutSeconds?: number;
   dmPolicy?: "pairing" | "allowlist" | "open" | "disabled";
   dmContinuity?: NostrDmContinuityConfig;
@@ -570,6 +571,7 @@ export function resolveNostrAccount(opts: {
       nip17Enabled: nostrCfg?.nip17Enabled,
       nip04Enabled: nostrCfg?.nip04Enabled,
       inboundDispatchTimeoutSeconds: nostrCfg?.inboundDispatchTimeoutSeconds,
+      inboundDispatchAbortSeconds: nostrCfg?.inboundDispatchAbortSeconds,
       publishTimeoutSeconds: nostrCfg?.publishTimeoutSeconds,
       dmPolicy: nostrCfg?.dmPolicy,
       allowFrom: nostrCfg?.allowFrom,