@junando/core 0.12.2 → 0.12.3

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import pino from "pino";
 import { Writable } from "node:stream";
 import { Redis } from "ioredis";
 //#region src/shared/constants.d.ts
-declare enum AlertType {
+export declare enum AlertType {
   Error = "http_500",
   Warning = "latency_spike",
   Success = "recovery"
@@ -15,60 +15,63 @@ interface AlertTypeConfig {
   readonly summary: (service: string, i: number, count: number) => string;
 }
 declare const _alertTypeConfigs: Record<AlertType, AlertTypeConfig>;
-declare const ALERT_TYPE_LABELS: Readonly<typeof _alertTypeConfigs>;
-declare enum LLMProviderType {
+export declare const ALERT_TYPE_LABELS: Readonly<typeof _alertTypeConfigs>;
+export declare enum LLMProviderType {
   Gemini = "gemini",
   Claude = "claude",
   OpenRouter = "openrouter",
   Qwen = "qwen"
 }
-declare const HTTP_TIMEOUT_MS: Readonly<{
+export declare const HTTP_TIMEOUT_MS: Readonly<{
   Default: 5000;
   LLM: 30000;
+  SlackResponseUrl: 500;
+  RollbackHandler: 2000;
 }>;
-declare const CIRCUIT_BREAKER: Readonly<{
+export declare const CIRCUIT_BREAKER: Readonly<{
   Timeout: 10000;
   ErrorThresholdPercentage: 70;
   ResetTimeoutMs: 30000;
 }>;
-declare const LLM_MAX_TOKENS = 1024;
-declare const RATE_LIMITER: Readonly<{
+export declare const LLM_MAX_TOKENS = 1024;
+export declare const RATE_LIMITER: Readonly<{
   MinTimeMs: 100;
   MaxConcurrent: 5;
 }>;
-declare const DEV_SERVER_PORT = 4000;
-declare const DEDUP_TTL_MS_MULTIPLIER = 1000;
-declare const HOUR_MS = 3600000;
-declare const LLM_FALLBACK_DEFAULTS: Readonly<{
+export declare const DEV_SERVER_PORT = 4000;
+export declare const DEDUP_TTL_MS_MULTIPLIER = 1000;
+export declare const HOUR_MS = 3600000;
+export declare const LLM_FALLBACK_DEFAULTS: Readonly<{
   TimeoutMs: 60000;
   Models: string[];
 }>;
-declare const LLM_MODELS: Readonly<{
+export declare const LLM_MODELS: Readonly<{
   Gemini: "gemini-2.0-flash";
   Claude: "claude-haiku-4-5";
   OpenRouter: "qwen/qwen-2.5-72b-instruct";
 }>;
-declare const SLACK_API_URL = "https://slack.com/api/chat.postMessage";
-declare const TEAMS_WEBHOOK_TIMEOUT_MS = 10000;
+export declare const SLACK_API_URL = "https://slack.com/api/chat.postMessage";
+export declare const ROLLBACK_ACTION_ID = "trigger_rollback";
+export declare const TEAMS_WEBHOOK_TIMEOUT_MS = 10000;
 declare const _urgencyEmoji: Record<string, string>;
-declare const URGENCY_EMOJI: Readonly<typeof _urgencyEmoji>;
-declare const REDIS_KEY_PREFIX = "junando:dedup:";
-declare const WEBHOOK_DEFAULTS: Readonly<{
+export declare const URGENCY_EMOJI: Readonly<typeof _urgencyEmoji>;
+export declare const REDIS_KEY_PREFIX = "junando:dedup:";
+export declare const WEBHOOK_DEFAULTS: Readonly<{
   AlertmanagerUrl: "http://localhost:9093";
   WebhookUrl: "http://localhost:4000/webhook/alert";
 }>;
-declare const PAYLOAD_DEFAULTS: Readonly<{
+export declare const PAYLOAD_DEFAULTS: Readonly<{
   Version: "4";
   TruncatedAlerts: 0;
   Receiver: "junando";
 }>;
 //#endregion
 //#region src/domain/entities/alert.d.ts
-declare const AlertStatusSchema: z.ZodEnum<{
+export declare const AlertStatusSchema: z.ZodEnum<{
   firing: "firing";
   resolved: "resolved";
 }>;
-declare const NormalizedAlertSchema: z.ZodObject<{
+export declare const NormalizedAlertSchema: z.ZodObject<{
   fingerprint: z.ZodString;
   alertName: z.ZodString;
   status: z.ZodEnum<{
@@ -84,7 +87,7 @@ declare const NormalizedAlertSchema: z.ZodObject<{
   labels: z.ZodRecord<z.ZodString, z.ZodString>;
   annotations: z.ZodRecord<z.ZodString, z.ZodString>;
 }, z.core.$strip>;
-declare const AlertmanagerPayloadSchema: z.ZodObject<{
+export declare const AlertmanagerPayloadSchema: z.ZodObject<{
   version: z.ZodDefault<z.ZodString>;
   groupKey: z.ZodString;
   truncatedAlerts: z.ZodDefault<z.ZodNumber>;
@@ -109,13 +112,13 @@ declare const AlertmanagerPayloadSchema: z.ZodObject<{
     fingerprint: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>>;
 }, z.core.$strip>;
-type AlertStatus = z.infer<typeof AlertStatusSchema>;
-type NormalizedAlert = z.infer<typeof NormalizedAlertSchema>;
-type AlertmanagerPayload = z.infer<typeof AlertmanagerPayloadSchema>;
-type AlertErrorType = NormalizedAlert['alertType'];
+export type AlertStatus = z.infer<typeof AlertStatusSchema>;
+export type NormalizedAlert = z.infer<typeof NormalizedAlertSchema>;
+export type AlertmanagerPayload = z.infer<typeof AlertmanagerPayloadSchema>;
+export type AlertErrorType = NormalizedAlert['alertType'];
 //#endregion
 //#region src/domain/entities/cluster.d.ts
-declare const AlertClusterSchema: z.ZodObject<{
+export declare const AlertClusterSchema: z.ZodObject<{
   fingerprint: z.ZodString;
   serviceName: z.ZodString;
   alertType: z.ZodEnum<typeof AlertType>;
@@ -132,16 +135,16 @@ declare const AlertClusterSchema: z.ZodObject<{
   }>>;
   labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
-type AlertCluster = z.infer<typeof AlertClusterSchema>;
+export type AlertCluster = z.infer<typeof AlertClusterSchema>;
 //#endregion
 //#region src/domain/entities/incident.d.ts
-declare const UrgencyLevelSchema: z.ZodEnum<{
+export declare const UrgencyLevelSchema: z.ZodEnum<{
   critical: "critical";
   high: "high";
   low: "low";
   medium: "medium";
 }>;
-declare const LLMAnalysisSchema: z.ZodObject<{
+export declare const LLMAnalysisSchema: z.ZodObject<{
   probable_cause: z.ZodString;
   impacted_services: z.ZodArray<z.ZodString>;
   recommended_steps: z.ZodArray<z.ZodString>;
@@ -153,7 +156,7 @@ declare const LLMAnalysisSchema: z.ZodObject<{
   }>;
   requires_rollback: z.ZodBoolean;
 }, z.core.$strip>;
-declare const IncidentSchema: z.ZodObject<{
+export declare const IncidentSchema: z.ZodObject<{
   cluster: z.ZodObject<{
     fingerprint: z.ZodString;
     serviceName: z.ZodString;
@@ -186,29 +189,29 @@ declare const IncidentSchema: z.ZodObject<{
   }, z.core.$strip>>;
   processedAt: z.ZodString;
 }, z.core.$strip>;
-type UrgencyLevel = z.infer<typeof UrgencyLevelSchema>;
-type LLMAnalysis = z.infer<typeof LLMAnalysisSchema>;
-type Incident = z.infer<typeof IncidentSchema>;
+export type UrgencyLevel = z.infer<typeof UrgencyLevelSchema>;
+export type LLMAnalysis = z.infer<typeof LLMAnalysisSchema>;
+export type Incident = z.infer<typeof IncidentSchema>;
 //#endregion
 //#region src/domain/entities/rule.d.ts
-declare enum RuleActionType {
+export declare enum RuleActionType {
   Suppress = "suppress",
   Route = "route",
   Escalate = "escalate",
   Tag = "tag"
 }
-declare enum SeverityLevel {
+export declare enum SeverityLevel {
   Critical = "critical",
   High = "high",
   Medium = "medium",
   Low = "low"
 }
 /** Rule evaluation points in the pipeline */
-declare enum RuleEvaluationPhase {
+export declare enum RuleEvaluationPhase {
   PreLlm = "pre-llm",
   PostLlm = "post-llm"
 }
-interface RuleCondition {
+export interface RuleCondition {
   serviceName?: string;
   alertType?: AlertType;
   severity?: SeverityLevel;
@@ -227,7 +230,7 @@ interface RuleCondition {
   requiresRollback?: boolean;
   impactedServices?: string[];
 }
-declare const RuleConditionSchema: z.ZodObject<{
+export declare const RuleConditionSchema: z.ZodObject<{
   serviceName: z.ZodOptional<z.ZodString>;
   alertType: z.ZodOptional<z.ZodEnum<typeof AlertType>>;
   severity: z.ZodOptional<z.ZodEnum<typeof SeverityLevel>>;
@@ -250,7 +253,7 @@ declare const RuleConditionSchema: z.ZodObject<{
   requiresRollback: z.ZodOptional<z.ZodBoolean>;
   impactedServices: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
-type RuleAction = {
+export type RuleAction = {
   type: RuleActionType.Suppress;
 } | {
   type: RuleActionType.Route;
@@ -263,7 +266,7 @@ type RuleAction = {
   key: string;
   value: string;
 };
-declare const RuleActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const RuleActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   type: z.ZodLiteral<RuleActionType.Suppress>;
 }, z.core.$strip>, z.ZodObject<{
   type: z.ZodLiteral<RuleActionType.Route>;
@@ -276,7 +279,7 @@ declare const RuleActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   key: z.ZodString;
   value: z.ZodString;
 }, z.core.$strip>], "type">;
-interface Rule {
+export interface Rule {
   id: string;
   name?: string;
   condition: RuleCondition;
@@ -285,7 +288,7 @@ interface Rule {
   urgencyLevel?: z.infer<typeof UrgencyLevelSchema>;
   requiresRollback?: boolean;
 }
-declare const RuleSchema: z.ZodObject<{
+export declare const RuleSchema: z.ZodObject<{
   id: z.ZodString;
   name: z.ZodOptional<z.ZodString>;
   condition: z.ZodObject<{
@@ -332,10 +335,10 @@ declare const RuleSchema: z.ZodObject<{
   }>>;
   requiresRollback: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
-interface RuleSection {
+export interface RuleSection {
   rules: Rule[];
 }
-declare const RuleSectionSchema: z.ZodObject<{
+export declare const RuleSectionSchema: z.ZodObject<{
   rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
     id: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
@@ -384,11 +387,11 @@ declare const RuleSectionSchema: z.ZodObject<{
     requiresRollback: z.ZodOptional<z.ZodBoolean>;
   }, z.core.$strip>>>;
 }, z.core.$strip>;
-interface RuleConfiguration {
+export interface RuleConfiguration {
   [RuleEvaluationPhase.PreLlm]: RuleSection;
   [RuleEvaluationPhase.PostLlm]: RuleSection;
 }
-declare const RuleConfigurationSchema: z.ZodObject<{
+export declare const RuleConfigurationSchema: z.ZodObject<{
   "pre-llm": z.ZodObject<{
     rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
       id: z.ZodString;
@@ -488,11 +491,11 @@ declare const RuleConfigurationSchema: z.ZodObject<{
     }, z.core.$strip>>>;
   }, z.core.$strip>;
 }, z.core.$strip>;
-type ValidatedRuleCondition = z.infer<typeof RuleConditionSchema>;
-type ValidatedRuleAction = z.infer<typeof RuleActionSchema>;
-type ValidatedRule = z.infer<typeof RuleSchema>;
-type ValidatedRuleSection = z.infer<typeof RuleSectionSchema>;
-type ValidatedRuleConfiguration = z.infer<typeof RuleConfigurationSchema>;
+export type ValidatedRuleCondition = z.infer<typeof RuleConditionSchema>;
+export type ValidatedRuleAction = z.infer<typeof RuleActionSchema>;
+export type ValidatedRule = z.infer<typeof RuleSchema>;
+export type ValidatedRuleSection = z.infer<typeof RuleSectionSchema>;
+export type ValidatedRuleConfiguration = z.infer<typeof RuleConfigurationSchema>;
 //#endregion
 //#region src/domain/entities/traceability.d.ts
 interface TraceabilityDocument {
@@ -509,7 +512,7 @@ interface TraceabilityDocument {
 }
 //#endregion
 //#region src/domain/value-objects/fingerprint.d.ts
-declare class Fingerprint {
+export declare class Fingerprint {
   readonly value: string;
   private constructor();
   static fromAlert(alert: NormalizedAlert): Fingerprint;
@@ -579,11 +582,11 @@ interface ILLMProvider {
  * Terminal outcome of a single notification send.
  * Feeds the `notify` section of the wide event.
  */
-declare const NotifyOutcome: {
+export declare const NotifyOutcome: {
   readonly Success: 'success';
   readonly Failure: 'failure';
 };
-type NotifyOutcome = (typeof NotifyOutcome)[keyof typeof NotifyOutcome];
+export type NotifyOutcome = (typeof NotifyOutcome)[keyof typeof NotifyOutcome];
 /**
  * Structured result of a notification send.
  * Adapters throw on failure (the caller records NotifyOutcome.Failure and
@@ -643,9 +646,43 @@ interface IRuleEngine {
    */
   evaluatePostLlm(cluster: AlertCluster, analysis: LLMAnalysis): RuleActionResult;
 }
+/**
+ * Request dispatched to a rollback action handler.
+ * Minimal incident metadata encoded in the Slack button value plus the user
+ * who triggered the action.
+ */
+interface RollbackActionRequest {
+  fingerprint: string;
+  serviceName: string;
+  endpointPath: string;
+  alertType: AlertType;
+  urgencyLevel?: 'low' | 'medium' | 'high' | 'critical';
+  triggeredBy: {
+    id?: string;
+    username?: string;
+    channel: 'slack' | 'teams';
+  };
+  correlationId?: string;
+  messageTs?: string;
+}
+/**
+ * Result of a rollback action handler invocation.
+ */
+interface RollbackActionResult {
+  ok: boolean;
+  message: string;
+}
+/**
+ * Configurable rollback action handler.
+ * Implementations wire Junando to a team's deployment pipeline.
+ * The default no-op adapter logs and returns success so nothing breaks.
+ */
+interface IRollbackActionHandler {
+  handle(request: RollbackActionRequest): Promise<RollbackActionResult>;
+}
 //#endregion
 //#region src/domain/services/clustering.service.d.ts
-declare class ClusteringService {
+export declare class ClusteringService {
   /**
    * Groups alerts by fingerprint and builds AlertCluster objects.
    * 300 alerts with the same root cause → 1 cluster with 2 representative traces.
@@ -656,7 +693,140 @@ declare class ClusteringService {
 }
 //#endregion
 //#region src/application/dtos/normalize-payload.d.ts
-declare function normalizePayload(payload: AlertmanagerPayload): NormalizedAlert[];
+export declare function normalizePayload(payload: AlertmanagerPayload): NormalizedAlert[];
+//#endregion
+//#region src/shared/logger/enums.d.ts
+/**
+ * Pipeline component taxonomy.
+ *
+ * `component` (not `service`) distinguishes pipeline stages in wide events.
+ * `service` stays constant ("junando"); `component` tells you WHERE the event
+ * was emitted from.
+ */
+export declare const Component: {
+  readonly Webhook: 'webhook';
+  readonly Worker: 'worker';
+  readonly UseCase: 'useCase';
+  readonly Llm: 'llm';
+  readonly Notifier: 'notifier';
+  readonly Dedup: 'dedup';
+  readonly Traces: 'traces';
+  readonly Ingest: 'ingest';
+  readonly Rollback: 'rollback';
+};
+export type Component = (typeof Component)[keyof typeof Component];
+/**
+ * Pipeline stages that write their results into the WideEventBuilder.
+ */
+export declare const Stage: {
+  readonly Dedup: 'dedup';
+  readonly RulesPre: 'rulesPre';
+  readonly Traces: 'traces';
+  readonly Llm: 'llm';
+  readonly RulesPost: 'rulesPost';
+  readonly Notify: 'notify';
+};
+export type Stage = (typeof Stage)[keyof typeof Stage];
+/**
+ * Terminal outcomes for a wide event across all entry points.
+ */
+export declare const Outcome: {
+  readonly Success: 'success';
+  readonly Suppressed: 'suppressed';
+  readonly Degraded: 'degraded';
+  readonly Error: 'error';
+  readonly Accepted: 'accepted';
+  readonly Empty: 'empty';
+  readonly ParseError: 'parse_error';
+};
+export type Outcome = (typeof Outcome)[keyof typeof Outcome];
+/**
+ * Reason recorded for a tail-sampling decision.
+ */
+export declare const SamplingDecision: {
+  readonly Error: 'error';
+  readonly Slow: 'slow';
+  readonly Random: 'random';
+  readonly Skipped: 'skipped';
+};
+export type SamplingDecision = (typeof SamplingDecision)[keyof typeof SamplingDecision];
+//#endregion
+//#region src/shared/logger/wide-event-builder.d.ts
+interface ClusterSection {
+  fingerprint: string;
+  serviceName: string;
+  alertCount: number;
+  spanCount: number;
+  /** Number of representative traces that failed to fetch (fail-open). */
+  traceErrors?: number;
+}
+interface DedupSection {
+  isNew: boolean;
+  ttlSeconds: number;
+  /** Fail-open error message when the store was unreachable (e.g. Redis down). */
+  error?: string;
+}
+interface RuleSection$1 {
+  matched: boolean;
+  suppressed: boolean;
+  /** ID of the rule that matched, when the engine reports one. */
+  matchedRuleId?: string;
+}
+interface LlmSection {
+  provider: string;
+  model: string;
+  latencyMs: number;
+  urgency: string;
+  tokens: number;
+}
+interface NotifySection {
+  channels: string[];
+  outcome: string;
+  latencyMs: number;
+}
+interface RollbackSection {
+  actionId: string;
+  channel: string;
+  outcome: 'ok' | 'error';
+  handlerMessage: string;
+}
+interface ErrorSection {
+  message: string;
+  name?: string;
+  stack?: string;
+}
+interface WideEvent {
+  requestId: string;
+  correlationId?: string;
+  timestamp: string;
+  component: Component;
+  version?: string;
+  outcome?: Outcome;
+  cluster?: ClusterSection;
+  dedup?: DedupSection;
+  rule?: RuleSection$1;
+  llm?: LlmSection;
+  notify?: NotifySection;
+  rollback?: RollbackSection;
+  durationMs?: number;
+  error?: ErrorSection;
+  /** Present only when the 256 KB guard truncated the event. */
+  _truncated?: boolean;
+}
+/** Fields the builder owns — callers cannot set or merge them. */
+type BuilderOwnedKey = 'requestId' | 'component' | 'timestamp' | '_truncated';
+/** Keys callers may write via set()/merge(). */
+type SettableKey = Exclude<keyof WideEvent, BuilderOwnedKey>;
+export declare class WideEventBuilder {
+  private readonly requestId;
+  private readonly component;
+  private fields;
+  constructor(requestId: string, component: Component);
+  set<K extends SettableKey>(key: K, value: WideEvent[K]): this;
+  merge(obj: Partial<WideEvent>): this;
+  flush(): WideEvent;
+  private enforceSizeLimit;
+}
 //#endregion
 //#region src/shared/logger/index.d.ts
 type Logger = pino.Logger;
@@ -669,7 +839,7 @@ interface LoggerOptions {
  * Module-level callers get a proxy that automatically starts writing to Loki
  * once reinitLogger() is called inside the handler after loadConfig().
  */
-declare function createLogger(levelOrOptions?: string | LoggerOptions): Logger;
+export declare function createLogger(levelOrOptions?: string | LoggerOptions): Logger;
 /**
  * Re-creates the root logger with current env vars (including LOKI_URL).
  * Call this inside your Lambda handler immediately after loadConfig():
@@ -678,7 +848,7 @@ declare function createLogger(levelOrOptions?: string | LoggerOptions): Logger;
  * const config = await loadConfig();
  * reinitLogger(); // all module-level proxy loggers now write to Loki
  */
-declare function reinitLogger(opts?: LoggerOptions): void;
+export declare function reinitLogger(opts?: LoggerOptions): void;
 //#endregion
 //#region src/application/use-cases/process-incident.use-case.d.ts
 interface Dependencies {
@@ -692,7 +862,7 @@ interface Dependencies {
   onClustersBuilt?: (count: number) => void;
   ruleEngine?: IRuleEngine;
 }
-declare class ProcessIncidentUseCase {
+export declare class ProcessIncidentUseCase {
   private readonly deps;
   private readonly clustering;
   private readonly wideEventsEnabled;
@@ -706,14 +876,14 @@ declare class ProcessIncidentUseCase {
 }
 //#endregion
 //#region src/infrastructure/dedup/redis-dedup.adapter.d.ts
-declare class RedisDeduplicationStore implements IDeduplicationStore {
+export declare class RedisDeduplicationStore implements IDeduplicationStore {
   private readonly redis;
   private readonly keyPrefix;
   constructor(redis: Redis);
   isNew(fingerprint: string, ttlSeconds: number): Promise<DedupResult>;
   reset(fingerprint: string): Promise<void>;
 }
-declare class InMemoryDeduplicationStore implements IDeduplicationStore {
+export declare class InMemoryDeduplicationStore implements IDeduplicationStore {
   private readonly store;
   isNew(fingerprint: string, ttlSeconds: number): Promise<DedupResult>;
   reset(fingerprint: string): Promise<void>;
@@ -738,7 +908,7 @@ interface OpenSearchIndexerDeps {
   region: string;
   fetcher: OpenSearchHttpFetcher;
 }
-declare class OpenSearchIndexer implements IIndexer<TraceabilityDocument> {
+export declare class OpenSearchIndexer implements IIndexer<TraceabilityDocument> {
   private readonly endpoint;
   private readonly indexName;
   private readonly region;
@@ -746,7 +916,7 @@ declare class OpenSearchIndexer implements IIndexer<TraceabilityDocument> {
   constructor(deps: OpenSearchIndexerDeps);
   index(doc: TraceabilityDocument): Promise<void>;
 }
-declare class InMemoryIndexer implements IIndexer<TraceabilityDocument> {
+export declare class InMemoryIndexer implements IIndexer<TraceabilityDocument> {
   readonly indexed: TraceabilityDocument[];
   index(doc: TraceabilityDocument): Promise<void>;
 }
@@ -756,7 +926,7 @@ declare class InMemoryIndexer implements IIndexer<TraceabilityDocument> {
  * Gemini LLM provider using Google Generative AI SDK.
  * Wrapped with circuit breaker for resilience.
  */
-declare class GeminiProvider implements ILLMProvider {
+export declare class GeminiProvider implements ILLMProvider {
   private readonly apiKey;
   private readonly model;
   private readonly breaker;
@@ -769,7 +939,7 @@ declare class GeminiProvider implements ILLMProvider {
  * Claude LLM provider using Anthropic SDK.
  * Supports Claude Haiku and other models.
  */
-declare class ClaudeProvider implements ILLMProvider {
+export declare class ClaudeProvider implements ILLMProvider {
   private readonly apiKey;
   private readonly model;
   constructor(apiKey: string, model?: string);
@@ -779,7 +949,7 @@ declare class ClaudeProvider implements ILLMProvider {
  * Mock LLM provider for testing and local development.
  * Returns deterministic responses without external API calls.
  */
-declare class MockLLMProvider implements ILLMProvider {
+export declare class MockLLMProvider implements ILLMProvider {
   readonly callLog: Array<{
     cluster: AlertCluster;
   }>;
@@ -793,7 +963,7 @@ interface FallbackOptions {
   fallbackModels?: string[];
   fallbackTimeoutMs?: number;
 }
-declare function createLLMProvider(provider: string, apiKey: string, model?: string, options?: FallbackOptions): ILLMProvider;
+export declare function createLLMProvider(provider: string, apiKey: string, model?: string, options?: FallbackOptions): ILLMProvider;
 //#endregion
 //#region src/shared/config/index.d.ts
 declare enum NodeEnvironment {
@@ -818,6 +988,8 @@ declare const ConfigSchema: z.ZodObject<{
   slackBotToken: z.ZodOptional<z.ZodString>;
   slackSigningSecret: z.ZodOptional<z.ZodString>;
   slackChannel: z.ZodOptional<z.ZodString>;
+  rollbackActionEnabled: z.ZodDefault<z.ZodBoolean>;
+  rollbackActionAllowedSlackUserIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
   teamsWebhookUrl: z.ZodOptional<z.ZodString>;
   lokiUrl: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
   redisUrl: z.ZodString;
@@ -837,7 +1009,33 @@ declare const ConfigSchema: z.ZodObject<{
   rulesConfigPath: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
 }, z.core.$strip>;
 type Config = z.infer<typeof ConfigSchema>;
-declare function loadConfig(): Promise<Config>;
+export declare function loadConfig(): Promise<Config>;
+//#endregion
+//#region src/infrastructure/rules/channel-registry.d.ts
+export declare class ChannelRegistry {
+  private readonly _channels;
+  private _default;
+  /**
+   * Register a notifier for a given channel name.
+   * Overwrites any existing registration for that name.
+   */
+  register(channel: string, notifier: INotifier): void;
+  /**
+   * Set the default notifier to use when a channel is not found.
+   */
+  setDefault(notifier: INotifier): void;
+  /**
+   * Resolve a channel name to its notifier instance.
+   * Falls back to the default notifier if the channel is unknown.
+   *
+   * @throws {Error} if the channel is unknown and no default is set
+   */
+  resolve(channel: string): INotifier;
+  /**
+   * Check if a channel is registered.
+   */
+  has(channel: string): boolean;
+}
 //#endregion
 //#region src/infrastructure/notifier/factory.d.ts
 /**
@@ -851,10 +1049,31 @@ declare function loadConfig(): Promise<Config>;
  * When `config.rulesConfigPath` is NOT set:
  *   - Returns the default notifier directly (backward-compatible)
  */
-declare function createNotifier(config: Config): INotifier;
+export declare function createNotifier(config: Config): INotifier;
+//#endregion
+//#region src/infrastructure/rollback/factory.d.ts
+/**
+ * Creates the rollback action handler for the application.
+ *
+ * In the first slice the factory always returns the no-op handler. Later slices
+ * can add env-based selection (e.g. a custom handler registered via config).
+ */
+export declare function createRollbackActionHandler(_config: Config): IRollbackActionHandler;
+//#endregion
+//#region src/infrastructure/rollback/noop-rollback-action.handler.d.ts
+/**
+ * Default rollback action handler.
+ *
+ * Logs the request and returns success so teams without a custom deployment
+ * pipeline still see a safe, predictable behavior when the rollback button is
+ * clicked. Never throws.
+ */
+export declare class NoopRollbackActionHandler implements IRollbackActionHandler {
+  handle(request: RollbackActionRequest): Promise<RollbackActionResult>;
+}
 //#endregion
 //#region src/infrastructure/notifier/slack.adapter.d.ts
-declare class SlackNotifier implements INotifier {
+export declare class SlackNotifier implements INotifier {
   private readonly botToken;
   private readonly channel;
   constructor(botToken: string, channel: string);
@@ -862,7 +1081,7 @@ declare class SlackNotifier implements INotifier {
   private buildAnalysisMessage;
   private buildFallbackMessage;
 }
-declare class ConsoleNotifier implements INotifier {
+export declare class ConsoleNotifier implements INotifier {
   readonly sent: Array<{
     cluster: AlertCluster;
     analysis: LLMAnalysis | null;
@@ -871,10 +1090,10 @@ declare class ConsoleNotifier implements INotifier {
 }
 //#endregion
 //#region src/infrastructure/notifier/teams.adapter.d.ts
-declare class TeamsNotifierError extends Error {
+export declare class TeamsNotifierError extends Error {
   constructor(message: string);
 }
-declare class TeamsNotifier implements INotifier {
+export declare class TeamsNotifier implements INotifier {
   private readonly webhookUrl;
   private readonly timeoutMs;
   private readonly hostForErrors;
@@ -882,42 +1101,13 @@ declare class TeamsNotifier implements INotifier {
   send(cluster: AlertCluster, analysis: LLMAnalysis | null, _channel?: string): Promise<NotifyResult>;
 }
 //#endregion
-//#region src/infrastructure/rules/channel-registry.d.ts
-declare class ChannelRegistry {
-  private readonly _channels;
-  private _default;
-  /**
-   * Register a notifier for a given channel name.
-   * Overwrites any existing registration for that name.
-   */
-  register(channel: string, notifier: INotifier): void;
-  /**
-   * Set the default notifier to use when a channel is not found.
-   */
-  setDefault(notifier: INotifier): void;
-  /**
-   * Resolve a channel name to its notifier instance.
-   * Falls back to the default notifier if the channel is unknown.
-   *
-   * @throws {Error} if the channel is unknown and no default is set
-   */
-  resolve(channel: string): INotifier;
-  /**
-   * Check if a channel is registered.
-   */
-  has(channel: string): boolean;
-}
-//#endregion
 //#region src/infrastructure/notifier/routing-notifier.d.ts
-declare class RoutingNotifier implements INotifier {
+export declare class RoutingNotifier implements INotifier {
   private readonly registry;
   private readonly defaultNotifier;
   constructor(registry: ChannelRegistry, defaultNotifier: INotifier);
-  /**
-   * Implements INotifier.send — sends via default notifier.
-   * Backward-compatible with existing call sites that don't use rule actions.
-   */
-  send(cluster: AlertCluster, analysis: LLMAnalysis | null): Promise<NotifyResult>;
+  /** Routes to `channel` when given, else to the default notifier. */
+  send(cluster: AlertCluster, analysis: LLMAnalysis | null, channel?: string): Promise<NotifyResult>;
   /**
    * Dispatch notifications based on rule engine actions.
    *
@@ -934,6 +1124,11 @@ declare class RoutingNotifier implements INotifier {
    * Falls back to default notifier if channel is unknown.
    */
   private tryResolveAndSend;
+  /**
+   * Guards channel resolution only — a delivery failure must propagate so the
+   * use case can let SQS retry it.
+   */
+  private resolveOrDefault;
 }
 //#endregion
 //#region src/infrastructure/queue/sqs.adapter.d.ts
@@ -942,7 +1137,7 @@ interface SendMessageParams {
   messageGroupId: string;
   messageDeduplicationId: string;
 }
-declare class SQSAlertQueue implements IAlertQueue {
+export declare class SQSAlertQueue implements IAlertQueue {
   private readonly queueUrl;
   private readonly region?;
   private sqsClient;
@@ -951,16 +1146,16 @@ declare class SQSAlertQueue implements IAlertQueue {
   sendMessage(params: SendMessageParams): Promise<void>;
   publish(alert: NormalizedAlert): Promise<void>;
 }
-declare class InMemoryAlertQueue implements IAlertQueue {
+export declare class InMemoryAlertQueue implements IAlertQueue {
   readonly published: NormalizedAlert[];
   publish(alert: NormalizedAlert): Promise<void>;
 }
 //#endregion
 //#region src/infrastructure/queue/sqs-lag-poller.d.ts
-declare function startSqsLagPoller(queueUrl: string, intervalMs: number, region?: string): () => void;
+export declare function startSqsLagPoller(queueUrl: string, intervalMs: number, region?: string): () => void;
 //#endregion
 //#region src/infrastructure/traces/loki-trace.adapter.d.ts
-declare class LokiTraceRepository implements ITraceRepository {
+export declare class LokiTraceRepository implements ITraceRepository {
   private readonly lokiUrl;
   private readonly apiKey?;
   constructor(lokiUrl: string, apiKey?: string | undefined);
@@ -968,7 +1163,7 @@ declare class LokiTraceRepository implements ITraceRepository {
   private parseResponse;
   private tryParseJSON;
 }
-declare class MockTraceRepository implements ITraceRepository {
+export declare class MockTraceRepository implements ITraceRepository {
   private readonly fixtures;
   constructor(fixtures?: Map<string, Record<string, unknown>[]>);
   findByTraceId(traceId: string): Promise<Record<string, unknown>[]>;
@@ -982,7 +1177,7 @@ declare class MockTraceRepository implements ITraceRepository {
  *
  * @throws {Error} if YAML is malformed or Zod validation fails
  */
-declare function parseRuleConfig(yamlString: string): ValidatedRuleConfiguration;
+export declare function parseRuleConfig(yamlString: string): ValidatedRuleConfiguration;
 //#endregion
 //#region src/infrastructure/rules/condition-evaluator.d.ts
 type Predicate = (cluster: AlertCluster, analysis?: LLMAnalysis) => boolean;
@@ -994,7 +1189,7 @@ type Predicate = (cluster: AlertCluster, analysis?: LLMAnalysis) => boolean;
  * All specified conditions must match (AND logic).
  * If no fields are specified, the predicate returns true (match-all).
  */
-declare function compileCondition(condition: ValidatedRuleCondition): Predicate;
+export declare function compileCondition(condition: ValidatedRuleCondition): Predicate;
 //#endregion
 //#region src/infrastructure/rules/action-dispatcher.d.ts
 /**
@@ -1004,10 +1199,10 @@ declare function compileCondition(condition: ValidatedRuleCondition): Predicate;
  *
  * Pure function — no I/O, no side effects beyond the returned result.
  */
-declare function dispatchActions(actions: RuleAction[]): RuleActionResult;
+export declare function dispatchActions(actions: RuleAction[]): RuleActionResult;
 //#endregion
 //#region src/infrastructure/rules/rule-engine.d.ts
-declare class RuleEngine implements IRuleEngine {
+export declare class RuleEngine implements IRuleEngine {
   private readonly preLlmRules;
   private readonly postLlmRules;
   constructor(config: ValidatedRuleConfiguration);
@@ -1028,7 +1223,7 @@ declare class RuleEngine implements IRuleEngine {
 }
 //#endregion
 //#region src/shared/factory-registry.d.ts
-declare class FactoryRegistry<T> {
+export declare class FactoryRegistry<T> {
   private readonly _factories;
   private _default;
   /**
@@ -1061,7 +1256,7 @@ declare class FactoryRegistry<T> {
  * Call this at the END of the Lambda handler, after all business logic completes.
  * Errors are swallowed — Loki is best-effort; CloudWatch is the primary sink.
  */
-declare function flushLoki(): Promise<void>;
+export declare function flushLoki(): Promise<void>;
 //#endregion
-export { ALERT_TYPE_LABELS, AlertCluster, AlertClusterSchema, AlertErrorType, AlertStatus, AlertStatusSchema, AlertType, AlertmanagerPayload, AlertmanagerPayloadSchema, CIRCUIT_BREAKER, ChannelRegistry, ClaudeProvider, ClusteringService, type Config, ConsoleNotifier, DEDUP_TTL_MS_MULTIPLIER, DEV_SERVER_PORT, type DedupResult, FactoryRegistry, Fingerprint, GeminiProvider, HOUR_MS, HTTP_TIMEOUT_MS, type IAlertQueue, type IDeduplicationStore, type IIndexer, type ILLMProvider, type INotifier, type IRuleEngine, type ITraceRepository, InMemoryAlertQueue, InMemoryDeduplicationStore, InMemoryIndexer, Incident, IncidentSchema, LLMAnalysis, LLMAnalysisSchema, LLMProviderType, type LLMResult, LLM_FALLBACK_DEFAULTS, LLM_MAX_TOKENS, LLM_MODELS, type Logger, type LoggerOptions, LokiTraceRepository, MockLLMProvider, MockTraceRepository, NormalizedAlert, NormalizedAlertSchema, NotifyOutcome, type NotifyResult, type OpenSearchHttpFetcher, type OpenSearchHttpResponse, OpenSearchIndexer, type OpenSearchIndexerDeps, PAYLOAD_DEFAULTS, ProcessIncidentUseCase, RATE_LIMITER, REDIS_KEY_PREFIX, RedisDeduplicationStore, RoutingNotifier, Rule, RuleAction, type RuleActionResult, RuleActionSchema, RuleActionType, RuleCondition, RuleConditionSchema, RuleConfiguration, RuleConfigurationSchema, RuleEngine, RuleEvaluationPhase, RuleSchema, RuleSection, RuleSectionSchema, SLACK_API_URL, SQSAlertQueue, SeverityLevel, type SignedHttpRequest, SlackNotifier, TEAMS_WEBHOOK_TIMEOUT_MS, TeamsNotifier, TeamsNotifierError, type TraceabilityDocument, URGENCY_EMOJI, UrgencyLevel, UrgencyLevelSchema, ValidatedRule, ValidatedRuleAction, ValidatedRuleCondition, ValidatedRuleConfiguration, ValidatedRuleSection, WEBHOOK_DEFAULTS, compileCondition, createLLMProvider, createLogger, createNotifier, dispatchActions, flushLoki, loadConfig, index_d_exports as metrics, normalizePayload, parseRuleConfig, reinitLogger, startSqsLagPoller };
+export { type Config, type DedupResult, type IAlertQueue, type IDeduplicationStore, type IIndexer, type ILLMProvider, type INotifier, type IRollbackActionHandler, type IRuleEngine, type ITraceRepository, type LLMResult, type Logger, type LoggerOptions, type NotifyResult, type OpenSearchHttpFetcher, type OpenSearchHttpResponse, type OpenSearchIndexerDeps, type RollbackActionRequest, type RollbackActionResult, type RuleActionResult, type SignedHttpRequest, type TraceabilityDocument, index_d_exports as metrics };
 //# sourceMappingURL=index.d.ts.map