@pinet/slack-bridge 0.1.0

package/dist/helpers.d.ts

@@ -0,0 +1,550 @@
+import { type RuntimeScopeCarrier } from "@pinet/transport-core";
+import type { ReactionCommandSettings } from "./reaction-triggers.js";
+export interface SlackBridgeSettings {
+    botToken?: string;
+    appToken?: string;
+    appId?: string;
+    appConfigToken?: string;
+    allowedUsers?: string[];
+    allowAllWorkspaceUsers?: boolean;
+    defaultChannel?: string;
+    logChannel?: string;
+    logLevel?: "errors" | "actions" | "verbose";
+    suggestedPrompts?: {
+        title: string;
+        message: string;
+    }[];
+    reactionCommands?: ReactionCommandSettings;
+    runtimeMode?: "off" | "single" | "broker" | "follower";
+    brokerPrompt?: string;
+    autoConnect?: boolean;
+    autoFollow?: boolean;
+    ralphLoopIntervalMs?: number;
+    ralphSnoozeAfterEmptyCycles?: number;
+    ralphSnoozeDurationMs?: number;
+    skinTheme?: string;
+    agentName?: string;
+    agentEmoji?: string;
+    meshSecret?: string;
+    meshSecretPath?: string;
+    imessage?: {
+        enabled?: boolean;
+    };
+    security?: {
+        readOnly?: boolean;
+        requireConfirmation?: string[];
+        blockedTools?: string[];
+    };
+}
+export interface ResolvedPinetMeshAuthSettings {
+    meshSecret: string | null;
+    meshSecretPath: string | null;
+}
+export declare function buildSlackCompatibilityScope(options?: {
+    teamId?: string | null;
+    channelId?: string | null;
+    installId?: string | null;
+    instanceId?: string | null;
+    instanceName?: string | null;
+}): RuntimeScopeCarrier;
+export declare function resolvePinetMeshAuth(settings: SlackBridgeSettings, env?: NodeJS.ProcessEnv): ResolvedPinetMeshAuthSettings;
+export declare function loadSettings(settingsPath?: string): SlackBridgeSettings;
+export declare function resolveAllowAllWorkspaceUsers(settings: SlackBridgeSettings, envVar?: string | undefined): boolean;
+export declare function buildAllowlist(settings: SlackBridgeSettings, envVar?: string, allowAllEnvVar?: string | undefined): Set<string> | null;
+export declare function describeSlackUserAccess(allowlist: Set<string> | null, options?: {
+    allowAllWorkspaceUsers?: boolean;
+}): string;
+export declare function getSlackUserAccessWarning(allowlist: Set<string> | null): string | null;
+export declare function isUserAllowed(allowlist: Set<string> | null, userId: string): boolean;
+export interface InboxMessage {
+    channel: string;
+    threadTs: string;
+    userId: string;
+    text: string;
+    timestamp: string;
+    isChannelMention?: boolean;
+    brokerInboxId?: number;
+    metadata?: Record<string, unknown> | null;
+    scope?: RuntimeScopeCarrier | null;
+}
+export interface SqliteJournalModeResult {
+    journal_mode?: string | null;
+}
+export declare function getSqliteJournalMode(result?: SqliteJournalModeResult): string;
+export declare function isSqliteWalEnabled(result?: SqliteJournalModeResult): boolean;
+export declare function buildSqliteWalFallbackWarning(component: string, result?: SqliteJournalModeResult): string;
+export declare function formatInboxMessages(messages: InboxMessage[], userNames: {
+    get(key: string): string | undefined;
+}): string;
+export declare function isTerminalPinetStandDownMessage(body: string | null | undefined): boolean;
+export declare function formatPinetInboxMessages(entries: FollowerInboxEntry[]): string;
+export type PinetControlCommand = "interrupt" | "reload" | "exit";
+export interface PinetRemoteControlState {
+    currentCommand: PinetControlCommand | null;
+    queuedCommand: PinetControlCommand | null;
+}
+export interface PinetRemoteControlRequestResult extends PinetRemoteControlState {
+    accepted: boolean;
+    shouldStartNow: boolean;
+    status: "start" | "queued" | "covered";
+    scheduledCommand: PinetControlCommand;
+    ackDisposition: "immediate" | "on_start";
+}
+export declare function parsePinetControlCommand(value: unknown): PinetControlCommand | null;
+export declare function queuePinetRemoteControl(state: PinetRemoteControlState, command: PinetControlCommand): PinetRemoteControlRequestResult;
+export declare function finishPinetRemoteControl(state: PinetRemoteControlState): PinetRemoteControlState & {
+    nextCommand: PinetControlCommand | null;
+};
+export interface PinetRuntimeReloader<State> {
+    getCurrentRole: () => "broker" | "follower" | null;
+    snapshotState: () => State;
+    restoreState: (snapshot: State) => void;
+    refreshState: () => void;
+    validateRefreshedState: () => void | Promise<void>;
+    stopRuntime: () => Promise<void>;
+    startRuntime: (role: "broker" | "follower") => Promise<void>;
+}
+export declare function reloadPinetRuntimeSafely<State>(reloader: PinetRuntimeReloader<State>): Promise<void>;
+export interface PinetControlEnvelope {
+    type: "pinet:control";
+    action: PinetControlCommand;
+}
+export declare function getPinetControlCommandFromText(text: string | undefined): PinetControlCommand | null;
+export declare function buildPinetControlMetadata(command: PinetControlCommand): PinetControlEnvelope;
+export declare function buildPinetControlMessage(command: PinetControlCommand): string;
+export declare function normalizeOutgoingPinetControlMessage(body: string, metadata?: Record<string, unknown>): {
+    body: string;
+    metadata: Record<string, unknown>;
+} | null;
+export type PinetSkinStatusKey = "idle" | "working" | "healthy" | "stale" | "ghost" | "resumable";
+export type PinetSkinStatusVocabulary = Partial<Record<PinetSkinStatusKey, string>>;
+export declare function extractPinetControlCommand(message: {
+    threadId?: string;
+    body?: string;
+    metadata?: Record<string, unknown> | null;
+}): PinetControlCommand | null;
+export declare const FORM_METHODS: Set<string>;
+export declare function buildSlackRequest(method: string, token: string, body?: Record<string, unknown>): {
+    url: string;
+    init: RequestInit;
+};
+export interface AbortableOperationTracker {
+    run<T>(operation: (signal: AbortSignal) => Promise<T>): Promise<T>;
+    abortAndWait(): Promise<void>;
+    isAborting(): boolean;
+}
+export declare function createAbortError(message?: string): Error;
+export declare function isAbortError(error: unknown): boolean;
+export declare function abortableDelay(ms: number, signal: AbortSignal): Promise<void>;
+export declare function createAbortableOperationTracker(): AbortableOperationTracker;
+export declare function stripBotMention(text: string, botUserId: string): string;
+export declare function isChannelId(nameOrId: string): boolean;
+export interface AgentCapabilities {
+    repo?: string;
+    repoRoot?: string;
+    branch?: string;
+    workdirDirty?: boolean;
+    role?: string;
+    tools?: string[];
+    tags?: string[];
+    scope?: RuntimeScopeCarrier | null;
+}
+export type AgentHealth = "healthy" | "stale" | "ghost" | "resumable";
+export interface AgentDisplayInfo {
+    emoji: string;
+    name: string;
+    id: string;
+    pid?: number;
+    status: "working" | "idle";
+    metadata?: {
+        cwd?: string;
+        branch?: string;
+        workdirDirty?: boolean;
+        workdirDirtyFileCount?: number;
+        gitProbeFailed?: boolean;
+        gitProbedAt?: string;
+        host?: string;
+        repo?: string;
+        role?: string;
+        worktreePath?: string;
+        worktreeKind?: "main" | "linked";
+        brokerManaged?: boolean;
+        brokerManagedBy?: string;
+        launchSource?: string;
+        tmuxSession?: string;
+        brokerManagedAt?: string;
+        skinTheme?: string;
+        personality?: string;
+        skinStatusVocabulary?: PinetSkinStatusVocabulary;
+        capabilities?: AgentCapabilities | null;
+        scope?: RuntimeScopeCarrier | null;
+    } | null;
+    lastHeartbeat?: string;
+    leaseExpiresAt?: string | null;
+    heartbeatAgeMs?: number | null;
+    heartbeatSummary?: string | null;
+    leaseSummary?: string | null;
+    health?: AgentHealth;
+    ghost?: boolean;
+    stuck?: boolean;
+    idleSince?: string | null;
+    lastActivity?: string | null;
+    idleDuration?: string | null;
+    lastActivityAge?: string | null;
+    outboundCount?: number | null;
+    pendingInboxCount?: number | null;
+    capabilityTags?: string[];
+    routingScore?: number;
+    routingReasons?: string[];
+}
+export interface AgentVisibilityInput {
+    emoji: string;
+    name: string;
+    id: string;
+    pid?: number;
+    status: "working" | "idle";
+    metadata?: Record<string, unknown> | null;
+    lastHeartbeat?: string;
+    lastSeen?: string;
+    disconnectedAt?: string | null;
+    resumableUntil?: string | null;
+    idleSince?: string | null;
+    lastActivity?: string | null;
+    outboundCount?: number | null;
+    pendingInboxCount?: number | null;
+}
+export interface AgentVisibilityOptions {
+    now?: number;
+    heartbeatTimeoutMs?: number;
+    heartbeatIntervalMs?: number;
+}
+export interface AgentRoutingHint {
+    repo?: string;
+    branch?: string;
+    role?: string;
+    requiredTools?: string[];
+    task?: string;
+}
+export declare function shortenPath(p: string, homedir: string): string;
+export declare function extractAgentCapabilities(metadata: Record<string, unknown> | null | undefined): AgentCapabilities;
+export declare function buildAgentCapabilityTags(capabilities: AgentCapabilities): string[];
+export interface MeshVisibilityOptions {
+    includeGhosts?: boolean;
+    now?: number;
+    recentDisconnectWindowMs: number;
+}
+export declare function isAgentVisibleInMesh(agent: {
+    disconnectedAt?: string | null;
+}, options: MeshVisibilityOptions): boolean;
+export declare function filterAgentsForMeshVisibility<T extends {
+    disconnectedAt?: string | null;
+}>(agents: T[], options: MeshVisibilityOptions): T[];
+export declare function buildAgentDisplayInfo(agent: AgentVisibilityInput, options?: AgentVisibilityOptions): AgentDisplayInfo;
+export declare function rankAgentsForRouting(agents: AgentDisplayInfo[], hint: AgentRoutingHint): AgentDisplayInfo[];
+export declare const DEFAULT_RALPH_LOOP_INTERVAL_MS: number;
+export declare const DEFAULT_RALPH_LOOP_IDLE_WITH_WORK_THRESHOLD_MS = 60000;
+export declare const DEFAULT_RALPH_LOOP_NUDGE_COOLDOWN_MS: number;
+export declare const DEFAULT_RALPH_LOOP_FOLLOW_UP_COOLDOWN_MS = 60000;
+export declare const DEFAULT_RALPH_LOOP_STUCK_WORKING_THRESHOLD_MS: number;
+export declare const MIN_RALPH_LOOP_INTERVAL_MS = 1000;
+export declare const MAX_RALPH_LOOP_INTERVAL_MS = 2147483647;
+export declare const DEFAULT_RALPH_SNOOZE_DURATION_MS: number;
+export declare const MIN_RALPH_SNOOZE_DURATION_MS = 60000;
+export declare const MAX_RALPH_SNOOZE_DURATION_MS: number;
+export declare const DEFAULT_RALPH_SNOOZE_AFTER_EMPTY_CYCLES = 0;
+export declare const MAX_RALPH_SNOOZE_AFTER_EMPTY_CYCLES = 100;
+export declare function resolveRalphLoopIntervalMs(settings?: SlackBridgeSettings): number;
+export declare function resolveRalphSnoozeDurationMs(settings?: SlackBridgeSettings): number;
+export declare function resolveRalphSnoozeAfterEmptyCycles(settings?: SlackBridgeSettings): number;
+export interface RalphLoopAgentWorkload extends AgentVisibilityInput {
+    lastSeen?: string;
+    pendingInboxCount: number;
+    ownedThreadCount: number;
+}
+export interface RalphLoopEvaluationOptions extends AgentVisibilityOptions {
+    idleWithWorkThresholdMs?: number;
+    stuckWorkingThresholdMs?: number;
+    pendingBacklogCount?: number;
+    currentBranch?: string | null;
+    expectedMainBranch?: string;
+    brokerHeartbeatActive?: boolean;
+    brokerMaintenanceActive?: boolean;
+    brokerAgentId?: string;
+}
+export interface RalphLoopEvaluationResult {
+    ghostAgentIds: string[];
+    nudgeAgentIds: string[];
+    idleDrainAgentIds: string[];
+    stuckAgentIds: string[];
+    anomalies: string[];
+}
+export interface RalphLoopGhostAnomalyRewriteResult {
+    evaluation: RalphLoopEvaluationResult;
+    nonGhostAnomalies: string[];
+    newGhostIds: string[];
+    clearedGhostIds: string[];
+    nextReportedGhostIds: string[];
+}
+export declare function evaluateRalphLoopCycle(workloads: RalphLoopAgentWorkload[], options?: RalphLoopEvaluationOptions): RalphLoopEvaluationResult;
+export interface RalphLoopGhostAnomalyRewriteOptions {
+    suppressedGhostIds?: Iterable<string>;
+}
+export declare function rewriteRalphLoopGhostAnomalies(evaluation: RalphLoopEvaluationResult, previousGhostIds?: Iterable<string>, options?: RalphLoopGhostAnomalyRewriteOptions): RalphLoopGhostAnomalyRewriteResult;
+export declare function buildRalphLoopNudgeMessage(pendingInboxCount: number, ownedThreadCount: number, cycleStartedAt?: string): string;
+export declare function buildRalphLoopAnomalySignature(evaluation: RalphLoopEvaluationResult): string;
+export declare function buildRalphLoopStatusMessage(summary: string, cycleStartedAt: string): string;
+export interface RalphLoopFollowUpDeliveryOptions {
+    signature: string;
+    lastDeliveredSignature?: string;
+    lastDeliveredAt?: number;
+    now?: number;
+    cooldownMs?: number;
+    pending?: boolean;
+    idle?: boolean;
+}
+export declare function shouldDeliverRalphLoopFollowUp(options: RalphLoopFollowUpDeliveryOptions): boolean;
+export declare function buildRalphLoopFollowUpMessage(evaluation: RalphLoopEvaluationResult, cycleStartedAt: string): string | null;
+export interface RalphLoopCycleNotifications {
+    followUpPrompt: string | null;
+    anomalyStatus: string | null;
+    recoveryStatus: string;
+}
+export declare function buildRalphLoopCycleNotifications(evaluation: RalphLoopEvaluationResult, cycleStartedAt: string): RalphLoopCycleNotifications;
+export declare function buildBrokerProtocolGuardrailsPrompt(): string;
+export declare function buildWorkerPromptGuidelines(): string[];
+export declare function buildPinetSkinPromptGuideline(theme: string | null | undefined, personality: string | null | undefined): string | null;
+export declare function buildIdentityReplyGuidelines(agentEmoji: string, agentName: string, location: string): [string, string, string];
+export interface AgentPersonalityProfile {
+    descriptor?: string;
+    animal?: string;
+    traits: string[];
+}
+export declare function resolveAgentPersonality(agentName: string): AgentPersonalityProfile;
+export declare function buildAgentPersonalityGuidelines(agentName: string): string[];
+export declare function resolvePersistedAgentIdentity(settings: SlackBridgeSettings, persistedName?: string, persistedEmoji?: string, envNickname?: string, seed?: string, role?: AgentIdentityRole): {
+    name: string;
+    emoji: string;
+};
+export declare function buildAgentStableId(sessionFile?: string, host?: string, cwd?: string, leafId?: string): string;
+export declare function resolveAgentStableId(persistedStableId?: string, sessionFile?: string, host?: string, cwd?: string, leafId?: string): string;
+export declare function buildBrokerStableId(host?: string, cwd?: string): string;
+export declare function resolveBrokerStableId(persistedStableId?: string, host?: string, cwd?: string): string;
+export interface PinetRegistrationContext {
+    sessionHeader?: {
+        parentSession?: string;
+    } | null;
+    sessionFile?: string;
+    leafId?: string;
+    argv?: string[];
+    hasUI?: boolean;
+    stdinIsTTY?: boolean;
+    stdoutIsTTY?: boolean;
+}
+export declare function isLikelyLocalSubagentContext(context?: PinetRegistrationContext): boolean;
+export interface FollowerThreadState {
+    channelId: string;
+    threadTs: string;
+    userId: string;
+    source?: string;
+    owner?: string;
+}
+export interface FollowerInboxEntry {
+    inboxId?: number;
+    message: {
+        threadId?: string;
+        source?: string;
+        sender?: string;
+        body?: string;
+        createdAt?: string;
+        metadata: Record<string, unknown> | null;
+    };
+}
+export interface FollowerInboxSyncResult {
+    inboxMessages: InboxMessage[];
+    threadUpdates: FollowerThreadState[];
+    lastDmChannel: string | null;
+    changed: boolean;
+}
+export interface TransferredSlackThreadSyncResult {
+    threadUpdates: FollowerThreadState[];
+    changed: boolean;
+}
+export interface BrokerInboxControlEntry {
+    inboxId: number;
+    command: PinetControlCommand;
+}
+export interface BrokerInboxSyncResult {
+    controlEntries: BrokerInboxControlEntry[];
+    inboxMessages: InboxMessage[];
+}
+export declare function isDirectMessageChannel(channel: string): boolean;
+export declare function syncTransferredSlackThreadContexts(entries: FollowerInboxEntry[], existingThreads: ReadonlyMap<string, FollowerThreadState>, agentOwner: string): TransferredSlackThreadSyncResult;
+export declare function syncFollowerInboxEntries(entries: FollowerInboxEntry[], existingThreads: ReadonlyMap<string, FollowerThreadState>, agentOwner: string, lastDmChannel: string | null): FollowerInboxSyncResult;
+export declare function syncBrokerInboxEntries(entries: FollowerInboxEntry[]): BrokerInboxSyncResult;
+export interface FollowerThreadChannelResolution {
+    channelId: string | null;
+    threadUpdate?: FollowerThreadState;
+    changed: boolean;
+}
+export declare function resolveFollowerThreadChannel(threadTs: string | undefined, existingThread: FollowerThreadState | undefined, resolveThread?: (threadTs: string) => Promise<string | null>): Promise<FollowerThreadChannelResolution>;
+export type FollowerRuntimeDiagnosticKind = "broker_disconnect" | "poll_failure" | "registration_refresh_failure" | "reconnect_stopped";
+export type FollowerRuntimeDiagnosticState = "reconnecting" | "degraded" | "error";
+export interface FollowerRuntimeDiagnostic {
+    kind: FollowerRuntimeDiagnosticKind;
+    state: FollowerRuntimeDiagnosticState;
+    reason: string;
+    nextStep: string;
+    detail?: string;
+}
+export declare function buildFollowerRuntimeDiagnostic(kind: FollowerRuntimeDiagnosticKind, options?: {
+    detail?: string | null;
+    connected?: boolean;
+}): FollowerRuntimeDiagnostic;
+export declare function formatFollowerRuntimeDiagnosticHealth(diagnostic: FollowerRuntimeDiagnostic | null): string;
+export declare function formatFollowerRuntimeDiagnosticNextStep(diagnostic: FollowerRuntimeDiagnostic | null): string;
+export interface FollowerReconnectUiUpdate {
+    nextWasDisconnected: boolean;
+    notify?: {
+        level: "warning" | "info";
+        message: string;
+    };
+}
+export declare function getFollowerReconnectUiUpdate(event: "disconnect" | "reconnect", wasDisconnected: boolean): FollowerReconnectUiUpdate;
+export declare function agentOwnsThread(owner: string | undefined, agentName: string, agentAliases?: Iterable<string>, ownerToken?: string): boolean;
+export declare function normalizeOwnedThreads(threads: Iterable<{
+    owner?: string;
+}>, agentName: string, ownerToken: string, agentAliases?: Iterable<string>): boolean;
+export declare function getFollowerOwnedThreadClaims(threads: ReadonlyMap<string, Pick<FollowerThreadState, "threadTs" | "channelId" | "source" | "owner">>, agentName: string, agentAliases?: Iterable<string>, ownerToken?: string): Array<{
+    threadTs: string;
+    channelId: string;
+    source?: string;
+}>;
+export declare function getFollowerOwnedThreadReclaims(threads: ReadonlyMap<string, Pick<FollowerThreadState, "threadTs" | "channelId" | "source" | "owner">>, agentName: string, agentAliases?: Iterable<string>, ownerToken?: string): Array<{
+    threadTs: string;
+    channelId: string;
+    source: string;
+}>;
+/**
+ * Cache a thread from a broker inbound message in the local threads map.
+ * The broker DB remains the source of truth; this is only a read-through
+ * cache so Slack tools can resolve channels without hitting the DB every time.
+ */
+export declare function trackBrokerInboundThread(threads: Map<string, FollowerThreadState>, inMsg: {
+    threadId: string;
+    channel: string;
+    userId?: string;
+    source?: string;
+}, owner?: string): void;
+export declare function formatAgentList(agents: AgentDisplayInfo[], homedir: string): string;
+export type AgentIdentityRole = "broker" | "worker";
+export declare function buildPinetOwnerToken(stableId: string): string;
+export declare function generateAgentName(seed?: string, role?: AgentIdentityRole): {
+    name: string;
+    emoji: string;
+};
+export type PinetSkinRole = "broker" | "worker";
+export interface PinetSkinAssignment {
+    theme: string;
+    role: PinetSkinRole;
+    name: string;
+    emoji: string;
+    personality: string;
+    statusVocabulary?: PinetSkinStatusVocabulary;
+}
+export declare const DEFAULT_PINET_SKIN_THEME = "default";
+export declare const FOUNDATION_PINET_SKIN_THEME = "foundation";
+export declare const COSMERE_PINET_SKIN_THEME = "cosmere";
+export declare function normalizePinetSkinTheme(theme: string | undefined): string | null;
+export declare function buildPinetSkinAssignment(options: {
+    theme: string;
+    role: PinetSkinRole;
+    seed: string;
+}): PinetSkinAssignment;
+export declare function resolveAgentIdentity(settings: SlackBridgeSettings, envNickname?: string, seed?: string, role?: AgentIdentityRole): {
+    name: string;
+    emoji: string;
+};
+export declare function alignAgentIdentityToRole(currentIdentity: {
+    name: string;
+    emoji: string;
+}, settings: SlackBridgeSettings, envNickname?: string, seed?: string, role?: AgentIdentityRole): {
+    name: string;
+    emoji: string;
+};
+export declare function resolveRuntimeAgentIdentity(currentIdentity: {
+    name: string;
+    emoji: string;
+}, settings: SlackBridgeSettings, envNickname?: string, seed?: string, role?: AgentIdentityRole): {
+    name: string;
+    emoji: string;
+};
+export interface ConfirmationRequest {
+    toolPattern: string;
+    action: string;
+    requestedAt: number;
+}
+export interface ThreadConfirmationState {
+    pending: ConfirmationRequest[];
+    approved: ConfirmationRequest[];
+    rejected: ConfirmationRequest[];
+}
+export interface RegisterThreadConfirmationRequestResult {
+    state: ThreadConfirmationState;
+    status: "created" | "refreshed" | "conflict";
+    conflict?: ConfirmationRequest;
+}
+export declare const DEFAULT_CONFIRMATION_REQUEST_TTL_MS: number;
+export declare function normalizeThreadConfirmationState(state: ThreadConfirmationState, now?: number, ttlMs?: number): ThreadConfirmationState;
+export declare function isThreadConfirmationStateEmpty(state: ThreadConfirmationState): boolean;
+export declare function confirmationRequestMatches(request: ConfirmationRequest, toolName: string, action: string): boolean;
+export declare function consumeMatchingConfirmationRequest(list: ConfirmationRequest[], toolName: string, action: string): ConfirmationRequest | null;
+export declare function registerThreadConfirmationRequest(state: ThreadConfirmationState, request: ConfirmationRequest, now?: number): RegisterThreadConfirmationRequestResult;
+/**
+ * Standard Slack API response shape.
+ */
+export interface SlackResult {
+    ok: boolean;
+    error?: string;
+    [key: string]: unknown;
+}
+export interface CallSlackAPIOptions {
+    signal?: AbortSignal;
+    retryCount?: number;
+}
+export declare function callSlackAPI(method: string, token: string, body?: Record<string, unknown>, options?: CallSlackAPIOptions): Promise<SlackResult>;
+export declare function isRalphNudgeEntry(entry: {
+    message: {
+        metadata?: Record<string, unknown> | null;
+    };
+}): boolean;
+export declare function isAgentToAgentEntry(entry: {
+    message: {
+        threadId?: string;
+        metadata?: Record<string, unknown> | null;
+    };
+}): boolean;
+export declare function partitionFollowerInboxEntries<T extends {
+    message: {
+        threadId?: string;
+        metadata?: Record<string, unknown> | null;
+    };
+}>(entries: T[]): {
+    nudges: T[];
+    agentMessages: T[];
+    regular: T[];
+};
+export interface RalphCycleRecord {
+    id?: number;
+    startedAt: string;
+    completedAt: string | null;
+    durationMs: number | null;
+    ghostAgentIds: string[];
+    nudgeAgentIds: string[];
+    idleDrainAgentIds: string[];
+    stuckAgentIds: string[];
+    anomalies: string[];
+    anomalySignature: string;
+    followUpDelivered: boolean;
+    agentCount: number;
+    backlogCount: number;
+}