@hachej/boring-automation 0.1.71 → 0.1.80

package/dist/front/index.js

@@ -2,7 +2,7 @@
 
 // src/front/index.tsx
 import { definePlugin } from "@hachej/boring-workspace/plugin";
-import { CalendarClock } from "lucide-react";
+import { CalendarClock as CalendarClock2 } from "lucide-react";
 
 // src/shared/constants.ts
 var BORING_AUTOMATION_PLUGIN_ID = "boring-automation";
@@ -12,12 +12,110 @@ var BORING_AUTOMATION_ROUTE_PREFIX = "/api/v1/boring-automation";
 // src/shared/error-codes.ts
 var BORING_AUTOMATION_ERROR_CODES = {
   INVALID_BODY: "BORING_AUTOMATION_INVALID_BODY",
+  INVALID_CRON: "BORING_AUTOMATION_INVALID_CRON",
+  INVALID_TIMEZONE: "BORING_AUTOMATION_INVALID_TIMEZONE",
+  INVALID_MODEL: "BORING_AUTOMATION_INVALID_MODEL",
   AUTOMATION_NOT_FOUND: "BORING_AUTOMATION_NOT_FOUND",
-  RUN_NOT_FOUND: "BORING_AUTOMATION_RUN_NOT_FOUND"
+  RUN_NOT_FOUND: "BORING_AUTOMATION_RUN_NOT_FOUND",
+  RUN_ALREADY_ACTIVE: "BORING_AUTOMATION_RUN_ALREADY_ACTIVE",
+  RUN_ALREADY_RECORDED: "BORING_AUTOMATION_RUN_ALREADY_RECORDED",
+  RUN_EXECUTOR_UNAVAILABLE: "BORING_AUTOMATION_RUN_EXECUTOR_UNAVAILABLE",
+  TRIGGER_FORBIDDEN: "BORING_AUTOMATION_TRIGGER_FORBIDDEN",
+  RUN_FAILED: "BORING_AUTOMATION_RUN_FAILED"
 };
 
 // src/shared/schema.ts
 import { z } from "zod";
+
+// src/shared/schedule.ts
+import { Cron } from "croner";
+var AUTOMATION_SCHEDULE_ERRORS = {
+  INVALID_CRON: "Invalid cron schedule. Use exactly five fields, for example 0 9 * * *.",
+  INVALID_TIMEZONE: "Invalid timezone. Use a valid IANA timezone, for example UTC or America/New_York."
+};
+function validateAutomationSchedule(cron, timezone) {
+  const errors = {};
+  if (!isValidFiveFieldCron(cron)) errors.cron = AUTOMATION_SCHEDULE_ERRORS.INVALID_CRON;
+  if (!isValidIanaTimeZone(timezone)) errors.timezone = AUTOMATION_SCHEDULE_ERRORS.INVALID_TIMEZONE;
+  return { ok: Object.keys(errors).length === 0, errors };
+}
+function isValidFiveFieldCron(cron) {
+  const normalized = normalizeSpace(cron);
+  if (!normalized || normalized.split(" ").length !== 5) return false;
+  try {
+    new Cron(normalized);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidIanaTimeZone(timezone) {
+  const normalized = timezone.trim();
+  if (!normalized) return false;
+  try {
+    const resolved = new Intl.DateTimeFormat("en-US", { timeZone: normalized }).resolvedOptions().timeZone;
+    return resolved === "UTC" || resolved.includes("/");
+  } catch {
+    return false;
+  }
+}
+function evaluateAutomationSchedule(input) {
+  const now = new Date(input.now);
+  const scheduledFor = floorToMinute(now).toISOString();
+  const runs = [...input.runs];
+  const decisions = input.automations.map((automation) => {
+    const validation = validateAutomationSchedule(automation.cron, automation.timezone);
+    if (validation.errors.cron) return skip(automation, null, "invalid-cron", validation.errors.cron);
+    if (validation.errors.timezone) return skip(automation, null, "invalid-timezone", validation.errors.timezone);
+    if (!automation.enabled) return skip(automation, null, "disabled", "Automation is disabled.");
+    const cron = new Cron(normalizeSpace(automation.cron), { timezone: automation.timezone.trim() });
+    if (!cron.match(new Date(scheduledFor))) {
+      return skip(automation, null, "not-current-minute", "Automation is not scheduled for the current minute.");
+    }
+    if (hasDuplicateScheduledRun(runs, automation.id, scheduledFor)) {
+      return skip(automation, scheduledFor, "duplicate-scheduled-run", "A run already exists for this scheduled minute.");
+    }
+    if (hasActiveRun(runs, automation.id)) {
+      return skip(automation, scheduledFor, "active-run", "Automation already has a queued or running run.");
+    }
+    return {
+      kind: "due",
+      automation,
+      automationId: automation.id,
+      scheduledFor,
+      reason: "current-minute-matched"
+    };
+  }).sort(compareScheduleDecisions);
+  return { decisions, due: decisions.filter((decision) => decision.kind === "due") };
+}
+function skip(automation, scheduledFor, reason, message) {
+  return { kind: "skip", automation, automationId: automation.id, scheduledFor, reason, message };
+}
+function hasDuplicateScheduledRun(runs, automationId, scheduledFor) {
+  return runs.some((run) => run.automationId === automationId && run.trigger === "scheduled" && run.scheduledFor === scheduledFor);
+}
+function hasActiveRun(runs, automationId) {
+  return runs.some((run) => run.automationId === automationId && (run.status === "queued" || run.status === "running"));
+}
+function floorToMinute(date) {
+  const next = new Date(date);
+  next.setUTCSeconds(0, 0);
+  return next;
+}
+function normalizeSpace(value) {
+  return value.trim().replace(/\s+/g, " ");
+}
+function compareScheduleDecisions(a, b) {
+  return compareNullableString(a.scheduledFor, b.scheduledFor) || a.automationId.localeCompare(b.automationId);
+}
+function compareNullableString(a, b) {
+  if (a === b) return 0;
+  if (a === null) return 1;
+  if (b === null) return -1;
+  return a.localeCompare(b);
+}
+
+// src/shared/schema.ts
 var nonEmptyString = z.string().trim().min(1);
 var isoString = z.string().datetime({ offset: true });
 var nonNegativeInteger = z.number().int().nonnegative();
@@ -30,37 +128,32 @@ var AutomationCreateSchema = z.object({
   timezone: nonEmptyString,
   model: nonEmptyString,
   prompt: z.string().optional()
-}).strict();
+}).strict().superRefine((value, ctx) => {
+  addScheduleIssues(ctx, value);
+});
 var AutomationPatchSchema = z.object({
   title: nonEmptyString.optional(),
   enabled: z.boolean().optional(),
   cron: nonEmptyString.optional(),
   timezone: nonEmptyString.optional(),
   model: nonEmptyString.optional()
-}).strict().refine((value) => Object.keys(value).length > 0, "at least one field must be provided");
+}).strict().refine((value) => Object.keys(value).length > 0, "at least one field must be provided").superRefine((value, ctx) => {
+  addScheduleIssues(ctx, value);
+});
 var PromptUpdateSchema = z.object({
   prompt: z.string()
 }).strict();
-var AutomationRunCreateSchema = z.object({
+var AutomationRunBeginSchema = z.object({
   automationId: nonEmptyString,
-  sessionId: nonEmptyString.nullable().optional(),
-  status: AutomationRunStatusSchema.optional(),
   trigger: AutomationRunTriggerSchema,
   scheduledFor: isoString.nullable().optional(),
-  startedAt: isoString.nullable().optional(),
-  completedAt: isoString.nullable().optional(),
-  durationMs: nonNegativeInteger.nullable().optional(),
-  inputTokens: nonNegativeInteger.nullable().optional(),
-  outputTokens: nonNegativeInteger.nullable().optional(),
-  totalTokens: nonNegativeInteger.nullable().optional(),
   promptSnapshot: z.string(),
   modelSnapshot: nonEmptyString,
-  error: z.string().nullable().optional()
+  createdAt: isoString.optional()
 }).strict();
-var AutomationRunPatchSchema = z.object({
+var AutomationRunLifecyclePatchSchema = z.object({
   sessionId: nonEmptyString.nullable().optional(),
   status: AutomationRunStatusSchema.optional(),
-  scheduledFor: isoString.nullable().optional(),
   startedAt: isoString.nullable().optional(),
   completedAt: isoString.nullable().optional(),
   durationMs: nonNegativeInteger.nullable().optional(),
@@ -70,26 +163,854 @@ var AutomationRunPatchSchema = z.object({
   error: z.string().nullable().optional()
 }).strict().refine((value) => Object.keys(value).length > 0, "at least one field must be provided");
 var IdParamsSchema = z.object({ id: nonEmptyString });
+function addScheduleIssues(ctx, value) {
+  if (value.cron !== void 0 && !isValidFiveFieldCron(value.cron)) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["cron"], message: AUTOMATION_SCHEDULE_ERRORS.INVALID_CRON });
+  }
+  if (value.timezone !== void 0 && !isValidIanaTimeZone(value.timezone)) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["timezone"], message: AUTOMATION_SCHEDULE_ERRORS.INVALID_TIMEZONE });
+  }
+}
 
-// src/front/index.tsx
+// src/front/AutomationPanel.tsx
+import { useCallback, useEffect as useEffect2, useMemo as useMemo3, useRef, useState as useState2 } from "react";
+import { CalendarClock, Plus, RefreshCw } from "lucide-react";
+import { Button as Button4, EmptyState, Notice, Spinner } from "@hachej/boring-ui-kit";
+import { useWorkspaceShellCapabilities } from "@hachej/boring-workspace/plugin";
+
+// src/front/AutomationCard.tsx
+import { ChevronDown, Play, Trash2 } from "lucide-react";
+import { Button as Button2, cn as cn2 } from "@hachej/boring-ui-kit";
+
+// src/front/format.ts
+function formatDateTime(value) {
+  if (!value) return "\u2014";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return new Intl.DateTimeFormat(void 0, {
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit"
+  }).format(date);
+}
+function formatDuration(run) {
+  const value = run.durationMs ?? inferDuration(run);
+  if (value == null) return "\u2014";
+  if (value < 1e3) return `${value}ms`;
+  const seconds = Math.round(value / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainder = seconds % 60;
+  return remainder ? `${minutes}m ${remainder}s` : `${minutes}m`;
+}
+function tokenTotal(run) {
+  if (run.totalTokens != null) return run.totalTokens;
+  if (run.inputTokens != null || run.outputTokens != null) return (run.inputTokens ?? 0) + (run.outputTokens ?? 0);
+  return null;
+}
+function statusLabel(status) {
+  switch (status) {
+    case "queued":
+      return "Queued";
+    case "running":
+      return "Running";
+    case "succeeded":
+      return "Succeeded";
+    case "failed":
+      return "Failed";
+    case "cancelled":
+      return "Cancelled";
+  }
+}
+function statusTone(status) {
+  switch (status) {
+    case "succeeded":
+      return "bg-[color:var(--success-soft)] text-success";
+    case "failed":
+      return "bg-destructive/10 text-destructive";
+    case "running":
+      return "bg-foreground/[0.07] text-foreground";
+    case "cancelled":
+      return "bg-foreground/[0.07] text-muted-foreground";
+    case "queued":
+      return "bg-foreground/[0.07] text-muted-foreground";
+  }
+}
+function inferDuration(run) {
+  if (!run?.startedAt || !run.completedAt) return null;
+  const started = new Date(run.startedAt).getTime();
+  const completed = new Date(run.completedAt).getTime();
+  if (Number.isNaN(started) || Number.isNaN(completed) || completed < started) return null;
+  return completed - started;
+}
+
+// src/front/RunHistory.tsx
+import { MessageSquare } from "lucide-react";
+import { Button, cn } from "@hachej/boring-ui-kit";
 import { jsx, jsxs } from "react/jsx-runtime";
+function RunHistory({
+  runs,
+  loading,
+  onOpenRun
+}) {
+  if (loading) {
+    return /* @__PURE__ */ jsx("div", { className: "px-4 py-5 text-sm text-muted-foreground", children: "Loading run history\u2026" });
+  }
+  if (runs.length === 0) {
+    return /* @__PURE__ */ jsx("div", { className: "px-4 py-5 text-sm text-muted-foreground", children: "No runs yet. Future execution slices will write sessions here." });
+  }
+  return /* @__PURE__ */ jsx("ul", { role: "list", className: "divide-y divide-border/60 bg-card/70", children: runs.map((run) => {
+    const tokens = tokenTotal(run);
+    const startedOrScheduled = run.startedAt ?? run.scheduledFor ?? run.createdAt;
+    const title = run.sessionId ? `Open session ${run.sessionId}` : "Run has no session";
+    return /* @__PURE__ */ jsxs("li", { className: "group flex min-h-12 items-center gap-2 px-4 py-2 text-left text-[12px] focus-within:bg-muted/40 hover:bg-muted/40 motion-reduce:transition-none", children: [
+      /* @__PURE__ */ jsx("span", { className: cn("shrink-0 rounded-full px-2 py-0.5 text-[10px] font-medium", statusTone(run.status)), children: statusLabel(run.status) }),
+      /* @__PURE__ */ jsxs("div", { className: "min-w-0 flex-1", children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-wrap items-center gap-x-2 gap-y-1 text-foreground", children: [
+          /* @__PURE__ */ jsx("span", { className: "font-medium", children: run.trigger === "scheduled" ? "Scheduled" : "Manual" }),
+          /* @__PURE__ */ jsxs("span", { className: "text-muted-foreground", children: [
+            "Start ",
+            formatDateTime(startedOrScheduled)
+          ] }),
+          /* @__PURE__ */ jsxs("span", { className: "text-muted-foreground", children: [
+            "Duration ",
+            formatDuration(run)
+          ] }),
+          tokens != null ? /* @__PURE__ */ jsxs("span", { className: "text-muted-foreground", children: [
+            "Tokens ",
+            tokens.toLocaleString()
+          ] }) : null
+        ] }),
+        run.error ? /* @__PURE__ */ jsx("div", { className: "mt-1 line-clamp-2 text-destructive", children: run.error }) : null
+      ] }),
+      /* @__PURE__ */ jsxs(
+        Button,
+        {
+          type: "button",
+          variant: "ghost",
+          size: "sm",
+          disabled: !run.sessionId,
+          "aria-label": title,
+          title,
+          className: "h-7 shrink-0 px-2 text-xs",
+          onClick: () => onOpenRun(run),
+          children: [
+            /* @__PURE__ */ jsx(MessageSquare, { className: "mr-1 size-3.5", "aria-hidden": "true" }),
+            "Session"
+          ]
+        }
+      )
+    ] }, run.id);
+  }) });
+}
+
+// src/front/AutomationCard.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function AutomationCard({
+  automation,
+  expanded,
+  deleting,
+  runs,
+  runsLoading,
+  runningNow,
+  onToggle,
+  onEdit,
+  onRunNow,
+  onDeleteRequest,
+  onDeleteCancel,
+  onDeleteConfirm,
+  onOpenRun
+}) {
+  const historyId = `automation-runs-${automation.id}`;
+  const deleteTitleId = `automation-delete-title-${automation.id}`;
+  return /* @__PURE__ */ jsxs2("article", { className: "border-b border-border/60 bg-card/80 last:border-b-0", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "group flex min-h-14 w-full items-center gap-3 px-4 py-2 text-sm transition-colors hover:bg-muted/50 focus-within:bg-muted/50 motion-reduce:transition-none", children: [
+      /* @__PURE__ */ jsxs2(
+        "button",
+        {
+          type: "button",
+          className: "flex min-w-0 flex-1 items-center gap-3 text-left focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring/40",
+          "aria-expanded": expanded,
+          "aria-controls": historyId,
+          onClick: onToggle,
+          children: [
+            /* @__PURE__ */ jsx2(ChevronDown, { className: cn2("size-4 shrink-0 text-muted-foreground transition-transform motion-reduce:transition-none", expanded && "rotate-180"), "aria-hidden": "true" }),
+            /* @__PURE__ */ jsx2("span", { className: cn2("size-2 shrink-0 rounded-full", automation.enabled ? "bg-[color:var(--success)]" : "bg-muted-foreground/40"), "aria-hidden": "true" }),
+            /* @__PURE__ */ jsxs2("span", { className: "min-w-0 flex-1", children: [
+              /* @__PURE__ */ jsx2("span", { className: "block truncate font-medium text-foreground", children: automation.title }),
+              /* @__PURE__ */ jsxs2("span", { className: "block truncate text-xs text-muted-foreground", children: [
+                automation.cron,
+                " \xB7 ",
+                automation.timezone,
+                " \xB7 ",
+                automation.model
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxs2("span", { className: "hidden shrink-0 text-xs text-muted-foreground sm:block", children: [
+              "Updated ",
+              formatDateTime(automation.updatedAt)
+            ] })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs2(Button2, { type: "button", variant: "ghost", size: "sm", onClick: onRunNow, disabled: runningNow, "aria-label": `Run ${automation.title} now`, children: [
+        /* @__PURE__ */ jsx2(Play, { className: "size-3.5", "aria-hidden": "true" }),
+        runningNow ? "Running\u2026" : "Run now"
+      ] }),
+      /* @__PURE__ */ jsx2(Button2, { type: "button", variant: "ghost", size: "sm", onClick: onEdit, children: "Edit" }),
+      /* @__PURE__ */ jsx2(Button2, { type: "button", variant: "ghost", size: "icon-sm", "aria-label": `Delete ${automation.title}`, title: "Delete", onClick: onDeleteRequest, children: /* @__PURE__ */ jsx2(Trash2, { className: "size-4", "aria-hidden": "true" }) })
+    ] }),
+    deleting ? /* @__PURE__ */ jsxs2("div", { className: "border-t border-border/60 bg-background px-4 py-3 text-sm", role: "region", "aria-labelledby": deleteTitleId, children: [
+      /* @__PURE__ */ jsx2("div", { id: deleteTitleId, className: "font-medium text-foreground", children: "Delete this automation?" }),
+      /* @__PURE__ */ jsx2("p", { className: "mt-1 text-muted-foreground", children: "Only automation metadata is removed. Prompt Markdown, run records, and Pi chat sessions remain." }),
+      /* @__PURE__ */ jsxs2("div", { className: "mt-3 flex gap-2", children: [
+        /* @__PURE__ */ jsx2(Button2, { type: "button", variant: "destructive", size: "sm", onClick: onDeleteConfirm, children: "Delete" }),
+        /* @__PURE__ */ jsx2(Button2, { type: "button", variant: "ghost", size: "sm", onClick: onDeleteCancel, children: "Cancel" })
+      ] })
+    ] }) : null,
+    expanded ? /* @__PURE__ */ jsxs2("div", { id: historyId, className: "border-t border-border/60", children: [
+      /* @__PURE__ */ jsx2("div", { className: "px-4 pb-1 pt-3 text-[11px] font-semibold uppercase tracking-[0.14em] text-muted-foreground/70", children: "Run history" }),
+      /* @__PURE__ */ jsx2(RunHistory, { runs, loading: runsLoading, onOpenRun })
+    ] }) : null
+  ] });
+}
+
+// src/front/AutomationForm.tsx
+import { useEffect, useMemo, useState } from "react";
+import { Button as Button3, Checkbox, Field, FieldDescription, FieldError, FieldLabel, Input, Textarea } from "@hachej/boring-ui-kit";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var DEFAULT_DRAFT = {
+  title: "",
+  enabled: true,
+  cron: "0 9 * * *",
+  timezone: "UTC",
+  model: "",
+  prompt: ""
+};
+function draftFromAutomation(automation, prompt) {
+  return {
+    title: automation.title,
+    enabled: automation.enabled,
+    cron: automation.cron,
+    timezone: automation.timezone,
+    model: automation.model,
+    prompt
+  };
+}
+function emptyAutomationDraft() {
+  return { ...DEFAULT_DRAFT };
+}
+function validateAutomationDraft(draft) {
+  const errors = {};
+  if (!draft.title.trim()) errors.title = "Title is required.";
+  const schedule = validateAutomationSchedule(draft.cron, draft.timezone);
+  if (schedule.errors.cron) errors.cron = schedule.errors.cron;
+  if (schedule.errors.timezone) errors.timezone = schedule.errors.timezone;
+  const model = draft.model.trim();
+  if (!model) errors.model = "Model is required.";
+  else {
+    const separator = model.indexOf(":");
+    if (separator <= 0 || !model.slice(0, separator).trim() || !model.slice(separator + 1).trim()) {
+      errors.model = "Use provider:model-id syntax.";
+    }
+  }
+  return errors;
+}
+function toAutomationCreate(draft) {
+  return {
+    title: draft.title.trim(),
+    enabled: draft.enabled,
+    cron: draft.cron.trim(),
+    timezone: draft.timezone.trim(),
+    model: draft.model.trim(),
+    prompt: draft.prompt
+  };
+}
+function toAutomationPatch(draft) {
+  return {
+    title: draft.title.trim(),
+    enabled: draft.enabled,
+    cron: draft.cron.trim(),
+    timezone: draft.timezone.trim(),
+    model: draft.model.trim()
+  };
+}
+function AutomationForm({
+  automation,
+  prompt,
+  mode,
+  saving,
+  onCancel,
+  onSubmit
+}) {
+  const [draft, setDraft] = useState(() => automation ? draftFromAutomation(automation, prompt) : emptyAutomationDraft());
+  const [submitted, setSubmitted] = useState(false);
+  useEffect(() => {
+    setDraft(automation ? draftFromAutomation(automation, prompt) : emptyAutomationDraft());
+    setSubmitted(false);
+  }, [automation, prompt]);
+  const errors = useMemo(() => validateAutomationDraft(draft), [draft]);
+  const hasErrors = Object.keys(errors).length > 0;
+  const cronDescriptionIds = submitted && errors.cron ? "automation-cron-description automation-cron-error" : "automation-cron-description";
+  const timezoneDescriptionIds = submitted && errors.timezone ? "automation-timezone-description automation-timezone-error" : "automation-timezone-description";
+  const modelDescriptionIds = submitted && errors.model ? "automation-model-description automation-model-error" : "automation-model-description";
+  function submit(event) {
+    event.preventDefault();
+    setSubmitted(true);
+    if (hasErrors) return;
+    onSubmit(draft);
+  }
+  return /* @__PURE__ */ jsxs3("form", { className: "space-y-4", onSubmit: submit, noValidate: true, "aria-label": `${mode === "create" ? "Create" : "Edit"} automation form`, children: [
+    /* @__PURE__ */ jsxs3("div", { className: "grid gap-3 md:grid-cols-2", children: [
+      /* @__PURE__ */ jsxs3(Field, { children: [
+        /* @__PURE__ */ jsx3(FieldLabel, { htmlFor: "automation-title", children: "Title" }),
+        /* @__PURE__ */ jsx3(
+          Input,
+          {
+            id: "automation-title",
+            value: draft.title,
+            onChange: (event) => setDraft((current) => ({ ...current, title: event.target.value })),
+            "aria-invalid": submitted && !!errors.title,
+            "aria-describedby": submitted && errors.title ? "automation-title-error" : void 0
+          }
+        ),
+        submitted && errors.title ? /* @__PURE__ */ jsx3(FieldError, { id: "automation-title-error", children: errors.title }) : null
+      ] }),
+      /* @__PURE__ */ jsxs3(Field, { children: [
+        /* @__PURE__ */ jsx3(FieldLabel, { htmlFor: "automation-model", children: "Model" }),
+        /* @__PURE__ */ jsx3(
+          Input,
+          {
+            id: "automation-model",
+            value: draft.model,
+            placeholder: "provider:model-id",
+            onChange: (event) => setDraft((current) => ({ ...current, model: event.target.value })),
+            "aria-invalid": submitted && !!errors.model,
+            "aria-describedby": modelDescriptionIds
+          }
+        ),
+        /* @__PURE__ */ jsx3(FieldDescription, { id: "automation-model-description", children: "Explicit provider and model ID, for example anthropic:claude-sonnet-4-5." }),
+        submitted && errors.model ? /* @__PURE__ */ jsx3(FieldError, { id: "automation-model-error", children: errors.model }) : null
+      ] }),
+      /* @__PURE__ */ jsxs3(Field, { children: [
+        /* @__PURE__ */ jsx3(FieldLabel, { htmlFor: "automation-cron", children: "Cron" }),
+        /* @__PURE__ */ jsx3(
+          Input,
+          {
+            id: "automation-cron",
+            value: draft.cron,
+            onChange: (event) => setDraft((current) => ({ ...current, cron: event.target.value })),
+            "aria-invalid": submitted && !!errors.cron,
+            "aria-describedby": cronDescriptionIds
+          }
+        ),
+        /* @__PURE__ */ jsx3(FieldDescription, { id: "automation-cron-description", children: "Five-field cron, for example 0 9 * * *" }),
+        submitted && errors.cron ? /* @__PURE__ */ jsx3(FieldError, { id: "automation-cron-error", children: errors.cron }) : null
+      ] }),
+      /* @__PURE__ */ jsxs3(Field, { children: [
+        /* @__PURE__ */ jsx3(FieldLabel, { htmlFor: "automation-timezone", children: "Timezone" }),
+        /* @__PURE__ */ jsx3(
+          Input,
+          {
+            id: "automation-timezone",
+            value: draft.timezone,
+            onChange: (event) => setDraft((current) => ({ ...current, timezone: event.target.value })),
+            "aria-invalid": submitted && !!errors.timezone,
+            "aria-describedby": timezoneDescriptionIds
+          }
+        ),
+        /* @__PURE__ */ jsx3(FieldDescription, { id: "automation-timezone-description", children: "IANA timezone, for example UTC or America/New_York." }),
+        submitted && errors.timezone ? /* @__PURE__ */ jsx3(FieldError, { id: "automation-timezone-error", children: errors.timezone }) : null
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs3("label", { className: "flex w-fit items-center gap-2 rounded-md text-sm text-foreground focus-within:ring-2 focus-within:ring-ring/40", children: [
+      /* @__PURE__ */ jsx3(
+        Checkbox,
+        {
+          checked: draft.enabled,
+          onCheckedChange: (checked) => setDraft((current) => ({ ...current, enabled: checked === true })),
+          "aria-label": "Automation enabled"
+        }
+      ),
+      "Enabled"
+    ] }),
+    /* @__PURE__ */ jsxs3(Field, { children: [
+      /* @__PURE__ */ jsx3(FieldLabel, { htmlFor: "automation-prompt", children: "Markdown prompt" }),
+      /* @__PURE__ */ jsx3(
+        Textarea,
+        {
+          id: "automation-prompt",
+          value: draft.prompt,
+          onChange: (event) => setDraft((current) => ({ ...current, prompt: event.target.value })),
+          rows: 12,
+          spellCheck: false,
+          className: "min-h-64 resize-y font-mono text-[13px] leading-5",
+          "aria-describedby": "automation-prompt-description"
+        }
+      ),
+      /* @__PURE__ */ jsx3(FieldDescription, { id: "automation-prompt-description", children: "Saved through the canonical prompt route; local CLI mode writes the Markdown prompt file." })
+    ] }),
+    /* @__PURE__ */ jsxs3("div", { className: "flex flex-wrap justify-end gap-2", children: [
+      /* @__PURE__ */ jsx3(Button3, { type: "button", variant: "ghost", onClick: onCancel, disabled: saving, children: "Cancel" }),
+      /* @__PURE__ */ jsx3(Button3, { type: "submit", disabled: saving, children: saving ? "Saving\u2026" : mode === "create" ? "Create automation" : "Save automation" })
+    ] })
+  ] });
+}
+
+// src/front/client.ts
+var AutomationClientError = class extends Error {
+  constructor(code, message, statusCode = 0) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "AutomationClientError";
+  }
+  code;
+  statusCode;
+};
+function joinUrl(apiBaseUrl, path) {
+  const base = apiBaseUrl?.replace(/\/$/, "") ?? "";
+  return `${base}${path}`;
+}
+function timeoutReason(timeoutMs) {
+  if (typeof DOMException !== "undefined") return new DOMException(`Automation request timed out after ${timeoutMs}ms`, "TimeoutError");
+  return new Error(`Automation request timed out after ${timeoutMs}ms`);
+}
+function composeRequestSignal(source, timeoutMs) {
+  const shouldTimeout = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0;
+  if (!source && !shouldTimeout) return { signal: void 0, cleanup: () => {
+  }, timedOut: () => false };
+  const controller = new AbortController();
+  let didTimeout = false;
+  let timeoutId;
+  const abortFromSource = () => controller.abort(source?.reason);
+  if (source?.aborted) {
+    controller.abort(source.reason);
+  } else {
+    source?.addEventListener("abort", abortFromSource, { once: true });
+  }
+  if (shouldTimeout) {
+    timeoutId = setTimeout(() => {
+      didTimeout = true;
+      controller.abort(timeoutReason(timeoutMs));
+    }, timeoutMs);
+  }
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      if (timeoutId !== void 0) clearTimeout(timeoutId);
+      source?.removeEventListener("abort", abortFromSource);
+    },
+    timedOut: () => didTimeout
+  };
+}
+function createAutomationClient(options = {}) {
+  async function request(path, init = {}) {
+    const headers = {
+      ...init.body ? { "Content-Type": "application/json" } : {},
+      ...options.headers ?? {},
+      ...init.headers ?? {}
+    };
+    const requestSignal = composeRequestSignal(init.signal ?? void 0, options.apiTimeout);
+    try {
+      const response = await fetch(joinUrl(options.apiBaseUrl, `${BORING_AUTOMATION_ROUTE_PREFIX}${path}`), {
+        ...init,
+        headers,
+        signal: requestSignal.signal
+      });
+      if (response.status === 204) return void 0;
+      const payload = await response.json().catch(() => ({}));
+      if (!response.ok || payload.ok === false) {
+        if (response.status === 401 || response.status === 403) options.onAuthError?.(response.status);
+        throw new AutomationClientError(
+          "code" in payload && typeof payload.code === "string" ? payload.code : "BORING_AUTOMATION_ROUTE_ERROR",
+          "error" in payload && typeof payload.error === "string" ? payload.error : "Automation request failed",
+          response.status
+        );
+      }
+      return payload;
+    } catch (error) {
+      if (requestSignal.timedOut()) {
+        throw new AutomationClientError(
+          "BORING_AUTOMATION_TIMEOUT",
+          `Automation request timed out after ${options.apiTimeout}ms`
+        );
+      }
+      throw error;
+    } finally {
+      requestSignal.cleanup();
+    }
+  }
+  return {
+    async listAutomations(requestOptions = {}) {
+      const payload = await request("/automations", { signal: requestOptions.signal });
+      return payload.automations;
+    },
+    async createAutomation(input) {
+      const payload = await request("/automations", {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+      return payload.automation;
+    },
+    async getAutomation(id, requestOptions = {}) {
+      const payload = await request(`/automations/${encodeURIComponent(id)}`, { signal: requestOptions.signal });
+      return payload.automation;
+    },
+    async updateAutomation(id, patch) {
+      const payload = await request(`/automations/${encodeURIComponent(id)}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch)
+      });
+      return payload.automation;
+    },
+    async deleteAutomation(id) {
+      await request(`/automations/${encodeURIComponent(id)}`, { method: "DELETE" });
+    },
+    async getPrompt(id, requestOptions = {}) {
+      const payload = await request(`/automations/${encodeURIComponent(id)}/prompt`, { signal: requestOptions.signal });
+      return payload.prompt;
+    },
+    async updatePrompt(id, prompt) {
+      await request(`/automations/${encodeURIComponent(id)}/prompt`, {
+        method: "PUT",
+        body: JSON.stringify({ prompt })
+      });
+    },
+    async runNow(id) {
+      const payload = await request(`/automations/${encodeURIComponent(id)}/run`, { method: "POST" });
+      return payload.run;
+    },
+    async listRuns(id, requestOptions = {}) {
+      const payload = await request(`/automations/${encodeURIComponent(id)}/runs`, { signal: requestOptions.signal });
+      return payload.runs;
+    }
+  };
+}
+
+// src/front/AutomationRuntimeContext.tsx
+import { createContext, useContext, useMemo as useMemo2 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var AutomationClientContext = createContext(null);
+function AutomationRuntimeProvider({ apiBaseUrl, authHeaders, onAuthError, apiTimeout, children }) {
+  const client = useMemo2(
+    () => createAutomationClient({ apiBaseUrl, headers: authHeaders, onAuthError, apiTimeout }),
+    [apiBaseUrl, authHeaders, onAuthError, apiTimeout]
+  );
+  return /* @__PURE__ */ jsx4(AutomationClientContext.Provider, { value: client, children });
+}
+function useAutomationClient() {
+  const client = useContext(AutomationClientContext);
+  if (!client) throw new Error("useAutomationClient must be used within AutomationRuntimeProvider");
+  return client;
+}
+
+// src/front/AutomationPanel.tsx
+import { Fragment, jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function errorMessage(error) {
+  if (error instanceof AutomationClientError) return error.message;
+  if (error instanceof Error) return error.message;
+  return "Automation request failed";
+}
+function detailWithPatch(previous, patch) {
+  return {
+    prompt: previous?.prompt ?? "",
+    promptLoading: previous?.promptLoading ?? false,
+    runs: previous?.runs ?? [],
+    runsLoading: previous?.runsLoading ?? false,
+    ...patch
+  };
+}
+function patchDetail(current, automationId, patch) {
+  return { ...current, [automationId]: detailWithPatch(current[automationId], patch) };
+}
+function bumpGeneration(generations, automationId) {
+  const generation = (generations.current[automationId] ?? 0) + 1;
+  generations.current[automationId] = generation;
+  return generation;
+}
+function isCurrentGeneration(generations, automationId, generation, signal) {
+  return !signal?.aborted && generations.current[automationId] === generation;
+}
 function AutomationPanel() {
-  return /* @__PURE__ */ jsxs("div", { className: "flex h-full min-h-0 flex-col bg-background p-4 text-sm text-foreground", children: [
-    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 font-medium", children: [
-      /* @__PURE__ */ jsx(CalendarClock, { className: "h-4 w-4 text-muted-foreground" }),
-      BORING_AUTOMATION_PLUGIN_LABEL
+  const client = useAutomationClient();
+  const shell = useWorkspaceShellCapabilities();
+  const [automations, setAutomations] = useState2([]);
+  const [details, setDetails] = useState2({});
+  const [expandedId, setExpandedId] = useState2(null);
+  const [editor, setEditor] = useState2({ mode: "closed" });
+  const [deleteId, setDeleteId] = useState2(null);
+  const [loading, setLoading] = useState2(true);
+  const [saving, setSaving] = useState2(false);
+  const [runningNowIds, setRunningNowIds] = useState2(() => /* @__PURE__ */ new Set());
+  const [routeError, setRouteError] = useState2(null);
+  const [shellError, setShellError] = useState2(null);
+  const [saveNotice, setSaveNotice] = useState2(null);
+  const promptRequestGeneration = useRef({});
+  const runRequestGeneration = useRef({});
+  const selectedAutomation = useMemo3(
+    () => editor.mode === "edit" ? automations.find((automation) => automation.id === editor.automationId) ?? null : null,
+    [automations, editor]
+  );
+  const loadAutomations = useCallback(async (signal) => {
+    setLoading(true);
+    setRouteError(null);
+    try {
+      const next = await client.listAutomations({ signal });
+      setAutomations(next);
+    } catch (error) {
+      if (signal?.aborted) return;
+      setRouteError(errorMessage(error));
+    } finally {
+      if (!signal?.aborted) setLoading(false);
+    }
+  }, [client]);
+  const loadPrompt = useCallback(async (automationId, signal) => {
+    const generation = bumpGeneration(promptRequestGeneration, automationId);
+    setDetails((current) => patchDetail(current, automationId, { promptLoading: true }));
+    try {
+      const prompt = await client.getPrompt(automationId, { signal });
+      if (!isCurrentGeneration(promptRequestGeneration, automationId, generation, signal)) return;
+      setDetails((current) => patchDetail(current, automationId, { prompt, promptLoading: false }));
+    } catch (error) {
+      if (!isCurrentGeneration(promptRequestGeneration, automationId, generation, signal)) return;
+      setRouteError(errorMessage(error));
+      setDetails((current) => patchDetail(current, automationId, { promptLoading: false }));
+    }
+  }, [client]);
+  const loadRuns = useCallback(async (automationId, signal) => {
+    const generation = bumpGeneration(runRequestGeneration, automationId);
+    setDetails((current) => patchDetail(current, automationId, { runsLoading: true }));
+    try {
+      const runs = await client.listRuns(automationId, { signal });
+      if (!isCurrentGeneration(runRequestGeneration, automationId, generation, signal)) return;
+      setDetails((current) => patchDetail(current, automationId, { runs, runsLoading: false }));
+    } catch (error) {
+      if (!isCurrentGeneration(runRequestGeneration, automationId, generation, signal)) return;
+      setRouteError(errorMessage(error));
+      setDetails((current) => patchDetail(current, automationId, { runsLoading: false }));
+    }
+  }, [client]);
+  useEffect2(() => {
+    const controller = new AbortController();
+    void loadAutomations(controller.signal);
+    return () => controller.abort();
+  }, [loadAutomations]);
+  const openCreate = useCallback(() => {
+    setEditor({ mode: "create" });
+    setSaveNotice(null);
+    setShellError(null);
+  }, []);
+  const openEdit = useCallback((automation) => {
+    setEditor({ mode: "edit", automationId: automation.id });
+    setSaveNotice(null);
+    setShellError(null);
+    void loadPrompt(automation.id);
+  }, [loadPrompt]);
+  const toggleExpanded = useCallback((automation) => {
+    const willExpand = expandedId !== automation.id;
+    setExpandedId(willExpand ? automation.id : null);
+    setShellError(null);
+    if (willExpand) void loadRuns(automation.id);
+  }, [expandedId, loadRuns]);
+  async function refreshAutomationAndPrompt(automationId) {
+    const generation = bumpGeneration(promptRequestGeneration, automationId);
+    setDetails((current) => patchDetail(current, automationId, { promptLoading: true }));
+    const [automation, prompt] = await Promise.all([
+      client.getAutomation(automationId),
+      client.getPrompt(automationId)
+    ]);
+    if (!isCurrentGeneration(promptRequestGeneration, automationId, generation)) return;
+    setAutomations((current) => current.map((item) => item.id === automation.id ? automation : item));
+    setDetails((current) => patchDetail(current, automation.id, { prompt, promptLoading: false }));
+  }
+  async function saveDraft(draft) {
+    setSaving(true);
+    setRouteError(null);
+    setSaveNotice(null);
+    try {
+      if (editor.mode === "create") {
+        const created = await client.createAutomation(toAutomationCreate(draft));
+        bumpGeneration(promptRequestGeneration, created.id);
+        setAutomations((current) => [created, ...current]);
+        setDetails((current) => patchDetail(current, created.id, { prompt: draft.prompt, promptLoading: false, runs: [], runsLoading: false }));
+        setExpandedId(created.id);
+        setEditor({ mode: "edit", automationId: created.id });
+        setSaveNotice({ tone: "success", message: "Automation created." });
+        return;
+      }
+      if (editor.mode === "edit") {
+        const automationId = editor.automationId;
+        bumpGeneration(promptRequestGeneration, automationId);
+        await client.updatePrompt(automationId, draft.prompt);
+        setDetails((current) => patchDetail(current, automationId, { prompt: draft.prompt, promptLoading: false }));
+        try {
+          const updated = await client.updateAutomation(automationId, toAutomationPatch(draft));
+          setAutomations((current) => current.map((automation) => automation.id === updated.id ? updated : automation));
+          setSaveNotice({ tone: "success", message: "Automation saved." });
+        } catch (metadataError) {
+          try {
+            await refreshAutomationAndPrompt(automationId);
+            setSaveNotice({ tone: "warning", message: `Prompt saved, but automation metadata was not saved: ${errorMessage(metadataError)}. Refreshed latest server state.` });
+          } catch (refreshError) {
+            setSaveNotice({ tone: "warning", message: `Prompt saved, but automation metadata was not saved: ${errorMessage(metadataError)}. Refresh failed: ${errorMessage(refreshError)}` });
+          }
+        }
+      }
+    } catch (error) {
+      setRouteError(errorMessage(error));
+    } finally {
+      setSaving(false);
+    }
+  }
+  async function deleteAutomation(id) {
+    setRouteError(null);
+    try {
+      await client.deleteAutomation(id);
+      setAutomations((current) => current.filter((automation) => automation.id !== id));
+      setDetails((current) => {
+        const next = { ...current };
+        delete next[id];
+        return next;
+      });
+      if (expandedId === id) setExpandedId(null);
+      if (editor.mode === "edit" && editor.automationId === id) setEditor({ mode: "closed" });
+      setDeleteId(null);
+      setSaveNotice({ tone: "success", message: "Automation deleted." });
+    } catch (error) {
+      setRouteError(errorMessage(error));
+    }
+  }
+  async function runNow(automation) {
+    if (runningNowIds.has(automation.id)) return;
+    setRunningNowIds((current) => new Set(current).add(automation.id));
+    setRouteError(null);
+    setSaveNotice(null);
+    setExpandedId(automation.id);
+    try {
+      const run = await client.runNow(automation.id);
+      setDetails((current) => patchDetail(current, automation.id, {
+        runs: [run, ...(current[automation.id]?.runs ?? []).filter((item) => item.id !== run.id)],
+        runsLoading: false
+      }));
+      setSaveNotice({ tone: "success", message: run.sessionId ? "Automation finished. Open its session from run history." : "Automation finished." });
+    } catch (error) {
+      setRouteError(errorMessage(error));
+      await loadRuns(automation.id);
+    } finally {
+      setRunningNowIds((current) => {
+        const next = new Set(current);
+        next.delete(automation.id);
+        return next;
+      });
+    }
+  }
+  function openRun(run) {
+    if (!run.sessionId) return;
+    const result = shell.openDetachedChat(run.sessionId, { title: run.modelSnapshot || "Automation run" });
+    setShellError(result.success ? null : result.message);
+  }
+  const editorPrompt = selectedAutomation ? details[selectedAutomation.id]?.prompt ?? "" : emptyAutomationDraft().prompt;
+  const editorLoading = editor.mode === "edit" && selectedAutomation ? details[selectedAutomation.id]?.promptLoading === true : false;
+  return /* @__PURE__ */ jsxs4("div", { className: "flex h-full min-h-0 flex-col bg-background text-sm text-foreground", children: [
+    /* @__PURE__ */ jsxs4("header", { className: "flex min-h-14 shrink-0 items-center justify-between gap-3 border-b border-border/60 px-4 py-3", children: [
+      /* @__PURE__ */ jsxs4("div", { className: "min-w-0", children: [
+        /* @__PURE__ */ jsxs4("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx5("span", { className: "grid size-7 place-items-center rounded-lg bg-[color:oklch(from_var(--accent)_l_c_h/0.14)] text-[color:var(--accent)]", children: /* @__PURE__ */ jsx5(CalendarClock, { className: "size-4", "aria-hidden": "true" }) }),
+          /* @__PURE__ */ jsx5("h2", { className: "truncate text-sm font-semibold tracking-tight", children: BORING_AUTOMATION_PLUGIN_LABEL })
+        ] }),
+        /* @__PURE__ */ jsx5("p", { className: "mt-1 text-xs text-muted-foreground", children: "Local scheduled prompts with Markdown prompt files and Pi session history." })
+      ] }),
+      /* @__PURE__ */ jsxs4("div", { className: "flex shrink-0 items-center gap-2", children: [
+        /* @__PURE__ */ jsxs4(Button4, { type: "button", variant: "ghost", size: "sm", onClick: () => void loadAutomations(), disabled: loading || editor.mode !== "closed", children: [
+          /* @__PURE__ */ jsx5(RefreshCw, { className: "size-4", "aria-hidden": "true" }),
+          "Refresh"
+        ] }),
+        /* @__PURE__ */ jsxs4(Button4, { type: "button", size: "sm", onClick: openCreate, children: [
+          /* @__PURE__ */ jsx5(Plus, { className: "size-4", "aria-hidden": "true" }),
+          "New"
+        ] })
+      ] })
     ] }),
-    /* @__PURE__ */ jsx("p", { className: "mt-2 max-w-prose text-sm text-muted-foreground", children: "Automation UI is implemented in the next slice. Slice 1 provides the trusted plugin shell, file-backed store, and CRUD routes." })
+    /* @__PURE__ */ jsx5("div", { className: "min-h-0 flex-1 overflow-y-auto bg-[color:oklch(from_var(--background)_calc(l-0.012)_c_h)]", children: /* @__PURE__ */ jsxs4("div", { className: "mx-auto grid w-full max-w-6xl gap-4 p-4 lg:grid-cols-[minmax(0,1fr)_minmax(360px,440px)]", children: [
+      /* @__PURE__ */ jsx5("section", { className: "min-w-0 overflow-hidden rounded-xl border border-border/70 bg-card/60", "aria-label": "Automation list", children: loading ? /* @__PURE__ */ jsxs4("div", { className: "flex min-h-48 items-center justify-center gap-2 text-sm text-muted-foreground", children: [
+        /* @__PURE__ */ jsx5(Spinner, { className: "size-4" }),
+        " Loading automations\u2026"
+      ] }) : automations.length === 0 ? /* @__PURE__ */ jsx5(
+        EmptyState,
+        {
+          title: "No automations yet",
+          description: "Create a focused scheduled prompt with cron, timezone, model, and canonical Markdown.",
+          icon: /* @__PURE__ */ jsx5(CalendarClock, { className: "size-8", "aria-hidden": "true" }),
+          actions: /* @__PURE__ */ jsx5(Button4, { type: "button", onClick: openCreate, children: "Create automation" }),
+          className: "min-h-64"
+        }
+      ) : /* @__PURE__ */ jsx5("div", { children: automations.map((automation) => {
+        const detail = details[automation.id];
+        return /* @__PURE__ */ jsx5(
+          AutomationCard,
+          {
+            automation,
+            expanded: expandedId === automation.id,
+            deleting: deleteId === automation.id,
+            runs: detail?.runs ?? [],
+            runsLoading: detail?.runsLoading === true,
+            runningNow: runningNowIds.has(automation.id),
+            onToggle: () => toggleExpanded(automation),
+            onEdit: () => openEdit(automation),
+            onRunNow: () => void runNow(automation),
+            onDeleteRequest: () => setDeleteId(automation.id),
+            onDeleteCancel: () => setDeleteId(null),
+            onDeleteConfirm: () => void deleteAutomation(automation.id),
+            onOpenRun: openRun
+          },
+          automation.id
+        );
+      }) }) }),
+      /* @__PURE__ */ jsxs4("aside", { className: "min-w-0 rounded-xl border border-border/70 bg-card/80 p-4", "aria-label": "Automation editor", children: [
+        routeError ? /* @__PURE__ */ jsx5(Notice, { tone: "destructive", className: "mb-3", role: "alert", children: routeError }) : null,
+        shellError ? /* @__PURE__ */ jsx5(Notice, { tone: "destructive", className: "mb-3", role: "alert", children: shellError }) : null,
+        saveNotice ? /* @__PURE__ */ jsx5(Notice, { tone: saveNotice.tone, className: "mb-3", role: "status", children: saveNotice.message }) : null,
+        editor.mode === "closed" ? /* @__PURE__ */ jsx5("div", { className: "flex min-h-80 items-center justify-center px-4 text-center text-sm text-muted-foreground", children: /* @__PURE__ */ jsxs4("div", { children: [
+          /* @__PURE__ */ jsx5("div", { className: "font-medium text-foreground", children: "Select an automation to edit" }),
+          /* @__PURE__ */ jsx5("p", { className: "mt-1 max-w-xs", children: "Cards expand for read-only run history. The editor saves metadata and Markdown through separate public routes." })
+        ] }) }) : editor.mode === "create" ? /* @__PURE__ */ jsxs4(Fragment, { children: [
+          /* @__PURE__ */ jsxs4("div", { className: "mb-4", children: [
+            /* @__PURE__ */ jsx5("h3", { className: "font-semibold text-foreground", children: "New automation" }),
+            /* @__PURE__ */ jsx5("p", { className: "mt-1 text-xs text-muted-foreground", children: "Define the schedule and canonical Markdown prompt." })
+          ] }),
+          /* @__PURE__ */ jsx5(AutomationForm, { mode: "create", prompt: "", saving, onCancel: () => setEditor({ mode: "closed" }), onSubmit: (draft) => void saveDraft(draft) })
+        ] }) : selectedAutomation ? editorLoading ? /* @__PURE__ */ jsxs4("div", { className: "flex min-h-80 items-center justify-center gap-2 text-muted-foreground", children: [
+          /* @__PURE__ */ jsx5(Spinner, { className: "size-4" }),
+          " Loading prompt\u2026"
+        ] }) : /* @__PURE__ */ jsxs4(Fragment, { children: [
+          /* @__PURE__ */ jsxs4("div", { className: "mb-4", children: [
+            /* @__PURE__ */ jsx5("h3", { className: "font-semibold text-foreground", children: "Edit automation" }),
+            /* @__PURE__ */ jsx5("p", { className: "mt-1 text-xs text-muted-foreground", children: selectedAutomation.id })
+          ] }),
+          /* @__PURE__ */ jsx5(AutomationForm, { automation: selectedAutomation, mode: "edit", prompt: editorPrompt, saving, onCancel: () => setEditor({ mode: "closed" }), onSubmit: (draft) => void saveDraft(draft) })
+        ] }) : /* @__PURE__ */ jsx5(Notice, { tone: "destructive", children: "Automation not found." })
+      ] })
+    ] }) })
   ] });
 }
+
+// src/front/index.tsx
 var boringAutomationPlugin = definePlugin({
   id: BORING_AUTOMATION_PLUGIN_ID,
   label: BORING_AUTOMATION_PLUGIN_LABEL,
+  providers: [
+    {
+      id: `${BORING_AUTOMATION_PLUGIN_ID}.runtime`,
+      component: AutomationRuntimeProvider
+    }
+  ],
   panels: [
     {
       id: `${BORING_AUTOMATION_PLUGIN_ID}.panel`,
       label: BORING_AUTOMATION_PLUGIN_LABEL,
-      icon: CalendarClock,
+      icon: CalendarClock2,
       component: AutomationPanel,
       placement: "center",
       source: "builtin"
@@ -105,10 +1026,12 @@ var boringAutomationPlugin = definePlugin({
 });
 var front_default = boringAutomationPlugin;
 export {
+  AUTOMATION_SCHEDULE_ERRORS,
+  AutomationClientError,
   AutomationCreateSchema,
   AutomationPatchSchema,
-  AutomationRunCreateSchema,
-  AutomationRunPatchSchema,
+  AutomationRunBeginSchema,
+  AutomationRunLifecyclePatchSchema,
   AutomationRunStatusSchema,
   AutomationRunTriggerSchema,
   BORING_AUTOMATION_ERROR_CODES,
@@ -118,5 +1041,10 @@ export {
   IdParamsSchema,
   PromptUpdateSchema,
   boringAutomationPlugin,
-  front_default as default
+  createAutomationClient,
+  front_default as default,
+  evaluateAutomationSchedule,
+  isValidFiveFieldCron,
+  isValidIanaTimeZone,
+  validateAutomationSchedule
 };