@swarmclawai/swarmclaw 0.7.2 → 0.7.4

package/src/lib/server/agent-runtime-config.test.ts

@@ -0,0 +1,141 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import type { Agent, GatewayProfile } from '@/types'
+import { normalizeProviderEndpoint } from '@/lib/openclaw-endpoint'
+import {
+  applyResolvedRoute,
+  resolveAgentRouteCandidatesWithProfiles,
+} from './agent-runtime-config'
+
+function makeGateway(overrides: Partial<GatewayProfile> = {}): GatewayProfile {
+  const now = Date.now()
+  return {
+    id: 'gateway-default',
+    name: 'Gateway Default',
+    provider: 'openclaw',
+    endpoint: 'https://gateway.example.com/v1',
+    wsUrl: 'wss://gateway.example.com',
+    credentialId: 'cred-gateway',
+    status: 'healthy',
+    tags: [],
+    isDefault: true,
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  }
+}
+
+function makeAgent(overrides: Partial<Agent> = {}): Agent {
+  const now = Date.now()
+  return {
+    id: 'agent-1',
+    name: 'OpenClaw Ops',
+    description: '',
+    systemPrompt: '',
+    provider: 'openclaw',
+    model: '',
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  }
+}
+
+test('resolveAgentRouteCandidatesWithProfiles applies the default OpenClaw gateway profile to base agents', () => {
+  const gateways = [
+    makeGateway(),
+    makeGateway({
+      id: 'gateway-secondary',
+      name: 'Gateway Secondary',
+      endpoint: 'https://secondary.example.com/v1',
+      wsUrl: 'wss://secondary.example.com',
+      credentialId: 'cred-secondary',
+      isDefault: false,
+    }),
+  ]
+
+  const [route] = resolveAgentRouteCandidatesWithProfiles(makeAgent(), gateways)
+  assert.ok(route)
+  assert.equal(route.provider, 'openclaw')
+  assert.equal(route.model, 'default')
+  assert.equal(route.gatewayProfileId, 'gateway-default')
+  assert.equal(route.credentialId, 'cred-gateway')
+  assert.equal(route.apiEndpoint, normalizeProviderEndpoint('openclaw', 'https://gateway.example.com/v1'))
+})
+
+test('resolveAgentRouteCandidatesWithProfiles respects routing strategy but deprioritizes cooling providers', () => {
+  const gateways = [
+    makeGateway({
+      id: 'gateway-economy',
+      name: 'Economy Gateway',
+      endpoint: 'https://economy.example.com/v1',
+      wsUrl: 'wss://economy.example.com',
+      credentialId: 'cred-economy',
+      isDefault: false,
+    }),
+  ]
+
+  const agent = makeAgent({
+    provider: 'openai',
+    model: 'gpt-4o',
+    gatewayProfileId: null,
+    routingStrategy: 'economy',
+    routingTargets: [
+      {
+        id: 'economy-route',
+        label: 'Economy',
+        provider: 'openclaw',
+        model: 'default',
+        gatewayProfileId: 'gateway-economy',
+        role: 'economy',
+      },
+      {
+        id: 'premium-route',
+        label: 'Premium',
+        provider: 'openai',
+        model: 'gpt-5',
+        role: 'premium',
+      },
+    ],
+  })
+
+  const preferred = resolveAgentRouteCandidatesWithProfiles(agent, gateways)
+  assert.equal(preferred[0]?.id, 'economy-route')
+  assert.equal(preferred[0]?.apiEndpoint, normalizeProviderEndpoint('openclaw', 'https://economy.example.com/v1'))
+
+  const cooled = resolveAgentRouteCandidatesWithProfiles(agent, gateways, undefined, (providerId) => providerId === 'openclaw')
+  assert.equal(cooled[0]?.id, 'base')
+  assert.equal(cooled[0]?.provider, 'openai')
+})
+
+test('applyResolvedRoute copies gateway, endpoint, and fallback credentials onto a target session-like object', () => {
+  const target = {
+    provider: 'claude-cli' as const,
+    model: 'claude-sonnet-4-5',
+    credentialId: null,
+    fallbackCredentialIds: [] as string[],
+    apiEndpoint: null,
+    gatewayProfileId: null,
+  }
+
+  const next = applyResolvedRoute(target, {
+    id: 'route-1',
+    label: 'Gateway route',
+    provider: 'openclaw',
+    model: 'default',
+    credentialId: 'cred-1',
+    fallbackCredentialIds: ['cred-2', 'cred-3'],
+    apiEndpoint: 'https://gateway.example.com/v1',
+    gatewayProfileId: 'gateway-1',
+    priority: 0,
+    source: 'routing-target',
+  })
+
+  assert.deepEqual(next, {
+    provider: 'openclaw',
+    model: 'default',
+    credentialId: 'cred-1',
+    fallbackCredentialIds: ['cred-2', 'cred-3'],
+    apiEndpoint: 'https://gateway.example.com/v1',
+    gatewayProfileId: 'gateway-1',
+  })
+})

package/src/lib/server/agent-runtime-config.ts

@@ -0,0 +1,277 @@
+import type {
+  Agent,
+  AgentRoutingStrategy,
+  AgentRoutingTarget,
+  GatewayProfile,
+  ProviderType,
+} from '@/types'
+import { deriveOpenClawWsUrl, normalizeProviderEndpoint } from '@/lib/openclaw-endpoint'
+import { loadGatewayProfiles } from './storage'
+import { isProviderCoolingDown } from './provider-health'
+
+const DEFAULT_OPENCLAW_ENDPOINT = 'http://localhost:18789/v1'
+const DEFAULT_OPENCLAW_MODEL = 'default'
+
+export interface ResolvedAgentRoute {
+  id: string
+  label: string
+  provider: ProviderType
+  model: string
+  credentialId?: string | null
+  fallbackCredentialIds: string[]
+  apiEndpoint?: string | null
+  gatewayProfileId?: string | null
+  role?: NonNullable<AgentRoutingTarget['role']>
+  priority: number
+  source: 'agent' | 'routing-target'
+}
+
+interface RouteSeed {
+  id: string
+  label?: string
+  provider?: ProviderType | null
+  model?: string | null
+  credentialId?: string | null
+  fallbackCredentialIds?: string[]
+  apiEndpoint?: string | null
+  gatewayProfileId?: string | null
+  role?: AgentRoutingTarget['role']
+  priority?: number
+  source: ResolvedAgentRoute['source']
+}
+
+function ensureStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  return value
+    .map((item) => (typeof item === 'string' ? item.trim() : ''))
+    .filter(Boolean)
+}
+
+function normalizeGateway(raw: unknown, id: string): GatewayProfile | null {
+  if (!raw || typeof raw !== 'object') return null
+  const gateway = raw as Partial<GatewayProfile> & Record<string, unknown>
+  const endpoint = normalizeProviderEndpoint(
+    'openclaw',
+    typeof gateway.endpoint === 'string' && gateway.endpoint.trim()
+      ? gateway.endpoint
+      : DEFAULT_OPENCLAW_ENDPOINT,
+  )
+  if (!endpoint) return null
+  return {
+    id,
+    name: typeof gateway.name === 'string' && gateway.name.trim() ? gateway.name.trim() : id,
+    provider: 'openclaw',
+    endpoint,
+    wsUrl: typeof gateway.wsUrl === 'string' && gateway.wsUrl.trim() ? gateway.wsUrl.trim() : deriveOpenClawWsUrl(endpoint),
+    credentialId: typeof gateway.credentialId === 'string' && gateway.credentialId.trim() ? gateway.credentialId.trim() : null,
+    status: gateway.status === 'healthy' || gateway.status === 'degraded' || gateway.status === 'offline' || gateway.status === 'pending' ? gateway.status : 'unknown',
+    notes: typeof gateway.notes === 'string' ? gateway.notes : null,
+    tags: ensureStringArray(gateway.tags),
+    lastError: typeof gateway.lastError === 'string' ? gateway.lastError : null,
+    lastCheckedAt: typeof gateway.lastCheckedAt === 'number' ? gateway.lastCheckedAt : null,
+    lastModelCount: typeof gateway.lastModelCount === 'number' ? gateway.lastModelCount : null,
+    discoveredHost: typeof gateway.discoveredHost === 'string' ? gateway.discoveredHost : null,
+    discoveredPort: typeof gateway.discoveredPort === 'number' ? gateway.discoveredPort : null,
+    isDefault: gateway.isDefault === true,
+    createdAt: typeof gateway.createdAt === 'number' ? gateway.createdAt : Date.now(),
+    updatedAt: typeof gateway.updatedAt === 'number' ? gateway.updatedAt : Date.now(),
+  }
+}
+
+function findGatewayProfile(
+  gatewayProfiles: GatewayProfile[],
+  profileId?: string | null,
+): GatewayProfile | null {
+  const id = typeof profileId === 'string' ? profileId.trim() : ''
+  if (!id) return null
+  return gatewayProfiles.find((profile) => profile.id === id) || null
+}
+
+export function getGatewayProfiles(provider: GatewayProfile['provider'] | null = null): GatewayProfile[] {
+  const all = loadGatewayProfiles()
+  return Object.entries(all)
+    .map(([id, value]) => normalizeGateway(value, id))
+    .filter((value): value is GatewayProfile => Boolean(value))
+    .filter((value) => !provider || value.provider === provider)
+    .sort((a, b) => {
+      if ((a.isDefault === true) !== (b.isDefault === true)) return a.isDefault ? -1 : 1
+      return a.name.localeCompare(b.name)
+    })
+}
+
+export function getGatewayProfile(profileId?: string | null): GatewayProfile | null {
+  return findGatewayProfile(getGatewayProfiles(), profileId)
+}
+
+function defaultGatewayProfile(gatewayProfiles: GatewayProfile[]): GatewayProfile | null {
+  return gatewayProfiles.find((profile) => profile.isDefault) || gatewayProfiles[0] || null
+}
+
+function roleWeight(strategy: AgentRoutingStrategy, role?: AgentRoutingTarget['role']): number {
+  const normalized = role || 'primary'
+  const matrix: Record<AgentRoutingStrategy, Record<string, number>> = {
+    single: { primary: 0, backup: 10, premium: 20, reasoning: 30, economy: 40 },
+    balanced: { primary: 0, premium: 4, economy: 4, reasoning: 6, backup: 12 },
+    economy: { economy: 0, primary: 10, backup: 18, premium: 28, reasoning: 36 },
+    premium: { premium: 0, reasoning: 4, primary: 10, backup: 18, economy: 28 },
+    reasoning: { reasoning: 0, premium: 4, primary: 10, backup: 18, economy: 28 },
+  }
+  return matrix[strategy][normalized] ?? 50
+}
+
+function dedupeCredentialIds(primary: string | null | undefined, candidates: string[] | undefined): string[] {
+  const seen = new Set<string>()
+  const normalizedPrimary = typeof primary === 'string' && primary.trim() ? primary.trim() : null
+  const result: string[] = []
+  for (const value of ensureStringArray(candidates)) {
+    if (normalizedPrimary && value === normalizedPrimary) continue
+    if (seen.has(value)) continue
+    seen.add(value)
+    result.push(value)
+  }
+  return result
+}
+
+function buildRouteFromSeed(
+  seed: RouteSeed,
+  gatewayProfiles: GatewayProfile[],
+  agentGatewayProfileId?: string | null,
+): ResolvedAgentRoute | null {
+  const provider = (seed.provider || 'claude-cli') as ProviderType
+  let gatewayProfileId = seed.gatewayProfileId ?? null
+  if (!gatewayProfileId && provider === 'openclaw') {
+    gatewayProfileId = agentGatewayProfileId ?? defaultGatewayProfile(gatewayProfiles)?.id ?? null
+  }
+  const gatewayProfile = findGatewayProfile(gatewayProfiles, gatewayProfileId)
+
+  const providerFromGateway = gatewayProfile?.provider === 'openclaw' ? 'openclaw' : provider
+  const apiEndpoint = normalizeProviderEndpoint(
+    providerFromGateway,
+    seed.apiEndpoint ?? gatewayProfile?.endpoint ?? null,
+  )
+  const model = (seed.model || '').trim() || (providerFromGateway === 'openclaw' ? DEFAULT_OPENCLAW_MODEL : '')
+  if (!providerFromGateway || !model) return null
+
+  const credentialId = seed.credentialId ?? gatewayProfile?.credentialId ?? null
+  return {
+    id: seed.id,
+    label: seed.label?.trim() || (gatewayProfile?.name || `${providerFromGateway}:${model}`),
+    provider: providerFromGateway,
+    model,
+    credentialId,
+    fallbackCredentialIds: dedupeCredentialIds(credentialId, seed.fallbackCredentialIds),
+    apiEndpoint,
+    gatewayProfileId,
+    role: seed.role,
+    priority: typeof seed.priority === 'number' ? seed.priority : 100,
+    source: seed.source,
+  }
+}
+
+function dedupeRoutes(routes: ResolvedAgentRoute[]): ResolvedAgentRoute[] {
+  const seen = new Set<string>()
+  const deduped: ResolvedAgentRoute[] = []
+  for (const route of routes) {
+    const key = [
+      route.provider,
+      route.model,
+      route.credentialId || '',
+      route.apiEndpoint || '',
+      route.gatewayProfileId || '',
+    ].join('::')
+    if (seen.has(key)) continue
+    seen.add(key)
+    deduped.push(route)
+  }
+  return deduped
+}
+
+export function resolveAgentRouteCandidates(
+  agent: Agent | null | undefined,
+  preferredStrategy?: AgentRoutingStrategy | null,
+): ResolvedAgentRoute[] {
+  return resolveAgentRouteCandidatesWithProfiles(agent, getGatewayProfiles('openclaw'), preferredStrategy)
+}
+
+export function resolveAgentRouteCandidatesWithProfiles(
+  agent: Agent | null | undefined,
+  gatewayProfiles: GatewayProfile[],
+  preferredStrategy?: AgentRoutingStrategy | null,
+  isCoolingDown: (providerId: string) => boolean = isProviderCoolingDown,
+): ResolvedAgentRoute[] {
+  if (!agent) return []
+  const strategy = preferredStrategy || agent.routingStrategy || 'single'
+  const seeds: RouteSeed[] = [
+    {
+      id: 'base',
+      label: agent.name,
+      provider: agent.provider,
+      model: agent.model,
+      credentialId: agent.credentialId ?? null,
+      fallbackCredentialIds: agent.fallbackCredentialIds || [],
+      apiEndpoint: agent.apiEndpoint ?? null,
+      gatewayProfileId: agent.gatewayProfileId ?? null,
+      role: 'primary',
+      priority: 0,
+      source: 'agent',
+    },
+    ...((agent.routingTargets || []).map((target, index) => ({
+      id: target.id || `route-${index + 1}`,
+      label: target.label,
+      provider: target.provider,
+      model: target.model,
+      credentialId: target.credentialId ?? null,
+      fallbackCredentialIds: target.fallbackCredentialIds || [],
+      apiEndpoint: target.apiEndpoint ?? null,
+      gatewayProfileId: target.gatewayProfileId ?? null,
+      role: target.role,
+      priority: typeof target.priority === 'number' ? target.priority : index + 1,
+      source: 'routing-target' as const,
+    }))),
+  ]
+
+  return dedupeRoutes(
+    seeds
+      .map((seed) => buildRouteFromSeed(seed, gatewayProfiles, agent.gatewayProfileId ?? null))
+      .filter((route): route is ResolvedAgentRoute => Boolean(route)),
+  ).sort((left, right) => {
+    const leftCooling = isCoolingDown(left.provider)
+    const rightCooling = isCoolingDown(right.provider)
+    if (leftCooling !== rightCooling) return leftCooling ? 1 : -1
+    const leftRole = roleWeight(strategy, left.role)
+    const rightRole = roleWeight(strategy, right.role)
+    if (leftRole !== rightRole) return leftRole - rightRole
+    if (left.priority !== right.priority) return left.priority - right.priority
+    return left.label.localeCompare(right.label)
+  })
+}
+
+export function resolvePrimaryAgentRoute(
+  agent: Agent | null | undefined,
+  preferredStrategy?: AgentRoutingStrategy | null,
+): ResolvedAgentRoute | null {
+  return resolveAgentRouteCandidates(agent, preferredStrategy)[0] || null
+}
+
+export function applyResolvedRoute<T extends {
+  provider: ProviderType
+  model: string
+  credentialId?: string | null
+  fallbackCredentialIds?: string[]
+  apiEndpoint?: string | null
+  gatewayProfileId?: string | null
+}>(
+  target: T,
+  route: ResolvedAgentRoute | null | undefined,
+): T {
+  if (!route) return target
+  return {
+    ...target,
+    provider: route.provider,
+    model: route.model,
+    credentialId: route.credentialId ?? null,
+    fallbackCredentialIds: [...route.fallbackCredentialIds],
+    apiEndpoint: route.apiEndpoint ?? null,
+    gatewayProfileId: route.gatewayProfileId ?? null,
+  }
+}

package/src/lib/server/approval-connector-notify.test.ts

@@ -0,0 +1,253 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { describe, it } from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-approval-connector-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: tempDir,
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+describe('approval connector reminders', () => {
+  it('resolves a due approval to the session connector target and records one-shot delivery state', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      const storage = storageMod.default || storageMod
+      const approvals = approvalsMod.default || approvalsMod
+
+      const now = Date.now()
+      storage.saveSettings({
+        approvalConnectorNotifyEnabled: true,
+        approvalConnectorNotifyDelaySec: 60,
+      })
+      storage.saveAgents({
+        agent_1: {
+          id: 'agent_1',
+          name: 'Molly',
+          description: 'Test agent',
+          systemPrompt: 'You are Molly.',
+          provider: 'openai',
+          model: 'gpt-test',
+          plugins: [],
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+      storage.saveSessions({
+        session_1: {
+          id: 'session_1',
+          name: 'Connector session',
+          cwd: process.cwd(),
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          credentialId: null,
+          apiEndpoint: null,
+          claudeSessionId: null,
+          codexThreadId: null,
+          opencodeSessionId: null,
+          delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
+          messages: [
+            {
+              role: 'user',
+              text: 'Please ask me before spending money.',
+              time: now - 1_000,
+              source: { connectorId: 'conn-1', channelId: 'chat-42', threadId: 'topic-7' },
+            },
+          ],
+          createdAt: now - 120_000,
+          lastActiveAt: now - 1_000,
+          sessionType: 'human',
+          agentId: 'agent_1',
+          plugins: [],
+          connectorContext: {
+            connectorId: 'conn-1',
+            platform: 'telegram',
+            channelId: 'chat-42',
+            threadId: 'topic-7',
+            lastInboundAt: now - 1_000,
+          },
+        },
+      })
+
+      const approval = approvals.requestApproval({
+        category: 'human_loop',
+        title: 'Approve plugin install',
+        description: 'Need permission to install a plugin.',
+        data: {},
+        sessionId: 'session_1',
+        agentId: 'agent_1',
+      })
+
+      const dueAt = approval.createdAt + 61_000
+      const reminders = approvals.listPendingApprovalsNeedingConnectorNotification({
+        now: dueAt,
+        runningConnectors: [
+          { id: 'conn-1', agentId: 'agent_1', supportsSend: true, configuredTargets: [], recentChannelId: 'chat-42' },
+        ],
+      })
+
+      approvals.markApprovalConnectorNotificationSent(approval.id, {
+        at: dueAt,
+        connectorId: 'conn-1',
+        channelId: 'chat-42',
+        threadId: 'topic-7',
+        messageId: 'msg-9',
+      })
+
+      const afterSend = approvals.listPendingApprovalsNeedingConnectorNotification({
+        now: dueAt + 1_000,
+        runningConnectors: [
+          { id: 'conn-1', agentId: 'agent_1', supportsSend: true, configuredTargets: [], recentChannelId: 'chat-42' },
+        ],
+      })
+
+      const storedApproval = storage.loadApprovals()[approval.id]
+      console.log(JSON.stringify({
+        reminderCount: reminders.length,
+        reminder: reminders[0],
+        afterSendCount: afterSend.length,
+        storedApproval,
+      }))
+    `)
+
+    assert.equal(output.reminderCount, 1)
+    assert.equal(output.reminder.connectorId, 'conn-1')
+    assert.equal(output.reminder.channelId, 'chat-42')
+    assert.equal(output.reminder.threadId, 'topic-7')
+    assert.match(output.reminder.text, /Molly is waiting for your approval/i)
+    assert.equal(output.afterSendCount, 0)
+    assert.equal(output.storedApproval.connectorNotification.sentAt > 0, true)
+    assert.equal(output.storedApproval.connectorNotification.messageId, 'msg-9')
+  })
+
+  it('falls back to a running owned connector and respects retry cooldowns after failed sends', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      const storage = storageMod.default || storageMod
+      const approvals = approvalsMod.default || approvalsMod
+
+      const now = Date.now()
+      storage.saveSettings({
+        approvalConnectorNotifyEnabled: true,
+        approvalConnectorNotifyDelaySec: 30,
+      })
+      storage.saveAgents({
+        agent_2: {
+          id: 'agent_2',
+          name: 'Writer',
+          description: 'Test agent',
+          systemPrompt: 'You are Writer.',
+          provider: 'openai',
+          model: 'gpt-test',
+          plugins: [],
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+      storage.saveSessions({
+        session_plain: {
+          id: 'session_plain',
+          name: 'Non-connector session',
+          cwd: process.cwd(),
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          credentialId: null,
+          apiEndpoint: null,
+          claudeSessionId: null,
+          codexThreadId: null,
+          opencodeSessionId: null,
+          delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
+          messages: [],
+          createdAt: now - 60_000,
+          lastActiveAt: now - 1_000,
+          sessionType: 'human',
+          agentId: 'agent_2',
+          plugins: [],
+        },
+      })
+
+      const approval = approvals.requestApproval({
+        category: 'task_tool',
+        title: 'Approve outbound outreach',
+        description: 'Need your approval before sending a message.',
+        data: {},
+        sessionId: 'session_plain',
+        agentId: 'agent_2',
+      })
+
+      const dueAt = approval.createdAt + 31_000
+      const first = approvals.listPendingApprovalsNeedingConnectorNotification({
+        now: dueAt,
+        runningConnectors: [
+          { id: 'conn-fallback', agentId: 'agent_2', supportsSend: true, configuredTargets: [], recentChannelId: 'dm-88' },
+        ],
+      })
+
+      approvals.markApprovalConnectorNotificationAttempt(approval.id, {
+        at: dueAt,
+        connectorId: 'conn-fallback',
+        channelId: 'dm-88',
+        lastError: 'connector temporarily unavailable',
+      })
+
+      const withinCooldown = approvals.listPendingApprovalsNeedingConnectorNotification({
+        now: dueAt + 5_000,
+        runningConnectors: [
+          { id: 'conn-fallback', agentId: 'agent_2', supportsSend: true, configuredTargets: [], recentChannelId: 'dm-88' },
+        ],
+      })
+
+      const afterCooldown = approvals.listPendingApprovalsNeedingConnectorNotification({
+        now: dueAt + (10 * 60_000) + 1_000,
+        runningConnectors: [
+          { id: 'conn-fallback', agentId: 'agent_2', supportsSend: true, configuredTargets: [], recentChannelId: 'dm-88' },
+        ],
+      })
+
+      const storedApproval = storage.loadApprovals()[approval.id]
+      console.log(JSON.stringify({
+        firstCount: first.length,
+        fallbackConnectorId: first[0]?.connectorId || null,
+        fallbackChannelId: first[0]?.channelId || null,
+        withinCooldownCount: withinCooldown.length,
+        afterCooldownCount: afterCooldown.length,
+        storedApproval,
+      }))
+    `)
+
+    assert.equal(output.firstCount, 1)
+    assert.equal(output.fallbackConnectorId, 'conn-fallback')
+    assert.equal(output.fallbackChannelId, 'dm-88')
+    assert.equal(output.withinCooldownCount, 0)
+    assert.equal(output.afterCooldownCount, 1)
+    assert.equal(output.storedApproval.connectorNotification.lastError, 'connector temporarily unavailable')
+  })
+})