skykoi 2026.3.21 → 2026.3.23

package/dist/plugin-sdk/config/zod-schema.session.d.ts

@@ -0,0 +1,183 @@
+import { z } from "zod";
+export declare const SessionSendPolicySchema: z.ZodObject<{
+    default: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"allow">, z.ZodLiteral<"deny">]>>;
+    rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        action: z.ZodUnion<readonly [z.ZodLiteral<"allow">, z.ZodLiteral<"deny">]>;
+        match: z.ZodOptional<z.ZodObject<{
+            channel: z.ZodOptional<z.ZodString>;
+            chatType: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"direct">, z.ZodLiteral<"group">, z.ZodLiteral<"channel">]>>;
+            keyPrefix: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const SessionSchema: z.ZodOptional<z.ZodObject<{
+    scope: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"per-sender">, z.ZodLiteral<"global">]>>;
+    dmScope: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"main">, z.ZodLiteral<"per-peer">, z.ZodLiteral<"per-channel-peer">, z.ZodLiteral<"per-account-channel-peer">]>>;
+    identityLinks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    resetTriggers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    idleMinutes: z.ZodOptional<z.ZodNumber>;
+    reset: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"daily">, z.ZodLiteral<"idle">]>>;
+        atHour: z.ZodOptional<z.ZodNumber>;
+        idleMinutes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    resetByType: z.ZodOptional<z.ZodObject<{
+        dm: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"daily">, z.ZodLiteral<"idle">]>>;
+            atHour: z.ZodOptional<z.ZodNumber>;
+            idleMinutes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        group: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"daily">, z.ZodLiteral<"idle">]>>;
+            atHour: z.ZodOptional<z.ZodNumber>;
+            idleMinutes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        thread: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"daily">, z.ZodLiteral<"idle">]>>;
+            atHour: z.ZodOptional<z.ZodNumber>;
+            idleMinutes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    resetByChannel: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        mode: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"daily">, z.ZodLiteral<"idle">]>>;
+        atHour: z.ZodOptional<z.ZodNumber>;
+        idleMinutes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    store: z.ZodOptional<z.ZodString>;
+    typingIntervalSeconds: z.ZodOptional<z.ZodNumber>;
+    typingMode: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"never">, z.ZodLiteral<"instant">, z.ZodLiteral<"thinking">, z.ZodLiteral<"message">]>>;
+    mainKey: z.ZodOptional<z.ZodString>;
+    sendPolicy: z.ZodOptional<z.ZodObject<{
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"allow">, z.ZodLiteral<"deny">]>>;
+        rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            action: z.ZodUnion<readonly [z.ZodLiteral<"allow">, z.ZodLiteral<"deny">]>;
+            match: z.ZodOptional<z.ZodObject<{
+                channel: z.ZodOptional<z.ZodString>;
+                chatType: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"direct">, z.ZodLiteral<"group">, z.ZodLiteral<"channel">]>>;
+                keyPrefix: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    agentToAgent: z.ZodOptional<z.ZodObject<{
+        maxPingPongTurns: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const MessagesSchema: z.ZodOptional<z.ZodObject<{
+    messagePrefix: z.ZodOptional<z.ZodString>;
+    responsePrefix: z.ZodOptional<z.ZodString>;
+    groupChat: z.ZodOptional<z.ZodObject<{
+        mentionPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        historyLimit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    queue: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"steer">, z.ZodLiteral<"followup">, z.ZodLiteral<"collect">, z.ZodLiteral<"steer-backlog">, z.ZodLiteral<"steer+backlog">, z.ZodLiteral<"queue">, z.ZodLiteral<"interrupt">]>>;
+        byChannel: z.ZodOptional<z.ZodObject<{
+            whatsapp: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"steer">, z.ZodLiteral<"followup">, z.ZodLiteral<"collect">, z.ZodLiteral<"steer-backlog">, z.ZodLiteral<"steer+backlog">, z.ZodLiteral<"queue">, z.ZodLiteral<"interrupt">]>>;
+            telegram: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"steer">, z.ZodLiteral<"followup">, z.ZodLiteral<"collect">, z.ZodLiteral<"steer-backlog">, z.ZodLiteral<"steer+backlog">, z.ZodLiteral<"queue">, z.ZodLiteral<"interrupt">]>>;
+            discord: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"steer">, z.ZodLiteral<"followup">, z.ZodLiteral<"collect">, z.ZodLiteral<"steer-backlog">, z.ZodLiteral<"steer+backlog">, z.ZodLiteral<"queue">, z.ZodLiteral<"interrupt">]>>;
+            slack: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"steer">, z.ZodLiteral<"followup">, z.ZodLiteral<"collect">, z.ZodLiteral<"steer-backlog">, z.ZodLiteral<"steer+backlog">, z.ZodLiteral<"queue">, z.ZodLiteral<"interrupt">]>>;
+            mattermost: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"steer">, z.ZodLiteral<"followup">, z.ZodLiteral<"collect">, z.ZodLiteral<"steer-backlog">, z.ZodLiteral<"steer+backlog">, z.ZodLiteral<"queue">, z.ZodLiteral<"interrupt">]>>;
+            signal: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"steer">, z.ZodLiteral<"followup">, z.ZodLiteral<"collect">, z.ZodLiteral<"steer-backlog">, z.ZodLiteral<"steer+backlog">, z.ZodLiteral<"queue">, z.ZodLiteral<"interrupt">]>>;
+            imessage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"steer">, z.ZodLiteral<"followup">, z.ZodLiteral<"collect">, z.ZodLiteral<"steer-backlog">, z.ZodLiteral<"steer+backlog">, z.ZodLiteral<"queue">, z.ZodLiteral<"interrupt">]>>;
+            msteams: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"steer">, z.ZodLiteral<"followup">, z.ZodLiteral<"collect">, z.ZodLiteral<"steer-backlog">, z.ZodLiteral<"steer+backlog">, z.ZodLiteral<"queue">, z.ZodLiteral<"interrupt">]>>;
+            webchat: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"steer">, z.ZodLiteral<"followup">, z.ZodLiteral<"collect">, z.ZodLiteral<"steer-backlog">, z.ZodLiteral<"steer+backlog">, z.ZodLiteral<"queue">, z.ZodLiteral<"interrupt">]>>;
+        }, z.core.$strict>>;
+        debounceMs: z.ZodOptional<z.ZodNumber>;
+        debounceMsByChannel: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        cap: z.ZodOptional<z.ZodNumber>;
+        drop: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"old">, z.ZodLiteral<"new">, z.ZodLiteral<"summarize">]>>;
+    }, z.core.$strict>>;
+    inbound: z.ZodOptional<z.ZodObject<{
+        debounceMs: z.ZodOptional<z.ZodNumber>;
+        byChannel: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strict>>;
+    ackReaction: z.ZodOptional<z.ZodString>;
+    ackReactionScope: z.ZodOptional<z.ZodEnum<{
+        direct: "direct";
+        all: "all";
+        "group-mentions": "group-mentions";
+        "group-all": "group-all";
+    }>>;
+    removeAckAfterReply: z.ZodOptional<z.ZodBoolean>;
+    tts: z.ZodOptional<z.ZodObject<{
+        auto: z.ZodOptional<z.ZodEnum<{
+            off: "off";
+            always: "always";
+            inbound: "inbound";
+            tagged: "tagged";
+        }>>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            all: "all";
+            final: "final";
+        }>>;
+        provider: z.ZodOptional<z.ZodEnum<{
+            openai: "openai";
+            elevenlabs: "elevenlabs";
+            edge: "edge";
+        }>>;
+        summaryModel: z.ZodOptional<z.ZodString>;
+        modelOverrides: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            allowText: z.ZodOptional<z.ZodBoolean>;
+            allowProvider: z.ZodOptional<z.ZodBoolean>;
+            allowVoice: z.ZodOptional<z.ZodBoolean>;
+            allowModelId: z.ZodOptional<z.ZodBoolean>;
+            allowVoiceSettings: z.ZodOptional<z.ZodBoolean>;
+            allowNormalization: z.ZodOptional<z.ZodBoolean>;
+            allowSeed: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        elevenlabs: z.ZodOptional<z.ZodObject<{
+            apiKey: z.ZodOptional<z.ZodString>;
+            baseUrl: z.ZodOptional<z.ZodString>;
+            voiceId: z.ZodOptional<z.ZodString>;
+            modelId: z.ZodOptional<z.ZodString>;
+            seed: z.ZodOptional<z.ZodNumber>;
+            applyTextNormalization: z.ZodOptional<z.ZodEnum<{
+                off: "off";
+                auto: "auto";
+                on: "on";
+            }>>;
+            languageCode: z.ZodOptional<z.ZodString>;
+            voiceSettings: z.ZodOptional<z.ZodObject<{
+                stability: z.ZodOptional<z.ZodNumber>;
+                similarityBoost: z.ZodOptional<z.ZodNumber>;
+                style: z.ZodOptional<z.ZodNumber>;
+                useSpeakerBoost: z.ZodOptional<z.ZodBoolean>;
+                speed: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        openai: z.ZodOptional<z.ZodObject<{
+            apiKey: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            voice: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        edge: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            voice: z.ZodOptional<z.ZodString>;
+            lang: z.ZodOptional<z.ZodString>;
+            outputFormat: z.ZodOptional<z.ZodString>;
+            pitch: z.ZodOptional<z.ZodString>;
+            rate: z.ZodOptional<z.ZodString>;
+            volume: z.ZodOptional<z.ZodString>;
+            saveSubtitles: z.ZodOptional<z.ZodBoolean>;
+            proxy: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        prefsPath: z.ZodOptional<z.ZodString>;
+        maxTextLength: z.ZodOptional<z.ZodNumber>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const CommandsSchema: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+    native: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>>;
+    nativeSkills: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>>;
+    text: z.ZodOptional<z.ZodBoolean>;
+    bash: z.ZodOptional<z.ZodBoolean>;
+    bashForegroundMs: z.ZodOptional<z.ZodNumber>;
+    config: z.ZodOptional<z.ZodBoolean>;
+    debug: z.ZodOptional<z.ZodBoolean>;
+    restart: z.ZodOptional<z.ZodBoolean>;
+    useAccessGroups: z.ZodOptional<z.ZodBoolean>;
+    ownerAllowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+}, z.core.$strict>>>;

package/dist/plugin-sdk/cron/delivery.d.ts

@@ -0,0 +1,9 @@
+import type { CronDeliveryMode, CronJob, CronMessageChannel } from "./types.js";
+export type CronDeliveryPlan = {
+    mode: CronDeliveryMode;
+    channel: CronMessageChannel;
+    to?: string;
+    source: "delivery" | "payload";
+    requested: boolean;
+};
+export declare function resolveCronDeliveryPlan(job: CronJob): CronDeliveryPlan;

package/dist/plugin-sdk/cron/normalize.d.ts

@@ -0,0 +1,9 @@
+import type { CronJobCreate, CronJobPatch } from "./types.js";
+type UnknownRecord = Record<string, unknown>;
+type NormalizeOptions = {
+    applyDefaults?: boolean;
+};
+export declare function normalizeCronJobInput(raw: unknown, options?: NormalizeOptions): UnknownRecord | null;
+export declare function normalizeCronJobCreate(raw: unknown, options?: NormalizeOptions): CronJobCreate | null;
+export declare function normalizeCronJobPatch(raw: unknown, options?: NormalizeOptions): CronJobPatch | null;
+export {};

package/dist/plugin-sdk/cron/parse.d.ts

@@ -0,0 +1 @@
+export declare function parseAbsoluteTimeMs(input: string): number | null;

package/dist/plugin-sdk/cron/payload-migration.d.ts

@@ -0,0 +1,3 @@
+type UnknownRecord = Record<string, unknown>;
+export declare function migrateLegacyCronPayload(payload: UnknownRecord): boolean;
+export {};

package/dist/plugin-sdk/cron/schedule.d.ts

@@ -0,0 +1,2 @@
+import type { CronSchedule } from "./types.js";
+export declare function computeNextRunAtMs(schedule: CronSchedule, nowMs: number): number | undefined;

package/dist/plugin-sdk/cron/service/jobs.d.ts

@@ -0,0 +1,13 @@
+import type { CronJob, CronJobCreate, CronJobPatch } from "../types.js";
+import type { CronServiceState } from "./state.js";
+export declare function assertSupportedJobSpec(job: Pick<CronJob, "sessionTarget" | "payload">): void;
+export declare function findJobOrThrow(state: CronServiceState, id: string): CronJob;
+export declare function computeJobNextRunAtMs(job: CronJob, nowMs: number): number | undefined;
+export declare function recomputeNextRuns(state: CronServiceState): boolean;
+export declare function nextWakeAtMs(state: CronServiceState): number | undefined;
+export declare function createJob(state: CronServiceState, input: CronJobCreate): CronJob;
+export declare function applyJobPatch(job: CronJob, patch: CronJobPatch): void;
+export declare function isJobDue(job: CronJob, nowMs: number, opts: {
+    forced: boolean;
+}): boolean;
+export declare function resolveJobPayloadTextForMain(job: CronJob): string | undefined;

package/dist/plugin-sdk/cron/service/locked.d.ts

@@ -0,0 +1,2 @@
+import type { CronServiceState } from "./state.js";
+export declare function locked<T>(state: CronServiceState, fn: () => Promise<T>): Promise<T>;

package/dist/plugin-sdk/cron/service/normalize.d.ts

@@ -0,0 +1,17 @@
+import type { CronPayload } from "../types.js";
+export declare function normalizeRequiredName(raw: unknown): string;
+export declare function normalizeOptionalText(raw: unknown): string | undefined;
+export declare function normalizeOptionalAgentId(raw: unknown): string | undefined;
+export declare function inferLegacyName(job: {
+    schedule?: {
+        kind?: unknown;
+        everyMs?: unknown;
+        expr?: unknown;
+    };
+    payload?: {
+        kind?: unknown;
+        text?: unknown;
+        message?: unknown;
+    };
+}): string;
+export declare function normalizePayloadToSystemText(payload: CronPayload): string;

package/dist/plugin-sdk/cron/service/ops.d.ts

@@ -0,0 +1,43 @@
+import type { CronJobCreate, CronJobPatch } from "../types.js";
+import type { CronServiceState } from "./state.js";
+export declare function start(state: CronServiceState): Promise<void>;
+export declare function stop(state: CronServiceState): void;
+export declare function status(state: CronServiceState): Promise<{
+    enabled: boolean;
+    storePath: string;
+    jobs: number;
+    nextWakeAtMs: number | null;
+}>;
+export declare function list(state: CronServiceState, opts?: {
+    includeDisabled?: boolean;
+}): Promise<import("../types.js").CronJob[]>;
+export declare function add(state: CronServiceState, input: CronJobCreate): Promise<import("../types.js").CronJob>;
+export declare function update(state: CronServiceState, id: string, patch: CronJobPatch): Promise<import("../types.js").CronJob>;
+export declare function remove(state: CronServiceState, id: string): Promise<{
+    readonly ok: false;
+    readonly removed: false;
+} | {
+    readonly ok: true;
+    readonly removed: boolean;
+}>;
+export declare function run(state: CronServiceState, id: string, mode?: "due" | "force"): Promise<{
+    ok: boolean;
+    ran: boolean;
+    reason: "already-running";
+} | {
+    ok: boolean;
+    ran: boolean;
+    reason: "not-due";
+} | {
+    readonly ok: true;
+    readonly ran: true;
+    reason?: undefined;
+}>;
+export declare function wakeNow(state: CronServiceState, opts: {
+    mode: "now" | "next-heartbeat";
+    text: string;
+}): {
+    readonly ok: false;
+} | {
+    readonly ok: true;
+};

package/dist/plugin-sdk/cron/service/state.d.ts

@@ -0,0 +1,96 @@
+import type { HeartbeatRunResult } from "../../infra/heartbeat-wake.js";
+import type { CronJob, CronJobCreate, CronJobPatch, CronStoreFile } from "../types.js";
+export type CronEvent = {
+    jobId: string;
+    action: "added" | "updated" | "removed" | "started" | "finished";
+    runAtMs?: number;
+    durationMs?: number;
+    status?: "ok" | "error" | "skipped";
+    error?: string;
+    summary?: string;
+    sessionId?: string;
+    sessionKey?: string;
+    nextRunAtMs?: number;
+};
+export type Logger = {
+    debug: (obj: unknown, msg?: string) => void;
+    info: (obj: unknown, msg?: string) => void;
+    warn: (obj: unknown, msg?: string) => void;
+    error: (obj: unknown, msg?: string) => void;
+};
+export type CronServiceDeps = {
+    nowMs?: () => number;
+    log: Logger;
+    storePath: string;
+    cronEnabled: boolean;
+    enqueueSystemEvent: (text: string, opts?: {
+        agentId?: string;
+    }) => void;
+    requestHeartbeatNow: (opts?: {
+        reason?: string;
+    }) => void;
+    runHeartbeatOnce?: (opts?: {
+        reason?: string;
+    }) => Promise<HeartbeatRunResult>;
+    runIsolatedAgentJob: (params: {
+        job: CronJob;
+        message: string;
+    }) => Promise<{
+        status: "ok" | "error" | "skipped";
+        summary?: string;
+        /** Last non-empty agent text output (not truncated). */
+        outputText?: string;
+        error?: string;
+        sessionId?: string;
+        sessionKey?: string;
+    }>;
+    onEvent?: (evt: CronEvent) => void;
+};
+export type CronServiceDepsInternal = Omit<CronServiceDeps, "nowMs"> & {
+    nowMs: () => number;
+};
+export type CronServiceState = {
+    deps: CronServiceDepsInternal;
+    store: CronStoreFile | null;
+    timer: NodeJS.Timeout | null;
+    running: boolean;
+    op: Promise<unknown>;
+    warnedDisabled: boolean;
+    storeLoadedAtMs: number | null;
+    storeFileMtimeMs: number | null;
+};
+export declare function createCronServiceState(deps: CronServiceDeps): CronServiceState;
+export type CronRunMode = "due" | "force";
+export type CronWakeMode = "now" | "next-heartbeat";
+export type CronStatusSummary = {
+    enabled: boolean;
+    storePath: string;
+    jobs: number;
+    nextWakeAtMs: number | null;
+};
+export type CronRunResult = {
+    ok: true;
+    ran: true;
+} | {
+    ok: true;
+    ran: false;
+    reason: "not-due";
+} | {
+    ok: true;
+    ran: false;
+    reason: "already-running";
+} | {
+    ok: false;
+};
+export type CronRemoveResult = {
+    ok: true;
+    removed: boolean;
+} | {
+    ok: false;
+    removed: false;
+};
+export type CronAddResult = CronJob;
+export type CronUpdateResult = CronJob;
+export type CronListResult = CronJob[];
+export type CronAddInput = CronJobCreate;
+export type CronUpdateInput = CronJobPatch;

package/dist/plugin-sdk/cron/service/store.d.ts

@@ -0,0 +1,9 @@
+import type { CronServiceState } from "./state.js";
+export declare function ensureLoaded(state: CronServiceState, opts?: {
+    forceReload?: boolean;
+    /** Skip recomputing nextRunAtMs after load so the caller can run due
+     *  jobs against the persisted values first (see onTimer). */
+    skipRecompute?: boolean;
+}): Promise<void>;
+export declare function warnIfDisabled(state: CronServiceState, action: string): void;
+export declare function persist(state: CronServiceState): Promise<void>;

package/dist/plugin-sdk/cron/service/timer.d.ts

@@ -0,0 +1,23 @@
+import type { CronJob } from "../types.js";
+import type { CronEvent, CronServiceState } from "./state.js";
+export declare function armTimer(state: CronServiceState): void;
+export declare function onTimer(state: CronServiceState): Promise<void>;
+export declare function runMissedJobs(state: CronServiceState): Promise<void>;
+export declare function runDueJobs(state: CronServiceState): Promise<void>;
+/**
+ * Execute a job. This version is used by the `run` command and other
+ * places that need the full execution with state updates.
+ */
+export declare function executeJob(state: CronServiceState, job: CronJob, nowMs: number, opts: {
+    forced: boolean;
+}): Promise<void>;
+export declare function wake(state: CronServiceState, opts: {
+    mode: "now" | "next-heartbeat";
+    text: string;
+}): {
+    readonly ok: false;
+} | {
+    readonly ok: true;
+};
+export declare function stopTimer(state: CronServiceState): void;
+export declare function emit(state: CronServiceState, evt: CronEvent): void;

package/dist/plugin-sdk/cron/service.d.ts

@@ -0,0 +1,48 @@
+import type { CronJobCreate, CronJobPatch } from "./types.js";
+import { type CronServiceDeps } from "./service/state.js";
+export type { CronEvent, CronServiceDeps } from "./service/state.js";
+export declare class CronService {
+    private readonly state;
+    constructor(deps: CronServiceDeps);
+    start(): Promise<void>;
+    stop(): void;
+    status(): Promise<{
+        enabled: boolean;
+        storePath: string;
+        jobs: number;
+        nextWakeAtMs: number | null;
+    }>;
+    list(opts?: {
+        includeDisabled?: boolean;
+    }): Promise<import("./types.js").CronJob[]>;
+    add(input: CronJobCreate): Promise<import("./types.js").CronJob>;
+    update(id: string, patch: CronJobPatch): Promise<import("./types.js").CronJob>;
+    remove(id: string): Promise<{
+        readonly ok: false;
+        readonly removed: false;
+    } | {
+        readonly ok: true;
+        readonly removed: boolean;
+    }>;
+    run(id: string, mode?: "due" | "force"): Promise<{
+        ok: boolean;
+        ran: boolean;
+        reason: "already-running";
+    } | {
+        ok: boolean;
+        ran: boolean;
+        reason: "not-due";
+    } | {
+        readonly ok: true;
+        readonly ran: true;
+        reason?: undefined;
+    }>;
+    wake(opts: {
+        mode: "now" | "next-heartbeat";
+        text: string;
+    }): {
+        readonly ok: false;
+    } | {
+        readonly ok: true;
+    };
+}

package/dist/plugin-sdk/cron/store.d.ts

@@ -0,0 +1,6 @@
+import type { CronStoreFile } from "./types.js";
+export declare const DEFAULT_CRON_DIR: string;
+export declare const DEFAULT_CRON_STORE_PATH: string;
+export declare function resolveCronStorePath(storePath?: string): string;
+export declare function loadCronStore(storePath: string): Promise<CronStoreFile>;
+export declare function saveCronStore(storePath: string, store: CronStoreFile): Promise<void>;

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

@@ -0,0 +1,91 @@
+import type { ChannelId } from "../channels/plugins/types.js";
+export type CronSchedule = {
+    kind: "at";
+    at: string;
+} | {
+    kind: "every";
+    everyMs: number;
+    anchorMs?: number;
+} | {
+    kind: "cron";
+    expr: string;
+    tz?: string;
+};
+export type CronSessionTarget = "main" | "isolated";
+export type CronWakeMode = "next-heartbeat" | "now";
+export type CronMessageChannel = ChannelId | "last";
+export type CronDeliveryMode = "none" | "announce";
+export type CronDelivery = {
+    mode: CronDeliveryMode;
+    channel?: CronMessageChannel;
+    to?: string;
+    bestEffort?: boolean;
+};
+export type CronDeliveryPatch = Partial<CronDelivery>;
+export type CronPayload = {
+    kind: "systemEvent";
+    text: string;
+} | {
+    kind: "agentTurn";
+    message: string;
+    /** Optional model override (provider/model or alias). */
+    model?: string;
+    thinking?: string;
+    timeoutSeconds?: number;
+    allowUnsafeExternalContent?: boolean;
+    deliver?: boolean;
+    channel?: CronMessageChannel;
+    to?: string;
+    bestEffortDeliver?: boolean;
+};
+export type CronPayloadPatch = {
+    kind: "systemEvent";
+    text?: string;
+} | {
+    kind: "agentTurn";
+    message?: string;
+    model?: string;
+    thinking?: string;
+    timeoutSeconds?: number;
+    allowUnsafeExternalContent?: boolean;
+    deliver?: boolean;
+    channel?: CronMessageChannel;
+    to?: string;
+    bestEffortDeliver?: boolean;
+};
+export type CronJobState = {
+    nextRunAtMs?: number;
+    runningAtMs?: number;
+    lastRunAtMs?: number;
+    lastStatus?: "ok" | "error" | "skipped";
+    lastError?: string;
+    lastDurationMs?: number;
+};
+export type CronJob = {
+    id: string;
+    agentId?: string;
+    name: string;
+    description?: string;
+    enabled: boolean;
+    deleteAfterRun?: boolean;
+    createdAtMs: number;
+    updatedAtMs: number;
+    schedule: CronSchedule;
+    sessionTarget: CronSessionTarget;
+    wakeMode: CronWakeMode;
+    payload: CronPayload;
+    delivery?: CronDelivery;
+    state: CronJobState;
+};
+export type CronStoreFile = {
+    version: 1;
+    jobs: CronJob[];
+};
+export type CronJobCreate = Omit<CronJob, "id" | "createdAtMs" | "updatedAtMs" | "state"> & {
+    state?: Partial<CronJobState>;
+};
+export type CronJobPatch = Partial<Omit<CronJob, "id" | "createdAtMs" | "state" | "payload">> & {
+    payload?: CronPayloadPatch;
+    delivery?: CronDeliveryPatch;
+    state?: Partial<CronJobState>;
+};

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

@@ -0,0 +1,30 @@
+export declare const GATEWAY_LAUNCH_AGENT_LABEL = "ai.skykoi.gateway";
+export declare const GATEWAY_SYSTEMD_SERVICE_NAME = "SKYKOI-gateway";
+export declare const GATEWAY_WINDOWS_TASK_NAME = "SKYKOI Gateway";
+export declare const GATEWAY_SERVICE_MARKER = "skykoi";
+export declare const GATEWAY_SERVICE_KIND = "gateway";
+export declare const NODE_LAUNCH_AGENT_LABEL = "ai.skykoi.node";
+export declare const NODE_SYSTEMD_SERVICE_NAME = "SKYKOI-node";
+export declare const NODE_WINDOWS_TASK_NAME = "SKYKOI Node";
+export declare const NODE_SERVICE_MARKER = "skykoi";
+export declare const NODE_SERVICE_KIND = "node";
+export declare const NODE_WINDOWS_TASK_SCRIPT_NAME = "node.cmd";
+export declare const LEGACY_GATEWAY_LAUNCH_AGENT_LABELS: string[];
+export declare const LEGACY_GATEWAY_SYSTEMD_SERVICE_NAMES: string[];
+export declare const LEGACY_GATEWAY_WINDOWS_TASK_NAMES: string[];
+export declare function normalizeGatewayProfile(profile?: string): string | null;
+export declare function resolveGatewayProfileSuffix(profile?: string): string;
+export declare function resolveGatewayLaunchAgentLabel(profile?: string): string;
+export declare function resolveLegacyGatewayLaunchAgentLabels(profile?: string): string[];
+export declare function resolveGatewaySystemdServiceName(profile?: string): string;
+export declare function resolveGatewayWindowsTaskName(profile?: string): string;
+export declare function formatGatewayServiceDescription(params?: {
+    profile?: string;
+    version?: string;
+}): string;
+export declare function resolveNodeLaunchAgentLabel(): string;
+export declare function resolveNodeSystemdServiceName(): string;
+export declare function resolveNodeWindowsTaskName(): string;
+export declare function formatNodeServiceDescription(params?: {
+    version?: string;
+}): string;

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

@@ -0,0 +1,17 @@
+import type { SKYKOIConfig } from "../config/config.js";
+import type { DiscordAccountConfig } from "../config/types.js";
+export type ResolvedDiscordAccount = {
+    accountId: string;
+    enabled: boolean;
+    name?: string;
+    token: string;
+    tokenSource: "env" | "config" | "none";
+    config: DiscordAccountConfig;
+};
+export declare function listDiscordAccountIds(cfg: SKYKOIConfig): string[];
+export declare function resolveDefaultDiscordAccountId(cfg: SKYKOIConfig): string;
+export declare function resolveDiscordAccount(params: {
+    cfg: SKYKOIConfig;
+    accountId?: string | null;
+}): ResolvedDiscordAccount;
+export declare function listEnabledDiscordAccounts(cfg: SKYKOIConfig): ResolvedDiscordAccount[];

package/dist/plugin-sdk/discord/api.d.ts

@@ -0,0 +1,11 @@
+import { type RetryConfig } from "../infra/retry.js";
+export declare class DiscordApiError extends Error {
+    status: number;
+    retryAfter?: number;
+    constructor(message: string, status: number, retryAfter?: number);
+}
+export type DiscordFetchOptions = {
+    retry?: RetryConfig;
+    label?: string;
+};
+export declare function fetchDiscord<T>(path: string, token: string, fetcher?: typeof fetch, options?: DiscordFetchOptions): Promise<T>;