feat(kiloclaw): deliver morning briefing to configured channels (#2813)

* feat(kiloclaw): deliver Morning Briefing to configured channels

Send generated briefings to configured Telegram, Discord, and Slack routes with channel-friendly formatting and delivery status reporting so users can receive briefings where they work. Add robust routing, timeout/retry hardening, and run-path warmup handling so generation success is decoupled from delivery flakiness.

* refactor(kiloclaw): consolidate morning briefing delivery internals

Split command and channel-delivery concerns into dedicated modules, tighten timeout retry semantics, and reuse shared UI typing to reduce schema drift. Add cron JSON compatibility fallback to avoid controller/runtime option skew.

* fix(kiloclaw): avoid exposing delivery payloads in UI errors

Render morning briefing delivery failures with reason-only text in Settings so stored command errors remain available for diagnostics without leaking message content in the dashboard.

* fix(kiloclaw): stabilize morning briefing warmup transitions

Treat gateway and briefing readiness as boot-session fresh data to avoid stale Disabled flaps, and clear cached gateway/morning-briefing queries on start, provision, and restarts so controls remain in warmup state until current boot data arrives.

* fix(kiloclaw): remove warmup disabled-state flap

Stop emitting synthetic enabled=false during morning-briefing warmup and treat gateway_warming_up as authoritative in the dashboard card. Keep warmup badge styling and delivery visibility gated until status fields are resolved to prevent transient Disabled and Last delivery flaps.

* fix(kiloclaw): polish morning briefing status metadata UI

Move Last delivery beneath Last generated, render channel/status labels with user-friendly capitalization, and top-align action buttons so the card layout stays consistent as metadata lines appear.

* fix(kiloclaw): align morning briefing metadata layout

Add a topical Morning Briefing icon, keep delivery labels user-friendly and capitalized, and place the source summary in the same content column so metadata lines share a consistent leading edge.

* fix(kiloclaw): format last delivery provider labels

Render Morning Briefing Last delivery entries as provider-first labels with status in parentheses while keeping the bullet delimiter for readability.

* fix(kiloclaw): simplify morning briefing failures section

Rename the report heading to Failures and keep the section omitted when no failures exist so the daily briefing body stays concise and focused.

* style(web): apply formatting for morning briefing UI

* fix(kiloclaw): preserve links with parentheses in delivery text

Replace regex-only markdown link expansion with a balanced-parentheses parser so channel messages keep full URLs when links contain nested parentheses.

* fix(kiloclaw): stop retrying run requests on timeout

Use endpoint-specific warmup retry policy so morning-briefing run no longer retries timeout errors that can overlap in-flight runs and duplicate sends. Return a dedicated run-timeout response code for clients.

* test(web): lock warmup state against disabled flap

Extract morning briefing card state derivation and add regression coverage for stale enabled values plus gateway_warming_up payloads so the card stays in warmup state instead of flashing Disabled.

* fix(kiloclaw): sanitize stored morning briefing delivery errors

Store concise delivery failure details instead of full command text to reduce sensitive payload exposure while preserving operator diagnostics. Update lifecycle assertions to match sanitized error persistence.

* fix(kiloclaw): tighten briefing run timeout and delivery observability

Rename timeout test semantics, add focused delivery-utils unit coverage, and emit structured delivery outcome events for sent/skipped/failed paths. Include latest Morning Briefing warmup/source-summary alignment tweak in the same push-ready set.

* refactor(kiloclaw): share morning briefing delivery constants

Extract delivery channel/status/reason enums into a shared module and reuse them in gateway response schemas and plugin delivery utilities to prevent drift.

* Revert "refactor(kiloclaw): share morning briefing delivery constants"

This reverts commit 384cc0d.

* refactor(kiloclaw): dedupe delivery enums via shared constants

Define morning briefing delivery channel/status/reason enums once and reuse them in both plugin delivery logic and gateway controller response schemas to prevent drift.

* fix(kiloclaw): import delivery channels from constants module

Resolve plugin pack build failure by importing DELIVERY_CHANNELS directly from delivery-constants instead of delivery-utils, keeping a single source for delivery enum declarations.

Author: joshavant

apps/web/src/app/(app)/claw/components/SettingsTab.tsx

@@ -8,22 +8,23 @@ import {
   FileCode,
   Hash,
   Info,
+  Newspaper,
   RotateCcw,
   Save,
   Settings,
   ShieldCheck,
   Square,
   X,
 } from 'lucide-react';
-import { useEffect, useMemo, useState } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 import { OpenclawImportCard } from './OpenclawImportCard';
 
 import { usePostHog } from 'posthog-js/react';
 import { toast } from 'sonner';
 import { useModelSelectorList } from '@/app/api/openrouter/hooks';
 import { useUser } from '@/hooks/useUser';
 import { ModelCombobox, type ModelOption } from '@/components/shared/ModelCombobox';
-import type { KiloClawDashboardStatus } from '@/lib/kiloclaw/types';
+import type { KiloClawDashboardStatus, MorningBriefingStatusLite } from '@/lib/kiloclaw/types';
 import { calverAtLeast, cleanVersion } from '@/lib/kiloclaw/version';
 import type { useKiloClawMutations } from '@/hooks/useKiloClaw';
 import {
@@ -66,6 +67,7 @@ import { Switch } from '@/components/ui/switch';
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { DetailTile } from './DetailTile';
 import { EMBEDDING_MODELS, DEFAULT_EMBEDDING_MODEL } from './embeddingModels';
+import { deriveMorningBriefingCardState } from './morning-briefing-card-state';
 
 import { getEntriesByCategory } from '@kilocode/kiloclaw-secret-catalog';
 import { SecretEntrySection } from './SecretEntrySection';
@@ -500,24 +502,7 @@ function MorningBriefingCard({
   actionsReady,
 }: {
   mutations: ClawMutations;
-  briefingStatus:
-    | {
-        enabled?: boolean;
-        desiredEnabled?: boolean;
-        observedEnabled?: boolean | null;
-        reconcileState?: 'idle' | 'in_progress' | 'succeeded' | 'failed';
-        lastReconcileAction?: 'enable' | 'disable' | null;
-        code?: string;
-        cron?: string;
-        timezone?: string;
-        lastGeneratedDate?: string | null;
-        sourceReadiness?: {
-          github: { configured: boolean; summary: string };
-          linear: { configured: boolean; summary: string };
-          web: { configured: boolean; summary: string };
-        };
-      }
-    | undefined;
+  briefingStatus: MorningBriefingStatusLite | undefined;
   fallbackReadiness: {
     githubConfigured: boolean;
     linearConfigured: boolean;
@@ -553,11 +538,14 @@ function MorningBriefingCard({
     } as const);
 
   const hasSchedule = Boolean(briefingStatus?.cron && briefingStatus?.timezone);
-  const desiredEnabled = briefingStatus?.desiredEnabled ?? briefingStatus?.enabled ?? false;
-  const observedEnabled = briefingStatus?.observedEnabled ?? briefingStatus?.enabled ?? false;
+  const { desiredEnabled, observedEnabled, hasResolvedBriefingToggleState, isWarmupState } =
+    deriveMorningBriefingCardState({
+      isRunning,
+      actionsReady,
+      briefingStatus,
+    });
   const reconcileState = briefingStatus?.reconcileState ?? 'idle';
   const lastReconcileAction = briefingStatus?.lastReconcileAction ?? null;
-  const isWarmupState = isRunning && actionsReady === false;
   const isTransitioning =
     reconcileState === 'in_progress' ||
     mutations.enableMorningBriefing.isPending ||
@@ -596,8 +584,9 @@ function MorningBriefingCard({
 
     return observedEnabled ? 'Enabled' : 'Disabled';
   })();
-  const statusVariant =
-    statusLabel === 'Instance Stopped'
+  const statusVariant = isWarmupState
+    ? 'secondary'
+    : statusLabel === 'Instance Stopped'
       ? 'secondary'
       : observedEnabled || (isTransitioning && desiredEnabled)
         ? 'default'
@@ -623,25 +612,73 @@ function MorningBriefingCard({
   const showScheduleDetails = !isWarmupState && hasSchedule && desiredEnabled;
   const controlsEnabled = actionsReady && !isWarmupState;
   const canUseBriefingControls = controlsEnabled && desiredEnabled;
+  const lastDelivery = briefingStatus?.lastDelivery ?? [];
+  const showLastDelivery =
+    !isWarmupState && actionsReady && hasResolvedBriefingToggleState && lastDelivery.length > 0;
+  const deliveryChannelLabel = {
+    telegram: 'Telegram',
+    discord: 'Discord',
+    slack: 'Slack',
+  } as const;
+  const deliveryStatusLabel = {
+    sent: 'Sent',
+    skipped: 'Skipped',
+    failed: 'Failed',
+  } as const;
+  const deliveryReasonLabel = {
+    missing_target: 'Missing target',
+    ambiguous_target: 'Ambiguous target',
+    send_failed: 'Send failed',
+    config_unavailable: 'Config unavailable',
+  } as const;
 
   return (
     <div className="rounded-lg border px-4 py-3">
-      <div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
-        <div>
-          <div className="flex items-center gap-2">
-            <p className="text-sm font-medium">Morning Briefing</p>
-            <Badge variant={statusVariant}>{statusLabel}</Badge>
+      <div className="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between">
+        <div className="flex items-start gap-3">
+          <Newspaper className="text-muted-foreground h-5 w-5 shrink-0" />
+          <div>
+            <div className="flex items-center gap-2">
+              <p className="text-sm font-medium">Morning Briefing</p>
+              <Badge variant={statusVariant} className="px-1.5 py-0 text-[10px] leading-4">
+                {statusLabel}
+              </Badge>
+            </div>
+            {showScheduleDetails && briefingStatus?.cron && briefingStatus?.timezone && (
+              <p className="text-muted-foreground text-xs">
+                {formatMorningBriefingSchedule(briefingStatus.cron, briefingStatus.timezone)}
+              </p>
+            )}
+            {showScheduleDetails && (
+              <p className="text-muted-foreground text-xs">
+                Last generated: {briefingStatus?.lastGeneratedDate ?? '(none)'}
+              </p>
+            )}
+            {showLastDelivery && (
+              <p className="text-muted-foreground text-xs">
+                Last delivery:{' '}
+                {lastDelivery
+                  .map(entry => {
+                    const channel = deliveryChannelLabel[entry.channel] ?? entry.channel;
+                    const status = deliveryStatusLabel[entry.status] ?? entry.status;
+                    const reason = entry.reason
+                      ? (deliveryReasonLabel[entry.reason] ?? entry.reason)
+                      : undefined;
+                    return reason ? `${channel} (${status}: ${reason})` : `${channel} (${status})`;
+                  })
+                  .join(' • ')}
+              </p>
+            )}
+
+            {isWarmupState && (
+              <p className="text-muted-foreground mt-2 text-xs">
+                Instance is still warming up. Morning Briefing controls will become available once
+                the gateway is fully ready.
+              </p>
+            )}
+
+            <p className="text-muted-foreground mt-3 text-xs">{sourceSummaryText}</p>
           </div>
-          {showScheduleDetails && briefingStatus?.cron && briefingStatus?.timezone && (
-            <p className="text-muted-foreground text-xs">
-              {formatMorningBriefingSchedule(briefingStatus.cron, briefingStatus.timezone)}
-            </p>
-          )}
-          {showScheduleDetails && (
-            <p className="text-muted-foreground text-xs">
-              Last generated: {briefingStatus?.lastGeneratedDate ?? '(none)'}
-            </p>
-          )}
         </div>
         <div className="flex flex-wrap gap-2">
           <Button
@@ -712,21 +749,12 @@ function MorningBriefingCard({
         </div>
       </div>
 
-      {isWarmupState && (
-        <p className="text-muted-foreground mt-2 text-xs">
-          Instance is still warming up. Morning Briefing controls will become available once the
-          gateway is fully ready.
-        </p>
-      )}
-
       {!desiredEnabled && controlsEnabled && (
         <p className="text-muted-foreground mt-2 text-xs">
           Enable Morning Briefing to get a personalized briefing everyday.
         </p>
       )}
 
-      <p className="text-muted-foreground mt-3 text-xs">{sourceSummaryText}</p>
-
       {requestedDay && (
         <div className="mt-3">
           {isReading ? (
@@ -1314,10 +1342,40 @@ export function SettingsTab({
     isControllerVersionError,
   } = useClawUpdateAvailable(status);
   const { data: myPin } = useClawMyPin();
-  const { data: morningBriefingStatus } = useClawMorningBriefingStatus(true);
-  const { data: gatewayReady } = useClawGatewayReady(isRunning);
+  const morningBriefingStatusQuery = useClawMorningBriefingStatus(isRunning);
+  const morningBriefingStatus = morningBriefingStatusQuery.data;
+  const gatewayReadyQuery = useClawGatewayReady(isRunning);
+  const gatewayReady = gatewayReadyQuery.data;
   const [confirmDestroy, setConfirmDestroy] = useState(false);
   const [confirmRestore, setConfirmRestore] = useState(false);
+  const [bootStartedAtMs, setBootStartedAtMs] = useState<number | null>(null);
+  const previousStatusRef = useRef(status.status);
+
+  useEffect(() => {
+    const previousStatus = previousStatusRef.current;
+    if (status.status === 'running' && previousStatus !== 'running') {
+      setBootStartedAtMs(Date.now());
+    }
+    if (status.status !== 'running' && previousStatus === 'running') {
+      setBootStartedAtMs(null);
+    }
+    previousStatusRef.current = status.status;
+  }, [status.status]);
+
+  const hasFreshGatewayReady =
+    isRunning &&
+    (bootStartedAtMs === null || gatewayReadyQuery.dataUpdatedAt >= bootStartedAtMs) &&
+    gatewayReadyQuery.dataUpdatedAt > 0;
+  const hasFreshMorningBriefingStatus =
+    isRunning &&
+    (bootStartedAtMs === null || morningBriefingStatusQuery.dataUpdatedAt >= bootStartedAtMs) &&
+    morningBriefingStatusQuery.dataUpdatedAt > 0;
+  const morningBriefingActionsReady =
+    isRunning &&
+    hasFreshGatewayReady &&
+    hasFreshMorningBriefingStatus &&
+    gatewayReady?.ready === true &&
+    gatewayReady?.settled === true;
   const hasModelSelectionError = isRunning && isControllerVersionError;
   const modelSelectionError = hasModelSelectionError
     ? 'Failed to load the running OpenClaw version. Retry before changing the default model.'
@@ -1867,9 +1925,7 @@ export function SettingsTab({
               mutations={mutations}
               briefingStatus={morningBriefingStatus}
               isRunning={isRunning}
-              actionsReady={
-                isRunning && gatewayReady?.ready === true && gatewayReady?.settled === true
-              }
+              actionsReady={morningBriefingActionsReady}
               fallbackReadiness={{
                 githubConfigured: configuredSecrets.github ?? false,
                 linearConfigured: configuredSecrets.linear ?? false,

apps/web/src/app/(app)/claw/components/morning-briefing-card-state.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from '@jest/globals';
+import { deriveMorningBriefingCardState } from './morning-briefing-card-state';
+
+describe('deriveMorningBriefingCardState', () => {
+  test('keeps warmup state when gateway_warming_up payload coexists with stale enabled=false', () => {
+    const state = deriveMorningBriefingCardState({
+      isRunning: true,
+      actionsReady: true,
+      briefingStatus: {
+        code: 'gateway_warming_up',
+        enabled: false,
+        desiredEnabled: false,
+        observedEnabled: false,
+        reconcileState: 'in_progress',
+      },
+    });
+
+    expect(state.isWarmupState).toBe(true);
+    expect(state.isGatewayWarmupStatus).toBe(true);
+  });
+
+  test('exits warmup when actions are ready and status is resolved without warmup code', () => {
+    const state = deriveMorningBriefingCardState({
+      isRunning: true,
+      actionsReady: true,
+      briefingStatus: {
+        enabled: true,
+        desiredEnabled: true,
+        observedEnabled: true,
+        reconcileState: 'succeeded',
+      },
+    });
+
+    expect(state.isWarmupState).toBe(false);
+    expect(state.desiredEnabled).toBe(true);
+    expect(state.observedEnabled).toBe(true);
+  });
+});

apps/web/src/app/(app)/claw/components/morning-briefing-card-state.ts

@@ -0,0 +1,39 @@
+import type { MorningBriefingStatusLite } from '@/lib/kiloclaw/types';
+
+export type MorningBriefingCardStateInput = {
+  isRunning: boolean;
+  actionsReady: boolean;
+  briefingStatus: MorningBriefingStatusLite | undefined;
+};
+
+export type MorningBriefingCardState = {
+  desiredEnabled: boolean;
+  observedEnabled: boolean;
+  hasResolvedBriefingToggleState: boolean;
+  isGatewayWarmupStatus: boolean;
+  isWarmupState: boolean;
+};
+
+export function deriveMorningBriefingCardState(
+  input: MorningBriefingCardStateInput
+): MorningBriefingCardState {
+  const desiredEnabledValue = input.briefingStatus?.desiredEnabled ?? input.briefingStatus?.enabled;
+  const observedEnabledValue =
+    input.briefingStatus?.observedEnabled ?? input.briefingStatus?.enabled;
+  const isGatewayWarmupStatus = input.briefingStatus?.code === 'gateway_warming_up';
+  const hasResolvedBriefingToggleState =
+    typeof desiredEnabledValue === 'boolean' && typeof observedEnabledValue === 'boolean';
+  const desiredEnabled = desiredEnabledValue ?? false;
+  const observedEnabled = observedEnabledValue ?? false;
+  const isWarmupState =
+    input.isRunning &&
+    (input.actionsReady === false || isGatewayWarmupStatus || !hasResolvedBriefingToggleState);
+
+  return {
+    desiredEnabled,
+    observedEnabled,
+    hasResolvedBriefingToggleState,
+    isGatewayWarmupStatus,
+    isWarmupState,
+  };
+}

apps/web/src/hooks/useKiloClaw.ts

@@ -160,6 +160,11 @@ export function useKiloClawMutations() {
     ]);
   };
 
+  const clearGatewayAndMorningBriefingCaches = () => {
+    queryClient.removeQueries({ queryKey: trpc.kiloclaw.gatewayReady.queryKey() });
+    queryClient.removeQueries({ queryKey: trpc.kiloclaw.getMorningBriefingStatus.queryKey() });
+  };
+
   // Wipe all instance-scoped caches so no stale data (e.g. gatewayReady
   // from the old instance) bleeds into a subsequent re-provision flow.
   // removeQueries drops the cached payload entirely; invalidateQueries
@@ -183,13 +188,25 @@ export function useKiloClawMutations() {
   };
 
   return {
-    start: useMutation(trpc.kiloclaw.start.mutationOptions({ onSuccess: invalidateStatus })),
+    start: useMutation(
+      trpc.kiloclaw.start.mutationOptions({
+        onSuccess: async () => {
+          clearGatewayAndMorningBriefingCaches();
+          await invalidateStatus();
+        },
+      })
+    ),
     stop: useMutation(trpc.kiloclaw.stop.mutationOptions({ onSuccess: invalidateStatus })),
     destroy: useMutation(
       trpc.kiloclaw.destroy.mutationOptions({ onSuccess: resetAllInstanceState })
     ),
     provision: useMutation(
-      trpc.kiloclaw.provision.mutationOptions({ onSuccess: invalidateStatusAndBilling })
+      trpc.kiloclaw.provision.mutationOptions({
+        onSuccess: async () => {
+          clearGatewayAndMorningBriefingCaches();
+          await invalidateStatusAndBilling();
+        },
+      })
     ),
     cycleInboundEmailAddress: useMutation(
       trpc.kiloclaw.cycleInboundEmailAddress.mutationOptions({ onSuccess: invalidateStatus })
@@ -222,6 +239,7 @@ export function useKiloClawMutations() {
     restartMachine: useMutation(
       trpc.kiloclaw.restartMachine.mutationOptions({
         onSuccess: async () => {
+          clearGatewayAndMorningBriefingCaches();
           await invalidateStatus();
           await queryClient.invalidateQueries({
             queryKey: trpc.kiloclaw.gatewayStatus.queryKey(),
@@ -232,6 +250,7 @@ export function useKiloClawMutations() {
     restartOpenClaw: useMutation(
       trpc.kiloclaw.restartOpenClaw.mutationOptions({
         onSuccess: async () => {
+          clearGatewayAndMorningBriefingCaches();
           await invalidateStatus();
           await queryClient.invalidateQueries({
             queryKey: trpc.kiloclaw.gatewayStatus.queryKey(),