pulseed 0.4.0 → 0.4.1

package/dist/runtime/schedule/presets.d.ts

@@ -0,0 +1,536 @@
+import { z } from "zod";
+import { type ScheduleEntryInput, type ScheduleTriggerInput } from "../types/schedule.js";
+type CreateScheduleEntryInput = Omit<ScheduleEntryInput, "id" | "created_at" | "updated_at" | "last_fired_at" | "next_fire_at" | "consecutive_failures" | "last_escalation_at" | "baseline_results" | "total_executions" | "total_tokens_used" | "max_tokens_per_day" | "tokens_used_today" | "budget_reset_at" | "escalation_timestamps">;
+export declare const DailyBriefPresetInputSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    trigger: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    }, {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"interval">;
+        seconds: z.ZodNumber;
+        jitter_factor: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    }, {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    }>]>>;
+} & {
+    preset: z.ZodLiteral<"daily_brief">;
+    context_sources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    context_sources: string[];
+    preset: "daily_brief";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    } | undefined;
+}, {
+    preset: "daily_brief";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    } | undefined;
+    enabled?: boolean | undefined;
+    context_sources?: string[] | undefined;
+}>;
+export declare const WeeklyReviewPresetInputSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    trigger: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    }, {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"interval">;
+        seconds: z.ZodNumber;
+        jitter_factor: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    }, {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    }>]>>;
+} & {
+    preset: z.ZodLiteral<"weekly_review">;
+    context_sources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    context_sources: string[];
+    preset: "weekly_review";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    } | undefined;
+}, {
+    preset: "weekly_review";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    } | undefined;
+    enabled?: boolean | undefined;
+    context_sources?: string[] | undefined;
+}>;
+export declare const DreamConsolidationPresetInputSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    trigger: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    }, {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"interval">;
+        seconds: z.ZodNumber;
+        jitter_factor: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    }, {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    }>]>>;
+} & {
+    preset: z.ZodLiteral<"dream_consolidation">;
+    context_sources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    context_sources: string[];
+    preset: "dream_consolidation";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    } | undefined;
+}, {
+    preset: "dream_consolidation";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    } | undefined;
+    enabled?: boolean | undefined;
+    context_sources?: string[] | undefined;
+}>;
+export declare const GoalProbePresetInputSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    trigger: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    }, {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"interval">;
+        seconds: z.ZodNumber;
+        jitter_factor: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    }, {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    }>]>>;
+} & {
+    preset: z.ZodLiteral<"goal_probe">;
+    data_source_id: z.ZodString;
+    probe_dimension: z.ZodOptional<z.ZodString>;
+    query_params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    detector_mode: z.ZodDefault<z.ZodEnum<["threshold", "diff", "presence"]>>;
+    threshold_value: z.ZodOptional<z.ZodNumber>;
+    baseline_window: z.ZodDefault<z.ZodNumber>;
+    llm_on_change: z.ZodDefault<z.ZodBoolean>;
+    llm_prompt_template: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    data_source_id: string;
+    query_params: Record<string, unknown>;
+    baseline_window: number;
+    llm_on_change: boolean;
+    preset: "goal_probe";
+    detector_mode: "threshold" | "diff" | "presence";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    } | undefined;
+    threshold_value?: number | undefined;
+    probe_dimension?: string | undefined;
+    llm_prompt_template?: string | undefined;
+}, {
+    data_source_id: string;
+    preset: "goal_probe";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    } | undefined;
+    threshold_value?: number | undefined;
+    enabled?: boolean | undefined;
+    probe_dimension?: string | undefined;
+    query_params?: Record<string, unknown> | undefined;
+    baseline_window?: number | undefined;
+    llm_on_change?: boolean | undefined;
+    llm_prompt_template?: string | undefined;
+    detector_mode?: "threshold" | "diff" | "presence" | undefined;
+}>;
+export declare const SchedulePresetInputSchema: z.ZodDiscriminatedUnion<"preset", [z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    trigger: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    }, {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"interval">;
+        seconds: z.ZodNumber;
+        jitter_factor: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    }, {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    }>]>>;
+} & {
+    preset: z.ZodLiteral<"daily_brief">;
+    context_sources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    context_sources: string[];
+    preset: "daily_brief";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    } | undefined;
+}, {
+    preset: "daily_brief";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    } | undefined;
+    enabled?: boolean | undefined;
+    context_sources?: string[] | undefined;
+}>, z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    trigger: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    }, {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"interval">;
+        seconds: z.ZodNumber;
+        jitter_factor: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    }, {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    }>]>>;
+} & {
+    preset: z.ZodLiteral<"weekly_review">;
+    context_sources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    context_sources: string[];
+    preset: "weekly_review";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    } | undefined;
+}, {
+    preset: "weekly_review";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    } | undefined;
+    enabled?: boolean | undefined;
+    context_sources?: string[] | undefined;
+}>, z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    trigger: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    }, {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"interval">;
+        seconds: z.ZodNumber;
+        jitter_factor: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    }, {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    }>]>>;
+} & {
+    preset: z.ZodLiteral<"dream_consolidation">;
+    context_sources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    context_sources: string[];
+    preset: "dream_consolidation";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    } | undefined;
+}, {
+    preset: "dream_consolidation";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    } | undefined;
+    enabled?: boolean | undefined;
+    context_sources?: string[] | undefined;
+}>, z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    trigger: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    }, {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"interval">;
+        seconds: z.ZodNumber;
+        jitter_factor: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    }, {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    }>]>>;
+} & {
+    preset: z.ZodLiteral<"goal_probe">;
+    data_source_id: z.ZodString;
+    probe_dimension: z.ZodOptional<z.ZodString>;
+    query_params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    detector_mode: z.ZodDefault<z.ZodEnum<["threshold", "diff", "presence"]>>;
+    threshold_value: z.ZodOptional<z.ZodNumber>;
+    baseline_window: z.ZodDefault<z.ZodNumber>;
+    llm_on_change: z.ZodDefault<z.ZodBoolean>;
+    llm_prompt_template: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    data_source_id: string;
+    query_params: Record<string, unknown>;
+    baseline_window: number;
+    llm_on_change: boolean;
+    preset: "goal_probe";
+    detector_mode: "threshold" | "diff" | "presence";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    } | undefined;
+    threshold_value?: number | undefined;
+    probe_dimension?: string | undefined;
+    llm_prompt_template?: string | undefined;
+}, {
+    data_source_id: string;
+    preset: "goal_probe";
+    name?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    } | undefined;
+    threshold_value?: number | undefined;
+    enabled?: boolean | undefined;
+    probe_dimension?: string | undefined;
+    query_params?: Record<string, unknown> | undefined;
+    baseline_window?: number | undefined;
+    llm_on_change?: boolean | undefined;
+    llm_prompt_template?: string | undefined;
+    detector_mode?: "threshold" | "diff" | "presence" | undefined;
+}>]>;
+export type SchedulePresetInput = z.input<typeof SchedulePresetInputSchema>;
+export type SchedulePresetKey = SchedulePresetInput["preset"];
+export interface SchedulePresetDefinition {
+    key: SchedulePresetKey;
+    title: string;
+    description: string;
+    defaultTrigger: ScheduleTriggerInput;
+    dependencyHints: string[];
+}
+export declare function listSchedulePresetDefinitions(): SchedulePresetDefinition[];
+export declare function getSchedulePresetDefinition(key: SchedulePresetKey): SchedulePresetDefinition;
+export declare function buildSchedulePresetEntry(input: SchedulePresetInput): CreateScheduleEntryInput;
+export {};
+//# sourceMappingURL=presets.d.ts.map

package/dist/runtime/schedule/presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../../src/runtime/schedule/presets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EAC1B,MAAM,sBAAsB,CAAC;AAE9B,KAAK,wBAAwB,GAAG,IAAI,CAClC,kBAAkB,EAChB,IAAI,GACJ,YAAY,GACZ,YAAY,GACZ,eAAe,GACf,cAAc,GACd,sBAAsB,GACtB,oBAAoB,GACpB,kBAAkB,GAClB,kBAAkB,GAClB,mBAAmB,GACnB,oBAAoB,GACpB,mBAAmB,GACnB,iBAAiB,GACjB,uBAAuB,CAC1B,CAAC;AAUF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxC,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG9C,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUrC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,MAAM,MAAM,iBAAiB,GAAG,mBAAmB,CAAC,QAAQ,CAAC,CAAC;AAE9D,MAAM,WAAW,wBAAwB;IACvC,GAAG,EAAE,iBAAiB,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,oBAAoB,CAAC;IACrC,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B;AAuCD,wBAAgB,6BAA6B,IAAI,wBAAwB,EAAE,CAM1E;AAED,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,iBAAiB,GAAG,wBAAwB,CAO5F;AAMD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,mBAAmB,GAAG,wBAAwB,CA2E7F"}

package/dist/runtime/schedule/presets.js

@@ -0,0 +1,166 @@
+import { z } from "zod";
+import { ScheduleTriggerSchema, } from "../types/schedule.js";
+const RecordSchema = z.record(z.string(), z.unknown());
+const SchedulePresetBaseSchema = z.object({
+    name: z.string().min(1).optional(),
+    enabled: z.boolean().default(true),
+    trigger: ScheduleTriggerSchema.optional(),
+});
+export const DailyBriefPresetInputSchema = SchedulePresetBaseSchema.extend({
+    preset: z.literal("daily_brief"),
+    context_sources: z.array(z.string()).default([]),
+});
+export const WeeklyReviewPresetInputSchema = SchedulePresetBaseSchema.extend({
+    preset: z.literal("weekly_review"),
+    context_sources: z.array(z.string()).default([]),
+});
+export const DreamConsolidationPresetInputSchema = SchedulePresetBaseSchema.extend({
+    preset: z.literal("dream_consolidation"),
+    context_sources: z.array(z.string()).default([]),
+});
+export const GoalProbePresetInputSchema = SchedulePresetBaseSchema.extend({
+    preset: z.literal("goal_probe"),
+    data_source_id: z.string().min(1),
+    probe_dimension: z.string().optional(),
+    query_params: RecordSchema.default({}),
+    detector_mode: z.enum(["threshold", "diff", "presence"]).default("diff"),
+    threshold_value: z.number().optional(),
+    baseline_window: z.number().int().min(1).default(5),
+    llm_on_change: z.boolean().default(true),
+    llm_prompt_template: z.string().optional(),
+});
+export const SchedulePresetInputSchema = z.discriminatedUnion("preset", [
+    DailyBriefPresetInputSchema,
+    WeeklyReviewPresetInputSchema,
+    DreamConsolidationPresetInputSchema,
+    GoalProbePresetInputSchema,
+]);
+const PRESET_DEFINITIONS = {
+    daily_brief: {
+        key: "daily_brief",
+        title: "Daily brief",
+        description: "Runs the morning planning reflection and delivers a concise daily briefing.",
+        defaultTrigger: { type: "cron", expression: "0 9 * * *", timezone: "UTC" },
+        dependencyHints: ["llm_client", "notification_dispatcher"],
+    },
+    weekly_review: {
+        key: "weekly_review",
+        title: "Weekly review",
+        description: "Runs the weekly reflection review and emits a report plus notification.",
+        defaultTrigger: { type: "cron", expression: "0 9 * * 1", timezone: "UTC" },
+        dependencyHints: ["llm_client", "notification_dispatcher"],
+    },
+    dream_consolidation: {
+        key: "dream_consolidation",
+        title: "Dream consolidation",
+        description: "Runs overnight consolidation for memory and stale knowledge cleanup.",
+        defaultTrigger: { type: "cron", expression: "0 2 * * *", timezone: "UTC" },
+        dependencyHints: ["memory_lifecycle", "knowledge_manager"],
+    },
+    goal_probe: {
+        key: "goal_probe",
+        title: "Goal probe",
+        description: "Polls a data source and triggers change detection for goal-relevant signals.",
+        defaultTrigger: { type: "interval", seconds: 3600, jitter_factor: 0 },
+        dependencyHints: ["data_source_registry"],
+    },
+};
+function cloneTrigger(trigger) {
+    return trigger.type === "cron"
+        ? { type: "cron", expression: trigger.expression, timezone: trigger.timezone ?? "UTC" }
+        : { type: "interval", seconds: trigger.seconds, jitter_factor: trigger.jitter_factor ?? 0 };
+}
+export function listSchedulePresetDefinitions() {
+    return Object.values(PRESET_DEFINITIONS).map((definition) => ({
+        ...definition,
+        defaultTrigger: cloneTrigger(definition.defaultTrigger),
+        dependencyHints: [...definition.dependencyHints],
+    }));
+}
+export function getSchedulePresetDefinition(key) {
+    const definition = PRESET_DEFINITIONS[key];
+    return {
+        ...definition,
+        defaultTrigger: cloneTrigger(definition.defaultTrigger),
+        dependencyHints: [...definition.dependencyHints],
+    };
+}
+function resolveTrigger(input) {
+    return input.trigger ? input.trigger : cloneTrigger(PRESET_DEFINITIONS[input.preset].defaultTrigger);
+}
+export function buildSchedulePresetEntry(input) {
+    const parsed = SchedulePresetInputSchema.parse(input);
+    const definition = PRESET_DEFINITIONS[parsed.preset];
+    const base = {
+        name: parsed.name ?? definition.title,
+        enabled: parsed.enabled,
+        trigger: resolveTrigger(parsed),
+        metadata: {
+            source: "preset",
+            preset_key: parsed.preset,
+            dependency_hints: [...definition.dependencyHints],
+        },
+    };
+    switch (parsed.preset) {
+        case "daily_brief":
+            return {
+                ...base,
+                layer: "cron",
+                cron: {
+                    job_kind: "reflection",
+                    reflection_kind: "morning_planning",
+                    prompt_template: "Run the daily brief reflection workflow.",
+                    context_sources: parsed.context_sources,
+                    output_format: "notification",
+                    report_type: "daily_brief",
+                    max_tokens: 1200,
+                },
+            };
+        case "weekly_review":
+            return {
+                ...base,
+                layer: "cron",
+                cron: {
+                    job_kind: "reflection",
+                    reflection_kind: "weekly_review",
+                    prompt_template: "Run the weekly review reflection workflow.",
+                    context_sources: parsed.context_sources,
+                    output_format: "both",
+                    report_type: "weekly_review",
+                    max_tokens: 2000,
+                },
+            };
+        case "dream_consolidation":
+            return {
+                ...base,
+                layer: "cron",
+                cron: {
+                    job_kind: "reflection",
+                    reflection_kind: "dream_consolidation",
+                    prompt_template: "Run the dream consolidation workflow.",
+                    context_sources: parsed.context_sources,
+                    output_format: "report",
+                    report_type: "dream_consolidation",
+                    max_tokens: 1200,
+                },
+            };
+        case "goal_probe":
+            return {
+                ...base,
+                layer: "probe",
+                probe: {
+                    data_source_id: parsed.data_source_id,
+                    probe_dimension: parsed.probe_dimension,
+                    query_params: parsed.query_params,
+                    change_detector: {
+                        mode: parsed.detector_mode,
+                        threshold_value: parsed.threshold_value,
+                        baseline_window: parsed.baseline_window,
+                    },
+                    llm_on_change: parsed.llm_on_change,
+                    llm_prompt_template: parsed.llm_prompt_template,
+                },
+            };
+    }
+}
+//# sourceMappingURL=presets.js.map