skykoi 2026.3.21 → 2026.3.23

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

@@ -0,0 +1,19 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { DispatchInboundResult } from "../dispatch.js";
+import type { FinalizedMsgContext, MsgContext } from "../templating.js";
+import type { GetReplyOptions } from "../types.js";
+import type { ReplyDispatcherOptions, ReplyDispatcherWithTypingOptions } from "./reply-dispatcher.js";
+export declare function dispatchReplyWithBufferedBlockDispatcher(params: {
+    ctx: MsgContext | FinalizedMsgContext;
+    cfg: SKYKOIConfig;
+    dispatcherOptions: ReplyDispatcherWithTypingOptions;
+    replyOptions?: Omit<GetReplyOptions, "onToolResult" | "onBlockReply">;
+    replyResolver?: typeof import("../reply.js").getReplyFromConfig;
+}): Promise<DispatchInboundResult>;
+export declare function dispatchReplyWithDispatcher(params: {
+    ctx: MsgContext | FinalizedMsgContext;
+    cfg: SKYKOIConfig;
+    dispatcherOptions: ReplyDispatcherOptions;
+    replyOptions?: Omit<GetReplyOptions, "onToolResult" | "onBlockReply">;
+    replyResolver?: typeof import("../reply.js").getReplyFromConfig;
+}): Promise<DispatchInboundResult>;

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

@@ -0,0 +1,6 @@
+export type ClearSessionQueueResult = {
+    followupCleared: number;
+    laneCleared: number;
+    keys: string[];
+};
+export declare function clearSessionQueues(keys: Array<string | undefined>): ClearSessionQueueResult;

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

@@ -0,0 +1,15 @@
+import type { QueueDropPolicy, QueueMode } from "./types.js";
+export declare function extractQueueDirective(body?: string): {
+    cleaned: string;
+    queueMode?: QueueMode;
+    queueReset: boolean;
+    rawMode?: string;
+    hasDirective: boolean;
+    debounceMs?: number;
+    cap?: number;
+    dropPolicy?: QueueDropPolicy;
+    rawDebounce?: string;
+    rawCap?: string;
+    rawDrop?: string;
+    hasOptions: boolean;
+};

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

@@ -0,0 +1,2 @@
+import type { FollowupRun } from "./types.js";
+export declare function scheduleFollowupDrain(key: string, runFollowup: (run: FollowupRun) => Promise<void>): void;

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

@@ -0,0 +1,3 @@
+import type { FollowupRun, QueueDedupeMode, QueueSettings } from "./types.js";
+export declare function enqueueFollowupRun(key: string, run: FollowupRun, settings: QueueSettings, dedupeMode?: QueueDedupeMode): boolean;
+export declare function getFollowupQueueDepth(key: string): number;

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

@@ -0,0 +1,3 @@
+import type { QueueDropPolicy, QueueMode } from "./types.js";
+export declare function normalizeQueueMode(raw?: string): QueueMode | undefined;
+export declare function normalizeQueueDropPolicy(raw?: string): QueueDropPolicy | undefined;

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

@@ -0,0 +1,2 @@
+import type { QueueSettings, ResolveQueueSettingsParams } from "./types.js";
+export declare function resolveQueueSettings(params: ResolveQueueSettingsParams): QueueSettings;

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

@@ -0,0 +1,19 @@
+import type { FollowupRun, QueueDropPolicy, QueueMode, QueueSettings } from "./types.js";
+export type FollowupQueueState = {
+    items: FollowupRun[];
+    draining: boolean;
+    lastEnqueuedAt: number;
+    mode: QueueMode;
+    debounceMs: number;
+    cap: number;
+    dropPolicy: QueueDropPolicy;
+    droppedCount: number;
+    summaryLines: string[];
+    lastRun?: FollowupRun["run"];
+};
+export declare const DEFAULT_QUEUE_DEBOUNCE_MS = 1000;
+export declare const DEFAULT_QUEUE_CAP = 20;
+export declare const DEFAULT_QUEUE_DROP: QueueDropPolicy;
+export declare const FOLLOWUP_QUEUES: Map<string, FollowupQueueState>;
+export declare function getFollowupQueue(key: string, settings: QueueSettings): FollowupQueueState;
+export declare function clearFollowupQueue(key: string): number;

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 { SKYKOIConfig } 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: SKYKOIConfig;
+        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: SKYKOIConfig;
+    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-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,51 @@
+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>;
+};
+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,23 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import type { MsgContext } from "../templating.js";
+export declare function resolveElevatedPermissions(params: {
+    cfg: SKYKOIConfig;
+    agentId: string;
+    ctx: MsgContext;
+    provider: string;
+}): {
+    enabled: boolean;
+    allowed: boolean;
+    failures: Array<{
+        gate: string;
+        key: string;
+    }>;
+};
+export declare function formatElevatedUnavailableMessage(params: {
+    runtimeSandboxed: boolean;
+    failures: Array<{
+        gate: string;
+        key: string;
+    }>;
+    sessionKey?: string;
+}): 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-reference.d.ts

@@ -0,0 +1,20 @@
+import type { ReplyToMode } from "../../config/types.js";
+export type ReplyReferencePlanner = {
+    /** Returns the effective reply/thread id for the next send and updates state. */
+    use(): string | undefined;
+    /** Mark that a reply was sent (needed when no reference is used). */
+    markSent(): void;
+    /** Whether a reply has been sent in this flow. */
+    hasReplied(): boolean;
+};
+export declare function createReplyReferencePlanner(options: {
+    replyToMode: ReplyToMode;
+    /** Existing thread/reference id (always used when present). */
+    existingId?: string;
+    /** Id to start a new thread/reference when allowed (e.g., parent message id). */
+    startId?: string;
+    /** Disable reply references entirely (e.g., when posting inside a new thread). */
+    allowReference?: boolean;
+    /** Seed the planner with prior reply state. */
+    hasReplied?: boolean;
+}): ReplyReferencePlanner;

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 { SKYKOIConfig } 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: SKYKOIConfig, channel?: OriginatingChannelType, accountId?: string | null, chatType?: string | null): ReplyToMode;
+export declare function createReplyToModeFilter(mode: ReplyToMode, opts?: {
+    allowTagsWhenOff?: 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 { SKYKOIConfig } 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: SKYKOIConfig;
+    /** 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 { SKYKOIConfig } 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: SKYKOIConfig;
+    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-updates.d.ts

@@ -0,0 +1,34 @@
+import type { SKYKOIConfig } from "../../config/config.js";
+import { type SessionEntry } from "../../config/sessions.js";
+export declare function prependSystemEvents(params: {
+    cfg: SKYKOIConfig;
+    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: SKYKOIConfig;
+    /** 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,13 @@
+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;
+    modelUsed?: string;
+    providerUsed?: string;
+    contextTokensUsed?: 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 { SKYKOIConfig } 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: SKYKOIConfig;
+    commandAuthorized: boolean;
+}): Promise<SessionInitResult>;

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

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

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

@@ -0,0 +1,10 @@
+import type { ReplyDirectiveParseResult } from "./reply-directives.js";
+type ConsumeOptions = {
+    final?: boolean;
+    silentToken?: string;
+};
+export declare function createStreamingDirectiveAccumulator(): {
+    consume: (raw: string, options?: ConsumeOptions) => ReplyDirectiveParseResult | null;
+    reset: () => void;
+};
+export {};

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

@@ -0,0 +1,9 @@
+import type { SubagentRunRecord } from "../../agents/subagent-registry.js";
+export declare function formatDurationShort(valueMs?: number): string;
+export declare function formatAgeShort(valueMs?: number): string;
+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";