@noxsoft/anima 2.0.0

package/dist/plugin-sdk/auto-reply/reply/queue/types.d.ts

@@ -0,0 +1,84 @@
+import type { ExecToolDefaults } from "../../../agents/bash-tools.js";
+import type { SkillSnapshot } from "../../../agents/skills.js";
+import type { AnimaConfig } from "../../../config/config.js";
+import type { SessionEntry } from "../../../config/sessions.js";
+import type { OriginatingChannelType } from "../../templating.js";
+import type { ElevatedLevel, ReasoningLevel, ThinkLevel, VerboseLevel } from "../directives.js";
+export type QueueMode = "steer" | "followup" | "collect" | "steer-backlog" | "interrupt" | "queue";
+export type QueueDropPolicy = "old" | "new" | "summarize";
+export type QueueSettings = {
+    mode: QueueMode;
+    debounceMs?: number;
+    cap?: number;
+    dropPolicy?: QueueDropPolicy;
+};
+export type QueueDedupeMode = "message-id" | "prompt" | "none";
+export type FollowupRun = {
+    prompt: string;
+    /** Provider message ID, when available (for deduplication). */
+    messageId?: string;
+    summaryLine?: string;
+    enqueuedAt: number;
+    /**
+     * Originating channel for reply routing.
+     * When set, replies should be routed back to this provider
+     * instead of using the session's lastChannel.
+     */
+    originatingChannel?: OriginatingChannelType;
+    /**
+     * Originating destination for reply routing.
+     * The chat/channel/user ID where the reply should be sent.
+     */
+    originatingTo?: string;
+    /** Provider account id (multi-account). */
+    originatingAccountId?: string;
+    /** Thread id for reply routing (Telegram topic id or Matrix thread event id). */
+    originatingThreadId?: string | number;
+    /** Chat type for context-aware threading (e.g., DM vs channel). */
+    originatingChatType?: string;
+    run: {
+        agentId: string;
+        agentDir: string;
+        sessionId: string;
+        sessionKey?: string;
+        messageProvider?: string;
+        agentAccountId?: string;
+        groupId?: string;
+        groupChannel?: string;
+        groupSpace?: string;
+        senderId?: string;
+        senderName?: string;
+        senderUsername?: string;
+        senderE164?: string;
+        sessionFile: string;
+        workspaceDir: string;
+        config: AnimaConfig;
+        skillsSnapshot?: SkillSnapshot;
+        provider: string;
+        model: string;
+        authProfileId?: string;
+        authProfileIdSource?: "auto" | "user";
+        thinkLevel?: ThinkLevel;
+        verboseLevel?: VerboseLevel;
+        reasoningLevel?: ReasoningLevel;
+        elevatedLevel?: ElevatedLevel;
+        execOverrides?: Pick<ExecToolDefaults, "host" | "security" | "ask" | "node">;
+        bashElevated?: {
+            enabled: boolean;
+            allowed: boolean;
+            defaultLevel: ElevatedLevel;
+        };
+        timeoutMs: number;
+        blockReplyBreak: "text_end" | "message_end";
+        ownerNumbers?: string[];
+        extraSystemPrompt?: string;
+        enforceFinalTag?: boolean;
+    };
+};
+export type ResolveQueueSettingsParams = {
+    cfg: AnimaConfig;
+    channel?: string;
+    sessionEntry?: SessionEntry;
+    inlineMode?: QueueMode;
+    inlineOptions?: Partial<QueueSettings>;
+};

package/dist/plugin-sdk/auto-reply/reply/queue.d.ts

@@ -0,0 +1,8 @@
+export { extractQueueDirective } from "./queue/directive.js";
+export { clearSessionQueues } from "./queue/cleanup.js";
+export type { ClearSessionQueueResult } from "./queue/cleanup.js";
+export { scheduleFollowupDrain } from "./queue/drain.js";
+export { enqueueFollowupRun, getFollowupQueueDepth } from "./queue/enqueue.js";
+export { resolveQueueSettings } from "./queue/settings.js";
+export { clearFollowupQueue } from "./queue/state.js";
+export type { FollowupRun, QueueDedupeMode, QueueDropPolicy, QueueMode, QueueSettings, } from "./queue/types.js";

package/dist/plugin-sdk/auto-reply/reply/reply-delivery.d.ts

@@ -0,0 +1,27 @@
+import type { BlockReplyContext, ReplyPayload } from "../types.js";
+import type { BlockReplyPipeline } from "./block-reply-pipeline.js";
+import type { TypingSignaler } from "./typing-mode.js";
+export type ReplyDirectiveParseMode = "always" | "auto" | "never";
+export declare function normalizeReplyPayloadDirectives(params: {
+    payload: ReplyPayload;
+    currentMessageId?: string;
+    silentToken?: string;
+    trimLeadingWhitespace?: boolean;
+    parseMode?: ReplyDirectiveParseMode;
+}): {
+    payload: ReplyPayload;
+    isSilent: boolean;
+};
+export declare function createBlockReplyDeliveryHandler(params: {
+    onBlockReply: (payload: ReplyPayload, context?: BlockReplyContext) => Promise<void> | void;
+    currentMessageId?: string;
+    normalizeStreamingText: (payload: ReplyPayload) => {
+        text?: string;
+        skip: boolean;
+    };
+    applyReplyToMode: (payload: ReplyPayload) => ReplyPayload;
+    typingSignals: TypingSignaler;
+    blockStreamingEnabled: boolean;
+    blockReplyPipeline: BlockReplyPipeline | null;
+    directlySentBlockKeys: Set<string>;
+}): (payload: ReplyPayload) => Promise<void>;

package/dist/plugin-sdk/auto-reply/reply/reply-directives.d.ts

@@ -0,0 +1,14 @@
+export type ReplyDirectiveParseResult = {
+    text: string;
+    mediaUrls?: string[];
+    mediaUrl?: string;
+    replyToId?: string;
+    replyToCurrent: boolean;
+    replyToTag: boolean;
+    audioAsVoice?: boolean;
+    isSilent: boolean;
+};
+export declare function parseReplyDirectives(raw: string, options?: {
+    currentMessageId?: string;
+    silentToken?: string;
+}): ReplyDirectiveParseResult;

package/dist/plugin-sdk/auto-reply/reply/reply-dispatcher.d.ts

@@ -0,0 +1,52 @@
+import type { HumanDelayConfig } from "../../config/types.js";
+import type { GetReplyOptions, ReplyPayload } from "../types.js";
+import type { ResponsePrefixContext } from "./response-prefix-template.js";
+import { type NormalizeReplySkipReason } from "./normalize-reply.js";
+export type ReplyDispatchKind = "tool" | "block" | "final";
+type ReplyDispatchErrorHandler = (err: unknown, info: {
+    kind: ReplyDispatchKind;
+}) => void;
+type ReplyDispatchSkipHandler = (payload: ReplyPayload, info: {
+    kind: ReplyDispatchKind;
+    reason: NormalizeReplySkipReason;
+}) => void;
+type ReplyDispatchDeliverer = (payload: ReplyPayload, info: {
+    kind: ReplyDispatchKind;
+}) => Promise<void>;
+export type ReplyDispatcherOptions = {
+    deliver: ReplyDispatchDeliverer;
+    responsePrefix?: string;
+    /** Static context for response prefix template interpolation. */
+    responsePrefixContext?: ResponsePrefixContext;
+    /** Dynamic context provider for response prefix template interpolation.
+     * Called at normalization time, after model selection is complete. */
+    responsePrefixContextProvider?: () => ResponsePrefixContext;
+    onHeartbeatStrip?: () => void;
+    onIdle?: () => void;
+    onError?: ReplyDispatchErrorHandler;
+    onSkip?: ReplyDispatchSkipHandler;
+    /** Human-like delay between block replies for natural rhythm. */
+    humanDelay?: HumanDelayConfig;
+};
+export type ReplyDispatcherWithTypingOptions = Omit<ReplyDispatcherOptions, "onIdle"> & {
+    onReplyStart?: () => Promise<void> | void;
+    onIdle?: () => void;
+    /** Called when the typing controller is cleaned up (e.g., on NO_REPLY). */
+    onCleanup?: () => void;
+};
+type ReplyDispatcherWithTypingResult = {
+    dispatcher: ReplyDispatcher;
+    replyOptions: Pick<GetReplyOptions, "onReplyStart" | "onTypingController" | "onTypingCleanup">;
+    markDispatchIdle: () => void;
+};
+export type ReplyDispatcher = {
+    sendToolResult: (payload: ReplyPayload) => boolean;
+    sendBlockReply: (payload: ReplyPayload) => boolean;
+    sendFinalReply: (payload: ReplyPayload) => boolean;
+    waitForIdle: () => Promise<void>;
+    getQueuedCounts: () => Record<ReplyDispatchKind, number>;
+    markComplete: () => void;
+};
+export declare function createReplyDispatcher(options: ReplyDispatcherOptions): ReplyDispatcher;
+export declare function createReplyDispatcherWithTyping(options: ReplyDispatcherWithTypingOptions): ReplyDispatcherWithTypingResult;
+export {};

package/dist/plugin-sdk/auto-reply/reply/reply-elevated.d.ts

@@ -0,0 +1,16 @@
+import type { AnimaConfig } from "../../config/config.js";
+import type { MsgContext } from "../templating.js";
+export { formatElevatedUnavailableMessage } from "./elevated-unavailable.js";
+export declare function resolveElevatedPermissions(params: {
+    cfg: AnimaConfig;
+    agentId: string;
+    ctx: MsgContext;
+    provider: string;
+}): {
+    enabled: boolean;
+    allowed: boolean;
+    failures: Array<{
+        gate: string;
+        key: string;
+    }>;
+};

package/dist/plugin-sdk/auto-reply/reply/reply-inline.d.ts

@@ -0,0 +1,8 @@
+export declare function extractInlineSimpleCommand(body?: string): {
+    command: string;
+    cleaned: string;
+} | null;
+export declare function stripInlineStatus(body: string): {
+    cleaned: string;
+    didStrip: boolean;
+};

package/dist/plugin-sdk/auto-reply/reply/reply-payloads.d.ts

@@ -0,0 +1,22 @@
+import type { MessagingToolSend } from "../../agents/pi-embedded-runner.js";
+import type { ReplyToMode } from "../../config/types.js";
+import type { OriginatingChannelType } from "../templating.js";
+import type { ReplyPayload } from "../types.js";
+export declare function applyReplyTagsToPayload(payload: ReplyPayload, currentMessageId?: string): ReplyPayload;
+export declare function isRenderablePayload(payload: ReplyPayload): boolean;
+export declare function applyReplyThreading(params: {
+    payloads: ReplyPayload[];
+    replyToMode: ReplyToMode;
+    replyToChannel?: OriginatingChannelType;
+    currentMessageId?: string;
+}): ReplyPayload[];
+export declare function filterMessagingToolDuplicates(params: {
+    payloads: ReplyPayload[];
+    sentTexts: string[];
+}): ReplyPayload[];
+export declare function shouldSuppressMessagingToolReplies(params: {
+    messageProvider?: string;
+    messagingToolSentTargets?: MessagingToolSend[];
+    originatingTo?: string;
+    accountId?: string;
+}): boolean;

package/dist/plugin-sdk/auto-reply/reply/reply-tags.d.ts

@@ -0,0 +1,6 @@
+export declare function extractReplyToTag(text?: string, currentMessageId?: string): {
+    cleaned: string;
+    replyToId?: string;
+    replyToCurrent: boolean;
+    hasTag: boolean;
+};

package/dist/plugin-sdk/auto-reply/reply/reply-threading.d.ts

@@ -0,0 +1,9 @@
+import type { AnimaConfig } from "../../config/config.js";
+import type { ReplyToMode } from "../../config/types.js";
+import type { OriginatingChannelType } from "../templating.js";
+import type { ReplyPayload } from "../types.js";
+export declare function resolveReplyToMode(cfg: AnimaConfig, channel?: OriginatingChannelType, accountId?: string | null, chatType?: string | null): ReplyToMode;
+export declare function createReplyToModeFilter(mode: ReplyToMode, opts?: {
+    allowExplicitReplyTagsWhenOff?: boolean;
+}): (payload: ReplyPayload) => ReplyPayload;
+export declare function createReplyToModeFilterForChannel(mode: ReplyToMode, channel?: OriginatingChannelType): (payload: ReplyPayload) => ReplyPayload;

package/dist/plugin-sdk/auto-reply/reply/response-prefix-template.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Template interpolation for response prefix.
+ *
+ * Supports variables like `{model}`, `{provider}`, `{thinkingLevel}`, etc.
+ * Variables are case-insensitive and unresolved ones remain as literal text.
+ */
+export type ResponsePrefixContext = {
+    /** Short model name (e.g., "gpt-5.2", "claude-opus-4-6") */
+    model?: string;
+    /** Full model ID including provider (e.g., "openai-codex/gpt-5.2") */
+    modelFull?: string;
+    /** Provider name (e.g., "openai-codex", "anthropic") */
+    provider?: string;
+    /** Current thinking level (e.g., "high", "low", "off") */
+    thinkingLevel?: string;
+    /** Agent identity name */
+    identityName?: string;
+};
+/**
+ * Interpolate template variables in a response prefix string.
+ *
+ * @param template - The template string with `{variable}` placeholders
+ * @param context - Context object with values for interpolation
+ * @returns The interpolated string, or undefined if template is undefined
+ *
+ * @example
+ * resolveResponsePrefixTemplate("[{model} | think:{thinkingLevel}]", {
+ *   model: "gpt-5.2",
+ *   thinkingLevel: "high"
+ * })
+ * // Returns: "[gpt-5.2 | think:high]"
+ */
+export declare function resolveResponsePrefixTemplate(template: string | undefined, context: ResponsePrefixContext): string | undefined;
+/**
+ * Extract short model name from a full model string.
+ *
+ * Strips:
+ * - Provider prefix (e.g., "openai/" from "openai/gpt-5.2")
+ * - Date suffixes (e.g., "-20260205" from "claude-opus-4-6-20260205")
+ * - Common version suffixes (e.g., "-latest")
+ *
+ * @example
+ * extractShortModelName("openai-codex/gpt-5.2") // "gpt-5.2"
+ * extractShortModelName("claude-opus-4-6-20260205") // "claude-opus-4-6"
+ * extractShortModelName("gpt-5.2-latest") // "gpt-5.2"
+ */
+export declare function extractShortModelName(fullModel: string): string;
+/**
+ * Check if a template string contains any template variables.
+ */
+export declare function hasTemplateVariables(template: string | undefined): boolean;

package/dist/plugin-sdk/auto-reply/reply/route-reply.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Provider-agnostic reply router.
+ *
+ * Routes replies to the originating channel based on OriginatingChannel/OriginatingTo
+ * instead of using the session's lastChannel. This ensures replies go back to the
+ * provider where the message originated, even when the main session is shared
+ * across multiple providers.
+ */
+import type { AnimaConfig } from "../../config/config.js";
+import type { OriginatingChannelType } from "../templating.js";
+import type { ReplyPayload } from "../types.js";
+import { INTERNAL_MESSAGE_CHANNEL } from "../../utils/message-channel.js";
+export type RouteReplyParams = {
+    /** The reply payload to send. */
+    payload: ReplyPayload;
+    /** The originating channel type (telegram, slack, etc). */
+    channel: OriginatingChannelType;
+    /** The destination chat/channel/user ID. */
+    to: string;
+    /** Session key for deriving agent identity defaults (multi-agent). */
+    sessionKey?: string;
+    /** Provider account id (multi-account). */
+    accountId?: string;
+    /** Thread id for replies (Telegram topic id or Matrix thread event id). */
+    threadId?: string | number;
+    /** Config for provider-specific settings. */
+    cfg: AnimaConfig;
+    /** Optional abort signal for cooperative cancellation. */
+    abortSignal?: AbortSignal;
+    /** Mirror reply into session transcript (default: true when sessionKey is set). */
+    mirror?: boolean;
+};
+export type RouteReplyResult = {
+    /** Whether the reply was sent successfully. */
+    ok: boolean;
+    /** Optional message ID from the provider. */
+    messageId?: string;
+    /** Error message if the send failed. */
+    error?: string;
+};
+/**
+ * Routes a reply payload to the specified channel.
+ *
+ * This function provides a unified interface for sending messages to any
+ * supported provider. It's used by the followup queue to route replies
+ * back to the originating channel when OriginatingChannel/OriginatingTo
+ * are set.
+ */
+export declare function routeReply(params: RouteReplyParams): Promise<RouteReplyResult>;
+/**
+ * Checks if a channel type is routable via routeReply.
+ *
+ * Some channels (webchat) require special handling and cannot be routed through
+ * this generic interface.
+ */
+export declare function isRoutableChannel(channel: OriginatingChannelType | undefined): channel is Exclude<OriginatingChannelType, typeof INTERNAL_MESSAGE_CHANNEL>;

package/dist/plugin-sdk/auto-reply/reply/session-reset-model.d.ts

@@ -0,0 +1,24 @@
+import type { AnimaConfig } from "../../config/config.js";
+import type { SessionEntry } from "../../config/sessions.js";
+import type { MsgContext, TemplateContext } from "../templating.js";
+import { type ModelAliasIndex } from "../../agents/model-selection.js";
+import { type ModelDirectiveSelection } from "./model-selection.js";
+type ResetModelResult = {
+    selection?: ModelDirectiveSelection;
+    cleanedBody?: string;
+};
+export declare function applyResetModelOverride(params: {
+    cfg: AnimaConfig;
+    resetTriggered: boolean;
+    bodyStripped?: string;
+    sessionCtx: TemplateContext;
+    ctx: MsgContext;
+    sessionEntry?: SessionEntry;
+    sessionStore?: Record<string, SessionEntry>;
+    sessionKey?: string;
+    storePath?: string;
+    defaultProvider: string;
+    defaultModel: string;
+    aliasIndex: ModelAliasIndex;
+}): Promise<ResetModelResult>;
+export {};

package/dist/plugin-sdk/auto-reply/reply/session-reset-prompt.d.ts

@@ -0,0 +1 @@
+export declare const BARE_SESSION_RESET_PROMPT = "A new session was started via /new or /reset. Greet the user in your configured persona, if one is provided. Be yourself - use your defined voice, mannerisms, and mood. Keep it to 1-3 sentences and ask what they want to do. If the runtime model differs from default_model in the system prompt, mention the default model. Do not mention internal steps, files, tools, or reasoning.";

package/dist/plugin-sdk/auto-reply/reply/session-run-accounting.d.ts

@@ -0,0 +1,11 @@
+import { type NormalizedUsage } from "../../agents/usage.js";
+import { incrementCompactionCount } from "./session-updates.js";
+import { persistSessionUsageUpdate } from "./session-usage.js";
+type PersistRunSessionUsageParams = Parameters<typeof persistSessionUsageUpdate>[0];
+type IncrementRunCompactionCountParams = Omit<Parameters<typeof incrementCompactionCount>[0], "tokensAfter"> & {
+    lastCallUsage?: NormalizedUsage;
+    contextTokensUsed?: number;
+};
+export declare function persistRunSessionUsage(params: PersistRunSessionUsageParams): Promise<void>;
+export declare function incrementRunCompactionCount(params: IncrementRunCompactionCountParams): Promise<number | undefined>;
+export {};

package/dist/plugin-sdk/auto-reply/reply/session-updates.d.ts

@@ -0,0 +1,34 @@
+import type { AnimaConfig } from "../../config/config.js";
+import { type SessionEntry } from "../../config/sessions.js";
+export declare function prependSystemEvents(params: {
+    cfg: AnimaConfig;
+    sessionKey: string;
+    isMainSession: boolean;
+    isNewSession: boolean;
+    prefixedBodyBase: string;
+}): Promise<string>;
+export declare function ensureSkillSnapshot(params: {
+    sessionEntry?: SessionEntry;
+    sessionStore?: Record<string, SessionEntry>;
+    sessionKey?: string;
+    storePath?: string;
+    sessionId?: string;
+    isFirstTurnInSession: boolean;
+    workspaceDir: string;
+    cfg: AnimaConfig;
+    /** If provided, only load skills with these names (for per-channel skill filtering) */
+    skillFilter?: string[];
+}): Promise<{
+    sessionEntry?: SessionEntry;
+    skillsSnapshot?: SessionEntry["skillsSnapshot"];
+    systemSent: boolean;
+}>;
+export declare function incrementCompactionCount(params: {
+    sessionEntry?: SessionEntry;
+    sessionStore?: Record<string, SessionEntry>;
+    sessionKey?: string;
+    storePath?: string;
+    now?: number;
+    /** Token count after compaction - if provided, updates session token counts */
+    tokensAfter?: number;
+}): Promise<number | undefined>;

package/dist/plugin-sdk/auto-reply/reply/session-usage.d.ts

@@ -0,0 +1,21 @@
+import { type NormalizedUsage } from "../../agents/usage.js";
+import { type SessionSystemPromptReport } from "../../config/sessions.js";
+export declare function persistSessionUsageUpdate(params: {
+    storePath?: string;
+    sessionKey?: string;
+    usage?: NormalizedUsage;
+    /**
+     * Usage from the last individual API call (not accumulated). When provided,
+     * this is used for `totalTokens` instead of the accumulated `usage` so that
+     * context-window utilization reflects the actual current context size rather
+     * than the sum of input tokens across all API calls in the run.
+     */
+    lastCallUsage?: NormalizedUsage;
+    modelUsed?: string;
+    providerUsed?: string;
+    contextTokensUsed?: number;
+    promptTokens?: number;
+    systemPromptReport?: SessionSystemPromptReport;
+    cliSessionId?: string;
+    logLabel?: string;
+}): Promise<void>;

package/dist/plugin-sdk/auto-reply/reply/session.d.ts

@@ -0,0 +1,26 @@
+import type { AnimaConfig } from "../../config/config.js";
+import type { MsgContext, TemplateContext } from "../templating.js";
+import { type GroupKeyResolution, type SessionEntry, type SessionScope } from "../../config/sessions.js";
+export type SessionInitResult = {
+    sessionCtx: TemplateContext;
+    sessionEntry: SessionEntry;
+    previousSessionEntry?: SessionEntry;
+    sessionStore: Record<string, SessionEntry>;
+    sessionKey: string;
+    sessionId: string;
+    isNewSession: boolean;
+    resetTriggered: boolean;
+    systemSent: boolean;
+    abortedLastRun: boolean;
+    storePath: string;
+    sessionScope: SessionScope;
+    groupResolution?: GroupKeyResolution;
+    isGroup: boolean;
+    bodyStripped?: string;
+    triggerBodyNormalized: string;
+};
+export declare function initSessionState(params: {
+    ctx: MsgContext;
+    cfg: AnimaConfig;
+    commandAuthorized: boolean;
+}): Promise<SessionInitResult>;

package/dist/plugin-sdk/auto-reply/reply/stage-sandbox-media.d.ts

@@ -0,0 +1,9 @@
+import type { AnimaConfig } from "../../config/config.js";
+import type { MsgContext, TemplateContext } from "../templating.js";
+export declare function stageSandboxMedia(params: {
+    ctx: MsgContext;
+    sessionCtx: TemplateContext;
+    cfg: AnimaConfig;
+    sessionKey?: string;
+    workspaceDir: string;
+}): Promise<void>;

package/dist/plugin-sdk/auto-reply/reply/subagents-utils.d.ts

@@ -0,0 +1,7 @@
+import type { SubagentRunRecord } from "../../agents/subagent-registry.js";
+export declare function resolveSubagentLabel(entry: SubagentRunRecord, fallback?: string): string;
+export declare function formatRunLabel(entry: SubagentRunRecord, options?: {
+    maxLength?: number;
+}): string;
+export declare function formatRunStatus(entry: SubagentRunRecord): "timeout" | "error" | "unknown" | "done" | "running";
+export declare function sortSubagentRuns(runs: SubagentRunRecord[]): SubagentRunRecord[];

package/dist/plugin-sdk/auto-reply/reply/typing-mode.d.ts

@@ -0,0 +1,27 @@
+import type { TypingMode } from "../../config/types.js";
+import type { TypingController } from "./typing.js";
+export type TypingModeContext = {
+    configured?: TypingMode;
+    isGroupChat: boolean;
+    wasMentioned: boolean;
+    isHeartbeat: boolean;
+};
+export declare const DEFAULT_GROUP_TYPING_MODE: TypingMode;
+export declare function resolveTypingMode({ configured, isGroupChat, wasMentioned, isHeartbeat, }: TypingModeContext): TypingMode;
+export type TypingSignaler = {
+    mode: TypingMode;
+    shouldStartImmediately: boolean;
+    shouldStartOnMessageStart: boolean;
+    shouldStartOnText: boolean;
+    shouldStartOnReasoning: boolean;
+    signalRunStart: () => Promise<void>;
+    signalMessageStart: () => Promise<void>;
+    signalTextDelta: (text?: string) => Promise<void>;
+    signalReasoningDelta: () => Promise<void>;
+    signalToolStart: () => Promise<void>;
+};
+export declare function createTypingSignaler(params: {
+    typing: TypingController;
+    mode: TypingMode;
+    isHeartbeat: boolean;
+}): TypingSignaler;

package/dist/plugin-sdk/auto-reply/reply/typing.d.ts

@@ -0,0 +1,18 @@
+export type TypingController = {
+    onReplyStart: () => Promise<void>;
+    startTypingLoop: () => Promise<void>;
+    startTypingOnText: (text?: string) => Promise<void>;
+    refreshTypingTtl: () => void;
+    isActive: () => boolean;
+    markRunComplete: () => void;
+    markDispatchIdle: () => void;
+    cleanup: () => void;
+};
+export declare function createTypingController(params: {
+    onReplyStart?: () => Promise<void> | void;
+    onCleanup?: () => void;
+    typingIntervalSeconds?: number;
+    typingTtlMs?: number;
+    silentToken?: string;
+    log?: (message: string) => void;
+}): TypingController;

package/dist/plugin-sdk/auto-reply/reply/untrusted-context.d.ts

@@ -0,0 +1 @@
+export declare function appendUntrustedContext(base: string, untrusted?: string[]): string;

package/dist/plugin-sdk/auto-reply/reply.d.ts

@@ -0,0 +1,6 @@
+export { extractElevatedDirective, extractReasoningDirective, extractThinkDirective, extractVerboseDirective, } from "./reply/directives.js";
+export { getReplyFromConfig } from "./reply/get-reply.js";
+export { extractExecDirective } from "./reply/exec.js";
+export { extractQueueDirective } from "./reply/queue.js";
+export { extractReplyToTag } from "./reply/reply-tags.js";
+export type { GetReplyOptions, ReplyPayload } from "./types.js";

package/dist/plugin-sdk/auto-reply/send-policy.d.ts

@@ -0,0 +1,6 @@
+export type SendPolicyOverride = "allow" | "deny";
+export declare function normalizeSendPolicyOverride(raw?: string | null): SendPolicyOverride | undefined;
+export declare function parseSendPolicyCommand(raw?: string): {
+    hasCommand: boolean;
+    mode?: SendPolicyOverride | "inherit";
+};

package/dist/plugin-sdk/auto-reply/skill-commands.d.ts

@@ -0,0 +1,18 @@
+import type { AnimaConfig } from "../config/config.js";
+import { type SkillCommandSpec } from "../agents/skills.js";
+export declare function listSkillCommandsForWorkspace(params: {
+    workspaceDir: string;
+    cfg: AnimaConfig;
+    skillFilter?: string[];
+}): SkillCommandSpec[];
+export declare function listSkillCommandsForAgents(params: {
+    cfg: AnimaConfig;
+    agentIds?: string[];
+}): SkillCommandSpec[];
+export declare function resolveSkillCommandInvocation(params: {
+    commandBodyNormalized: string;
+    skillCommands: SkillCommandSpec[];
+}): {
+    command: SkillCommandSpec;
+    args?: string;
+} | null;

package/dist/plugin-sdk/auto-reply/status.d.ts

@@ -0,0 +1,55 @@
+import type { SkillCommandSpec } from "../agents/skills.js";
+import type { AnimaConfig } from "../config/config.js";
+import type { MediaUnderstandingDecision } from "../media-understanding/types.js";
+import type { ElevatedLevel, ReasoningLevel, ThinkLevel, VerboseLevel } from "./thinking.js";
+import { type SessionEntry, type SessionScope } from "../config/sessions.js";
+import { formatTokenCount as formatTokenCountShared } from "../utils/usage-format.js";
+type AgentConfig = Partial<NonNullable<NonNullable<AnimaConfig["agents"]>["defaults"]>>;
+export declare const formatTokenCount: typeof formatTokenCountShared;
+type QueueStatus = {
+    mode?: string;
+    depth?: number;
+    debounceMs?: number;
+    cap?: number;
+    dropPolicy?: string;
+    showDetails?: boolean;
+};
+type StatusArgs = {
+    config?: AnimaConfig;
+    agent: AgentConfig;
+    agentId?: string;
+    sessionEntry?: SessionEntry;
+    sessionKey?: string;
+    sessionScope?: SessionScope;
+    sessionStorePath?: string;
+    groupActivation?: "mention" | "always";
+    resolvedThink?: ThinkLevel;
+    resolvedVerbose?: VerboseLevel;
+    resolvedReasoning?: ReasoningLevel;
+    resolvedElevated?: ElevatedLevel;
+    modelAuth?: string;
+    usageLine?: string;
+    timeLine?: string;
+    queue?: QueueStatus;
+    mediaDecisions?: MediaUnderstandingDecision[];
+    subagentsLine?: string;
+    includeTranscriptUsage?: boolean;
+    now?: number;
+};
+export declare const formatContextUsageShort: (total: number | null | undefined, contextTokens: number | null | undefined) => string;
+export declare function buildStatusMessage(args: StatusArgs): string;
+export declare function buildHelpMessage(cfg?: AnimaConfig): string;
+export type CommandsMessageOptions = {
+    page?: number;
+    surface?: string;
+};
+export type CommandsMessageResult = {
+    text: string;
+    totalPages: number;
+    currentPage: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+};
+export declare function buildCommandsMessage(cfg?: AnimaConfig, skillCommands?: SkillCommandSpec[], options?: CommandsMessageOptions): string;
+export declare function buildCommandsMessagePaginated(cfg?: AnimaConfig, skillCommands?: SkillCommandSpec[], options?: CommandsMessageOptions): CommandsMessageResult;
+export {};