skykoi 2026.3.21 → 2026.3.23

package/dist/plugin-sdk/gateway/protocol/schema/wizard.d.ts

@@ -0,0 +1,86 @@
+export declare const WizardStartParamsSchema: import("@sinclair/typebox").TObject<{
+    mode: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"local">, import("@sinclair/typebox").TLiteral<"remote">]>>;
+    workspace: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const WizardAnswerSchema: import("@sinclair/typebox").TObject<{
+    stepId: import("@sinclair/typebox").TString;
+    value: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+}>;
+export declare const WizardNextParamsSchema: import("@sinclair/typebox").TObject<{
+    sessionId: import("@sinclair/typebox").TString;
+    answer: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        stepId: import("@sinclair/typebox").TString;
+        value: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+    }>>;
+}>;
+export declare const WizardCancelParamsSchema: import("@sinclair/typebox").TObject<{
+    sessionId: import("@sinclair/typebox").TString;
+}>;
+export declare const WizardStatusParamsSchema: import("@sinclair/typebox").TObject<{
+    sessionId: import("@sinclair/typebox").TString;
+}>;
+export declare const WizardStepOptionSchema: import("@sinclair/typebox").TObject<{
+    value: import("@sinclair/typebox").TUnknown;
+    label: import("@sinclair/typebox").TString;
+    hint: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const WizardStepSchema: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+    type: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"note">, import("@sinclair/typebox").TLiteral<"select">, import("@sinclair/typebox").TLiteral<"text">, import("@sinclair/typebox").TLiteral<"confirm">, import("@sinclair/typebox").TLiteral<"multiselect">, import("@sinclair/typebox").TLiteral<"progress">, import("@sinclair/typebox").TLiteral<"action">]>;
+    title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    message: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    options: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        value: import("@sinclair/typebox").TUnknown;
+        label: import("@sinclair/typebox").TString;
+        hint: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>>>;
+    initialValue: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+    placeholder: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    sensitive: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    executor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"gateway">, import("@sinclair/typebox").TLiteral<"client">]>>;
+}>;
+export declare const WizardNextResultSchema: import("@sinclair/typebox").TObject<{
+    done: import("@sinclair/typebox").TBoolean;
+    step: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        type: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"note">, import("@sinclair/typebox").TLiteral<"select">, import("@sinclair/typebox").TLiteral<"text">, import("@sinclair/typebox").TLiteral<"confirm">, import("@sinclair/typebox").TLiteral<"multiselect">, import("@sinclair/typebox").TLiteral<"progress">, import("@sinclair/typebox").TLiteral<"action">]>;
+        title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        message: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        options: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            value: import("@sinclair/typebox").TUnknown;
+            label: import("@sinclair/typebox").TString;
+            hint: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>>>;
+        initialValue: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+        placeholder: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        sensitive: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        executor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"gateway">, import("@sinclair/typebox").TLiteral<"client">]>>;
+    }>>;
+    status: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"running">, import("@sinclair/typebox").TLiteral<"done">, import("@sinclair/typebox").TLiteral<"cancelled">, import("@sinclair/typebox").TLiteral<"error">]>>;
+    error: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const WizardStartResultSchema: import("@sinclair/typebox").TObject<{
+    sessionId: import("@sinclair/typebox").TString;
+    done: import("@sinclair/typebox").TBoolean;
+    step: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        type: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"note">, import("@sinclair/typebox").TLiteral<"select">, import("@sinclair/typebox").TLiteral<"text">, import("@sinclair/typebox").TLiteral<"confirm">, import("@sinclair/typebox").TLiteral<"multiselect">, import("@sinclair/typebox").TLiteral<"progress">, import("@sinclair/typebox").TLiteral<"action">]>;
+        title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        message: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        options: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            value: import("@sinclair/typebox").TUnknown;
+            label: import("@sinclair/typebox").TString;
+            hint: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>>>;
+        initialValue: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
+        placeholder: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        sensitive: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        executor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"gateway">, import("@sinclair/typebox").TLiteral<"client">]>>;
+    }>>;
+    status: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"running">, import("@sinclair/typebox").TLiteral<"done">, import("@sinclair/typebox").TLiteral<"cancelled">, import("@sinclair/typebox").TLiteral<"error">]>>;
+    error: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const WizardStatusResultSchema: import("@sinclair/typebox").TObject<{
+    status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"running">, import("@sinclair/typebox").TLiteral<"done">, import("@sinclair/typebox").TLiteral<"cancelled">, import("@sinclair/typebox").TLiteral<"error">]>;
+    error: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;

package/dist/plugin-sdk/gateway/protocol/schema.d.ts

@@ -0,0 +1,16 @@
+export * from "./schema/agent.js";
+export * from "./schema/agents-models-skills.js";
+export * from "./schema/channels.js";
+export * from "./schema/config.js";
+export * from "./schema/cron.js";
+export * from "./schema/error-codes.js";
+export * from "./schema/exec-approvals.js";
+export * from "./schema/devices.js";
+export * from "./schema/frames.js";
+export * from "./schema/logs-chat.js";
+export * from "./schema/nodes.js";
+export * from "./schema/protocol-schemas.js";
+export * from "./schema/sessions.js";
+export * from "./schema/snapshot.js";
+export * from "./schema/types.js";
+export * from "./schema/wizard.js";

package/dist/plugin-sdk/gateway/server/ws-types.d.ts

@@ -0,0 +1,9 @@
+import type { WebSocket } from "ws";
+import type { ConnectParams } from "../protocol/index.js";
+export type GatewayWsClient = {
+    socket: WebSocket;
+    connect: ConnectParams;
+    connId: string;
+    presenceKey?: string;
+    clientIp?: string;
+};

package/dist/plugin-sdk/gateway/server-channels.d.ts

@@ -0,0 +1,24 @@
+import type { ChannelAccountSnapshot } from "../channels/plugins/types.js";
+import type { SKYKOIConfig } from "../config/config.js";
+import type { createSubsystemLogger } from "../logging/subsystem.js";
+import type { RuntimeEnv } from "../runtime.js";
+import { type ChannelId } from "../channels/plugins/index.js";
+export type ChannelRuntimeSnapshot = {
+    channels: Partial<Record<ChannelId, ChannelAccountSnapshot>>;
+    channelAccounts: Partial<Record<ChannelId, Record<string, ChannelAccountSnapshot>>>;
+};
+type SubsystemLogger = ReturnType<typeof createSubsystemLogger>;
+type ChannelManagerOptions = {
+    loadConfig: () => SKYKOIConfig;
+    channelLogs: Record<ChannelId, SubsystemLogger>;
+    channelRuntimeEnvs: Record<ChannelId, RuntimeEnv>;
+};
+export type ChannelManager = {
+    getRuntimeSnapshot: () => ChannelRuntimeSnapshot;
+    startChannels: () => Promise<void>;
+    startChannel: (channel: ChannelId, accountId?: string) => Promise<void>;
+    stopChannel: (channel: ChannelId, accountId?: string) => Promise<void>;
+    markChannelLoggedOut: (channelId: ChannelId, cleared: boolean, accountId?: string) => void;
+};
+export declare function createChannelManager(opts: ChannelManagerOptions): ChannelManager;
+export {};

package/dist/plugin-sdk/gateway/server-methods/types.d.ts

@@ -0,0 +1,96 @@
+import type { ModelCatalogEntry } from "../../agents/model-catalog.js";
+import type { createDefaultDeps } from "../../cli/deps.js";
+import type { HealthSummary } from "../../commands/health.js";
+import type { CronService } from "../../cron/service.js";
+import type { createSubsystemLogger } from "../../logging/subsystem.js";
+import type { WizardSession } from "../../wizard/session.js";
+import type { ChatAbortControllerEntry } from "../chat-abort.js";
+import type { NodeRegistry } from "../node-registry.js";
+import type { ConnectParams, ErrorShape, RequestFrame } from "../protocol/index.js";
+import type { ChannelRuntimeSnapshot } from "../server-channels.js";
+import type { DedupeEntry } from "../server-shared.js";
+type SubsystemLogger = ReturnType<typeof createSubsystemLogger>;
+export type GatewayClient = {
+    connect: ConnectParams;
+    connId?: string;
+};
+export type RespondFn = (ok: boolean, payload?: unknown, error?: ErrorShape, meta?: Record<string, unknown>) => void;
+export type GatewayRequestContext = {
+    deps: ReturnType<typeof createDefaultDeps>;
+    cron: CronService;
+    cronStorePath: string;
+    loadGatewayModelCatalog: () => Promise<ModelCatalogEntry[]>;
+    getHealthCache: () => HealthSummary | null;
+    refreshHealthSnapshot: (opts?: {
+        probe?: boolean;
+    }) => Promise<HealthSummary>;
+    logHealth: {
+        error: (message: string) => void;
+    };
+    logGateway: SubsystemLogger;
+    incrementPresenceVersion: () => number;
+    getHealthVersion: () => number;
+    broadcast: (event: string, payload: unknown, opts?: {
+        dropIfSlow?: boolean;
+        stateVersion?: {
+            presence?: number;
+            health?: number;
+        };
+    }) => void;
+    broadcastToConnIds: (event: string, payload: unknown, connIds: ReadonlySet<string>, opts?: {
+        dropIfSlow?: boolean;
+        stateVersion?: {
+            presence?: number;
+            health?: number;
+        };
+    }) => void;
+    nodeSendToSession: (sessionKey: string, event: string, payload: unknown) => void;
+    nodeSendToAllSubscribed: (event: string, payload: unknown) => void;
+    nodeSubscribe: (nodeId: string, sessionKey: string) => void;
+    nodeUnsubscribe: (nodeId: string, sessionKey: string) => void;
+    nodeUnsubscribeAll: (nodeId: string) => void;
+    hasConnectedMobileNode: () => boolean;
+    nodeRegistry: NodeRegistry;
+    agentRunSeq: Map<string, number>;
+    chatAbortControllers: Map<string, ChatAbortControllerEntry>;
+    chatAbortedRuns: Map<string, number>;
+    chatRunBuffers: Map<string, string>;
+    chatDeltaSentAt: Map<string, number>;
+    addChatRun: (sessionId: string, entry: {
+        sessionKey: string;
+        clientRunId: string;
+    }) => void;
+    removeChatRun: (sessionId: string, clientRunId: string, sessionKey?: string) => {
+        sessionKey: string;
+        clientRunId: string;
+    } | undefined;
+    registerToolEventRecipient: (runId: string, connId: string) => void;
+    dedupe: Map<string, DedupeEntry>;
+    wizardSessions: Map<string, WizardSession>;
+    findRunningWizard: () => string | null;
+    purgeWizardSession: (id: string) => void;
+    getRuntimeSnapshot: () => ChannelRuntimeSnapshot;
+    startChannel: (channel: import("../../channels/plugins/types.js").ChannelId, accountId?: string) => Promise<void>;
+    stopChannel: (channel: import("../../channels/plugins/types.js").ChannelId, accountId?: string) => Promise<void>;
+    markChannelLoggedOut: (channelId: import("../../channels/plugins/types.js").ChannelId, cleared: boolean, accountId?: string) => void;
+    wizardRunner: (opts: import("../../commands/onboard-types.js").OnboardOptions, runtime: import("../../runtime.js").RuntimeEnv, prompter: import("../../wizard/prompts.js").WizardPrompter) => Promise<void>;
+    broadcastVoiceWakeChanged: (triggers: string[]) => void;
+};
+export type GatewayRequestOptions = {
+    req: RequestFrame;
+    client: GatewayClient | null;
+    isWebchatConnect: (params: ConnectParams | null | undefined) => boolean;
+    respond: RespondFn;
+    context: GatewayRequestContext;
+};
+export type GatewayRequestHandlerOptions = {
+    req: RequestFrame;
+    params: Record<string, unknown>;
+    client: GatewayClient | null;
+    isWebchatConnect: (params: ConnectParams | null | undefined) => boolean;
+    respond: RespondFn;
+    context: GatewayRequestContext;
+};
+export type GatewayRequestHandler = (opts: GatewayRequestHandlerOptions) => Promise<void> | void;
+export type GatewayRequestHandlers = Record<string, GatewayRequestHandler>;
+export {};

package/dist/plugin-sdk/gateway/server-shared.d.ts

@@ -0,0 +1,7 @@
+import type { ErrorShape } from "./protocol/index.js";
+export type DedupeEntry = {
+    ts: number;
+    ok: boolean;
+    payload?: unknown;
+    error?: ErrorShape;
+};

package/dist/plugin-sdk/gateway/session-utils.d.ts

@@ -0,0 +1,53 @@
+import type { GatewayAgentRow, GatewaySessionRow, GatewaySessionsDefaults, SessionsListResult } from "./session-utils.types.js";
+import { type SKYKOIConfig } from "../config/config.js";
+import { type SessionEntry, type SessionScope } from "../config/sessions.js";
+export { archiveFileOnDisk, capArrayByJsonBytes, readFirstUserMessageFromTranscript, readLastMessagePreviewFromTranscript, readSessionPreviewItemsFromTranscript, readSessionMessages, resolveSessionTranscriptCandidates, } from "./session-utils.fs.js";
+export type { GatewayAgentRow, GatewaySessionRow, GatewaySessionsDefaults, SessionsListResult, SessionsPatchResult, SessionsPreviewEntry, SessionsPreviewResult, } from "./session-utils.types.js";
+export declare function deriveSessionTitle(entry: SessionEntry | undefined, firstUserMessage?: string | null): string | undefined;
+export declare function loadSessionEntry(sessionKey: string): {
+    cfg: SKYKOIConfig;
+    storePath: string;
+    store: Record<string, SessionEntry>;
+    entry: SessionEntry;
+    canonicalKey: string;
+};
+export declare function classifySessionKey(key: string, entry?: SessionEntry): GatewaySessionRow["kind"];
+export declare function parseGroupKey(key: string): {
+    channel?: string;
+    kind?: "group" | "channel";
+    id?: string;
+} | null;
+export declare function listAgentsForGateway(cfg: SKYKOIConfig): {
+    defaultId: string;
+    mainKey: string;
+    scope: SessionScope;
+    agents: GatewayAgentRow[];
+};
+export declare function resolveSessionStoreKey(params: {
+    cfg: SKYKOIConfig;
+    sessionKey: string;
+}): string;
+export declare function resolveGatewaySessionStoreTarget(params: {
+    cfg: SKYKOIConfig;
+    key: string;
+}): {
+    agentId: string;
+    storePath: string;
+    canonicalKey: string;
+    storeKeys: string[];
+};
+export declare function loadCombinedSessionStoreForGateway(cfg: SKYKOIConfig): {
+    storePath: string;
+    store: Record<string, SessionEntry>;
+};
+export declare function getSessionDefaults(cfg: SKYKOIConfig): GatewaySessionsDefaults;
+export declare function resolveSessionModelRef(cfg: SKYKOIConfig, entry?: SessionEntry, agentId?: string): {
+    provider: string;
+    model: string;
+};
+export declare function listSessionsFromStore(params: {
+    cfg: SKYKOIConfig;
+    storePath: string;
+    store: Record<string, SessionEntry>;
+    opts: import("./protocol/index.js").SessionsListParams;
+}): SessionsListResult;

package/dist/plugin-sdk/gateway/session-utils.fs.d.ts

@@ -0,0 +1,11 @@
+import type { SessionPreviewItem } from "./session-utils.types.js";
+export declare function readSessionMessages(sessionId: string, storePath: string | undefined, sessionFile?: string): unknown[];
+export declare function resolveSessionTranscriptCandidates(sessionId: string, storePath: string | undefined, sessionFile?: string, agentId?: string): string[];
+export declare function archiveFileOnDisk(filePath: string, reason: string): string;
+export declare function capArrayByJsonBytes<T>(items: T[], maxBytes: number): {
+    items: T[];
+    bytes: number;
+};
+export declare function readFirstUserMessageFromTranscript(sessionId: string, storePath: string | undefined, sessionFile?: string, agentId?: string): string | null;
+export declare function readLastMessagePreviewFromTranscript(sessionId: string, storePath: string | undefined, sessionFile?: string, agentId?: string): string | null;
+export declare function readSessionPreviewItemsFromTranscript(sessionId: string, storePath: string | undefined, sessionFile: string | undefined, agentId: string | undefined, maxItems: number, maxChars: number): SessionPreviewItem[];

package/dist/plugin-sdk/gateway/session-utils.types.d.ts

@@ -0,0 +1,83 @@
+import type { NormalizedChatType } from "../channels/chat-type.js";
+import type { SessionEntry } from "../config/sessions.js";
+import type { DeliveryContext } from "../utils/delivery-context.js";
+export type GatewaySessionsDefaults = {
+    modelProvider: string | null;
+    model: string | null;
+    contextTokens: number | null;
+};
+export type GatewaySessionRow = {
+    key: string;
+    kind: "direct" | "group" | "global" | "unknown";
+    label?: string;
+    displayName?: string;
+    derivedTitle?: string;
+    lastMessagePreview?: string;
+    channel?: string;
+    subject?: string;
+    groupChannel?: string;
+    space?: string;
+    chatType?: NormalizedChatType;
+    origin?: SessionEntry["origin"];
+    updatedAt: number | null;
+    sessionId?: string;
+    systemSent?: boolean;
+    abortedLastRun?: boolean;
+    thinkingLevel?: string;
+    verboseLevel?: string;
+    reasoningLevel?: string;
+    elevatedLevel?: string;
+    sendPolicy?: "allow" | "deny";
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    responseUsage?: "on" | "off" | "tokens" | "full";
+    modelProvider?: string;
+    model?: string;
+    contextTokens?: number;
+    deliveryContext?: DeliveryContext;
+    lastChannel?: SessionEntry["lastChannel"];
+    lastTo?: string;
+    lastAccountId?: string;
+};
+export type GatewayAgentRow = {
+    id: string;
+    name?: string;
+    identity?: {
+        name?: string;
+        theme?: string;
+        emoji?: string;
+        avatar?: string;
+        avatarUrl?: string;
+    };
+};
+export type SessionPreviewItem = {
+    role: "user" | "assistant" | "tool" | "system" | "other";
+    text: string;
+};
+export type SessionsPreviewEntry = {
+    key: string;
+    status: "ok" | "empty" | "missing" | "error";
+    items: SessionPreviewItem[];
+};
+export type SessionsPreviewResult = {
+    ts: number;
+    previews: SessionsPreviewEntry[];
+};
+export type SessionsListResult = {
+    ts: number;
+    path: string;
+    count: number;
+    defaults: GatewaySessionsDefaults;
+    sessions: GatewaySessionRow[];
+};
+export type SessionsPatchResult = {
+    ok: true;
+    path: string;
+    key: string;
+    entry: SessionEntry;
+    resolved?: {
+        modelProvider?: string;
+        model?: string;
+    };
+};

package/dist/plugin-sdk/globals.d.ts

@@ -0,0 +1,11 @@
+export declare function setVerbose(v: boolean): void;
+export declare function isVerbose(): boolean;
+export declare function shouldLogVerbose(): boolean;
+export declare function logVerbose(message: string): void;
+export declare function logVerboseConsole(message: string): void;
+export declare function setYes(v: boolean): void;
+export declare function isYes(): boolean;
+export declare const success: import("chalk").ChalkInstance;
+export declare const warn: import("chalk").ChalkInstance;
+export declare const info: import("chalk").ChalkInstance;
+export declare const danger: import("chalk").ChalkInstance;

package/dist/plugin-sdk/hooks/internal-hooks.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Hook system for SKYKOI agent events
+ *
+ * Provides an extensible event-driven hook system for agent events
+ * like command processing, session lifecycle, etc.
+ */
+import type { WorkspaceBootstrapFile } from "../agents/workspace.js";
+import type { SKYKOIConfig } from "../config/config.js";
+export type InternalHookEventType = "command" | "session" | "agent" | "gateway";
+export type AgentBootstrapHookContext = {
+    workspaceDir: string;
+    bootstrapFiles: WorkspaceBootstrapFile[];
+    cfg?: SKYKOIConfig;
+    sessionKey?: string;
+    sessionId?: string;
+    agentId?: string;
+};
+export type AgentBootstrapHookEvent = InternalHookEvent & {
+    type: "agent";
+    action: "bootstrap";
+    context: AgentBootstrapHookContext;
+};
+export interface InternalHookEvent {
+    /** The type of event (command, session, agent, gateway, etc.) */
+    type: InternalHookEventType;
+    /** The specific action within the type (e.g., 'new', 'reset', 'stop') */
+    action: string;
+    /** The session key this event relates to */
+    sessionKey: string;
+    /** Additional context specific to the event */
+    context: Record<string, unknown>;
+    /** Timestamp when the event occurred */
+    timestamp: Date;
+    /** Messages to send back to the user (hooks can push to this array) */
+    messages: string[];
+}
+export type InternalHookHandler = (event: InternalHookEvent) => Promise<void> | void;
+/**
+ * Register a hook handler for a specific event type or event:action combination
+ *
+ * @param eventKey - Event type (e.g., 'command') or specific action (e.g., 'command:new')
+ * @param handler - Function to call when the event is triggered
+ *
+ * @example
+ * ```ts
+ * // Listen to all command events
+ * registerInternalHook('command', async (event) => {
+ *   console.log('Command:', event.action);
+ * });
+ *
+ * // Listen only to /new commands
+ * registerInternalHook('command:new', async (event) => {
+ *   await saveSessionToMemory(event);
+ * });
+ * ```
+ */
+export declare function registerInternalHook(eventKey: string, handler: InternalHookHandler): void;
+/**
+ * Unregister a specific hook handler
+ *
+ * @param eventKey - Event key the handler was registered for
+ * @param handler - The handler function to remove
+ */
+export declare function unregisterInternalHook(eventKey: string, handler: InternalHookHandler): void;
+/**
+ * Clear all registered hooks (useful for testing)
+ */
+export declare function clearInternalHooks(): void;
+/**
+ * Get all registered event keys (useful for debugging)
+ */
+export declare function getRegisteredEventKeys(): string[];
+/**
+ * Trigger a hook event
+ *
+ * Calls all handlers registered for:
+ * 1. The general event type (e.g., 'command')
+ * 2. The specific event:action combination (e.g., 'command:new')
+ *
+ * Handlers are called in registration order. Errors are caught and logged
+ * but don't prevent other handlers from running.
+ *
+ * @param event - The event to trigger
+ */
+export declare function triggerInternalHook(event: InternalHookEvent): Promise<void>;
+/**
+ * Create a hook event with common fields filled in
+ *
+ * @param type - The event type
+ * @param action - The action within that type
+ * @param sessionKey - The session key
+ * @param context - Additional context
+ */
+export declare function createInternalHookEvent(type: InternalHookEventType, action: string, sessionKey: string, context?: Record<string, unknown>): InternalHookEvent;
+export declare function isAgentBootstrapEvent(event: InternalHookEvent): event is AgentBootstrapHookEvent;

package/dist/plugin-sdk/hooks/types.d.ts

@@ -0,0 +1,62 @@
+export type HookInstallSpec = {
+    id?: string;
+    kind: "bundled" | "npm" | "git";
+    label?: string;
+    package?: string;
+    repository?: string;
+    bins?: string[];
+};
+export type SKYKOIHookMetadata = {
+    always?: boolean;
+    hookKey?: string;
+    emoji?: string;
+    homepage?: string;
+    /** Events this hook handles (e.g., ["command:new", "session:start"]) */
+    events: string[];
+    /** Optional export name (default: "default") */
+    export?: string;
+    os?: string[];
+    requires?: {
+        bins?: string[];
+        anyBins?: string[];
+        env?: string[];
+        config?: string[];
+    };
+    install?: HookInstallSpec[];
+};
+export type HookInvocationPolicy = {
+    enabled: boolean;
+};
+export type ParsedHookFrontmatter = Record<string, string>;
+export type Hook = {
+    name: string;
+    description: string;
+    source: "SKYKOI-bundled" | "SKYKOI-managed" | "SKYKOI-workspace" | "SKYKOI-plugin";
+    pluginId?: string;
+    filePath: string;
+    baseDir: string;
+    handlerPath: string;
+};
+export type HookSource = Hook["source"];
+export type HookEntry = {
+    hook: Hook;
+    frontmatter: ParsedHookFrontmatter;
+    metadata?: SKYKOIHookMetadata;
+    invocation?: HookInvocationPolicy;
+};
+export type HookEligibilityContext = {
+    remote?: {
+        platforms: string[];
+        hasBin: (bin: string) => boolean;
+        hasAnyBin: (bins: string[]) => boolean;
+        note?: string;
+    };
+};
+export type HookSnapshot = {
+    hooks: Array<{
+        name: string;
+        events: string[];
+    }>;
+    resolvedHooks?: Hook[];
+    version?: number;
+};

package/dist/plugin-sdk/imessage/accounts.d.ts

@@ -0,0 +1,16 @@
+import type { SKYKOIConfig } from "../config/config.js";
+import type { IMessageAccountConfig } from "../config/types.js";
+export type ResolvedIMessageAccount = {
+    accountId: string;
+    enabled: boolean;
+    name?: string;
+    config: IMessageAccountConfig;
+    configured: boolean;
+};
+export declare function listIMessageAccountIds(cfg: SKYKOIConfig): string[];
+export declare function resolveDefaultIMessageAccountId(cfg: SKYKOIConfig): string;
+export declare function resolveIMessageAccount(params: {
+    cfg: SKYKOIConfig;
+    accountId?: string | null;
+}): ResolvedIMessageAccount;
+export declare function listEnabledIMessageAccounts(cfg: SKYKOIConfig): ResolvedIMessageAccount[];

package/dist/plugin-sdk/imessage/client.d.ts

@@ -0,0 +1,46 @@
+import type { RuntimeEnv } from "../runtime.js";
+export type IMessageRpcError = {
+    code?: number;
+    message?: string;
+    data?: unknown;
+};
+export type IMessageRpcResponse<T> = {
+    jsonrpc?: string;
+    id?: string | number | null;
+    result?: T;
+    error?: IMessageRpcError;
+    method?: string;
+    params?: unknown;
+};
+export type IMessageRpcNotification = {
+    method: string;
+    params?: unknown;
+};
+export type IMessageRpcClientOptions = {
+    cliPath?: string;
+    dbPath?: string;
+    runtime?: RuntimeEnv;
+    onNotification?: (msg: IMessageRpcNotification) => void;
+};
+export declare class IMessageRpcClient {
+    private readonly cliPath;
+    private readonly dbPath?;
+    private readonly runtime?;
+    private readonly onNotification?;
+    private readonly pending;
+    private readonly closed;
+    private closedResolve;
+    private child;
+    private reader;
+    private nextId;
+    constructor(opts?: IMessageRpcClientOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    waitForClose(): Promise<void>;
+    request<T = unknown>(method: string, params?: Record<string, unknown>, opts?: {
+        timeoutMs?: number;
+    }): Promise<T>;
+    private handleLine;
+    private failAll;
+}
+export declare function createIMessageRpcClient(opts?: IMessageRpcClientOptions): Promise<IMessageRpcClient>;

package/dist/plugin-sdk/imessage/constants.d.ts

@@ -0,0 +1,2 @@
+/** Default timeout for iMessage probe/RPC operations (10 seconds). */
+export declare const DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS = 10000;

package/dist/plugin-sdk/imessage/monitor/deliver.d.ts

@@ -0,0 +1,17 @@
+import type { ReplyPayload } from "../../auto-reply/types.js";
+import type { RuntimeEnv } from "../../runtime.js";
+import type { createIMessageRpcClient } from "../client.js";
+type SentMessageCache = {
+    remember: (scope: string, text: string) => void;
+};
+export declare function deliverReplies(params: {
+    replies: ReplyPayload[];
+    target: string;
+    client: Awaited<ReturnType<typeof createIMessageRpcClient>>;
+    accountId?: string;
+    runtime: RuntimeEnv;
+    maxBytes: number;
+    textLimit: number;
+    sentMessageCache?: SentMessageCache;
+}): Promise<void>;
+export {};

package/dist/plugin-sdk/imessage/monitor/monitor-provider.d.ts

@@ -0,0 +1,2 @@
+import type { MonitorIMessageOpts } from "./types.js";
+export declare function monitorIMessageProvider(opts?: MonitorIMessageOpts): Promise<void>;