@xmoxmo/bncr 0.3.6 → 0.3.8

package/src/plugin/target-runtime.ts

@@ -0,0 +1,141 @@
+import {
+  buildCanonicalBncrSessionKey,
+  formatDisplayScope,
+  parseRouteFromDisplayScope,
+  parseStrictBncrSessionKey,
+  routeKey,
+} from '../core/targets.ts';
+import type { BncrRoute } from '../core/types.ts';
+import { getOpenClawRuntimeConfigOrDefault } from '../openclaw/config-runtime.ts';
+import type { BncrChannelConfigRoot } from './channel-runtime-types.ts';
+
+function asString(v: unknown, fallback = ''): string {
+  if (typeof v === 'string') return v;
+  if (v == null) return fallback;
+  return String(v);
+}
+
+export function createBncrTargetRuntime(runtime: {
+  api: Parameters<typeof getOpenClawRuntimeConfigOrDefault>[0];
+  channelId: string;
+  canonicalAgentId: string | null;
+  now: () => number;
+  normalizeAccountId: (accountId: string) => string;
+  sessionRoutes: Map<string, { accountId: string; route: BncrRoute; updatedAt: number }>;
+  routeAliases: Map<string, { accountId: string; route: BncrRoute; updatedAt: number }>;
+  lastSessionByAccount: Map<string, { sessionKey: string; scope: string; updatedAt: number }>;
+  markActivity: (accountId: string, at?: number) => void;
+  scheduleSave: () => void;
+  logInfo: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
+  logWarn: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
+  ensureCanonicalAgentId: (args: {
+    cfg: BncrChannelConfigRoot;
+    accountId: string;
+    channelId: string;
+    peer: { kind: 'direct'; id: string };
+  }) => string;
+}) {
+  function rememberSessionRoute(sessionKey: string, accountId: string, route: BncrRoute) {
+    const key = asString(sessionKey).trim();
+    if (!key) return;
+
+    const acc = runtime.normalizeAccountId(accountId);
+    const t = runtime.now();
+    const info = { accountId: acc, route, updatedAt: t };
+
+    runtime.sessionRoutes.set(key, info);
+    runtime.routeAliases.set(routeKey(acc, route), info);
+    runtime.lastSessionByAccount.set(acc, {
+      sessionKey: key,
+      scope: formatDisplayScope(route),
+      updatedAt: t,
+    });
+    runtime.markActivity(acc, t);
+    runtime.scheduleSave();
+  }
+
+  function resolveRouteBySession(sessionKey: string, accountId: string): BncrRoute | null {
+    const key = asString(sessionKey).trim();
+    const hit = runtime.sessionRoutes.get(key);
+    if (
+      hit &&
+      runtime.normalizeAccountId(accountId) === runtime.normalizeAccountId(hit.accountId)
+    ) {
+      return hit.route;
+    }
+
+    const parsed = parseStrictBncrSessionKey(key);
+    if (!parsed) return null;
+
+    const alias = runtime.routeAliases.get(
+      routeKey(runtime.normalizeAccountId(accountId), parsed.route),
+    );
+    return alias?.route || parsed.route;
+  }
+
+  function resolveVerifiedTarget(
+    rawTarget: string,
+    accountId: string,
+  ): { sessionKey: string; route: BncrRoute; displayScope: string } {
+    const acc = runtime.normalizeAccountId(accountId);
+    const raw = asString(rawTarget).trim();
+    if (!raw) throw new Error('bncr invalid target(empty)');
+
+    runtime.logInfo('target', `incoming raw=${raw} accountId=${acc}`, { debugOnly: true });
+
+    let route: BncrRoute | null = null;
+
+    const strict = parseStrictBncrSessionKey(raw);
+    if (strict) {
+      route = strict.route;
+    } else {
+      route = parseRouteFromDisplayScope(raw) || resolveRouteBySession(raw, acc);
+    }
+
+    if (!route) {
+      runtime.logWarn(
+        'target',
+        `invalid raw=${raw} accountId=${acc} reason=unparseable-or-unknown standardTo=Bncr:<platform>:<groupId>:<userId>|Bncr:<platform>:<userId> standardSessionKey=agent:<agentId>:bncr:direct:<hex(scope)>`,
+        { debugOnly: true },
+      );
+      throw new Error(
+        `bncr invalid target(standard: Bncr:<platform>:<groupId>:<userId> | Bncr:<platform>:<userId>): ${raw}`,
+      );
+    }
+
+    const canonicalAgentId =
+      runtime.canonicalAgentId ||
+      runtime.ensureCanonicalAgentId({
+        cfg: getOpenClawRuntimeConfigOrDefault<BncrChannelConfigRoot>(runtime.api, {}),
+        accountId: acc,
+        channelId: runtime.channelId,
+        peer: { kind: 'direct', id: route.groupId === '0' ? route.userId : route.groupId },
+      });
+    const verified = {
+      sessionKey: buildCanonicalBncrSessionKey(route, canonicalAgentId),
+      route,
+      displayScope: formatDisplayScope(route),
+    };
+
+    runtime.logInfo(
+      'target',
+      `canonical raw=${raw} accountId=${acc} verified=${JSON.stringify(verified)}`,
+      { debugOnly: true },
+    );
+
+    runtime.lastSessionByAccount.set(acc, {
+      sessionKey: verified.sessionKey,
+      scope: verified.displayScope,
+      updatedAt: runtime.now(),
+    });
+    runtime.scheduleSave();
+
+    return verified;
+  }
+
+  return {
+    rememberSessionRoute,
+    resolveRouteBySession,
+    resolveVerifiedTarget,
+  };
+}

package/src/plugin/target-status-runtime-group.ts

@@ -0,0 +1,130 @@
+import type {
+  BncrAckObservability,
+  BncrAckStrategy,
+  BncrRoute,
+  BncrRuntimeLastSession,
+  OutboxEntry,
+} from '../core/types.ts';
+import type { MediaDedupeCacheEntry } from '../messaging/outbound/media-dedupe.ts';
+import type { getOpenClawRuntimeConfigOrDefault } from '../openclaw/config-runtime.ts';
+import type { BncrChannelConfigRoot } from './channel-runtime-types.ts';
+import { createBncrMediaDedupeRuntime } from './media-dedupe-runtime.ts';
+import { createBncrStatusRuntime } from './status-runtime.ts';
+import { createBncrTargetRuntime } from './target-runtime.ts';
+
+export function createBncrTargetStatusRuntimeGroup(runtime: {
+  api: Parameters<typeof getOpenClawRuntimeConfigOrDefault>[0];
+  channelId: string;
+  canonicalAgentId: string | null;
+  getPluginRoot: () => string | null;
+  startedAt: number;
+  debugVerbose: boolean;
+  adaptiveAckTimeoutEnabled: boolean;
+  defaultMessageAckTimeoutMs: number;
+  fileAckTimeoutMs: number;
+  maxAckTimeoutMs: number;
+  now: () => number;
+  normalizeAccountId: (accountId: string) => string;
+  sessionRoutes: Map<string, { accountId: string; route: BncrRoute; updatedAt: number }>;
+  routeAliases: Map<string, { accountId: string; route: BncrRoute; updatedAt: number }>;
+  lastSessionByAccount: Map<string, BncrRuntimeLastSession>;
+  markActivity: (accountId: string, at?: number) => void;
+  scheduleSave: () => void;
+  logInfo: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
+  logWarn: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
+  ensureCanonicalAgentId: (args: {
+    cfg: BncrChannelConfigRoot;
+    accountId: string;
+    channelId: string;
+    peer: { kind: 'direct'; id: string };
+  }) => string;
+  recentMediaDedupeBySession: Map<string, Map<string, MediaDedupeCacheEntry>>;
+  resolveMessageAckTimeoutMs: (accountId?: string) => number;
+  isOnline: (accountId: string) => boolean;
+  outboxValues: () => Iterable<OutboxEntry>;
+  deadLetterEntries: () => OutboxEntry[];
+  sessionRouteValues: () => Iterable<{ accountId: string }>;
+  countInvalidOutboxSessionKeys: (accountId: string) => number;
+  countLegacyAccountResidue: (accountId: string) => number;
+  connectEventsByAccount: Map<string, number>;
+  inboundEventsByAccount: Map<string, number>;
+  activityEventsByAccount: Map<string, number>;
+  ackEventsByAccount: Map<string, number>;
+  activeConnectionCount: (accountId: string) => number;
+  lastActivityByAccount: Map<string, number>;
+  lastInboundByAccount: Map<string, number>;
+  lastOutboundByAccount: Map<string, number>;
+  buildRuntimeAckObservability: (accountId: string) => BncrAckObservability;
+  buildRuntimeAckStrategy: (ackObservability: BncrAckObservability) => BncrAckStrategy;
+  lastAckOkByAccount: Map<string, number>;
+  lastAckTimeoutByAccount: Map<string, number>;
+  getAckTimeoutCount: (accountId: string) => number;
+  getAccountPendingOutboxEntries: (accountId: string) => OutboxEntry[];
+  getAccountDeadLetterEntries: (accountId: string) => OutboxEntry[];
+  connectionsValues: () => Iterable<{ lastSeenAt: number }>;
+  connectTtlMs: number;
+}) {
+  const targetRuntime = createBncrTargetRuntime({
+    api: runtime.api,
+    channelId: runtime.channelId,
+    canonicalAgentId: runtime.canonicalAgentId,
+    now: runtime.now,
+    normalizeAccountId: runtime.normalizeAccountId,
+    sessionRoutes: runtime.sessionRoutes,
+    routeAliases: runtime.routeAliases,
+    lastSessionByAccount: runtime.lastSessionByAccount,
+    markActivity: runtime.markActivity,
+    scheduleSave: runtime.scheduleSave,
+    logInfo: runtime.logInfo,
+    logWarn: runtime.logWarn,
+    ensureCanonicalAgentId: runtime.ensureCanonicalAgentId,
+  });
+
+  const mediaDedupeRuntime = createBncrMediaDedupeRuntime({
+    now: runtime.now,
+    recentMediaDedupeBySession: runtime.recentMediaDedupeBySession,
+  });
+
+  const statusRuntime = createBncrStatusRuntime({
+    api: runtime.api,
+    getPluginRoot: runtime.getPluginRoot,
+    startedAt: runtime.startedAt,
+    debugVerbose: runtime.debugVerbose,
+    adaptiveAckTimeoutEnabled: runtime.adaptiveAckTimeoutEnabled,
+    defaultMessageAckTimeoutMs: runtime.defaultMessageAckTimeoutMs,
+    fileAckTimeoutMs: runtime.fileAckTimeoutMs,
+    maxAckTimeoutMs: runtime.maxAckTimeoutMs,
+    now: runtime.now,
+    resolveMessageAckTimeoutMs: runtime.resolveMessageAckTimeoutMs,
+    isOnline: runtime.isOnline,
+    outboxValues: runtime.outboxValues,
+    deadLetterEntries: runtime.deadLetterEntries,
+    sessionRouteValues: runtime.sessionRouteValues,
+    countInvalidOutboxSessionKeys: runtime.countInvalidOutboxSessionKeys,
+    countLegacyAccountResidue: runtime.countLegacyAccountResidue,
+    connectEventsByAccount: runtime.connectEventsByAccount,
+    inboundEventsByAccount: runtime.inboundEventsByAccount,
+    activityEventsByAccount: runtime.activityEventsByAccount,
+    ackEventsByAccount: runtime.ackEventsByAccount,
+    activeConnectionCount: runtime.activeConnectionCount,
+    lastSessionByAccount: runtime.lastSessionByAccount,
+    lastActivityByAccount: runtime.lastActivityByAccount,
+    lastInboundByAccount: runtime.lastInboundByAccount,
+    lastOutboundByAccount: runtime.lastOutboundByAccount,
+    buildRuntimeAckObservability: runtime.buildRuntimeAckObservability,
+    buildRuntimeAckStrategy: runtime.buildRuntimeAckStrategy,
+    lastAckOkByAccount: runtime.lastAckOkByAccount,
+    lastAckTimeoutByAccount: runtime.lastAckTimeoutByAccount,
+    getAckTimeoutCount: runtime.getAckTimeoutCount,
+    getAccountPendingOutboxEntries: runtime.getAccountPendingOutboxEntries,
+    getAccountDeadLetterEntries: runtime.getAccountDeadLetterEntries,
+    connectionsValues: runtime.connectionsValues,
+    connectTtlMs: runtime.connectTtlMs,
+  });
+
+  return {
+    targetRuntime,
+    mediaDedupeRuntime,
+    statusRuntime,
+  };
+}

package/src/plugin/transient-state-runtime.ts

@@ -0,0 +1,82 @@
+import type { BncrConnection } from '../core/types.ts';
+
+export function createBncrTransientStateRuntime(runtime: {
+  now: () => number;
+  connectTtlMs: number;
+  fileTransferKeepMs: number;
+  fileTransferTerminalKeepMs: number;
+  fileTransferAckTtlMs: number;
+  connections: Map<string, BncrConnection>;
+  activeConnectionByAccount: Map<string, string>;
+  recentInbound: Map<string, number>;
+  fileSendTransfers: Map<string, { status: string; startedAt: number; terminalAt?: number }>;
+  fileRecvTransfers: Map<string, { status: string; startedAt: number; terminalAt?: number }>;
+  earlyFileAcks: Map<string, { at: number }>;
+  logInfo: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
+  bridgeId: string;
+}) {
+  function cleanupFileTransfers() {
+    const t = runtime.now();
+    const keepMsForTransfer = (st: { status: string; startedAt: number; terminalAt?: number }) => {
+      const startedAt = Number.isFinite(st.startedAt) ? st.startedAt : t;
+      if (st.status === 'completed' || st.status === 'aborted') {
+        return {
+          since: Number.isFinite(st.terminalAt) ? (st.terminalAt as number) : startedAt,
+          keepMs: runtime.fileTransferTerminalKeepMs,
+        };
+      }
+      return { since: startedAt, keepMs: runtime.fileTransferKeepMs };
+    };
+
+    for (const [id, st] of runtime.fileSendTransfers.entries()) {
+      const keep = keepMsForTransfer(st);
+      if (t - keep.since > keep.keepMs) runtime.fileSendTransfers.delete(id);
+    }
+    for (const [id, st] of runtime.fileRecvTransfers.entries()) {
+      const keep = keepMsForTransfer(st);
+      if (t - keep.since > keep.keepMs) runtime.fileRecvTransfers.delete(id);
+    }
+    for (const [key, ack] of runtime.earlyFileAcks.entries()) {
+      if (t - ack.at > runtime.fileTransferAckTtlMs) runtime.earlyFileAcks.delete(key);
+    }
+  }
+
+  function gcTransientState() {
+    const t = runtime.now();
+    const staleBefore = t - runtime.connectTtlMs * 2;
+
+    for (const [key, c] of runtime.connections.entries()) {
+      if (c.lastSeenAt < staleBefore) {
+        runtime.logInfo(
+          'connection',
+          `gc ${JSON.stringify({
+            bridge: runtime.bridgeId,
+            key,
+            accountId: c.accountId,
+            connId: c.connId,
+            clientId: c.clientId,
+            lastSeenAt: c.lastSeenAt,
+            staleBefore,
+          })}`,
+          { debugOnly: true },
+        );
+        runtime.connections.delete(key);
+        if (runtime.activeConnectionByAccount.get(c.accountId) === key) {
+          runtime.activeConnectionByAccount.delete(c.accountId);
+        }
+      }
+    }
+
+    const dedupWindowMs = 90_000;
+    for (const [key, ts] of runtime.recentInbound.entries()) {
+      if (t - ts > dedupWindowMs) runtime.recentInbound.delete(key);
+    }
+
+    cleanupFileTransfers();
+  }
+
+  return {
+    gcTransientState,
+    cleanupFileTransfers,
+  };
+}

package/src/runtime/outbound-ack-timeout.ts

@@ -1,3 +1,5 @@
+import type { BncrAckObservability, BncrAckStrategy } from '../core/types.ts';
+
 type ComputeBncrRecommendedAckTimeoutArgs = {
   lateAckOkCount: number;
   recentAckTimeoutCount: number;
@@ -83,7 +85,7 @@ function asString(value: unknown, fallback = '') {
 }
 
 export function buildBncrRuntimeAckStrategy(args: {
-  ackObservability: Record<string, any>;
+  ackObservability: BncrAckObservability;
   defaultAckTimeoutMs: number;
   maxAckTimeoutMs: number;
 }) {
@@ -101,7 +103,7 @@ export function buildBncrRuntimeAckStrategy(args: {
     lastLateAckAgeMs: ackObservability.lastLateAckAgeMs ?? null,
     lateAckObservationTtlMs: ackObservability.lateAckObservationTtlMs ?? null,
     recovered: ackObservability.adaptiveAckRecovered === true,
-  };
+  } satisfies BncrAckStrategy;
 }
 
 export function buildBncrRuntimeAckObservability(args: {
@@ -165,5 +167,5 @@ export function buildBncrRuntimeAckObservability(args: {
     currentAckTimeoutMs: args.currentAckTimeoutMs,
     recommendedAckTimeoutMs: ackTimeoutDecision.timeoutMs,
     recommendedAckTimeoutReason: ackTimeoutDecision.reason,
-  };
+  } satisfies BncrAckObservability;
 }

package/src/runtime/outbound-flags.ts

@@ -1,7 +1,23 @@
 import { BNCR_DEFAULT_ACCOUNT_ID, CHANNEL_ID, normalizeAccountId } from '../core/accounts.ts';
 import { getOpenClawRuntimeConfig } from '../openclaw/config-runtime.ts';
+import type {
+  BncrChannelConfigRoot,
+  BncrChannelConfigSection,
+  BncrStatusRuntimeSnapshot,
+} from '../plugin/channel-runtime-types.ts';
 
 type RuntimeApiHolder = { api: unknown };
+type BncrAckConfigAccount = { outboundRequireAck?: boolean };
+type BncrAckConfigChannel = BncrChannelConfigSection & {
+  accounts?: Record<string, BncrAckConfigAccount | undefined>;
+};
+
+type OpenClawConfigApi = Parameters<typeof getOpenClawRuntimeConfig>[0];
+
+function resolveBncrAckConfigChannel(api: unknown): BncrAckConfigChannel | undefined {
+  const cfg = getOpenClawRuntimeConfig(api as OpenClawConfigApi) as BncrChannelConfigRoot;
+  return cfg?.channels?.[CHANNEL_ID] as BncrAckConfigChannel | undefined;
+}
 
 type ResolveOutboundAckRequiredArgs = RuntimeApiHolder & {
   accountId?: string;
@@ -9,11 +25,10 @@ type ResolveOutboundAckRequiredArgs = RuntimeApiHolder & {
 
 export function resolveBncrOutboundAckRequired(args: ResolveOutboundAckRequiredArgs) {
   try {
-    const cfg = getOpenClawRuntimeConfig(args.api as any);
-    const channelCfg = (cfg as any)?.channels?.[CHANNEL_ID];
+    const channelCfg = resolveBncrAckConfigChannel(args.api);
     const accountCfg =
       args.accountId && channelCfg?.accounts && typeof channelCfg.accounts === 'object'
-        ? (channelCfg.accounts as Record<string, any>)[normalizeAccountId(args.accountId)]
+        ? channelCfg.accounts[normalizeAccountId(args.accountId)]
         : null;
     const scoped = accountCfg?.outboundRequireAck;
     const global = channelCfg?.outboundRequireAck;
@@ -37,9 +52,9 @@ type BuildBncrRuntimeFlagsArgs = RuntimeApiHolder & {
 export function buildBncrRuntimeStatusInput(args: {
   accountId: string;
   connected: boolean;
-  queueSnapshot: Record<string, any>;
-  eventCounters: Record<string, any>;
-  activitySnapshot: Record<string, any>;
+  queueSnapshot: BncrStatusRuntimeSnapshot;
+  eventCounters: BncrStatusRuntimeSnapshot;
+  activitySnapshot: BncrStatusRuntimeSnapshot;
   startedAt: number | null;
   running?: boolean;
   channelRoot: string;
@@ -59,8 +74,7 @@ export function buildBncrRuntimeStatusInput(args: {
 export function buildBncrRuntimeFlags(args: BuildBncrRuntimeFlagsArgs) {
   let ackPolicySource: 'channel' | 'default' = 'default';
   try {
-    const cfg = getOpenClawRuntimeConfig(args.api as any);
-    const global = (cfg as any)?.channels?.[CHANNEL_ID]?.outboundRequireAck;
+    const global = resolveBncrAckConfigChannel(args.api)?.outboundRequireAck;
     if (typeof global === 'boolean') ackPolicySource = 'channel';
   } catch {
     // keep default source
@@ -79,3 +93,5 @@ export function buildBncrRuntimeFlags(args: BuildBncrRuntimeFlagsArgs) {
     debugVerbose: args.debugVerbose,
   };
 }
+
+export type BncrRuntimeFlags = ReturnType<typeof buildBncrRuntimeFlags>;

package/src/runtime/status-snapshots.ts

@@ -1,5 +1,34 @@
 import { normalizeAccountId } from '../core/accounts.ts';
-import type { OutboxEntry } from '../core/types.ts';
+import type { BncrRuntimeLastSession, OutboxEntry } from '../core/types.ts';
+
+export type RuntimeQueueSnapshot = {
+  pending: number;
+  deadLetter: number;
+  sessionRoutesCount: number;
+  invalidOutboxSessionKeys: number;
+  legacyAccountResidue: number;
+};
+
+export type RuntimeEventCounters = {
+  connectEvents: number;
+  inboundEvents: number;
+  activityEvents: number;
+  ackEvents: number;
+};
+
+export type RuntimeActivitySnapshot = {
+  activeConnections: number;
+  lastSession: BncrRuntimeLastSession | null;
+  lastActivityAt: number | null;
+  lastInboundAt: number | null;
+  lastOutboundAt: number | null;
+};
+
+export type RuntimeStatusSnapshots = {
+  queueSnapshot: RuntimeQueueSnapshot;
+  eventCounters: RuntimeEventCounters;
+  activitySnapshot: RuntimeActivitySnapshot;
+};
 
 function getCounter(map: Map<string, number>, accountId: string): number {
   return map.get(normalizeAccountId(accountId)) || 0;
@@ -12,7 +41,7 @@ export function buildRuntimeQueueSnapshot(args: {
   sessionRouteEntries: Iterable<{ accountId: string }>;
   countInvalidOutboxSessionKeys: (accountId: string) => number;
   countLegacyAccountResidue: (accountId: string) => number;
-}) {
+}): RuntimeQueueSnapshot {
   const accountId = normalizeAccountId(args.accountId);
   const pending = Array.from(args.outboxEntries).filter((v) => v.accountId === accountId).length;
   const deadLetter = Array.from(args.deadLetterEntries).filter(
@@ -36,7 +65,7 @@ export function buildRuntimeEventCounters(args: {
   inboundEventsByAccount: Map<string, number>;
   activityEventsByAccount: Map<string, number>;
   ackEventsByAccount: Map<string, number>;
-}) {
+}): RuntimeEventCounters {
   const accountId = normalizeAccountId(args.accountId);
   return {
     connectEvents: getCounter(args.connectEventsByAccount, accountId),
@@ -53,11 +82,11 @@ function nullableMapNumber(map: Map<string, number>, key: string): number | null
 export function buildRuntimeActivitySnapshot(args: {
   accountId: string;
   activeConnectionCount: (accountId: string) => number;
-  lastSessionByAccount: Map<string, { sessionKey: string; scope: string; updatedAt: number }>;
+  lastSessionByAccount: Map<string, BncrRuntimeLastSession>;
   lastActivityByAccount: Map<string, number>;
   lastInboundByAccount: Map<string, number>;
   lastOutboundByAccount: Map<string, number>;
-}) {
+}): RuntimeActivitySnapshot {
   const accountId = normalizeAccountId(args.accountId);
   return {
     activeConnections: args.activeConnectionCount(accountId),
@@ -80,11 +109,11 @@ export function buildRuntimeStatusSnapshots(args: {
   activityEventsByAccount: Map<string, number>;
   ackEventsByAccount: Map<string, number>;
   activeConnectionCount: (accountId: string) => number;
-  lastSessionByAccount: Map<string, { sessionKey: string; scope: string; updatedAt: number }>;
+  lastSessionByAccount: Map<string, BncrRuntimeLastSession>;
   lastActivityByAccount: Map<string, number>;
   lastInboundByAccount: Map<string, number>;
   lastOutboundByAccount: Map<string, number>;
-}) {
+}): RuntimeStatusSnapshots {
   const accountId = normalizeAccountId(args.accountId);
   return {
     queueSnapshot: buildRuntimeQueueSnapshot({

package/src/runtime/status-worker.ts

@@ -1,9 +1,39 @@
 import { normalizeAccountId } from '../core/accounts.ts';
+import type { BncrDiagnosticsSummary } from '../core/types.ts';
+
+type StatusRuntimeMeta = {
+  pending?: number;
+  pendingAdmissionsCount?: number;
+  pendingAdmissions?: unknown[];
+  deadLetter?: number;
+  lastSessionScope?: string | null;
+  lastSessionAt?: number | null;
+  lastSessionAgo?: string | null;
+  lastActivityAt?: number | null;
+  lastActivityAgo?: string | null;
+  lastInboundAt?: number | null;
+  lastInboundAgo?: string | null;
+  lastOutboundAt?: number | null;
+  lastOutboundAgo?: string | null;
+  diagnostics?: BncrDiagnosticsSummary | Record<string, unknown>;
+};
+
+type StatusRuntimeState = {
+  accountId?: string;
+  running?: boolean;
+  connected?: boolean;
+  restartPending?: boolean;
+  lastEventAt?: number | null;
+  lastStopAt?: number | null;
+  mode?: 'linked' | 'configured' | string;
+  lastError?: string | null;
+  meta?: StatusRuntimeMeta;
+};
 
 type StatusWorkerContext = {
   accountId: string;
-  getStatus?: () => Record<string, any>;
-  setStatus?: (status: Record<string, any>) => void;
+  getStatus?: () => StatusRuntimeState;
+  setStatus?: (status: StatusRuntimeState) => void;
   abortSignal?: {
     aborted?: boolean;
     addEventListener?: (event: 'abort', listener: () => void, options?: { once?: boolean }) => void;
@@ -70,10 +100,10 @@ export function updateHealthStatusLogState(args: {
 type StatusWorkerHooks = {
   isOnline: (accountId: string) => boolean;
   hasRecentInboundReachability: (accountId: string) => boolean;
-  getLastActivityAt: (accountId: string, previous: Record<string, any>) => number | null;
+  getLastActivityAt: (accountId: string, previous: StatusRuntimeState) => number | null;
   getActiveConnectionKey: (accountId: string) => string | null;
   getActiveConnections: (accountId: string) => Array<Record<string, unknown>>;
-  buildStatusMeta: (accountId: string) => Record<string, any>;
+  buildStatusMeta: (accountId: string) => StatusRuntimeMeta;
   logInfo: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
   logInfoDedup: (
     scope: string | undefined,