@capybara-hq/kernel 0.1.0-rc.20 → 0.1.0-rc.22

package/dist/schedules/schedules.schemas.d.ts

@@ -0,0 +1,316 @@
+import { z } from "zod";
+import type { RouteSchemas } from "../platform/route-schemas.js";
+import type { CreateTaskInput, GrantInput, UpdateTaskInput } from "./scheduled-tasks.service.js";
+/** Longest task name and prompt, in characters (the same bounds as the service). */
+export declare const SCHEDULE_NAME_MAX = 200;
+export declare const SCHEDULE_PROMPT_MAX = 20000;
+/**
+ * When a task fires, before the zone is fixed: a 5-field cron, or a local date-time
+ * (`2026-12-01T09:00`, no offset) for a one-off run.
+ */
+export declare const ScheduleTriggerInput: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"cron">;
+    expr: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"once">;
+    at: z.ZodString;
+}, z.core.$strict>], "kind">;
+/** The IM chat a `chat`-mode task posts into. */
+export declare const ScheduleChatInput: z.ZodObject<{
+    connectionId: z.ZodString;
+    chatId: z.ZodString;
+    chatType: z.ZodEnum<{
+        dm: "dm";
+        group: "group";
+    }>;
+}, z.core.$strict>;
+/**
+ * A model pick: the same `{ provider, model }` an agent's definition uses, its strings bounded on
+ * the fields (so the JSON schema shows the bounds). `new` mode only.
+ */
+export declare const ScheduleModel: z.ZodObject<{
+    provider: z.ZodString;
+    model: z.ZodString;
+}, z.core.$strict>;
+export declare const ScheduleEffort: z.ZodEnum<{
+    high: "high";
+    low: "low";
+    max: "max";
+    medium: "medium";
+    xhigh: "xhigh";
+}>;
+/**
+ * A tool the creator pre-approves for the task, or a domain as `network:<host>` (network
+ * ask-to-allow spec §8.1: one exact host; a host name is at most 253 characters).
+ */
+export declare const ScheduleGrantInput: z.ZodObject<{
+    toolKey: z.ZodString;
+    connectorId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ScheduleCreateBody: z.ZodObject<{
+    agentId: z.ZodString;
+    name: z.ZodString;
+    prompt: z.ZodString;
+    trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"cron">;
+        expr: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"once">;
+        at: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    timeZone: z.ZodOptional<z.ZodString>;
+    mode: z.ZodEnum<{
+        chat: "chat";
+        conversation: "conversation";
+        new: "new";
+    }>;
+    conversationId: z.ZodOptional<z.ZodString>;
+    chat: z.ZodOptional<z.ZodObject<{
+        connectionId: z.ZodString;
+        chatId: z.ZodString;
+        chatType: z.ZodEnum<{
+            dm: "dm";
+            group: "group";
+        }>;
+    }, z.core.$strict>>;
+    model: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strict>>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        max: "max";
+        medium: "medium";
+        xhigh: "xhigh";
+    }>>;
+    deviceId: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    grants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        toolKey: z.ZodString;
+        connectorId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const ScheduleUpdateBody: z.ZodObject<{
+    agentId: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    trigger: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"cron">;
+        expr: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"once">;
+        at: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    timeZone: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        chat: "chat";
+        conversation: "conversation";
+        new: "new";
+    }>>;
+    conversationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    chat: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        connectionId: z.ZodString;
+        chatId: z.ZodString;
+        chatType: z.ZodEnum<{
+            dm: "dm";
+            group: "group";
+        }>;
+    }, z.core.$strict>>>;
+    model: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strict>>>;
+    effort: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        max: "max";
+        medium: "medium";
+        xhigh: "xhigh";
+    }>>>;
+    deviceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    expiresAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export declare const ScheduleListQuery: z.ZodObject<{
+    all: z.ZodOptional<z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>>;
+    conversationId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ScheduleChatTargetsQuery: z.ZodObject<{}, z.core.$strict>;
+export declare const ScheduleGrantableQuery: z.ZodObject<{
+    agentId: z.ZodString;
+}, z.core.$strict>;
+export declare const ScheduleParams: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const ScheduleRunBody: z.ZodObject<{
+    trial: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const ScheduleRunsQuery: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export declare const ScheduleGrantsBody: z.ZodObject<{
+    grants: z.ZodArray<z.ZodObject<{
+        toolKey: z.ZodString;
+        connectorId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const ScheduleGrantParams: z.ZodObject<{
+    id: z.ZodString;
+    toolKey: z.ZodString;
+}, z.core.$strip>;
+declare const ScheduleCreateBodyDto_base: import("../infra/validation/create-zod-dto.js").ZodDtoClass<z.ZodObject<{
+    agentId: z.ZodString;
+    name: z.ZodString;
+    prompt: z.ZodString;
+    trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"cron">;
+        expr: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"once">;
+        at: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    timeZone: z.ZodOptional<z.ZodString>;
+    mode: z.ZodEnum<{
+        chat: "chat";
+        conversation: "conversation";
+        new: "new";
+    }>;
+    conversationId: z.ZodOptional<z.ZodString>;
+    chat: z.ZodOptional<z.ZodObject<{
+        connectionId: z.ZodString;
+        chatId: z.ZodString;
+        chatType: z.ZodEnum<{
+            dm: "dm";
+            group: "group";
+        }>;
+    }, z.core.$strict>>;
+    model: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strict>>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        max: "max";
+        medium: "medium";
+        xhigh: "xhigh";
+    }>>;
+    deviceId: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    grants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        toolKey: z.ZodString;
+        connectorId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
+export declare class ScheduleCreateBodyDto extends ScheduleCreateBodyDto_base {
+}
+declare const ScheduleUpdateBodyDto_base: import("../infra/validation/create-zod-dto.js").ZodDtoClass<z.ZodObject<{
+    agentId: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    trigger: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"cron">;
+        expr: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"once">;
+        at: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    timeZone: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        chat: "chat";
+        conversation: "conversation";
+        new: "new";
+    }>>;
+    conversationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    chat: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        connectionId: z.ZodString;
+        chatId: z.ZodString;
+        chatType: z.ZodEnum<{
+            dm: "dm";
+            group: "group";
+        }>;
+    }, z.core.$strict>>>;
+    model: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strict>>>;
+    effort: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        max: "max";
+        medium: "medium";
+        xhigh: "xhigh";
+    }>>>;
+    deviceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    expiresAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>>;
+export declare class ScheduleUpdateBodyDto extends ScheduleUpdateBodyDto_base {
+}
+declare const ScheduleListQueryDto_base: import("../infra/validation/create-zod-dto.js").ZodDtoClass<z.ZodObject<{
+    all: z.ZodOptional<z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>>;
+    conversationId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
+export declare class ScheduleListQueryDto extends ScheduleListQueryDto_base {
+}
+declare const ScheduleChatTargetsQueryDto_base: import("../infra/validation/create-zod-dto.js").ZodDtoClass<z.ZodObject<{}, z.core.$strict>>;
+export declare class ScheduleChatTargetsQueryDto extends ScheduleChatTargetsQueryDto_base {
+}
+declare const ScheduleGrantableQueryDto_base: import("../infra/validation/create-zod-dto.js").ZodDtoClass<z.ZodObject<{
+    agentId: z.ZodString;
+}, z.core.$strict>>;
+export declare class ScheduleGrantableQueryDto extends ScheduleGrantableQueryDto_base {
+}
+declare const ScheduleParamsDto_base: import("../infra/validation/create-zod-dto.js").ZodDtoClass<z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>>;
+export declare class ScheduleParamsDto extends ScheduleParamsDto_base {
+}
+declare const ScheduleRunBodyDto_base: import("../infra/validation/create-zod-dto.js").ZodDtoClass<z.ZodObject<{
+    trial: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>>;
+export declare class ScheduleRunBodyDto extends ScheduleRunBodyDto_base {
+}
+declare const ScheduleRunsQueryDto_base: import("../infra/validation/create-zod-dto.js").ZodDtoClass<z.ZodObject<{
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>>;
+export declare class ScheduleRunsQueryDto extends ScheduleRunsQueryDto_base {
+}
+declare const ScheduleGrantsBodyDto_base: import("../infra/validation/create-zod-dto.js").ZodDtoClass<z.ZodObject<{
+    grants: z.ZodArray<z.ZodObject<{
+        toolKey: z.ZodString;
+        connectorId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare class ScheduleGrantsBodyDto extends ScheduleGrantsBodyDto_base {
+}
+declare const ScheduleGrantParamsDto_base: import("../infra/validation/create-zod-dto.js").ZodDtoClass<z.ZodObject<{
+    id: z.ZodString;
+    toolKey: z.ZodString;
+}, z.core.$strip>>;
+export declare class ScheduleGrantParamsDto extends ScheduleGrantParamsDto_base {
+}
+/** The schedule routes the Platform operations mirror (`check:platform-ops` keys). */
+export declare const SCHEDULE_ROUTES: readonly RouteSchemas[];
+/** The object without its undefined properties (the service's inputs take absent, not undefined). */
+export declare function defined<T extends object>(o: T): {
+    [K in keyof T]: Exclude<T[K], undefined>;
+};
+/** A grant list as the service's input. */
+export declare const grantsOf: (grants: z.infer<typeof ScheduleGrantsBody>["grants"]) => GrantInput[];
+/**
+ * A create body as the service's input. `timeZone` is the browser zone and is not part of it: the
+ * service uses it only when the account has no zone (spec §5), so it is returned separately.
+ */
+export declare function createInputOf(body: z.infer<typeof ScheduleCreateBody>): {
+    input: CreateTaskInput;
+    browserTimeZone: string | undefined;
+};
+/** A patch body as the service's input (an explicit `timeZone` changes the task's zone). */
+export declare function updateInputOf(body: z.infer<typeof ScheduleUpdateBody>): UpdateTaskInput;
+export {};

package/dist/schedules/schedules.schemas.js

@@ -0,0 +1,186 @@
+import { z } from "zod";
+import { createZodDto } from "../infra/validation/create-zod-dto.js";
+import { IanaTimeZone } from "../time-zone.js";
+/** Longest task name and prompt, in characters (the same bounds as the service). */
+export const SCHEDULE_NAME_MAX = 200;
+export const SCHEDULE_PROMPT_MAX = 20_000;
+const Id = z.string().min(1).max(100);
+/**
+ * When a task fires, before the zone is fixed: a 5-field cron, or a local date-time
+ * (`2026-12-01T09:00`, no offset) for a one-off run.
+ */
+export const ScheduleTriggerInput = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("cron"), expr: z.string().trim().min(1).max(200) }).strict(),
+    z.object({ kind: z.literal("once"), at: z.string().trim().min(1).max(40) }).strict(),
+]);
+/** The IM chat a `chat`-mode task posts into. */
+export const ScheduleChatInput = z
+    .object({
+    connectionId: Id,
+    chatId: z.string().min(1).max(500),
+    chatType: z.enum(["dm", "group"]),
+})
+    .strict();
+/**
+ * A model pick: the same `{ provider, model }` an agent's definition uses, its strings bounded on
+ * the fields (so the JSON schema shows the bounds). `new` mode only.
+ */
+export const ScheduleModel = z
+    .object({ provider: z.string().min(1).max(100), model: z.string().min(1).max(200) })
+    .strict();
+export const ScheduleEffort = z.enum(["low", "medium", "high", "xhigh", "max"]);
+/** An end time as an ISO 8601 timestamp with an offset (`2026-12-31T00:00:00Z`). */
+const ExpiresAt = z.string().datetime({ offset: true });
+/**
+ * A tool the creator pre-approves for the task, or a domain as `network:<host>` (network
+ * ask-to-allow spec §8.1: one exact host; a host name is at most 253 characters).
+ */
+export const ScheduleGrantInput = z
+    .object({ toolKey: z.string().trim().min(1).max(270), connectorId: Id.optional() })
+    .strict();
+const Name = z.string().trim().min(1).max(SCHEDULE_NAME_MAX);
+const Prompt = z.string().trim().min(1).max(SCHEDULE_PROMPT_MAX);
+const Mode = z.enum(["new", "conversation", "chat"]);
+export const ScheduleCreateBody = z
+    .object({
+    agentId: Id,
+    name: Name,
+    prompt: Prompt,
+    trigger: ScheduleTriggerInput,
+    /** The browser's zone: used only when the account has no zone of its own. */
+    timeZone: IanaTimeZone.optional(),
+    mode: Mode,
+    conversationId: Id.optional(),
+    chat: ScheduleChatInput.optional(),
+    /** `new` mode only, as `effort` and `deviceId` (a conversation or chat task uses its own). */
+    model: ScheduleModel.optional(),
+    effort: ScheduleEffort.optional(),
+    deviceId: Id.optional(),
+    expiresAt: ExpiresAt.nullable().optional(),
+    grants: z.array(ScheduleGrantInput).max(50).optional(),
+})
+    .strict();
+export const ScheduleUpdateBody = z
+    .object({
+    agentId: Id.optional(),
+    name: Name.optional(),
+    prompt: Prompt.optional(),
+    trigger: ScheduleTriggerInput.optional(),
+    /** The task's own zone (an explicit change). */
+    timeZone: IanaTimeZone.optional(),
+    mode: Mode.optional(),
+    conversationId: Id.nullable().optional(),
+    chat: ScheduleChatInput.nullable().optional(),
+    /** `new` mode only; switching to another mode clears them. */
+    model: ScheduleModel.nullable().optional(),
+    effort: ScheduleEffort.nullable().optional(),
+    deviceId: Id.nullable().optional(),
+    /** Null: the org's default expiry for a cron task (as on create), else never. */
+    expiresAt: ExpiresAt.nullable().optional(),
+})
+    .strict();
+export const ScheduleListQuery = z
+    .object({
+    all: z.enum(["true", "false"]).optional(),
+    /** Only the tasks that post into this conversation (the conversation's side panel). */
+    conversationId: Id.optional(),
+})
+    .strict();
+export const ScheduleChatTargetsQuery = z.object({}).strict();
+export const ScheduleGrantableQuery = z.object({ agentId: Id }).strict();
+export const ScheduleParams = z.object({ id: Id });
+export const ScheduleRunBody = z.object({ trial: z.boolean().optional() }).strict();
+export const ScheduleRunsQuery = z
+    .object({ limit: z.coerce.number().int().min(1).max(200).optional() })
+    .strict();
+export const ScheduleGrantsBody = z
+    .object({ grants: z.array(ScheduleGrantInput).min(1).max(50) })
+    .strict();
+export const ScheduleGrantParams = z.object({ id: Id, toolKey: z.string().min(1).max(270) });
+export class ScheduleCreateBodyDto extends createZodDto(ScheduleCreateBody, "ScheduleCreateBody") {
+}
+export class ScheduleUpdateBodyDto extends createZodDto(ScheduleUpdateBody, "ScheduleUpdateBody") {
+}
+export class ScheduleListQueryDto extends createZodDto(ScheduleListQuery, "ScheduleListQuery") {
+}
+export class ScheduleChatTargetsQueryDto extends createZodDto(ScheduleChatTargetsQuery, "ScheduleChatTargetsQuery") {
+}
+export class ScheduleGrantableQueryDto extends createZodDto(ScheduleGrantableQuery, "ScheduleGrantableQuery") {
+}
+export class ScheduleParamsDto extends createZodDto(ScheduleParams, "ScheduleParams") {
+}
+export class ScheduleRunBodyDto extends createZodDto(ScheduleRunBody, "ScheduleRunBody") {
+}
+export class ScheduleRunsQueryDto extends createZodDto(ScheduleRunsQuery, "ScheduleRunsQuery") {
+}
+export class ScheduleGrantsBodyDto extends createZodDto(ScheduleGrantsBody, "ScheduleGrantsBody") {
+}
+export class ScheduleGrantParamsDto extends createZodDto(ScheduleGrantParams, "ScheduleGrantParams") {
+}
+/** The schedule routes the Platform operations mirror (`check:platform-ops` keys). */
+export const SCHEDULE_ROUTES = [
+    { route: "GET /api/v1/orgs/:orgId/schedules", query: ScheduleListQuery },
+    { route: "GET /api/v1/orgs/:orgId/schedules/chat-targets", query: ScheduleChatTargetsQuery },
+    { route: "GET /api/v1/orgs/:orgId/schedules/grantable-tools", query: ScheduleGrantableQuery },
+    { route: "POST /api/v1/orgs/:orgId/schedules", body: ScheduleCreateBody },
+    { route: "GET /api/v1/orgs/:orgId/schedules/:id", params: ScheduleParams },
+    {
+        route: "PATCH /api/v1/orgs/:orgId/schedules/:id",
+        params: ScheduleParams,
+        body: ScheduleUpdateBody,
+    },
+    { route: "DELETE /api/v1/orgs/:orgId/schedules/:id", params: ScheduleParams },
+    { route: "POST /api/v1/orgs/:orgId/schedules/:id/pause", params: ScheduleParams },
+    { route: "POST /api/v1/orgs/:orgId/schedules/:id/resume", params: ScheduleParams },
+    {
+        route: "POST /api/v1/orgs/:orgId/schedules/:id/run",
+        params: ScheduleParams,
+        body: ScheduleRunBody,
+    },
+    {
+        route: "GET /api/v1/orgs/:orgId/schedules/:id/runs",
+        params: ScheduleParams,
+        query: ScheduleRunsQuery,
+    },
+    { route: "GET /api/v1/orgs/:orgId/schedules/:id/grants", params: ScheduleParams },
+    {
+        route: "POST /api/v1/orgs/:orgId/schedules/:id/grants",
+        params: ScheduleParams,
+        body: ScheduleGrantsBody,
+    },
+    {
+        route: "DELETE /api/v1/orgs/:orgId/schedules/:id/grants/:toolKey",
+        params: ScheduleGrantParams,
+    },
+];
+/** The object without its undefined properties (the service's inputs take absent, not undefined). */
+export function defined(o) {
+    return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== undefined));
+}
+/** A grant list as the service's input. */
+export const grantsOf = (grants) => grants.map((g) => defined(g));
+/**
+ * A create body as the service's input. `timeZone` is the browser zone and is not part of it: the
+ * service uses it only when the account has no zone (spec §5), so it is returned separately.
+ */
+export function createInputOf(body) {
+    const { timeZone, expiresAt, grants, ...rest } = body;
+    return {
+        input: {
+            ...defined(rest),
+            ...(expiresAt !== undefined && {
+                expiresAt: expiresAt === null ? null : new Date(expiresAt),
+            }),
+            ...(grants !== undefined && { grants: grantsOf(grants) }),
+        },
+        browserTimeZone: timeZone,
+    };
+}
+/** A patch body as the service's input (an explicit `timeZone` changes the task's zone). */
+export function updateInputOf(body) {
+    const { expiresAt, ...rest } = body;
+    return {
+        ...defined(rest),
+        ...(expiresAt !== undefined && { expiresAt: expiresAt === null ? null : new Date(expiresAt) }),
+    };
+}

package/dist/schedules/store.d.ts

@@ -0,0 +1,81 @@
+import type { KernelSchemaDb } from "../db/kernel-schema.js";
+import type { ScheduledTask, ScheduledTaskGrant, TaskRun, TaskRunStatus } from "./types.js";
+/** What a caller supplies to create a task; the counters, pause fields and timestamps default. */
+export type ScheduledTaskInsert = Omit<ScheduledTask, "pauseReason" | "pausedBy" | "consecutiveFailures" | "createdAt" | "updatedAt">;
+/** The fields a task update may change (`updated_at` is always refreshed). */
+export type ScheduledTaskPatch = Partial<Omit<ScheduledTask, "id" | "orgId" | "accountId" | "createdAt" | "updatedAt">>;
+/** What a caller supplies to create a task run; it starts `pending`. */
+export interface TaskRunInsert {
+    id: string;
+    taskId: string;
+    orgId: string;
+    scheduledFor: Date;
+    trial: boolean;
+    /** A person's "run now" (default false: a tick of the schedule). */
+    manual?: boolean;
+    status?: TaskRunStatus;
+    skipReason?: TaskRun["skipReason"];
+    firedAt?: Date | null;
+    conversationId?: string | null;
+}
+export type TaskRunPatch = Partial<Omit<TaskRun, "id" | "taskId" | "orgId" | "trial" | "manual">>;
+/**
+ * Scheduled tasks, their runs and grants (spec §4): reads and writes rows only. Every method takes
+ * the database handle first so the caller decides the transaction (the scanner's `lockDue` and
+ * `insertRun` run in one, under the rows' locks).
+ */
+export declare class ScheduledTaskStore {
+    insertTask(t: KernelSchemaDb, task: ScheduledTaskInsert): Promise<ScheduledTask>;
+    /** A live (not deleted) task of the org; null when missing, deleted or in another org. */
+    getTask(t: KernelSchemaDb, orgId: string, id: string): Promise<ScheduledTask | null>;
+    /**
+     * {@link getTask} under `FOR UPDATE` (call it inside a transaction): a person's write holds the
+     * row, so the scanner's `lockDue` skips it until the write commits.
+     */
+    lockTask(t: KernelSchemaDb, orgId: string, id: string): Promise<ScheduledTask | null>;
+    /** Patches a live task; null when it is missing or deleted. */
+    updateTask(t: KernelSchemaDb, id: string, patch: ScheduledTaskPatch): Promise<ScheduledTask | null>;
+    /** Deletes a task softly: hidden from every read and never due again. */
+    softDelete(t: KernelSchemaDb, id: string): Promise<boolean>;
+    /** A creator's live tasks, newest first. */
+    listForAccount(t: KernelSchemaDb, orgId: string, accountId: string): Promise<ScheduledTask[]>;
+    /** Every live task of the org, newest first. */
+    listForOrg(t: KernelSchemaDb, orgId: string): Promise<ScheduledTask[]>;
+    /** Live tasks that count against the caps (`active` and `paused`), of the org or one creator. */
+    countActive(t: KernelSchemaDb, orgId: string, accountId?: string): Promise<number>;
+    /**
+     * Locks up to `limit` due tasks (active, live, `next_run_at <= now`), oldest first, skipping
+     * rows another transaction holds (`FOR UPDATE SKIP LOCKED`). Call it inside a transaction: the
+     * locks last until it ends.
+     */
+    lockDue(t: KernelSchemaDb, now: Date, limit: number): Promise<ScheduledTask[]>;
+    /**
+     * Inserts a task run; null when a non-trial run for the same tick already exists (the
+     * exactly-once guard, `UNIQUE (task_id, scheduled_for) WHERE NOT trial`).
+     */
+    insertRun(t: KernelSchemaDb, run: TaskRunInsert): Promise<TaskRun | null>;
+    /** Patches a task run; null when it does not exist. */
+    updateRun(t: KernelSchemaDb, id: string, patch: TaskRunPatch): Promise<TaskRun | null>;
+    /**
+     * The task's latest run still `pending` or `running` (the overlap check), other than `exceptId`
+     * (the run being fired); null when none.
+     */
+    latestNonTerminalRun(t: KernelSchemaDb, taskId: string, exceptId?: string): Promise<TaskRun | null>;
+    /**
+     * Runs of the org fired at or after `since` (the `maxRunsPerHour` count; trial runs included,
+     * skipped runs not: a run whose queued message a person removed was never run).
+     */
+    countFiredSince(t: KernelSchemaDb, orgId: string, since: Date): Promise<number>;
+    /** A task's runs, latest tick first. */
+    listRuns(t: KernelSchemaDb, taskId: string, limit: number): Promise<TaskRun[]>;
+    listGrants(t: KernelSchemaDb, taskId: string): Promise<ScheduledTaskGrant[]>;
+    /** Adds a grant, replacing the task's grant of the same tool key. */
+    addGrant(t: KernelSchemaDb, taskId: string, grant: ScheduledTaskGrant): Promise<void>;
+    removeGrant(t: KernelSchemaDb, taskId: string, toolKey: string): Promise<boolean>;
+}
+/**
+ * Whether the task holds a grant for this tool as defined now: same key, same spec hash, same
+ * connector (null for plugin and builtin tools). A grant of an older definition does not count.
+ * A plain function too, for the tool policy (`createDecidePolicy`), which is not a provider.
+ */
+export declare function findTaskGrant(t: KernelSchemaDb, taskId: string, toolKey: string, specHash: string, connectorId: string | null): Promise<boolean>;