foundr-companion 0.1.0

package/dist/bridge/work-mission-listener-loop.mjs

@@ -0,0 +1,737 @@
+import { createPrivateChatWakeSubscription } from './realtime-wake.mjs'
+import {
+  isPublicRoomMentionWakePayload,
+  runOnePublicRoomMentionIteration,
+  runOnePublicRoomMentionWakeIteration,
+} from './public-room-mention-listener-loop.mjs'
+
+const CLIENT_NAME = 'foundr-local-bridge'
+const CLIENT_VERSION = '0.1.0'
+const HEARTBEAT_INTERVAL_MS = 20_000
+const POLL_INTERVAL_MS = 1_000
+const PUBLIC_ROOM_MENTION_POLL_INTERVAL_MS = 1_000
+const WAKE_FALLBACK_POLL_INTERVAL_MS = 15_000
+const PROGRESS_FLUSH_INTERVAL_MS = 120
+const PROGRESS_MAX_BUFFER_CHARS = 180
+const FINAL_PROGRESS_FLUSH_TIMEOUT_MS = 150
+
+function nowMs() {
+  return performance.now()
+}
+
+function timingEnabled() {
+  return process.env.FOUNDR_WORK_MISSION_TIMING === '1' || process.env.FOUNDR_PRIVATE_CHAT_TIMING === '1'
+}
+
+function timingLog(startedAt, message) {
+  if (!timingEnabled()) return
+  console.error(`[foundr:work-missions:timing +${Math.round(nowMs() - startedAt)}ms] ${message}`)
+}
+
+function boundedError(error) {
+  const message = error instanceof Error ? error.message : String(error)
+  return message.replace(/\s+/g, ' ').trim().slice(0, 500)
+}
+
+function delay(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms)
+    timer.unref?.()
+  })
+}
+
+function timestampMs(value) {
+  const date = value instanceof Date ? value : new Date(value)
+  const time = date.getTime()
+  return Number.isNaN(time) ? 0 : time
+}
+
+function replyClientMsgId(messageId) {
+  return `work-mission-reply:${messageId}`.slice(0, 128)
+}
+
+function sortMessages(messages = []) {
+  return messages.slice().sort((a, b) => timestampMs(a.created_at) - timestampMs(b.created_at))
+}
+
+export function pendingWorkMissionFounderMessages(snapshot, {
+  ignoredMessageIds = new Set(),
+} = {}) {
+  const messages = sortMessages(snapshot?.messages ?? [])
+  const replyClientIds = new Set(
+    messages
+      .filter(message => message.sender_kind === 'agent' && message.client_msg_id)
+      .map(message => message.client_msg_id),
+  )
+
+  return messages.filter((message) => (
+    message.sender_kind === 'founder' &&
+    !ignoredMessageIds.has(message.id) &&
+    !replyClientIds.has(replyClientMsgId(message.id))
+  ))
+}
+
+export function workMissionEnvelope(snapshot, message, agent, delivery = null) {
+  return {
+    kind: 'work_mission',
+    mission: snapshot.mission,
+    thread: {
+      id: `mission:${snapshot.mission.id}`,
+      kind: 'work_mission',
+    },
+    message,
+    delivery: {
+      id: delivery?.id ?? message.id,
+      agent_key_id: delivery?.agent_key_id ?? agent?.id ?? '',
+      requested_model: delivery?.requested_model ?? null,
+    },
+    agent: agent ?? null,
+  }
+}
+
+function isWorkMissionWakePayload(payload) {
+  return payload?.type === 'work_mission_delivery_ready' &&
+    typeof payload.delivery_id === 'string' &&
+    typeof payload.mission_id === 'string' &&
+    typeof payload.message_id === 'string' &&
+    typeof payload.body === 'string'
+}
+
+function workMissionWakeEnvelope(payload, agent) {
+  const message = {
+    id: payload.message_id,
+    mission_id: payload.mission_id,
+    sender_kind: 'founder',
+    sender_founder_id: null,
+    sender_agent_key_id: null,
+    body: payload.body,
+    client_msg_id: null,
+    created_at: payload.sent_at ?? new Date().toISOString(),
+  }
+
+  return workMissionEnvelope({
+    mission: {
+      id: payload.mission_id,
+      title: payload.mission_title ?? 'Mission',
+      status: 'running',
+      priority: 'medium',
+    },
+    tasks: [],
+    decisions: [],
+    artifacts: [],
+    messages: [message],
+    deliveries: [],
+    agent_status: { status: 'listening', assigned_count: 1 },
+  }, message, agent, {
+    id: payload.delivery_id,
+    agent_key_id: agent?.id ?? '',
+    requested_model: payload.requested_model ?? null,
+  })
+}
+
+function replyText(reply) {
+  return String(reply?.text ?? '').trim()
+}
+
+function isUnknownToolError(error) {
+  const message = boundedError(error).toLowerCase()
+  return message.includes('unknown tool') ||
+    message.includes('method not found') ||
+    message.includes('tool not found')
+}
+
+async function completeWorkMissionReply({
+  client,
+  deliveryId,
+  sessionId,
+  missionId,
+  messageId,
+  text,
+}) {
+  const clientMsgId = replyClientMsgId(messageId)
+  try {
+    return await client.callTool('complete_work_mission_reply', {
+      delivery_id: deliveryId,
+      listener_session_id: sessionId,
+      body: text,
+      client_msg_id: clientMsgId,
+    })
+  } catch (error) {
+    if (!isUnknownToolError(error)) throw error
+    const sent = await client.callTool('append_work_mission_message', {
+      mission_id: missionId,
+      body: text,
+      client_msg_id: clientMsgId,
+    })
+    await client.callTool('ack_work_mission_message', {
+      delivery_id: deliveryId,
+      listener_session_id: sessionId,
+      status: 'replied',
+      response_message_id: sent.message.id,
+    })
+    return { message: sent.message }
+  }
+}
+
+function progressNumberFromEnv(name, fallback) {
+  const value = Number(process.env[name])
+  return Number.isFinite(value) && value > 0 ? value : fallback
+}
+
+function wakeFallbackPollMs(pollMs) {
+  const configured = Number(process.env.FOUNDR_WORK_MISSION_WAKE_FALLBACK_POLL_MS)
+  if (Number.isFinite(configured) && configured > 0) return configured
+  return Math.max(pollMs, WAKE_FALLBACK_POLL_INTERVAL_MS)
+}
+
+function createProgressReporter({ client, deliveryId, sessionId, iterationStartedAt }) {
+  const flushIntervalMs = progressNumberFromEnv('FOUNDR_WORK_MISSION_PROGRESS_FLUSH_MS', PROGRESS_FLUSH_INTERVAL_MS)
+  const maxBufferChars = progressNumberFromEnv('FOUNDR_WORK_MISSION_PROGRESS_MAX_CHARS', PROGRESS_MAX_BUFFER_CHARS)
+  const finalFlushTimeoutMs = progressNumberFromEnv(
+    'FOUNDR_WORK_MISSION_FINAL_PROGRESS_TIMEOUT_MS',
+    FINAL_PROGRESS_FLUSH_TIMEOUT_MS,
+  )
+
+  let bufferedText = ''
+  let pendingStatus = null
+  let pendingError = null
+  let flushTimer = null
+  let sawFirstDelta = false
+  let progressChain = Promise.resolve()
+
+  const clearFlushTimer = () => {
+    if (!flushTimer) return
+    clearTimeout(flushTimer)
+    flushTimer = null
+  }
+
+  const callProgressTool = (args) => {
+    progressChain = progressChain
+      .then(() => client.callTool('stream_work_mission_reply', {
+        delivery_id: deliveryId,
+        listener_session_id: sessionId,
+        ...args,
+      }))
+      .catch(() => {})
+    return progressChain
+  }
+
+  const flush = () => {
+    clearFlushTimer()
+    const textDelta = bufferedText
+    const status = pendingStatus
+    const error = pendingError
+    bufferedText = ''
+    pendingStatus = null
+    pendingError = null
+
+    if (!textDelta && !status && !error) return progressChain
+    const nextStatus = textDelta && status !== 'failed' ? 'writing' : status
+
+    return callProgressTool({
+      ...(textDelta ? { text_delta: textDelta } : {}),
+      ...(nextStatus ? { status: nextStatus } : {}),
+      ...(error ? { error } : {}),
+    })
+  }
+
+  const scheduleFlush = () => {
+    if (flushTimer) return
+    flushTimer = setTimeout(() => {
+      flushTimer = null
+      void flush()
+    }, flushIntervalMs)
+    flushTimer.unref?.()
+  }
+
+  return {
+    push(event) {
+      if (event.type === 'status') {
+        if (event.status === 'thinking') return
+        pendingStatus = event.status
+        if (event.status === 'failed') {
+          void flush()
+          return
+        }
+        scheduleFlush()
+        return
+      }
+
+      if (event.type !== 'delta' || !event.text) return
+      if (!sawFirstDelta) {
+        sawFirstDelta = true
+        timingLog(iterationStartedAt, `first delta delivery=${deliveryId}`)
+      }
+      bufferedText += event.text
+      pendingStatus = 'writing'
+      if (bufferedText.length >= maxBufferChars) {
+        void flush()
+      } else {
+        scheduleFlush()
+      }
+    },
+
+    async flushBeforeFinal() {
+      const flushed = flush()
+      await Promise.race([flushed, delay(finalFlushTimeoutMs)])
+    },
+
+    async fail(error) {
+      pendingStatus = 'failed'
+      pendingError = boundedError(error)
+      await flush()
+    },
+
+    cancel() {
+      clearFlushTimer()
+      bufferedText = ''
+      pendingStatus = null
+      pendingError = null
+    },
+  }
+}
+
+export async function runOneWorkMissionIteration({
+  client,
+  adapter,
+  agent,
+  sessionId,
+}) {
+  const iterationStartedAt = nowMs()
+  const inbound = await client.callTool('claim_work_mission_message', {
+    listener_session_id: sessionId,
+    include_snapshot: true,
+  })
+
+  if (inbound.timed_out) {
+    return { timed_out: true, replied: 0, skipped: 0, failed: 0 }
+  }
+
+  const deliveryId = inbound.delivery.id
+  timingLog(iterationStartedAt, `claimed delivery=${deliveryId}`)
+
+  const snapshotResult = inbound.snapshot
+    ? { snapshot: inbound.snapshot }
+    : await client.callTool('get_work_mission', {
+        mission_id: inbound.mission.id,
+      })
+  const snapshot = snapshotResult.snapshot ?? {
+    mission: inbound.mission,
+    tasks: [],
+    decisions: [],
+    artifacts: [],
+    messages: [inbound.message],
+    deliveries: [inbound.delivery],
+    agent_status: { status: 'listening', assigned_count: 1 },
+  }
+
+  const progress = createProgressReporter({
+    client,
+    deliveryId,
+    sessionId,
+    iterationStartedAt,
+  })
+
+  let text = ''
+  try {
+    text = replyText(await adapter.reply(
+      workMissionEnvelope(snapshot, inbound.message, agent, inbound.delivery),
+      {
+        onProgress: (event) => {
+          progress.push(event)
+        },
+      },
+    ))
+    await progress.flushBeforeFinal()
+    timingLog(iterationStartedAt, `adapter completed delivery=${deliveryId}`)
+  } catch (error) {
+    const errorText = boundedError(error)
+    await progress.fail(errorText).catch(() => {})
+    await client.callTool('ack_work_mission_message', {
+      delivery_id: deliveryId,
+      listener_session_id: sessionId,
+      status: 'failed',
+      error: errorText,
+    }).catch(() => {})
+    console.error(`[foundr:work-missions] reply failed mission=${inbound.mission.id} message=${inbound.message.id}: ${errorText}`)
+    return { replied: 0, skipped: 0, failed: 1 }
+  }
+
+  if (!text) {
+    await client.callTool('ack_work_mission_message', {
+      delivery_id: deliveryId,
+      listener_session_id: sessionId,
+      status: 'skipped',
+    })
+    return { replied: 0, skipped: 1, failed: 0 }
+  }
+
+  try {
+    const sent = await completeWorkMissionReply({
+      client,
+      deliveryId,
+      sessionId,
+      missionId: snapshot.mission.id,
+      messageId: inbound.message.id,
+      text,
+    })
+    const responseMessageId = sent.message.id
+    timingLog(iterationStartedAt, `reply sent delivery=${deliveryId}`)
+    return { replied: 1, skipped: 0, failed: 0, message_id: responseMessageId }
+  } catch (error) {
+    progress.cancel()
+    const errorText = boundedError(error)
+    await client.callTool('ack_work_mission_message', {
+      delivery_id: deliveryId,
+      listener_session_id: sessionId,
+      status: 'failed',
+      error: errorText,
+    }).catch(() => {})
+    return { replied: 0, skipped: 0, failed: 1, error: errorText }
+  }
+}
+
+export async function runOneWorkMissionWakeIteration({
+  client,
+  adapter,
+  agent,
+  sessionId,
+  wake,
+}) {
+  if (!isWorkMissionWakePayload(wake)) {
+    return runOneWorkMissionIteration({ client, adapter, agent, sessionId })
+  }
+
+  const iterationStartedAt = nowMs()
+  const deliveryId = wake.delivery_id
+  const messageId = wake.message_id
+  timingLog(iterationStartedAt, `wake delivery=${deliveryId}`)
+
+  let progress = null
+  const bufferedProgress = []
+  let replyError = null
+  const replyPromise = adapter.reply(workMissionWakeEnvelope(wake, agent), {
+    onProgress: (event) => {
+      if (progress) {
+        progress.push(event)
+      } else {
+        bufferedProgress.push(event)
+      }
+    },
+  }).catch((error) => {
+    replyError = error
+    return { text: '' }
+  })
+
+  const inbound = await client.callTool('claim_work_mission_message', {
+    listener_session_id: sessionId,
+    delivery_id: deliveryId,
+    include_snapshot: false,
+  })
+
+  if (inbound.timed_out) {
+    await replyPromise.catch(() => {})
+    return { timed_out: true, replied: 0, skipped: 0, failed: 0 }
+  }
+
+  timingLog(iterationStartedAt, `claimed wake delivery=${deliveryId}`)
+
+  progress = createProgressReporter({
+    client,
+    deliveryId,
+    sessionId,
+    iterationStartedAt,
+  })
+  for (const event of bufferedProgress) progress.push(event)
+
+  let text = ''
+  try {
+    const reply = await replyPromise
+    if (replyError) throw replyError
+    text = replyText(reply)
+    await progress.flushBeforeFinal()
+    timingLog(iterationStartedAt, `wake adapter completed delivery=${deliveryId}`)
+  } catch (error) {
+    const errorText = boundedError(error)
+    await progress.fail(errorText).catch(() => {})
+    await client.callTool('ack_work_mission_message', {
+      delivery_id: deliveryId,
+      listener_session_id: sessionId,
+      status: 'failed',
+      error: errorText,
+    }).catch(() => {})
+    console.error(`[foundr:work-missions] wake reply failed mission=${wake.mission_id} message=${messageId}: ${errorText}`)
+    return { replied: 0, skipped: 0, failed: 1 }
+  }
+
+  if (!text) {
+    await client.callTool('ack_work_mission_message', {
+      delivery_id: deliveryId,
+      listener_session_id: sessionId,
+      status: 'skipped',
+    })
+    return { replied: 0, skipped: 1, failed: 0 }
+  }
+
+  try {
+    const sent = await completeWorkMissionReply({
+      client,
+      deliveryId,
+      sessionId,
+      missionId: wake.mission_id,
+      messageId,
+      text,
+    })
+    const responseMessageId = sent.message.id
+    timingLog(iterationStartedAt, `wake reply sent delivery=${deliveryId}`)
+    return { replied: 1, skipped: 0, failed: 0, message_id: responseMessageId }
+  } catch (error) {
+    progress.cancel()
+    const errorText = boundedError(error)
+    await client.callTool('ack_work_mission_message', {
+      delivery_id: deliveryId,
+      listener_session_id: sessionId,
+      status: 'failed',
+      error: errorText,
+    }).catch(() => {})
+    return { replied: 0, skipped: 0, failed: 1, error: errorText }
+  }
+}
+
+export async function runWorkMissionListener({
+  client,
+  adapter,
+  clientName = CLIENT_NAME,
+  clientVersion = CLIENT_VERSION,
+  expectedAgentId,
+  pollMs = POLL_INTERVAL_MS,
+  publicMentionPollMs = PUBLIC_ROOM_MENTION_POLL_INTERVAL_MS,
+  transport = 'wake',
+  wakeSubscriptionFactory = createPrivateChatWakeSubscription,
+}) {
+  const adapterName = adapter.name ?? 'unknown'
+  const heartbeat = await client.callTool('heartbeat_private_chat_listener', {
+    client_name: clientName,
+    client_version: clientVersion,
+    status: 'listening',
+    metadata: { adapter: adapterName, channels: ['work_missions', 'public_room_mentions'] },
+  })
+  if (expectedAgentId && heartbeat.agent?.id !== expectedAgentId) {
+    throw new Error(
+      `Authenticated MCP token resolved to ${heartbeat.agent?.id ?? 'unknown'}; expected ${expectedAgentId}`,
+    )
+  }
+
+  const sessionId = heartbeat.session_id
+  const agent = heartbeat.agent ?? null
+  let stopping = false
+  let fatalError = null
+
+  const sendHeartbeat = (status) => client.callTool('heartbeat_private_chat_listener', {
+    session_id: sessionId,
+    client_name: clientName,
+    client_version: clientVersion,
+    status,
+    metadata: { adapter: adapterName, channels: ['work_missions', 'public_room_mentions'] },
+  })
+
+  const heartbeatTimer = setInterval(() => {
+    if (!stopping) void sendHeartbeat('listening').catch(() => {})
+  }, HEARTBEAT_INTERVAL_MS)
+
+  const stop = async () => {
+    if (stopping) return
+    stopping = true
+    clearInterval(heartbeatTimer)
+    adapter.close?.()
+    await sendHeartbeat('stopped').catch(() => {})
+    await client.close?.().catch(() => {})
+  }
+
+  let stopPromise = null
+  let resolveStopSignal
+  const stopSignal = new Promise((resolve) => {
+    resolveStopSignal = resolve
+  })
+  const requestStop = () => {
+    stopPromise ??= stop()
+    return stopPromise
+  }
+  const stopAndResolve = () => {
+    void requestStop().finally(() => {
+      resolveStopSignal()
+    })
+  }
+
+  const wakeQueue = []
+  const publicMentionWakeQueue = []
+  let wakeHealthy = false
+
+  const pollOnce = async ({
+    allowFallback = true,
+    allowPublicMentions = true,
+    publicMentionsOnly = false,
+  } = {}) => {
+    if (pollOnce.polling) {
+      pollOnce.needsPoll = pollOnce.needsPoll || !publicMentionsOnly
+      pollOnce.allowFallback = pollOnce.allowFallback || allowFallback
+      pollOnce.needsPublicMentions = pollOnce.needsPublicMentions || allowPublicMentions
+      return
+    }
+    pollOnce.polling = true
+    pollOnce.allowFallback = allowFallback
+    pollOnce.allowPublicMentions = allowPublicMentions
+    pollOnce.publicMentionsOnly = publicMentionsOnly
+    try {
+      do {
+        const shouldRunFallback = pollOnce.allowFallback
+        const shouldRunPublicMentions = pollOnce.allowPublicMentions || pollOnce.needsPublicMentions
+        const shouldRunWorkMissions = !pollOnce.publicMentionsOnly
+        pollOnce.needsPoll = false
+        pollOnce.allowFallback = false
+        pollOnce.allowPublicMentions = false
+        pollOnce.publicMentionsOnly = false
+        pollOnce.needsPublicMentions = false
+        if (shouldRunWorkMissions) {
+          while (!stopping && wakeQueue.length > 0) {
+            await runOneWorkMissionWakeIteration({
+              client,
+              adapter,
+              agent,
+              sessionId,
+              wake: wakeQueue.shift(),
+            })
+          }
+          if (shouldRunFallback) {
+            while (!stopping) {
+              const result = await runOneWorkMissionIteration({
+                client,
+                adapter,
+                agent,
+                sessionId,
+              })
+              if (wakeQueue.length > 0) break
+              if (result.timed_out && !pollOnce.needsPoll) break
+            }
+          }
+        }
+        if (shouldRunPublicMentions && !stopping) {
+          while (!stopping && publicMentionWakeQueue.length > 0) {
+            await runOnePublicRoomMentionWakeIteration({
+              client,
+              adapter,
+              agent,
+              wake: publicMentionWakeQueue.shift(),
+            })
+          }
+          const result = await runOnePublicRoomMentionIteration({
+            client,
+            adapter,
+            agent,
+          })
+          if (!result.timed_out) {
+            pollOnce.needsPublicMentions = true
+          }
+        }
+      } while (!stopping && (
+        pollOnce.needsPoll ||
+        pollOnce.allowFallback ||
+        pollOnce.needsPublicMentions ||
+        wakeQueue.length > 0 ||
+        publicMentionWakeQueue.length > 0
+      ))
+    } finally {
+      pollOnce.polling = false
+    }
+  }
+  pollOnce.polling = false
+  pollOnce.needsPoll = false
+  pollOnce.allowFallback = false
+  pollOnce.allowPublicMentions = false
+  pollOnce.needsPublicMentions = false
+  pollOnce.publicMentionsOnly = false
+
+  process.once('SIGINT', stopAndResolve)
+  process.once('SIGTERM', stopAndResolve)
+
+  const launchPoll = (options) => {
+    void pollOnce(options).catch((error) => {
+      if (stopping) return
+      fatalError = error
+      void requestStop().finally(resolveStopSignal)
+    })
+  }
+
+  const launchWake = (payload) => {
+    if (isWorkMissionWakePayload(payload)) wakeQueue.push(payload)
+    if (isPublicRoomMentionWakePayload(payload)) publicMentionWakeQueue.push(payload)
+    launchPoll({
+      allowFallback: false,
+      allowPublicMentions: isPublicRoomMentionWakePayload(payload),
+      publicMentionsOnly: isPublicRoomMentionWakePayload(payload),
+    })
+  }
+
+  let wakeSubscription = null
+  if (transport === 'wake' && heartbeat.wake) {
+    wakeSubscription = await wakeSubscriptionFactory({
+      wake: heartbeat.wake,
+      onWake: launchWake,
+      onStatus: (status) => {
+        if (status === 'SUBSCRIBED') {
+          wakeHealthy = true
+        }
+        if (status === 'CHANNEL_ERROR' || status === 'TIMED_OUT' || status === 'CLOSED') {
+          wakeHealthy = false
+          console.warn(`[foundr:work-missions] wake channel ${status}; fallback polling remains active`)
+        }
+      },
+    }).catch((error) => {
+      console.warn(`[foundr:work-missions] wake subscription unavailable: ${boundedError(error)}`)
+      return null
+    })
+  }
+
+  void adapter.start?.().catch((error) => {
+    if (!stopping) {
+      console.warn(`[foundr:work-missions] adapter warmup failed: ${boundedError(error)}`)
+    }
+  })
+
+  const fallbackPollMs = wakeSubscription ? wakeFallbackPollMs(pollMs) : pollMs
+  const pollTimer = setInterval(() => {
+    if (!stopping && (!wakeSubscription || !wakeHealthy)) launchPoll()
+  }, fallbackPollMs)
+  const publicMentionFallbackMs = wakeSubscription ? wakeFallbackPollMs(publicMentionPollMs) : publicMentionPollMs
+  const publicMentionTimer = setInterval(() => {
+    if (!stopping) {
+      launchPoll({
+        allowFallback: false,
+        allowPublicMentions: true,
+        publicMentionsOnly: true,
+      })
+    }
+  }, publicMentionFallbackMs)
+  publicMentionTimer.unref?.()
+  if (wakeSubscription) {
+    pollTimer.unref?.()
+  } else {
+    launchPoll()
+  }
+
+  try {
+    await stopSignal
+    if (fatalError) throw fatalError
+  } finally {
+    clearInterval(pollTimer)
+    clearInterval(publicMentionTimer)
+    await Promise.resolve(wakeSubscription?.close?.()).catch(() => {})
+    process.off('SIGINT', stopAndResolve)
+    process.off('SIGTERM', stopAndResolve)
+    if (stopPromise) {
+      await stopPromise
+    } else if (!stopping) {
+      await requestStop()
+    }
+  }
+}